all: rename expr_to_str_complex() to expr_to_str()
authorDan Carpenter <dan.carpenter@oracle.com>
Tue, 22 Jan 2013 20:22:05 +0000 (22 23:22 +0300)
committerDan Carpenter <dan.carpenter@oracle.com>
Tue, 22 Jan 2013 20:22:05 +0000 (22 23:22 +0300)
The _complex part of the name was misleading.

Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
23 files changed:
check_access_ok_math.c
check_assigned_expr.c
check_debug.c
check_dma_on_stack.c
check_leaks.c
check_locking.c
check_macro_side_effects.c
check_memory.c
check_min_t.c
check_missing_break.c
check_or_vs_and.c
check_overflow.c
check_passes_sizeof.c
check_pointer_math.c
check_signed.c
check_sizeof.c
check_type.c
check_user_data.c
check_wait_for_common.c
smatch.h
smatch_conditions.c
smatch_helper.c
smatch_type.c

index db99f2a..257ca8e 100644 (file)
@@ -51,7 +51,7 @@ static void match_size(struct expression *size_expr)
        if (!can_overflow(size_expr))
                return;
 
-       name = expr_to_str_complex(size_expr);
+       name = expr_to_str(size_expr);
        sm_msg("warn: math in access_ok() is dangerous '%s'", name);
 
        free_string(name);
index 1db6ad5..ac6f747 100644 (file)
@@ -35,7 +35,7 @@ static struct smatch_state *alloc_my_state(struct expression *expr)
 
        state = __alloc_smatch_state(0);
        expr = strip_expr(expr);
-       name = expr_to_str_complex(expr);
+       name = expr_to_str(expr);
        state->name = alloc_sname(name);
        free_string(name);
        state->data = expr;
index fc88abb..588ce38 100644 (file)
@@ -57,7 +57,7 @@ static void match_print_implied(const char *fn, struct expression *expr, void *i
        arg = get_argument_from_call_expr(expr->args, 0);
        get_implied_rl(arg, &rl);
 
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
        sm_msg("implied: %s = '%s'", name, show_rl(rl));
        free_string(name);
 }
