2 * sparse/smatch_helper.c
4 * Copyright (C) 2006 Dan Carpenter.
6 * Licensed under the Open Software License version 1.1
11 * Miscellaneous helper functions.
21 char *alloc_string(const char *str
)
27 tmp
= malloc(strlen(str
) + 1);
32 void free_string(char *str
)
37 void remove_parens(char *str
)
42 while (*src
!= '\0') {
43 if (*src
== '(' || *src
== ')') {
52 struct smatch_state
*alloc_state_num(int num
)
54 struct smatch_state
*state
;
55 static char buff
[256];
57 state
= __alloc_smatch_state(0);
58 snprintf(buff
, 255, "%d", num
);
60 state
->name
= alloc_string(buff
);
61 state
->data
= INT_PTR(num
);
65 void append(char *dest
, const char *data
, int buff_len
)
67 strncat(dest
, data
, buff_len
- strlen(dest
) - 1);
71 * If you have "foo(a, b, 1);" then use
72 * get_argument_from_call_expr(expr, 0) to return the expression for
73 * a. Yes, it does start counting from 0.
75 struct expression
*get_argument_from_call_expr(struct expression_list
*args
,
78 struct expression
*expr
;
84 FOR_EACH_PTR(args
, expr
) {
88 } END_FOR_EACH_PTR(expr
);
92 static struct expression
*get_array_expr(struct expression
*expr
)
96 if (expr
->type
!= EXPR_BINOP
|| expr
->op
!= '+')
99 type
= get_type(expr
->left
);
100 if (!type
|| type
->type
!= SYM_ARRAY
)
105 static void __get_variable_from_expr(struct symbol
**sym_ptr
, char *buf
,
106 struct expression
*expr
, int len
,
107 int *complicated
, int no_parens
)
109 struct expression
*tmp
;
111 switch (expr
->type
) {
117 __get_variable_from_expr(sym_ptr
, buf
, tmp
, len
, complicated
, no_parens
);
121 append(buf
, "->", len
);
123 append(buf
, ".", len
);
125 if (expr
->member
&& expr
->member
->name
)
126 append(buf
, expr
->member
->name
, len
);
128 append(buf
, "unknown_member", len
);
132 if (expr
->symbol_name
)
133 append(buf
, expr
->symbol_name
->name
, len
);
137 *sym_ptr
= expr
->symbol
;
143 if (get_expression_statement(expr
)) {
148 if (expr
->op
== '(') {
150 append(buf
, "(", len
);
151 } else if (expr
->op
!= '*' || !get_array_expr(expr
->unop
)) {
152 tmp
= show_special(expr
->op
);
153 append(buf
, tmp
, len
);
155 __get_variable_from_expr(sym_ptr
, buf
, expr
->unop
,
156 len
, complicated
, no_parens
);
158 if (expr
->op
== '(' && !no_parens
)
159 append(buf
, ")", len
);
161 if (expr
->op
== SPECIAL_DECREMENT
||
162 expr
->op
== SPECIAL_INCREMENT
)
170 __get_variable_from_expr(sym_ptr
, buf
, expr
->unop
,
171 len
, complicated
, no_parens
);
172 tmp
= show_special(expr
->op
);
173 append(buf
, tmp
, len
);
175 if (expr
->op
== SPECIAL_DECREMENT
|| expr
->op
== SPECIAL_INCREMENT
)
179 case EXPR_ASSIGNMENT
:
184 struct expression
*array_expr
;
187 array_expr
= get_array_expr(expr
);
189 __get_variable_from_expr(sym_ptr
, buf
, array_expr
, len
, complicated
, no_parens
);
190 append(buf
, "[", len
);
192 __get_variable_from_expr(sym_ptr
, buf
, expr
->left
, len
, complicated
, no_parens
);
193 snprintf(tmp
, sizeof(tmp
), " %s ", show_special(expr
->op
));
194 append(buf
, tmp
, len
);
196 __get_variable_from_expr(NULL
, buf
, expr
->right
, len
, complicated
, no_parens
);
198 append(buf
, "]", len
);
205 snprintf(tmp
, 25, "%lld", expr
->value
);
206 append(buf
, tmp
, len
);
210 append(buf
, "\"", len
);
211 append(buf
, expr
->string
->data
, len
);
212 append(buf
, "\"", len
);
215 struct expression
*tmp
;
219 __get_variable_from_expr(NULL
, buf
, expr
->fn
, len
, complicated
, no_parens
);
220 append(buf
, "(", len
);
222 FOR_EACH_PTR(expr
->args
, tmp
) {
224 append(buf
, ", ", len
);
225 __get_variable_from_expr(NULL
, buf
, tmp
, len
, complicated
, no_parens
);
226 } END_FOR_EACH_PTR(tmp
);
227 append(buf
, ")", len
);
231 __get_variable_from_expr(sym_ptr
, buf
,
232 expr
->cast_expression
, len
,
233 complicated
, no_parens
);
239 if (expr
->cast_type
&& get_base_type(expr
->cast_type
)) {
240 size
= (get_base_type(expr
->cast_type
))->bit_size
;
241 snprintf(tmp
, 25, "%d", bits_to_bytes(size
));
242 append(buf
, tmp
, len
);
246 case EXPR_IDENTIFIER
:
248 if (expr
->expr_ident
&& expr
->expr_ident
->name
)
249 append(buf
, expr
->expr_ident
->name
, len
);
253 //printf("unknown type = %d\n", expr->type);
259 * This is returns a stylized "c looking" representation of the
262 * It uses the same buffer every time so you have to save the result
263 * yourself if you want to keep it.
267 char *expr_to_str_sym(struct expression
*expr
, struct symbol
**sym_ptr
)
269 static char var_name
[VAR_LEN
];
278 __get_variable_from_expr(sym_ptr
, var_name
, expr
, sizeof(var_name
),
281 return alloc_string(var_name
);
286 char *expr_to_str(struct expression
*expr
)
288 return expr_to_str_sym(expr
, NULL
);
292 * get_variable_from_expr_simple() only returns simple variables.
293 * If it's a complicated variable like a->foo[x] instead of just 'a->foo'
294 * then it returns NULL.
296 char *expr_to_var_sym(struct expression
*expr
,
297 struct symbol
**sym_ptr
)
299 static char var_name
[VAR_LEN
];
308 expr
= strip_expr(expr
);
309 __get_variable_from_expr(sym_ptr
, var_name
, expr
, sizeof(var_name
),
317 return alloc_string(var_name
);
320 char *expr_to_var(struct expression
*expr
)
322 return expr_to_var_sym(expr
, NULL
);
325 int sym_name_is(const char *name
, struct expression
*expr
)
329 if (expr
->type
!= EXPR_SYMBOL
)
331 if (!strcmp(expr
->symbol_name
->name
, name
))
336 int is_zero(struct expression
*expr
)
340 if (get_value(expr
, &sval
) && sval
.value
== 0)
345 int is_array(struct expression
*expr
)
347 expr
= strip_expr(expr
);
348 if (!expr
|| expr
->type
!= EXPR_PREOP
|| expr
->op
!= '*')
356 struct expression
*get_array_name(struct expression
*expr
)
360 return strip_expr(expr
->unop
->left
);
363 struct expression
*get_array_offset(struct expression
*expr
)
367 return expr
->unop
->right
;
370 const char *show_state(struct smatch_state
*state
)
377 struct statement
*get_expression_statement(struct expression
*expr
)
379 /* What are those things called? if (({....; ret;})) { ...*/
381 if (expr
->type
!= EXPR_PREOP
)
385 if (expr
->unop
->type
!= EXPR_STATEMENT
)
387 if (expr
->unop
->statement
->type
!= STMT_COMPOUND
)
389 return expr
->unop
->statement
;
392 struct expression
*strip_parens(struct expression
*expr
)
397 if (expr
->type
== EXPR_PREOP
) {
398 if (expr
->op
== '(' && expr
->unop
->type
== EXPR_STATEMENT
&&
399 expr
->unop
->statement
->type
== STMT_COMPOUND
)
402 return strip_parens(expr
->unop
);
407 struct expression
*strip_expr(struct expression
*expr
)
412 switch (expr
->type
) {
413 case EXPR_FORCE_CAST
:
415 return strip_expr(expr
->cast_expression
);
417 if (expr
->op
== '(' && expr
->unop
->type
== EXPR_STATEMENT
&&
418 expr
->unop
->statement
->type
== STMT_COMPOUND
)
421 return strip_expr(expr
->unop
);
426 static void delete_state_tracker(struct tracker
*t
)
428 delete_state(t
->owner
, t
->name
, t
->sym
);
432 void scoped_state(int my_id
, const char *name
, struct symbol
*sym
)
436 t
= alloc_tracker(my_id
, name
, sym
);
437 add_scope_hook((scope_hook
*)&delete_state_tracker
, t
);
440 int is_error_return(struct expression
*expr
)
442 struct symbol
*cur_func
= cur_func_sym
;
447 if (cur_func
->type
!= SYM_NODE
)
449 cur_func
= get_base_type(cur_func
);
450 if (cur_func
->type
!= SYM_FN
)
452 cur_func
= get_base_type(cur_func
);
453 if (cur_func
== &void_ctype
)
455 if (!get_implied_value(expr
, &sval
))
459 if (cur_func
->type
== SYM_PTR
&& sval
.value
== 0)
464 int getting_address(void)
466 struct expression
*tmp
;
470 FOR_EACH_PTR_REVERSE(big_expression_stack
, tmp
) {
473 if (tmp
->type
== EXPR_PREOP
&& tmp
->op
== '(')
475 if (tmp
->op
== '.' && !dot_ops
++)
480 } END_FOR_EACH_PTR_REVERSE(tmp
);
484 char *get_member_name(struct expression
*expr
)
489 expr
= strip_expr(expr
);
490 if (expr
->type
!= EXPR_DEREF
)
492 sym
= get_type(expr
->deref
);
495 /* FIXME: HACK! Sparse isn't storing the names of unions... Just take last member */
496 if (sym
->type
== SYM_UNION
) {
499 FOR_EACH_PTR_REVERSE(sym
->symbol_list
, tmp
) {
501 const char *member_name
;
504 member_name
= expr
->member
->name
;
506 member_name
= "unknown_member";
507 snprintf(buf
, sizeof(buf
), "(union hack %s)->%s", tmp
->ident
->name
, member_name
);
508 return alloc_string(buf
);
510 } END_FOR_EACH_PTR_REVERSE(tmp
);
513 if (!sym
->ident
|| !expr
->member
)
515 snprintf(buf
, sizeof(buf
), "(struct %s)->%s", sym
->ident
->name
, expr
->member
->name
);
516 return alloc_string(buf
);
519 int positions_eq(struct position pos1
, struct position pos2
)
521 if (pos1
.line
!= pos2
.line
)
523 if (pos1
.pos
!= pos2
.pos
)
525 if (pos1
.stream
!= pos2
.stream
)
530 struct statement
*get_current_statement(void)
532 struct statement
*prev
, *tmp
;
534 prev
= last_ptr_list((struct ptr_list
*)big_statement_stack
);
536 if (!prev
|| !get_macro_name(prev
->pos
))
539 FOR_EACH_PTR_REVERSE(big_statement_stack
, tmp
) {
540 if (positions_eq(tmp
->pos
, prev
->pos
))
542 if (prev
->pos
.line
> tmp
->pos
.line
)
545 } END_FOR_EACH_PTR_REVERSE(tmp
);
549 int get_param_num_from_sym(struct symbol
*sym
)
558 FOR_EACH_PTR(cur_func_sym
->ctype
.base_type
->arguments
, tmp
) {
562 } END_FOR_EACH_PTR(tmp
);
566 int get_param_num(struct expression
*expr
)
573 name
= expr_to_var_sym(expr
, &sym
);
577 return get_param_num_from_sym(sym
);
580 int ms_since(struct timeval
*start
)
585 gettimeofday(&end
, NULL
);
586 diff
= (end
.tv_sec
- start
->tv_sec
) * 1000.0;
587 diff
+= (end
.tv_usec
- start
->tv_usec
) / 1000.0;