estate: rename alloc_estate_range_list() to alloc_estate_rl()
authorDan Carpenter <dan.carpenter@oracle.com>
Fri, 11 Jan 2013 12:07:35 +0000 (11 15:07 +0300)
committerDan Carpenter <dan.carpenter@oracle.com>
Fri, 11 Jan 2013 12:07:35 +0000 (11 15:07 +0300)
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
smatch_estate.c
smatch_extra.c
smatch_extra.h
smatch_function_hooks.c
smatch_implied.c
smatch_param_limit.c

index d7091fa..a3df00a 100644 (file)
@@ -32,7 +32,7 @@ struct smatch_state *merge_estates(struct smatch_state *s1, struct smatch_state
                return s1;
 
        value_ranges = rl_union(estate_ranges(s1), estate_ranges(s2));
-       tmp = alloc_estate_range_list(value_ranges);
+       tmp = alloc_estate_rl(value_ranges);
        rlist = get_shared_relations(estate_related(s1), estate_related(s2));
        set_related(tmp, rlist);
        if (estate_has_hard_max(s1) && estate_has_hard_max(s2))
@@ -215,7 +215,7 @@ struct smatch_state *alloc_estate_empty(void)
 
 struct smatch_state *extra_undefined(struct symbol *type)
 {
-       return alloc_estate_range_list(alloc_whole_rl(type));
+       return alloc_estate_rl(alloc_whole_rl(type));
 }
 
 struct smatch_state *extra_empty(void)
@@ -249,7 +249,7 @@ struct smatch_state *alloc_estate_range(sval_t min, sval_t max)
        return state;
 }
 
-struct smatch_state *alloc_estate_range_list(struct range_list *rl)
+struct smatch_state *alloc_estate_rl(struct range_list *rl)
 {
        struct smatch_state *state;
 
@@ -272,5 +272,5 @@ struct smatch_state *get_implied_estate(struct expression *expr)
                return state;
        if (!get_implied_rl(expr, &rl))
                rl = alloc_whole_rl(get_type(expr));
-       return alloc_estate_range_list(rl);
+       return alloc_estate_rl(rl);
 }
index dadf573..d6049fb 100644 (file)
@@ -178,7 +178,7 @@ struct smatch_state *filter_range(struct smatch_state *orig,
                orig = extra_undefined(filter_min.type);
 
        rl = remove_range(estate_ranges(orig), filter_min, filter_max);
-       return alloc_estate_range_list(rl);
+       return alloc_estate_rl(rl);
 }
 
 struct smatch_state *add_filter(struct smatch_state *orig, sval_t sval)
@@ -486,13 +486,13 @@ static void match_assign(struct expression *expr)
 
                if (get_implied_rl(right, &rl)) {
                        rl = cast_rl(get_type(expr->left), rl);
-                       state = alloc_estate_range_list(rl);
+                       state = alloc_estate_rl(rl);
                        if (get_hard_max(right, &tmp))
                                estate_set_hard_max(state);
                } else {
                        rl = alloc_whole_rl(get_type(right));
                        rl = cast_rl(get_type(expr->left), rl);
-                       state = alloc_estate_range_list(rl);
+                       state = alloc_estate_rl(rl);
                }
                set_extra_mod(name, sym, state);
                goto free;
@@ -522,7 +522,7 @@ static void match_assign(struct expression *expr)
                rl = cast_rl(get_type(expr->left), alloc_rl(right_min, right_max));
        else
                rl = alloc_whole_rl(get_type(expr->left));
-       set_extra_mod(name, sym, alloc_estate_range_list(rl));
+       set_extra_mod(name, sym, alloc_estate_rl(rl));
 free:
        free_string(right_name);
        free_string(name);
@@ -868,10 +868,10 @@ static void match_comparison(struct expression *expr)
                return;
        }
 
-       left_true_state = alloc_estate_range_list(cast_rl(get_type(left), left_true));
-       left_false_state = alloc_estate_range_list(cast_rl(get_type(left), left_false));
-       right_true_state = alloc_estate_range_list(cast_rl(get_type(right), right_true));
-       right_false_state = alloc_estate_range_list(cast_rl(get_type(right), right_false));
+       left_true_state = alloc_estate_rl(cast_rl(get_type(left), left_true));
+       left_false_state = alloc_estate_rl(cast_rl(get_type(left), left_false));
+       right_true_state = alloc_estate_rl(cast_rl(get_type(right), right_true));
+       right_false_state = alloc_estate_rl(cast_rl(get_type(right), right_false));
 
        switch (expr->op) {
        case '<':
@@ -1073,7 +1073,7 @@ static void db_param_limit_filter(struct expression *expr, int param, char *key,
        if (sm && rl_equiv(estate_ranges(sm->state), new))
                __set_sm(sm);
        else
-               set_extra_nomod(name, sym, alloc_estate_range_list(new));
+               set_extra_nomod(name, sym, alloc_estate_rl(new));
 
 free:
        free_string(name);
@@ -1110,7 +1110,7 @@ static void db_param_add(struct expression *expr, int param, char *key, char *va
                new = alloc_whole_rl(type);
        }
 
-       set_extra_mod(name, sym, alloc_estate_range_list(new));
+       set_extra_mod(name, sym, alloc_estate_rl(new));
 free:
        free_string(name);
 }
@@ -1156,7 +1156,7 @@ static void db_returned_states_param(struct expression *expr, int param, char *k
                }
                type = get_type(arg);
                str_to_rl(type, value, &rl);
-               set_extra_mod(name, sym, alloc_estate_range_list(rl));
+               set_extra_mod(name, sym, alloc_estate_rl(rl));
                free_string(name);
                return;
        }
