2 #include "smatch_extra.h"
4 DECLARE_ALLOCATOR(sname
);
5 __ALLOCATOR(struct expression
, "temporary expr", tmp_expression
);
7 static struct position
get_cur_pos(void)
9 static struct position pos
;
10 static struct position none
;
11 struct expression
*expr
;
12 struct statement
*stmt
;
14 expr
= last_ptr_list((struct ptr_list
*)big_expression_stack
);
15 stmt
= last_ptr_list((struct ptr_list
*)big_statement_stack
);
25 struct expression
*alloc_tmp_expression(struct position pos
, int type
)
27 struct expression
*expr
;
29 expr
= __alloc_tmp_expression(0);
30 expr
->smatch_flags
|= Tmp
;
36 void free_tmp_expressions(void)
38 clear_tmp_expression_alloc();
41 struct expression
*zero_expr(void)
43 struct expression
*zero
;
45 zero
= alloc_tmp_expression(get_cur_pos(), EXPR_VALUE
);
47 zero
->ctype
= &int_ctype
;
51 struct expression
*value_expr(long long val
)
53 struct expression
*expr
;
58 expr
= alloc_tmp_expression(get_cur_pos(), EXPR_VALUE
);
60 expr
->ctype
= &llong_ctype
;
64 struct expression
*member_expression(struct expression
*deref
, int op
, struct ident
*member
)
66 struct expression
*expr
;
68 expr
= alloc_tmp_expression(deref
->pos
, EXPR_DEREF
);
71 expr
->member
= member
;
72 expr
->member_offset
= -1;
76 struct expression
*preop_expression(struct expression
*expr
, int op
)
78 struct expression
*preop
;
80 preop
= alloc_tmp_expression(expr
->pos
, EXPR_PREOP
);
86 struct expression
*deref_expression(struct expression
*expr
)
88 if (expr
->type
== EXPR_BINOP
)
89 expr
= preop_expression(expr
, '(');
90 return preop_expression(expr
, '*');
93 struct expression
*assign_expression(struct expression
*left
, int op
, struct expression
*right
)
95 struct expression
*expr
;
100 /* FIXME: make this a tmp expression. */
101 expr
= alloc_expression(right
->pos
, EXPR_ASSIGNMENT
);
108 struct expression
*binop_expression(struct expression
*left
, int op
, struct expression
*right
)
110 struct expression
*expr
;
112 expr
= alloc_tmp_expression(right
->pos
, EXPR_BINOP
);
119 struct expression
*array_element_expression(struct expression
*array
, struct expression
*offset
)
121 struct expression
*expr
;
123 expr
= binop_expression(array
, '+', offset
);
124 return deref_expression(expr
);
127 struct expression
*symbol_expression(struct symbol
*sym
)
129 struct expression
*expr
;
131 expr
= alloc_tmp_expression(sym
->pos
, EXPR_SYMBOL
);
133 expr
->symbol_name
= sym
->ident
;
137 struct expression
*compare_expression(struct expression
*left
, int op
, struct expression
*right
)
139 struct expression
*expr
;
144 expr
= alloc_tmp_expression(get_cur_pos(), EXPR_COMPARE
);
151 struct expression
*gen_string_expression(char *str
)
153 struct expression
*ret
;
154 struct string
*string
;
157 len
= strlen(str
) + 1;
158 string
= (void *)__alloc_sname(4 + len
);
159 string
->length
= len
;
160 string
->immutable
= 0;
161 memcpy(string
->data
, str
, len
);
163 ret
= alloc_tmp_expression(get_cur_pos(), EXPR_STRING
);
165 ret
->string
= string
;
170 struct expression
*call_expression(struct expression
*fn
, struct expression_list
*args
)
172 struct expression
*expr
;
174 expr
= alloc_tmp_expression(fn
->pos
, EXPR_CALL
);
181 static struct expression
*get_expression_from_base_and_str(struct expression
*base
, const char *addition
)
183 struct expression
*ret
= NULL
;
184 struct token
*token
, *prev
, *end
;
187 if (addition
[0] == '\0')
190 alloc
= alloc_string_newline(addition
);
192 token
= tokenize_buffer(alloc
, strlen(alloc
), &end
);
195 if (token_type(token
) != TOKEN_STREAMBEGIN
)
200 while (token_type(token
) == TOKEN_SPECIAL
&&
201 (token
->special
== SPECIAL_DEREFERENCE
|| token
->special
== '.')) {
204 if (token_type(token
) != TOKEN_IDENT
)
206 switch (prev
->special
) {
207 case SPECIAL_DEREFERENCE
:
208 ret
= deref_expression(ret
);
209 ret
= member_expression(ret
, '*', token
->ident
);
212 ret
= member_expression(ret
, '.', token
->ident
);
220 if (token_type(token
) != TOKEN_STREAMEND
)
229 static struct expression
*gen_expression_from_name_sym_helper(const char *name
, struct symbol
*sym
)
231 struct expression
*ret
;
234 if (name
[0] == '&' ||
237 ret
= gen_expression_from_name_sym_helper(name
+ 1, sym
);
238 return preop_expression(ret
, name
[0]);
240 while (name
[skip
] != '\0' && name
[skip
] != '.' && name
[skip
] != '-')
243 return get_expression_from_base_and_str(symbol_expression(sym
), name
+ skip
);
246 struct expression
*gen_expression_from_name_sym(const char *name
, struct symbol
*sym
)
248 struct expression
*ret
;
250 ret
= gen_expression_from_name_sym_helper(name
, sym
);
252 char *new = expr_to_str(ret
);
255 * FIXME: this sometimes changes "foo->bar.a.b->c" into
256 * "foo->bar.a.b.c". I don't know why... :(
259 if (!new || strcmp(name
, new) != 0)
265 struct expression
*gen_expression_from_key(struct expression
*arg
, const char *key
)
267 struct expression
*ret
;
268 struct token
*token
, *prev
, *end
;
274 /* The idea is that we can parse either $0->foo or $->foo */
278 while (*p
>= '0' && *p
<= '9')
280 len
= snprintf(buf
, sizeof(buf
), "%s\n", p
);
281 alloc
= alloc_string(buf
);
283 token
= tokenize_buffer(alloc
, len
, &end
);
286 if (token_type(token
) != TOKEN_STREAMBEGIN
)
291 while (token_type(token
) == TOKEN_SPECIAL
&&
292 (token
->special
== SPECIAL_DEREFERENCE
|| token
->special
== '.')) {
295 if (token_type(token
) != TOKEN_IDENT
)
297 ret
= deref_expression(ret
);
298 ret
= member_expression(ret
,
299 (prev
->special
== SPECIAL_DEREFERENCE
) ? '*' : '.',
304 if (token_type(token
) != TOKEN_STREAMEND
)
310 struct expression
*gen_expr_from_param_key(struct expression
*expr
, int param
, const char *key
)
312 struct expression
*ret
= NULL
;
316 name
= get_name_sym_from_key(expr
, param
, key
, &sym
);
320 ret
= gen_expression_from_name_sym(name
, sym
);
326 bool is_fake_var(struct expression
*expr
)
328 if (expr
&& (expr
->smatch_flags
& Fake
))
333 struct expression
*fake_variable(struct symbol
*type
, const char *name
)
335 struct symbol
*sym
, *node
;
336 struct expression
*ret
;
342 ident
= alloc_ident(name
, strlen(name
));
344 sym
= alloc_symbol(get_cur_pos(), type
->type
);
346 sym
->ctype
.base_type
= type
;
347 sym
->ctype
.modifiers
|= MOD_AUTO
;
349 node
= alloc_symbol(get_cur_pos(), SYM_NODE
);
351 node
->ctype
.base_type
= type
;
352 node
->ctype
.modifiers
|= MOD_AUTO
;
354 ret
= symbol_expression(node
);
355 ret
->smatch_flags
|= Fake
;
360 void expr_set_parent_expr(struct expression
*expr
, struct expression
*parent
)
364 if (parent
&& parent
->smatch_flags
& Tmp
)
367 expr
->parent
= (unsigned long)parent
| 0x1UL
;
370 void expr_set_parent_stmt(struct expression
*expr
, struct statement
*parent
)
374 expr
->parent
= (unsigned long)parent
;
377 struct expression
*expr_get_parent_expr(struct expression
*expr
)
379 struct expression
*parent
;
383 if (!(expr
->parent
& 0x1UL
))
386 parent
= (struct expression
*)(expr
->parent
& ~0x1UL
);
387 if (parent
&& (parent
->smatch_flags
& Fake
))
388 return expr_get_parent_expr(parent
);
392 struct expression
*expr_get_fake_parent_expr(struct expression
*expr
)
394 struct expression
*parent
;
398 if (!(expr
->parent
& 0x1UL
))
401 parent
= (struct expression
*)(expr
->parent
& ~0x1UL
);
402 if (parent
&& (parent
->smatch_flags
& Fake
))
407 struct statement
*expr_get_parent_stmt(struct expression
*expr
)
411 if (expr
->parent
& 0x1UL
)
413 return (struct statement
*)expr
->parent
;