@@ -69,7 +69,7 @@ static void match_print_implied_min(const char *fn, struct expression *expr, voi
        char *name;
 
        arg = get_argument_from_call_expr(expr->args, 0);
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
 
        if (get_implied_min(arg, &sval))
                sm_msg("implied min: %s = %s", name, sval_to_str(sval));
@@ -86,7 +86,7 @@ static void match_print_implied_max(const char *fn, struct expression *expr, voi
        char *name;
 
        arg = get_argument_from_call_expr(expr->args, 0);
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
 
        if (get_implied_max(arg, &sval))
                sm_msg("implied max: %s = %s", name, sval_to_str(sval));
@@ -103,7 +103,7 @@ static void match_print_hard_max(const char *fn, struct expression *expr, void *
        char *name;
 
        arg = get_argument_from_call_expr(expr->args, 0);
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
 
        if (get_hard_max(arg, &sval))
                sm_msg("hard max: %s = %s", name, sval_to_str(sval));
@@ -120,7 +120,7 @@ static void match_print_fuzzy_max(const char *fn, struct expression *expr, void
        char *name;
 
        arg = get_argument_from_call_expr(expr->args, 0);
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
 
        if (get_fuzzy_max(arg, &sval))
                sm_msg("fuzzy max: %s = %s", name, sval_to_str(sval));
@@ -137,7 +137,7 @@ static void match_print_absolute_min(const char *fn, struct expression *expr, vo
        char *name;
 
        arg = get_argument_from_call_expr(expr->args, 0);
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
 
        if (get_absolute_min(arg, &sval))
                sm_msg("absolute min: %s = %s", name, sval_to_str(sval));
@@ -156,7 +156,7 @@ static void match_print_absolute_max(const char *fn, struct expression *expr, vo
        arg = get_argument_from_call_expr(expr->args, 0);
        get_absolute_max(arg, &sval);
 
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
        sm_msg("absolute max: %s = %s", name, sval_to_str(sval));
        free_string(name);
 }
@@ -168,7 +168,7 @@ static void match_sval_info(const char *fn, struct expression *expr, void *info)
        char *name;
 
        arg = get_argument_from_call_expr(expr->args, 0);
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
 
        if (!get_implied_value(arg, &sval)) {
                sm_msg("no sval for '%s'", name);
@@ -221,7 +221,7 @@ static void match_buf_size(const char *fn, struct expression *expr, void *info)
        elements = get_array_size(arg);
        bytes = get_array_size_bytes(arg);
 
-       name = expr_to_str_complex(arg);
+       name = expr_to_str(arg);
        sm_msg("buf size: '%s' %d elements, %d bytes", name, elements, bytes);
        free_string(name);
 }
index 56290d3..f1d15c6 100644 (file)
@@ -24,7 +24,7 @@ static void match_dma_func(const char *fn, struct expression *expr, void *param)
        if (arg->type == EXPR_PREOP && arg->op == '&') {
                if (arg->unop->type != EXPR_SYMBOL)
                        return;
-               name = expr_to_str_complex(arg);
+               name = expr_to_str(arg);
                sm_msg("error: doing dma on the stack (%s)", name);
                free_string(name);
                return;
index 6bfe4a7..b6475a0 100644 (file)
@@ -62,7 +62,7 @@ static char *get_parent_from_expr(struct expression *expr, struct symbol **sym)
 
        expr = strip_expr(expr);
 
-       name = expr_to_str_sym_complex(expr, sym);
+       name = expr_to_str_sym(expr, sym);
        free_string(name);
        if (!name || !*sym || !(*sym)->ident) {
                *sym = NULL;
@@ -77,7 +77,7 @@ static int is_local(struct expression *expr)
        struct symbol *sym;
        int ret = 0;
 
-       name = expr_to_str_sym_complex(expr, &sym);
+       name = expr_to_str_sym(expr, &sym);
        if (!name || !sym)
                goto out;
        if (sym->ctype.modifiers & (MOD_NONLOCAL | MOD_STATIC | MOD_ADDRESSABLE))
@@ -95,7 +95,7 @@ static int is_param(struct expression *expr)
        struct symbol *tmp;
        int ret = 0;
 
-       name = expr_to_str_sym_complex(expr, &sym);
+       name = expr_to_str_sym(expr, &sym);
        if (!name || !sym)
                goto out;
        FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, tmp) {
index 8329123..be0ed00 100644 (file)
@@ -377,7 +377,7 @@ static char *get_full_name(struct expression *expr, int index)
                if (!arg)
                        goto free;
                arg = remove_spinlock_check(arg);
-               name = expr_to_str_complex(arg);
+               name = expr_to_str(arg);
                if (!name)
                        goto free;
                full_name = make_full_name(lock->name, name);
index 3178f73..91e7422 100644 (file)
@@ -24,7 +24,7 @@ static struct smatch_state *alloc_my_state(struct expression *expr)
 
        state = __alloc_smatch_state(0);
        expr = strip_expr(expr);
-       name = expr_to_str_complex(expr);
+       name = expr_to_str(expr);
        state->name = alloc_sname(name);
        free_string(name);
        state->data = expr;
@@ -109,7 +109,7 @@ static void match_unop(struct expression *raw_expr)
        if (!positions_eq(old_pos, expr->pos))
                return;
 
-       name = expr_to_str_complex(raw_expr);
+       name = expr_to_str(raw_expr);
        sm_msg("warn: side effect in macro '%s' doing '%s'",
                macro, name);
        free_string(name);
index cb625a1..5421e46 100644 (file)
@@ -175,7 +175,7 @@ static void match_assign(struct expression *expr)
        struct sm_state *tmp;
 
        left = strip_expr(expr->left);
-       left_name = expr_to_str_sym_complex(left, &left_sym);
+       left_name = expr_to_str_sym(left, &left_sym);
 
        right = strip_expr(expr->right);
        while (right->type == EXPR_ASSIGNMENT)
@@ -189,7 +189,7 @@ static void match_assign(struct expression *expr)
                goto exit;
        }
 
-       right_name = expr_to_str_sym_complex(right, &right_sym);
+       right_name = expr_to_str_sym(right, &right_sym);
 
        if (right_name && (state = get_state(my_id, right_name, right_sym))) {
                if (state == &isfree && !is_complex(right))
@@ -319,7 +319,7 @@ static void match_return(struct expression *ret_value)
        char *name;
        struct symbol *sym;
 
-       name = expr_to_str_sym_complex(ret_value, &sym);
+       name = expr_to_str_sym(ret_value, &sym);
        if (sym)
                assign_parent(sym);
        free_string(name);
@@ -382,7 +382,7 @@ static void match_function_call(struct expression *expr)
 
        FOR_EACH_PTR(expr->args, tmp) {
                tmp = strip_expr(tmp);
-               name = expr_to_str_sym_complex(tmp, &sym);
+               name = expr_to_str_sym(tmp, &sym);
                if (!name)
                        continue;
                if ((state = get_sm_state(my_id, name, sym))) {
index da8eef3..362c13c 100644 (file)
@@ -34,7 +34,7 @@ static void match_assign(struct expression *expr)
        if (sval_cmp(max_left, max_right) >= 0)
                return;
 
-       name = expr_to_str_complex(expr->right);
+       name = expr_to_str(expr->right);
        sm_msg("warn: min_t truncates here '%s' (%s vs %s)", name, sval_to_str(max_left), sval_to_str(max_right));
        free_string(name);
 }
index 0144573..2c78112 100644 (file)
@@ -44,7 +44,7 @@ static struct smatch_state *alloc_my_state(struct expression *expr)
 
        state = __alloc_smatch_state(0);
        expr = strip_expr(expr);
-       name = expr_to_str_complex(expr);
+       name = expr_to_str(expr);
        if (!name)
                name = alloc_string("");
        state->name = alloc_sname(name);
index 3e31b4f..18ec757 100644 (file)
@@ -34,10 +34,10 @@ static int expr_equiv(struct expression *one, struct expression *two)
        if (does_inc_dec(one) || does_inc_dec(two))
                return 0;
 
-       one_name = expr_to_str_sym_complex(one, &one_sym);
+       one_name = expr_to_str_sym(one, &one_sym);
        if (!one_name || !one_sym)
                goto free;
-       two_name = expr_to_str_sym_complex(two, &two_sym);
+       two_name = expr_to_str_sym(two, &two_sym);
        if (!two_name || !two_sym)
                goto free;
        if (one_sym != two_sym)
index f0274a7..ee4ed31 100644 (file)
@@ -119,7 +119,7 @@ static void array_check(struct expression *expr)
                                return;
                }
 
-               name = expr_to_str_complex(array_expr);
+               name = expr_to_str(array_expr);
                /* Blast.  Smatch can't figure out glibc's strcmp __strcmp_cg()
                 * so it prints an error every time you compare to a string
                 * literal array with 4 or less chars.
@@ -195,8 +195,8 @@ static void match_strcpy(const char *fn, struct expression *expr, void *unused)
        if (data_size && dest_size >= data_size)
                return;
 
-       dest_name = expr_to_str_complex(dest);
-       data_name = expr_to_str_complex(data);
+       dest_name = expr_to_str(dest);
+       data_name = expr_to_str(data);
 
        if (data_size)
                sm_msg("error: %s() '%s' too large for '%s' (%d vs %d)",
@@ -237,7 +237,7 @@ static void match_snprintf(const char *fn, struct expression *expr, void *unused
                return;
        if (strcmp(format, "\"%s\""))
                goto free;
-       data_name = expr_to_str_complex(data);
+       data_name = expr_to_str(data);
        data_size = get_array_size_bytes(data);
        if (limit_size.value < data_size)
                sm_msg("error: snprintf() chops off the last chars of '%s': %d vs %s",
@@ -269,7 +269,7 @@ static void match_sprintf(const char *fn, struct expression *expr, void *unused)
                return;
        if (strcmp(format, "\"%s\""))
                goto free;
-       data_name = expr_to_str_complex(data);
+       data_name = expr_to_str(data);
        data_size = get_array_size_bytes(data);
        if (dest_size < data_size)
                sm_msg("error: sprintf() copies too much data from '%s': %d vs %d",
@@ -298,7 +298,7 @@ static void match_limited(const char *fn, struct expression *expr, void *_limite
        if (has >= needed.value)
                return;
 
-       dest_name = expr_to_str_complex(dest);
+       dest_name = expr_to_str(dest);
        sm_msg("error: %s() '%s' too small (%d vs %s)", fn, dest_name, has, sval_to_str(needed));
        free_string(dest_name);
 }
index 0d28f1d..202c96c 100644 (file)
@@ -27,10 +27,10 @@ static int expr_equiv(struct expression *one, struct expression *two)
        if (one->type != two->type)
                return 0;
 
-       one_name = expr_to_str_sym_complex(one, &one_sym);
+       one_name = expr_to_str_sym(one, &one_sym);
        if (!one_name || !one_sym)
                goto free;
-       two_name = expr_to_str_sym_complex(two, &two_sym);
+       two_name = expr_to_str_sym(two, &two_sym);
        if (!two_name || !two_sym)
                goto free;
        if (one_sym != two_sym)
index b82ce84..d90a93c 100644 (file)
@@ -69,7 +69,7 @@ static void match_binop(struct expression *expr)
        if (!is_size_in_bytes(expr->right))
                return;
 
-       name = expr_to_str_complex(expr->left);
+       name = expr_to_str(expr->left);
        sm_msg("warn: potential pointer math issue ('%s' is a %d bit pointer)",
               name, type->bit_size);
        free_string(name);
index c94d489..9938186 100644 (file)
@@ -45,8 +45,8 @@ static void match_assign(struct expression *expr)
                return;
        max = sval_type_max(sym);
        if (sval_cmp(max, sval) < 0 && !(sval.value < 256 && max.value == 127)) {
-               left_name = expr_to_str_complex(expr->left);
-               right_name = expr_to_str_complex(expr->right);
+               left_name = expr_to_str(expr->left);
+               right_name = expr_to_str(expr->right);
                sm_msg("warn: '%s' %s can't fit into %s '%s'",
                       right_name, sval_to_numstr(sval), sval_to_numstr(max), left_name);
                free_string(left_name);
@@ -61,7 +61,7 @@ static void match_assign(struct expression *expr)
                        return;
                if (sval_positive_bits(sval) == 7)
                        return;
-               left_name = expr_to_str_complex(expr->left);
+               left_name = expr_to_str(expr->left);
                if (min.value == 0) {
                        sm_msg("warn: assigning %s to unsigned variable '%s'",
                               sval_to_str(sval), left_name);
@@ -102,11 +102,11 @@ static int cap_gt_zero_and_lt(struct expression *expr)
                            right->op != SPECIAL_UNSIGNED_LTE)
                                return 0;
 
-                       name1 = expr_to_str_complex(var);
+                       name1 = expr_to_str(var);
                        if (!name1)
                                goto free;
 
-                       name2 = expr_to_str_complex(right->left);
+                       name2 = expr_to_str(right->left);
                        if (!name2)
                                goto free;
                        if (!strcmp(name1, name2))
@@ -152,11 +152,11 @@ static int cap_lt_zero_or_gt(struct expression *expr)
                            right->op != SPECIAL_UNSIGNED_GTE)
                                return 0;
 
-                       name1 = expr_to_str_complex(var);
+                       name1 = expr_to_str(var);
                        if (!name1)
                                goto free;
 
-                       name2 = expr_to_str_complex(right->left);
+                       name2 = expr_to_str(right->left);
                        if (!name2)
                                goto free;
                        if (!strcmp(name1, name2))
@@ -205,7 +205,7 @@ static int print_unsigned_never_less_than_zero(struct expression *expr)
        if (!get_value(expr->right, &known) || known.value != 0)
                return 0;
 
-       name = expr_to_str_complex(expr->left);
+       name = expr_to_str(expr->left);
        sm_msg("warn: unsigned '%s' is never less than zero.", name);
        free_string(name);
        return 1;
@@ -268,7 +268,7 @@ static void match_condition(struct expression *expr)
        }
 
        if (!possibly_true_rl(rl_left, expr->op, rl_right)) {
-               char *name = expr_to_str_complex(expr);
+               char *name = expr_to_str(expr);
 
                sm_msg("warn: impossible condition '(%s) => (%s %s %s)'", name,
                       show_rl(rl_left), show_special(expr->op),
@@ -277,7 +277,7 @@ static void match_condition(struct expression *expr)
        }
 
        if (!possibly_false_rl(rl_left, expr->op, rl_right)) {
-               char *name = expr_to_str_complex(expr);
+               char *name = expr_to_str(expr);
 
                sm_msg("warn: always true condition '(%s) => (%s %s %s)'", name,
                       show_rl(rl_left_orig), show_special(expr->op),
index 4b8de5b..5590126 100644 (file)
@@ -22,7 +22,7 @@ static void check_pointer(struct expression *expr, char *ptr_name)
        get_value(expr, &sval);
 
        expr = strip_expr(expr->cast_expression);
-       name = expr_to_str_complex(expr);
+       name = expr_to_str(expr);
        if (!name)
                return;
 
@@ -40,7 +40,7 @@ static void match_call_assignment(struct expression *expr)
        if (!is_pointer(expr->left))
                return;
 
-       ptr_name = expr_to_str_complex(expr->left);
+       ptr_name = expr_to_str(expr->left);
        if (!ptr_name)
                return;
 
index 1a37c43..e839858 100644 (file)
@@ -33,7 +33,7 @@ static void match_free(const char *fn, struct expression *expr, void *data)
        if (!type || !type->ident)
                return;
 
-       name = expr_to_str_complex(arg_expr);
+       name = expr_to_str(arg_expr);
 
        if (!strcmp("sk_buff", type->ident->name)) {
                sm_msg("error: use kfree_skb() here instead of kfree(%s)", name);
index 6f3cbca..efbeddf 100644 (file)
@@ -152,7 +152,7 @@ int is_user_data(struct expression *expr)
        if (tmp)
                return slist_has_state(tmp->possible, &user_data);
 
-       name = expr_to_str_sym_complex(expr, &sym);
+       name = expr_to_str_sym(expr, &sym);
        if (!name || !sym)
                goto free;
 
index 99241e5..1e00ad6 100644 (file)
@@ -17,7 +17,7 @@ static void match_wait_for_common(const char *fn, struct expression *expr, void
 
        if (!expr_unsigned(expr->left))
                return;
-       name = expr_to_str_complex(expr->left);
+       name = expr_to_str(expr->left);
        sm_msg("error: '%s()' returns negative and '%s' is unsigned", fn, name);
        free_string(name);
 }
index 20854ad..109521d 100644 (file)
--- a/smatch.h
+++ b/smatch.h
@@ -224,8 +224,8 @@ struct expression *get_argument_from_call_expr(struct expression_list *args,
                                               int num);
 
 char *expr_to_var(struct expression *expr);
-char *expr_to_str_complex(struct expression *expr);
-char *expr_to_str_sym_complex(struct expression *expr,
+char *expr_to_str(struct expression *expr);
+char *expr_to_str_sym(struct expression *expr,
                                     struct symbol **sym_ptr);
 char *expr_to_var_sym(struct expression *expr,
                             struct symbol **sym_ptr);
index 67544fe..616cd5b 100644 (file)
@@ -338,7 +338,7 @@ static void hackup_unsigned_compares(struct expression *expr)
 static void split_conditions(struct expression *expr)
 {
        if (option_debug) {
-               char *cond = expr_to_str_complex(expr);
+               char *cond = expr_to_str(expr);
 
                sm_debug("%d in split_conditions (%s)\n", get_lineno(), cond);
                free_string(cond);
index 474ee57..de3057b 100644 (file)
@@ -242,7 +242,7 @@ static void __get_variable_from_expr(struct symbol **sym_ptr, char *buf,
  *
  */
 
-char *expr_to_str_sym_complex(struct expression *expr, struct symbol **sym_ptr)
+char *expr_to_str_sym(struct expression *expr, struct symbol **sym_ptr)
 {
        static char var_name[VAR_LEN];
        int complicated = 0;
@@ -261,9 +261,9 @@ char *expr_to_str_sym_complex(struct expression *expr, struct symbol **sym_ptr)
                return NULL;
 }
 
-char *expr_to_str_complex(struct expression *expr)
+char *expr_to_str(struct expression *expr)
 {
-       return expr_to_str_sym_complex(expr, NULL);
+       return expr_to_str_sym(expr, NULL);
 }
 
 /*
index db69acb..9426e4d 100644 (file)
@@ -342,7 +342,7 @@ int is_static(struct expression *expr)
        struct symbol *sym;
        int ret = 0;
 
-       name = expr_to_str_sym_complex(expr, &sym);
+       name = expr_to_str_sym(expr, &sym);
        if (!name || !sym)
                goto free;
 
@@ -463,7 +463,7 @@ struct symbol *get_member_type_from_key(struct expression *expr, char *key)
                return get_real_base_type(sym);
        }
 
-       name = expr_to_str_sym_complex(expr, &sym);
+       name = expr_to_str_sym(expr, &sym);
        free_string(name);
        if (!sym)
                return NULL;