sval: update smatch_math.c to use range_list_sval
[smatch.git] / smatch_helper.c
blob11d73c30ef0229577ff6abdf43c9cdfcd21156e4
1 /*
2 * sparse/smatch_helper.c
4 * Copyright (C) 2006 Dan Carpenter.
6 * Licensed under the Open Software License version 1.1
8 */
11 * Miscellaneous helper functions.
14 #include <stdlib.h>
15 #include <stdio.h>
16 #include "allocate.h"
17 #include "smatch.h"
19 #define VAR_LEN 512
21 char *alloc_string(const char *str)
23 char *tmp;
25 if (!str)
26 return NULL;
27 tmp = malloc(strlen(str) + 1);
28 strcpy(tmp, str);
29 return tmp;
32 void free_string(char *str)
34 free(str);
37 struct smatch_state *alloc_state_num(int num)
39 struct smatch_state *state;
40 static char buff[256];
42 state = __alloc_smatch_state(0);
43 snprintf(buff, 255, "%d", num);
44 buff[255] = '\0';
45 state->name = alloc_string(buff);
46 state->data = INT_PTR(num);
47 return state;
50 static void append(char *dest, const char *data, int buff_len)
52 strncat(dest, data, buff_len - strlen(dest) - 1);
56 * If you have "foo(a, b, 1);" then use
57 * get_argument_from_call_expr(expr, 0) to return the expression for
58 * a. Yes, it does start counting from 0.
60 struct expression *get_argument_from_call_expr(struct expression_list *args,
61 int num)
63 struct expression *expr;
64 int i = 0;
66 if (!args)
67 return NULL;
69 FOR_EACH_PTR(args, expr) {
70 if (i == num)
71 return expr;
72 i++;
73 } END_FOR_EACH_PTR(expr);
74 return NULL;
77 static struct expression *get_array_expr(struct expression *expr)
79 struct symbol *type;
81 if (expr->type != EXPR_BINOP || expr->op != '+')
82 return NULL;
84 type = get_type(expr->left);
85 if (!type || type->type != SYM_ARRAY)
86 return NULL;
87 return expr->left;
90 static void __get_variable_from_expr(struct symbol **sym_ptr, char *buf,
91 struct expression *expr, int len,
92 int *complicated)
94 struct expression *tmp;
96 switch (expr->type) {
97 case EXPR_DEREF:
98 tmp = expr->deref;
99 if (tmp->op == '*')
100 tmp = tmp->unop;
102 __get_variable_from_expr(sym_ptr, buf, tmp, len, complicated);
104 tmp = expr->deref;
105 if (tmp->op == '*')
106 append(buf, "->", len);
107 else
108 append(buf, ".", len);
110 append(buf, expr->member->name, len);
112 return;
113 case EXPR_SYMBOL:
114 if (expr->symbol_name)
115 append(buf, expr->symbol_name->name, len);
116 if (sym_ptr) {
117 if (*sym_ptr)
118 *complicated = 1;
119 *sym_ptr = expr->symbol;
121 return;
122 case EXPR_PREOP: {
123 const char *tmp;
125 if (get_expression_statement(expr)) {
126 *complicated = 2;
127 return;
130 if (expr->op != '*' || !get_array_expr(expr->unop)) {
131 tmp = show_special(expr->op);
132 append(buf, tmp, len);
134 __get_variable_from_expr(sym_ptr, buf, expr->unop,
135 len, complicated);
137 if (expr->op == '(')
138 append(buf, ")", len);
140 if (expr->op == SPECIAL_DECREMENT ||
141 expr->op == SPECIAL_INCREMENT ||
142 expr->op == '&')
143 *complicated = 1;
145 return;
147 case EXPR_POSTOP: {
148 const char *tmp;
150 __get_variable_from_expr(sym_ptr, buf, expr->unop,
151 len, complicated);
152 tmp = show_special(expr->op);
153 append(buf, tmp, len);
155 if (expr->op == SPECIAL_DECREMENT || expr->op == SPECIAL_INCREMENT)
156 *complicated = 1;
157 return;
159 case EXPR_COMPARE:
160 case EXPR_LOGICAL:
161 case EXPR_BINOP: {
162 char tmp[10];
163 struct expression *array_expr;
165 *complicated = 1;
166 array_expr = get_array_expr(expr);
167 if (array_expr) {
168 __get_variable_from_expr(sym_ptr, buf, array_expr, len, complicated);
169 append(buf, "[", len);
170 } else {
171 __get_variable_from_expr(sym_ptr, buf, expr->left, len,
172 complicated);
173 snprintf(tmp, sizeof(tmp), " %s ", show_special(expr->op));
174 append(buf, tmp, len);
176 __get_variable_from_expr(NULL, buf, expr->right,
177 len, complicated);
178 if (array_expr)
179 append(buf, "]", len);
180 return;
182 case EXPR_VALUE: {
183 char tmp[25];
185 *complicated = 1;
186 snprintf(tmp, 25, "%lld", expr->value);
187 append(buf, tmp, len);
188 return;
190 case EXPR_STRING:
191 append(buf, "\"", len);
192 append(buf, expr->string->data, len);
193 append(buf, "\"", len);
194 return;
195 case EXPR_CALL: {
196 struct expression *tmp;
197 int i;
199 *complicated = 1;
200 __get_variable_from_expr(NULL, buf, expr->fn, len,
201 complicated);
202 append(buf, "(", len);
203 i = 0;
204 FOR_EACH_PTR_REVERSE(expr->args, tmp) {
205 if (i++)
206 append(buf, ", ", len);
207 __get_variable_from_expr(NULL, buf, tmp, len,
208 complicated);
209 } END_FOR_EACH_PTR_REVERSE(tmp);
210 append(buf, ")", len);
211 return;
213 case EXPR_CAST:
214 __get_variable_from_expr(sym_ptr, buf,
215 expr->cast_expression, len,
216 complicated);
217 return;
218 case EXPR_SIZEOF: {
219 int size;
220 char tmp[25];
222 if (expr->cast_type && get_base_type(expr->cast_type)) {
223 size = (get_base_type(expr->cast_type))->bit_size;
224 snprintf(tmp, 25, "%d", bits_to_bytes(size));
225 append(buf, tmp, len);
227 return;
229 default:
230 *complicated = 1;
231 //printf("unknown type = %d\n", expr->type);
232 return;
237 * This is returns a stylized "c looking" representation of the
238 * variable name.
240 * It uses the same buffer every time so you have to save the result
241 * yourself if you want to keep it.
245 char *get_variable_from_expr_complex(struct expression *expr, struct symbol **sym_ptr)
247 static char var_name[VAR_LEN];
248 int complicated = 0;
250 if (sym_ptr)
251 *sym_ptr = NULL;
252 var_name[0] = '\0';
254 if (!expr)
255 return NULL;
256 __get_variable_from_expr(sym_ptr, var_name, expr, sizeof(var_name),
257 &complicated);
258 if (complicated < 2)
259 return alloc_string(var_name);
260 else
261 return NULL;
265 * get_variable_from_expr_simple() only returns simple variables.
266 * If it's a complicated variable like a->foo instead of just 'a'
267 * then it returns NULL.
270 char *get_variable_from_expr(struct expression *expr,
271 struct symbol **sym_ptr)
273 static char var_name[VAR_LEN];
274 int complicated = 0;
276 if (sym_ptr)
277 *sym_ptr = NULL;
278 var_name[0] = '\0';
280 if (!expr)
281 return NULL;
282 expr = strip_expr(expr);
283 __get_variable_from_expr(sym_ptr, var_name, expr, sizeof(var_name),
284 &complicated);
286 if (complicated) {
287 if (sym_ptr)
288 *sym_ptr = NULL;
289 return NULL;
291 return alloc_string(var_name);
294 int sym_name_is(const char *name, struct expression *expr)
296 if (!expr)
297 return 0;
298 if (expr->type != EXPR_SYMBOL)
299 return 0;
300 if (!strcmp(expr->symbol_name->name, name))
301 return 1;
302 return 0;
305 int is_zero(struct expression *expr)
307 sval_t sval;
309 if (get_value_sval(expr, &sval) && sval.value == 0)
310 return 1;
311 return 0;
314 int is_array(struct expression *expr)
316 expr = strip_expr(expr);
317 if (expr->type != EXPR_PREOP || expr->op != '*')
318 return 0;
319 expr = expr->unop;
320 if (expr->op != '+')
321 return 0;
322 return 1;
325 struct expression *get_array_name(struct expression *expr)
327 if (!is_array(expr))
328 return NULL;
329 return strip_expr(expr->unop->left);
332 struct expression *get_array_offset(struct expression *expr)
334 if (!is_array(expr))
335 return NULL;
336 return expr->unop->right;
339 const char *show_state(struct smatch_state *state)
341 if (!state)
342 return NULL;
343 return state->name;
346 struct statement *get_expression_statement(struct expression *expr)
348 /* What are those things called? if (({....; ret;})) { ...*/
350 if (expr->type != EXPR_PREOP)
351 return NULL;
352 if (expr->op != '(')
353 return NULL;
354 if (expr->unop->type != EXPR_STATEMENT)
355 return NULL;
356 if (expr->unop->statement->type != STMT_COMPOUND)
357 return NULL;
358 return expr->unop->statement;
361 struct expression *strip_parens(struct expression *expr)
363 if (!expr)
364 return NULL;
366 if (expr->type == EXPR_PREOP) {
367 if (expr->op == '(' && expr->unop->type == EXPR_STATEMENT &&
368 expr->unop->statement->type == STMT_COMPOUND)
369 return expr;
370 if (expr->op == '(')
371 return strip_parens(expr->unop);
373 return expr;
376 struct expression *strip_expr(struct expression *expr)
378 if (!expr)
379 return NULL;
381 switch (expr->type) {
382 case EXPR_FORCE_CAST:
383 case EXPR_CAST:
384 return strip_expr(expr->cast_expression);
385 case EXPR_PREOP:
386 if (expr->op == '(' && expr->unop->type == EXPR_STATEMENT &&
387 expr->unop->statement->type == STMT_COMPOUND)
388 return expr;
389 if (expr->op == '(')
390 return strip_expr(expr->unop);
392 return expr;
395 static void delete_state_tracker(struct tracker *t)
397 delete_state(t->owner, t->name, t->sym);
398 __free_tracker(t);
401 void scoped_state(int my_id, const char *name, struct symbol *sym)
403 struct tracker *t;
405 t = alloc_tracker(my_id, name, sym);
406 add_scope_hook((scope_hook *)&delete_state_tracker, t);
409 int is_error_return(struct expression *expr)
411 struct symbol *cur_func = cur_func_sym;
412 sval_t sval;
414 if (!expr)
415 return 0;
416 if (cur_func->type != SYM_NODE)
417 return 0;
418 cur_func = get_base_type(cur_func);
419 if (cur_func->type != SYM_FN)
420 return 0;
421 cur_func = get_base_type(cur_func);
422 if (cur_func == &void_ctype)
423 return 0;
424 if (!get_value_sval(expr, &sval))
425 return 0;
426 if (sval_cmp_val(sval, 0) < 0)
427 return 1;
428 if (cur_func->type == SYM_PTR && sval.value == 0)
429 return 1;
430 return 0;
433 int getting_address(void)
435 struct expression *tmp;
436 int i = 0;
437 int dot_ops = 0;
439 FOR_EACH_PTR_REVERSE(big_expression_stack, tmp) {
440 if (!i++)
441 continue;
442 if (tmp->type == EXPR_PREOP && tmp->op == '(')
443 continue;
444 if (tmp->op == '.' && !dot_ops++)
445 continue;
446 if (tmp->op == '&')
447 return 1;
448 return 0;
449 } END_FOR_EACH_PTR_REVERSE(tmp);
450 return 0;
453 char *get_member_name(struct expression *expr)
455 char buf[256];
456 struct symbol *sym;
458 if (expr->type != EXPR_DEREF)
459 return NULL;
460 sym = get_type(expr->deref);
461 if (!sym || !sym->ident)
462 return NULL;
463 snprintf(buf, sizeof(buf), "(struct %s)->%s", sym->ident->name, expr->member->name);
464 return alloc_string(buf);
467 char *get_fnptr_name(struct expression *expr)
469 if (expr->type == EXPR_SYMBOL)
470 return get_variable_from_expr(expr, NULL);
471 return get_member_name(expr);
474 int positions_eq(struct position pos1, struct position pos2)
476 if (pos1.line != pos2.line)
477 return 0;
478 if (pos1.pos != pos2.pos)
479 return 0;
480 if (pos1.stream != pos2.stream)
481 return 0;
482 return 1;
485 struct statement *get_current_statement(void)
487 struct statement *prev, *tmp;
489 prev = last_ptr_list((struct ptr_list *)big_statement_stack);
491 if (!prev || !get_macro_name(prev->pos))
492 return prev;
494 FOR_EACH_PTR_REVERSE(big_statement_stack, tmp) {
495 if (positions_eq(tmp->pos, prev->pos))
496 continue;
497 if (prev->pos.line > tmp->pos.line)
498 return prev;
499 return tmp;
500 } END_FOR_EACH_PTR_REVERSE(tmp);
501 return prev;