@@ -1177,7 +1177,7 @@ static void db_returned_states_param(struct expression *expr, int param, char *k
        if (!type)
                goto free;
        str_to_rl(type, value, &rl);
-       set_extra_mod(member_name, sym, alloc_estate_range_list(rl));
+       set_extra_mod(member_name, sym, alloc_estate_rl(rl));
 free:
        free_string(name);
 }
@@ -1201,7 +1201,7 @@ static void db_returned_member_info(struct expression *expr, int param, char *ke
        if (!type)
                return;
        str_to_rl(type, value, &rl);
-       set_extra_mod(member_name, sym, alloc_estate_range_list(rl));
+       set_extra_mod(member_name, sym, alloc_estate_rl(rl));
 
 free:
        free_string(name);
@@ -1257,7 +1257,7 @@ static void set_param_value(const char *name, struct symbol *sym, char *key, cha
        snprintf(fullname, 256, "%s%s", name, key + 2);
        type = get_member_type_from_key(symbol_expression(sym), key);
        str_to_rl(type, value, &rl);
-       state = alloc_estate_range_list(rl);
+       state = alloc_estate_rl(rl);
        set_state(SMATCH_EXTRA, fullname, sym, state);
 }
 
index 495e41d..b6c9846 100644 (file)
@@ -89,7 +89,7 @@ void free_data_info_allocs(void);
 struct smatch_state *alloc_estate_empty(void);
 struct smatch_state *alloc_estate_sval(sval_t sval);
 struct smatch_state *alloc_estate_range(sval_t min, sval_t max);
-struct smatch_state *alloc_estate_range_list(struct range_list *rl);
+struct smatch_state *alloc_estate_rl(struct range_list *rl);
 struct smatch_state *extra_undefined(struct symbol *type);
 struct smatch_state *clone_estate(struct smatch_state *state);
 
index 64a4b85..bda4ac1 100644 (file)
@@ -480,7 +480,7 @@ static int db_assign_return_states_callback(void *unused, int argc, char **argv,
                        tmp->callback(db_info.expr, param, key, value);
        } END_FOR_EACH_PTR(tmp);
        ret_range = cast_rl(get_type(db_info.expr->left), ret_range);
-       set_extra_expr_mod(db_info.expr->left, alloc_estate_range_list(ret_range));
+       set_extra_expr_mod(db_info.expr->left, alloc_estate_rl(ret_range));
 
        return 0;
 }
@@ -541,7 +541,7 @@ static int handle_implied_return(struct expression *expr)
        if (!get_implied_return(expr->right, &rl))
                return 0;
        rl = cast_rl(get_type(expr->left), rl);
-       set_extra_expr_mod(expr->left, alloc_estate_range_list(rl));
+       set_extra_expr_mod(expr->left, alloc_estate_rl(rl));
        return 1;
 }
 
@@ -577,7 +577,7 @@ static void match_assign_call(struct expression *expr)
                if (!get_implied_rl(expr->right, &rl))
                        rl = alloc_whole_rl(get_type(expr->right));
                rl = cast_rl(get_type(expr->left), rl);
-               set_extra_expr_mod(expr->left, alloc_estate_range_list(rl));
+               set_extra_expr_mod(expr->left, alloc_estate_rl(rl));
        }
 }
 
index 522250f..ea1a848 100644 (file)
@@ -600,7 +600,7 @@ struct state_list *__implied_case_slist(struct expression *switch_expr,
        if (sm)
                separate_and_filter(sm, SPECIAL_EQUAL, vals, LEFT, *raw_slist, &true_states, &false_states);
 
-       set_state_slist(&true_states, SMATCH_EXTRA, name, sym, alloc_estate_range_list(vals));
+       set_state_slist(&true_states, SMATCH_EXTRA, name, sym, alloc_estate_rl(vals));
        overwrite_slist(true_states, &ret);
        free_slist(&true_states);
        free_slist(&false_states);
index 9c0a942..b9d9cd1 100644 (file)
@@ -53,7 +53,7 @@ static struct smatch_state *filter_my_sm(struct sm_state *sm)
                ret = rl_union(ret, estate_ranges(estate));
        } END_FOR_EACH_PTR(tmp);
 
-       return alloc_estate_range_list(ret);
+       return alloc_estate_rl(ret);
 }
 
 struct smatch_state *get_orig_estate(const char *name, struct symbol *sym)
@@ -68,7 +68,7 @@ struct smatch_state *get_orig_estate(const char *name, struct symbol *sym)
        state = get_state(SMATCH_EXTRA, name, sym);
        if (state)
                return state;
-       return alloc_estate_range_list(alloc_whole_rl(get_real_base_type(sym)));
+       return alloc_estate_rl(alloc_whole_rl(get_real_base_type(sym)));
 }
 
 static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr, struct state_list *slist)