11506 smatch resync

*** 112,122 ****
                  pop_op();
          while (rl_stack)
                  pop_rl(&rl_stack);
  }
  
! static int read_rl_from_var(struct expression *call, char *p, char **end, struct range_list **rl)
  {
          struct expression *arg;
          struct smatch_state *state;
          long param;
          char *name;
--- 112,122 ----
                  pop_op();
          while (rl_stack)
                  pop_rl(&rl_stack);
  }
  
! static int read_rl_from_var(struct expression *call, const char *p, const char **end, struct range_list **rl)
  {
          struct expression *arg;
          struct smatch_state *state;
          long param;
          char *name;
*** 123,133 ****
          struct symbol *sym;
          char buf[256];
          int star;
  
          p++;
!         param = strtol(p, &p, 10);
  
          arg = get_argument_from_call_expr(call->args, param);
          if (!arg)
                  return 0;
  
--- 123,133 ----
          struct symbol *sym;
          char buf[256];
          int star;
  
          p++;
!         param = strtol(p, (char **)&p, 10);
  
          arg = get_argument_from_call_expr(call->args, param);
          if (!arg)
                  return 0;
  
*** 163,173 ****
                  return 0;
          *rl = estate_rl(state);
          return 1;
  }
  
! static int read_var_num(struct expression *call, char *p, char **end, struct range_list **rl)
  {
          sval_t sval;
  
          while (*p == ' ')
                  p++;
--- 163,173 ----
                  return 0;
          *rl = estate_rl(state);
          return 1;
  }
  
! static int read_var_num(struct expression *call, const char *p, const char **end, struct range_list **rl)
  {
          sval_t sval;
  
          while (*p == ' ')
                  p++;
*** 174,191 ****
  
          if (*p == '$')
                  return read_rl_from_var(call, p, end, rl);
  
          sval.type = &llong_ctype;
!         sval.value = strtoll(p, end, 10);
          if (*end == p)
                  return 0;
          *rl = alloc_rl(sval, sval);
          return 1;
  }
  
! static char *read_op(char *p)
  {
          while (*p == ' ')
                  p++;
  
          switch (*p) {
--- 174,191 ----
  
          if (*p == '$')
                  return read_rl_from_var(call, p, end, rl);
  
          sval.type = &llong_ctype;
!         sval.value = strtoll(p, (char **)end, 10);
          if (*end == p)
                  return 0;
          *rl = alloc_rl(sval, sval);
          return 1;
  }
  
! static const char *read_op(const char *p)
  {
          while (*p == ' ')
                  p++;
  
          switch (*p) {
*** 197,214 ****
          default:
                  return NULL;
          }
  }
  
! int parse_call_math_rl(struct expression *call, char *math, struct range_list **rl)
  {
          struct range_list *tmp;
!         char *c;
  
          /* try to implement shunting yard algorithm. */
  
!         c = (char *)math;
          while (1) {
                  if (option_debug)
                          sm_msg("parsing %s", c);
  
                  /* read a number and push it onto the number stack */
--- 197,214 ----
          default:
                  return NULL;
          }
  }
  
! int parse_call_math_rl(struct expression *call, const char *math, struct range_list **rl)
  {
          struct range_list *tmp;
!         const char *c;
  
          /* try to implement shunting yard algorithm. */
  
!         c = math;
          while (1) {
                  if (option_debug)
                          sm_msg("parsing %s", c);
  
                  /* read a number and push it onto the number stack */
*** 342,351 ****
--- 342,361 ----
          if (param_was_set_var_sym(name, sym))
                  return 0;
          return format_name_sym_helper(buf, remaining, name, sym);
  }
  
+ static int is_mtag_sval(sval_t sval)
+ {
+         if (!is_ptr_type(sval.type))
+                 return 0;
+         if (sval_cmp(sval, valid_ptr_min_sval) >= 0 &&
+             sval_cmp(sval, valid_ptr_max_sval) <= 0)
+                 return 1;
+         return 0;
+ }
+ 
  static int format_expr_helper(char *buf, int remaining, struct expression *expr)
  {
          sval_t sval;
          int ret;
          char *cur;
*** 378,388 ****
                          return 0;
                  cur += ret;
                  return cur - buf;
          }
  
!         if (get_implied_value(expr, &sval)) {
                  ret = snprintf(cur, remaining, "%s", sval_to_str(sval));
                  remaining -= ret;
                  if (remaining <= 0)
                          return 0;
                  return ret;
--- 388,398 ----
                          return 0;
                  cur += ret;
                  return cur - buf;
          }
  
!         if (!param_was_set(expr) && get_implied_value(expr, &sval) && !is_mtag_sval(sval)) {
                  ret = snprintf(cur, remaining, "%s", sval_to_str(sval));
                  remaining -= ret;
                  if (remaining <= 0)
                          return 0;
                  return ret;
*** 433,442 ****
--- 443,453 ----
  {
          struct expression *tmp, *expr;
          char buf[256] = "";
          int ret;
          int cnt = 0;
+         sval_t sval;
  
          expr = get_assigned_expr_name_sym(name, sym);
          if (!expr)
                  return NULL;
          while ((tmp = get_assigned_expr(expr))) {
*** 443,452 ****
--- 454,466 ----
                  expr = strip_expr(tmp);
                  if (++cnt > 3)
                          break;
          }
  
+         if (get_implied_value(expr, &sval))
+                 return NULL;
+ 
          ret = format_expr_helper(buf, sizeof(buf), expr);
          if (ret == 0)
                  return NULL;
  
          return alloc_sname(buf);
*** 491,501 ****
          p = format;
          out = buf;
          while (*p) {
                  if (*p == '$') {
                          p++;
!                         param = strtol(p, &p, 10);
                          arg = get_argument_from_call_expr(call->args, param);
                          if (!arg)
                                  return NULL;
                          param = get_arg_number(arg);
                          if (param >= 0) {
--- 505,515 ----
          p = format;
          out = buf;
          while (*p) {
                  if (*p == '$') {
                          p++;
!                         param = strtol(p, (char **)&p, 10);
                          arg = get_argument_from_call_expr(call->args, param);
                          if (!arg)
                                  return NULL;
                          param = get_arg_number(arg);
                          if (param >= 0) {
*** 641,650 ****
--- 655,666 ----
  {
          int i;
  
          my_id = id;
  
+         set_dynamic_states(my_id);
+ 
          for (i = 0; i < ARRAY_SIZE(alloc_functions); i++)
                  add_function_assign_hook(alloc_functions[i].func, &match_alloc,
                                           INT_PTR(alloc_functions[i].param));
          add_hook(&match_call_assignment, CALL_ASSIGNMENT_HOOK);
          add_split_return_callback(print_returned_allocations);