2 * sparse/smatch_helper.c
4 * Copyright (C) 2006 Dan Carpenter.
6 * Licensed under the Open Software License version 1.1
15 static int star_count
;
19 char *alloc_string(const char *str
)
25 tmp
= malloc(strlen(str
) + 1);
30 void free_string(char *str
)
35 static void prepend(char *dest
, const char *data
, int buff_len
)
40 space_needed
= strlen(data
);
41 for (i
= buff_len
- space_needed
- 1; i
>= 0 ; i
--)
42 dest
[i
+ space_needed
] = dest
[i
];
43 for (i
= 0; i
< space_needed
% buff_len
; i
++)
45 dest
[buff_len
- 1] = '\0';
49 * If you have "foo(a, b, 1);" then use
50 * get_argument_from_call_expr(expr, 0) to return the expression for
51 * a. Yes, it does start counting from 0.
53 struct expression
*get_argument_from_call_expr(struct expression_list
*args
,
56 struct expression
*expr
;
62 FOR_EACH_PTR(args
, expr
) {
66 } END_FOR_EACH_PTR(expr
);
70 static void __get_variable_from_expr(struct symbol
**sym_ptr
, char *buf
,
71 struct expression
*expr
, int len
,
76 prepend(buf
, expr
->member
->name
, len
);
77 if (!strcmp(show_special(expr
->deref
->op
), "*"))
78 prepend(buf
, "->", len
);
80 prepend(buf
, ".", len
);
82 //printf("debug: %d\n", expr->deref
84 __get_variable_from_expr(sym_ptr
, buf
, expr
->deref
,
88 if (expr
->symbol_name
)
89 prepend(buf
, expr
->symbol_name
->name
, len
);
93 *sym_ptr
= expr
->symbol
;
99 if (get_block_thing(expr
)) {
107 __get_variable_from_expr(sym_ptr
, buf
, expr
->unop
,
109 tmp
= show_special(expr
->op
);
111 if (star_count
-- >= 0) {
112 prepend(buf
, tmp
, len
);
115 prepend(buf
, tmp
, len
);
119 strncat(buf
, ")", len
);
123 if ((!strcmp(tmp
, "--")) || (!strcmp(tmp
, "++")))
131 tmp
= show_special(expr
->op
);
132 prepend(buf
, tmp
, len
);
133 __get_variable_from_expr(sym_ptr
, buf
, expr
->unop
,
136 if ((!strcmp(tmp
, "--")) || (!strcmp(tmp
, "++")))
145 prepend(buf
, ")", len
);
146 __get_variable_from_expr(NULL
, buf
, expr
->right
, len
,
148 tmp
= show_special(expr
->op
);
149 prepend(buf
, tmp
, len
);
150 __get_variable_from_expr(sym_ptr
, buf
, expr
->left
,
152 prepend(buf
, "(", len
);
158 snprintf(tmp
, 25, "%lld", expr
->value
);
159 prepend(buf
, tmp
, len
);
163 prepend(buf
, expr
->string
->data
, len
);
166 struct expression
*tmp
;
170 prepend(buf
, ")", len
);
171 FOR_EACH_PTR_REVERSE(expr
->args
, tmp
) {
173 prepend(buf
, ", ", len
);
174 __get_variable_from_expr(NULL
, buf
, tmp
, len
,
176 } END_FOR_EACH_PTR_REVERSE(tmp
);
177 prepend(buf
, "(", len
);
178 __get_variable_from_expr(NULL
, buf
, expr
->fn
, len
,
183 __get_variable_from_expr(sym_ptr
, buf
,
184 expr
->cast_expression
, len
,
191 if (expr
->cast_type
&& get_base_type(expr
->cast_type
)) {
192 size
= (get_base_type(expr
->cast_type
))->bit_size
;
193 snprintf(tmp
, 25, "%d", size
);
194 prepend(buf
, tmp
, len
);
200 //printf("unknown type = %d\n", expr->type);
207 * This is returns a stylized "c looking" representation of the
210 * It uses the same buffer every time so you have to save the result
211 * yourself if you want to keep it.
215 char *get_variable_from_expr_complex(struct expression
*expr
, struct symbol
**sym_ptr
)
217 static char var_name
[VAR_LEN
];
227 __get_variable_from_expr(sym_ptr
, var_name
, expr
, sizeof(var_name
),
230 return alloc_string(var_name
);
236 * get_variable_from_expr_simple() only returns simple variables.
237 * If it's a complicated variable like a->foo instead of just 'a'
238 * then it returns NULL.
241 char *get_variable_from_expr(struct expression
*expr
,
242 struct symbol
**sym_ptr
)
244 static char var_name
[VAR_LEN
];
254 expr
= strip_expr(expr
);
255 __get_variable_from_expr(sym_ptr
, var_name
, expr
, sizeof(var_name
),
263 return alloc_string(var_name
);
266 int sym_name_is(const char *name
, struct expression
*expr
)
270 if (expr
->type
!= EXPR_SYMBOL
)
272 if (!strcmp(expr
->symbol_name
->name
, name
))
277 static int _get_value(struct expression
*expr
, int *discard
)
289 expr
= strip_expr(expr
);
296 if (!strcmp("-", show_special(expr
->op
)))
297 ret
= - _get_value(expr
->unop
, discard
);
304 if (!show_special(expr
->op
)) {
308 left
= _get_value(expr
->left
, discard
);
309 right
= _get_value(expr
->right
, discard
);
310 if (!strcmp("*", show_special(expr
->op
))) {
312 } else if (!strcmp("/", show_special(expr
->op
))) {
314 } else if (!strcmp("+", show_special(expr
->op
))) {
316 } else if (!strcmp("-", show_special(expr
->op
))) {
318 } else if (!strcmp("|", show_special(expr
->op
))) {
326 if (expr
->cast_type
&& get_base_type(expr
->cast_type
))
327 ret
= (get_base_type(expr
->cast_type
))->bit_size
/ 8;
332 //printf("ouchies-->%d\n", expr->type);
340 int get_value(struct expression
*expr
)
342 return _get_value(expr
, NULL
);
345 int is_zero(struct expression
*expr
)
347 if (get_value(expr
) == 0)
352 const char *show_state(struct smatch_state
*state
)
359 struct statement
*get_block_thing(struct expression
*expr
)
361 /* What are those things called? if (({....; ret;})) { ...*/
363 if (expr
->type
!= EXPR_PREOP
)
367 if (expr
->unop
->type
!= EXPR_STATEMENT
)
369 if (expr
->unop
->statement
->type
!= STMT_COMPOUND
)
371 return expr
->unop
->statement
;
374 struct expression
*strip_expr(struct expression
*expr
)
381 return strip_expr(expr
->cast_expression
);
383 if (expr
->op
== '(' && expr
->unop
->type
== EXPR_STATEMENT
&&
384 expr
->unop
->statement
->type
== STMT_COMPOUND
)
387 return strip_expr(expr
->unop
);