4 * Copyright (C) 2003 Transmeta Corp.
7 * Licensed under the Open Software License version 1.1
9 * This is the expression parsing part of parsing C.
24 #include "expression.h"
27 static int match_oplist(int op
, ...)
33 int nextop
= va_arg(args
, int);
41 static struct token
*comma_expression(struct token
*, struct expression
**);
43 struct token
*parens_expression(struct token
*token
, struct expression
**expr
, const char *where
)
45 token
= expect(token
, '(', where
);
46 if (match_op(token
, '{')) {
47 struct expression
*e
= alloc_expression(token
->pos
, EXPR_STATEMENT
);
48 struct statement
*stmt
= alloc_statement(token
->pos
, STMT_COMPOUND
);
52 token
= compound_statement(token
->next
, stmt
);
54 token
= expect(token
, '}', "at end of statement expression");
56 token
= parse_expression(token
, expr
);
57 return expect(token
, ')', where
);
60 static struct token
*string_expression(struct token
*token
, struct expression
*expr
)
62 struct string
*string
= token
->string
;
63 struct token
*next
= token
->next
;
65 if (token_type(next
) == TOKEN_STRING
) {
66 int totlen
= string
->length
;
70 totlen
+= next
->string
->length
-1;
72 } while (token_type(next
) == TOKEN_STRING
);
74 string
= __alloc_string(totlen
);
75 string
->length
= totlen
;
79 struct string
*s
= next
->string
;
83 memcpy(data
, s
->data
, len
);
85 } while (token_type(next
) == TOKEN_STRING
);
87 expr
->string
= string
;
91 static void get_fp_value(struct expression
*expr
, struct token
*token
)
95 expr
->ctype
= &double_ctype
;
98 warn(token
->pos
, "FP values not yet implemented");
103 static void get_number_value(struct expression
*expr
, struct token
*token
)
105 const char *str
= token
->number
;
106 unsigned long long value
= 0;
107 unsigned int base
= 10, digit
, bits
;
108 unsigned long modifiers
, extramod
;
113 base
= 18; // the -= 2 for the octal case will
114 str
++; // skip the '0'
117 str
++; // skip the '0' or 'x/X'
118 base
-= 2; // the fall-through will make this 8
128 value
= value
* base
+ digit
;
134 if (c
== 'u' || c
== 'U') {
135 modifiers
|= MOD_UNSIGNED
;
138 if (c
== 'l' || c
== 'L') {
139 if (modifiers
& MOD_LONG
)
140 modifiers
|= MOD_LONGLONG
;
141 modifiers
|= MOD_LONG
;
145 get_fp_value(expr
, token
);
151 bits
= bits_in_longlong
;
153 if (!(modifiers
& MOD_LONGLONG
)) {
154 if (value
& (~1ULL << (bits_in_long
-1))) {
155 extramod
= MOD_LONGLONG
| MOD_LONG
;
158 if (!(modifiers
& MOD_LONG
)) {
159 if (value
& (~1ULL << (bits_in_int
-1))) {
166 if (!(modifiers
& MOD_UNSIGNED
)) {
167 if (value
& (1ULL << (bits
-1))) {
168 extramod
|= MOD_UNSIGNED
;
173 * Special case: "int" gets promoted directly to "long"
174 * for normal decimal numbers..
176 modifiers
|= extramod
;
177 if (base
== 10 && modifiers
== MOD_UNSIGNED
) {
178 modifiers
= MOD_LONG
;
179 if (bits_in_long
== bits_in_int
)
180 modifiers
= MOD_LONG
| MOD_UNSIGNED
;
183 /* Hex or octal constants don't complain about missing signedness */
184 if (base
== 10 || extramod
!= MOD_UNSIGNED
)
185 warn(expr
->pos
, "constant %s is so big it is%s%s%s",
187 (modifiers
& MOD_UNSIGNED
) ? " unsigned":"",
188 (modifiers
& MOD_LONG
) ? " long":"",
189 (modifiers
& MOD_LONGLONG
) ? " long":"");
192 expr
->type
= EXPR_VALUE
;
193 expr
->ctype
= ctype_integer(modifiers
);
197 struct token
*primary_expression(struct token
*token
, struct expression
**tree
)
199 struct expression
*expr
= NULL
;
201 switch (token_type(token
)) {
203 expr
= alloc_expression(token
->pos
, EXPR_VALUE
);
204 expr
->ctype
= &int_ctype
;
205 expr
->value
= (unsigned char) token
->character
;
210 expr
= alloc_expression(token
->pos
, EXPR_VALUE
);
211 get_number_value(expr
, token
);
216 struct symbol
*sym
= lookup_symbol(token
->ident
, NS_SYMBOL
| NS_TYPEDEF
);
217 struct token
*next
= token
->next
;
219 expr
= alloc_expression(token
->pos
, EXPR_SYMBOL
);
222 * We support types as real first-class citizens, with type
225 * if (typeof(a) == int) ..
227 if (sym
&& sym
->namespace == NS_TYPEDEF
) {
228 warn(token
->pos
, "typename in expression");
231 expr
->symbol_name
= token
->ident
;
238 expr
= alloc_expression(token
->pos
, EXPR_STRING
);
239 token
= string_expression(token
, expr
);
244 if (token
->special
== '(') {
245 expr
= alloc_expression(token
->pos
, EXPR_PREOP
);
247 token
= parens_expression(token
, &expr
->unop
, "in expression");
250 if (token
->special
== '[' && lookup_type(token
->next
)) {
251 expr
= alloc_expression(token
->pos
, EXPR_TYPE
);
252 token
= typename(token
->next
, &expr
->symbol
);
253 token
= expect(token
, ']', "in type expression");
264 static struct token
*expression_list(struct token
*token
, struct expression_list
**list
)
266 while (!match_op(token
, ')')) {
267 struct expression
*expr
= NULL
;
268 token
= assignment_expression(token
, &expr
);
271 add_expression(list
, expr
);
272 if (!match_op(token
, ','))
280 * extend to deal with the ambiguous C grammar for parsing
281 * a cast expressions followed by an initializer.
283 static struct token
*postfix_expression(struct token
*token
, struct expression
**tree
, struct expression
*cast_init_expr
)
285 struct expression
*expr
= cast_init_expr
;
288 token
= primary_expression(token
, &expr
);
290 while (expr
&& token_type(token
) == TOKEN_SPECIAL
) {
291 switch (token
->special
) {
292 case '[': { /* Array dereference */
293 struct expression
*deref
= alloc_expression(token
->pos
, EXPR_PREOP
);
294 struct expression
*add
= alloc_expression(token
->pos
, EXPR_BINOP
);
301 token
= parse_expression(token
->next
, &add
->right
);
302 token
= expect(token
, ']', "at end of array dereference");
306 case SPECIAL_INCREMENT
: /* Post-increment */
307 case SPECIAL_DECREMENT
: { /* Post-decrement */
308 struct expression
*post
= alloc_expression(token
->pos
, EXPR_POSTOP
);
309 post
->op
= token
->special
;
315 case SPECIAL_DEREFERENCE
: { /* Structure pointer member dereference */
316 /* "x->y" is just shorthand for "(*x).y" */
317 struct expression
*inner
= alloc_expression(token
->pos
, EXPR_PREOP
);
323 case '.': { /* Structure member dereference */
324 struct expression
*deref
= alloc_expression(token
->pos
, EXPR_DEREF
);
328 if (token_type(token
) != TOKEN_IDENT
) {
329 warn(token
->pos
, "Expected member name");
332 deref
->member
= token
->ident
;
338 case '(': { /* Function call */
339 struct expression
*call
= alloc_expression(token
->pos
, EXPR_CALL
);
342 token
= expression_list(token
->next
, &call
->args
);
343 token
= expect(token
, ')', "in function call");
357 static struct token
*cast_expression(struct token
*token
, struct expression
**tree
);
358 static struct token
*unary_expression(struct token
*token
, struct expression
**tree
)
360 if (token_type(token
) == TOKEN_IDENT
&&
361 (token
->ident
== &sizeof_ident
||
362 token
->ident
== &__alignof___ident
)) {
363 struct expression
*sizeof_ex
= alloc_expression(token
->pos
, EXPR_SIZEOF
);
365 tree
= &sizeof_ex
->unop
;
367 if (!match_op(token
, '(') || !lookup_type(token
->next
))
368 return unary_expression(token
, &sizeof_ex
->cast_expression
);
369 token
= typename(token
->next
, &sizeof_ex
->cast_type
);
370 return expect(token
, ')', "at end of sizeof type-name");
373 if (token_type(token
) == TOKEN_SPECIAL
) {
374 if (match_oplist(token
->special
,
375 SPECIAL_INCREMENT
, SPECIAL_DECREMENT
,
376 '&', '*', '+', '-', '~', '!', 0)) {
377 struct expression
*unop
;
378 struct expression
*unary
;
381 next
= cast_expression(token
->next
, &unop
);
383 warn(token
->pos
, "Syntax error in unary expression");
386 unary
= alloc_expression(token
->pos
, EXPR_PREOP
);
387 unary
->op
= token
->special
;
393 /* Gcc extension: &&label gives the address of a label */
394 if (match_op(token
, SPECIAL_LOGICAL_AND
) &&
395 token_type(token
->next
) == TOKEN_IDENT
) {
396 struct expression
*label
= alloc_expression(token
->pos
, EXPR_LABEL
);
397 label
->label_symbol
= label_symbol(token
->next
);
399 return token
->next
->next
;
404 return postfix_expression(token
, tree
, NULL
);
408 * Ambiguity: a '(' can be either a cast-expression or
409 * a primary-expression depending on whether it is followed
412 * additional ambiguity: a "cast expression" followed by
413 * an initializer is really a postfix-expression.
415 static struct token
*cast_expression(struct token
*token
, struct expression
**tree
)
417 if (match_op(token
, '(')) {
418 struct token
*next
= token
->next
;
419 if (lookup_type(next
)) {
420 struct expression
*cast
= alloc_expression(next
->pos
, EXPR_CAST
);
423 token
= typename(next
, &sym
);
424 cast
->cast_type
= sym
;
425 token
= expect(token
, ')', "at end of cast operator");
426 if (match_op(token
, '{')) {
427 token
= initializer(&cast
->cast_expression
, token
);
428 return postfix_expression(token
, tree
, cast
);
431 token
= cast_expression(token
, &cast
->cast_expression
);
435 return unary_expression(token
, tree
);
438 /* Generic left-to-right binop parsing */
439 static struct token
*lr_binop_expression(struct token
*token
, struct expression
**tree
,
440 enum expression_type type
, struct token
*(*inner
)(struct token
*, struct expression
**), ...)
442 struct expression
*left
= NULL
;
443 struct token
* next
= inner(token
, &left
);
446 while (token_type(next
) == TOKEN_SPECIAL
) {
447 struct expression
*top
, *right
= NULL
;
448 int op
= next
->special
;
451 va_start(args
, inner
);
453 int nextop
= va_arg(args
, int);
460 top
= alloc_expression(next
->pos
, type
);
461 next
= inner(next
->next
, &right
);
463 warn(next
->pos
, "No right hand side of '%s'-expression", show_special(op
));
477 static struct token
*multiplicative_expression(struct token
*token
, struct expression
**tree
)
479 return lr_binop_expression(token
, tree
, EXPR_BINOP
, cast_expression
, '*', '/', '%', 0);
482 static struct token
*additive_expression(struct token
*token
, struct expression
**tree
)
484 return lr_binop_expression(token
, tree
, EXPR_BINOP
, multiplicative_expression
, '+', '-', 0);
487 static struct token
*shift_expression(struct token
*token
, struct expression
**tree
)
489 return lr_binop_expression(token
, tree
, EXPR_BINOP
, additive_expression
, SPECIAL_LEFTSHIFT
, SPECIAL_RIGHTSHIFT
, 0);
492 static struct token
*relational_expression(struct token
*token
, struct expression
**tree
)
494 return lr_binop_expression(token
, tree
, EXPR_COMPARE
, shift_expression
, '<', '>', SPECIAL_LTE
, SPECIAL_GTE
, 0);
497 static struct token
*equality_expression(struct token
*token
, struct expression
**tree
)
499 return lr_binop_expression(token
, tree
, EXPR_COMPARE
, relational_expression
, SPECIAL_EQUAL
, SPECIAL_NOTEQUAL
, 0);
502 static struct token
*bitwise_and_expression(struct token
*token
, struct expression
**tree
)
504 return lr_binop_expression(token
, tree
, EXPR_BINOP
, equality_expression
, '&', 0);
507 static struct token
*bitwise_xor_expression(struct token
*token
, struct expression
**tree
)
509 return lr_binop_expression(token
, tree
, EXPR_BINOP
, bitwise_and_expression
, '^', 0);
512 static struct token
*bitwise_or_expression(struct token
*token
, struct expression
**tree
)
514 return lr_binop_expression(token
, tree
, EXPR_BINOP
, bitwise_xor_expression
, '|', 0);
517 static struct token
*logical_and_expression(struct token
*token
, struct expression
**tree
)
519 return lr_binop_expression(token
, tree
, EXPR_LOGICAL
, bitwise_or_expression
, SPECIAL_LOGICAL_AND
, 0);
522 static struct token
*logical_or_expression(struct token
*token
, struct expression
**tree
)
524 return lr_binop_expression(token
, tree
, EXPR_LOGICAL
, logical_and_expression
, SPECIAL_LOGICAL_OR
, 0);
527 struct token
*conditional_expression(struct token
*token
, struct expression
**tree
)
529 token
= logical_or_expression(token
, tree
);
530 if (match_op(token
, '?')) {
531 struct expression
*expr
= alloc_expression(token
->pos
, EXPR_CONDITIONAL
);
532 expr
->op
= token
->special
;
535 token
= parse_expression(token
->next
, &expr
->cond_true
);
536 token
= expect(token
, ':', "in conditional expression");
537 token
= conditional_expression(token
, &expr
->cond_false
);
542 struct token
*assignment_expression(struct token
*token
, struct expression
**tree
)
544 token
= conditional_expression(token
, tree
);
545 if (token_type(token
) == TOKEN_SPECIAL
) {
546 static const int assignments
[] = {
548 SPECIAL_ADD_ASSIGN
, SPECIAL_SUB_ASSIGN
,
549 SPECIAL_MUL_ASSIGN
, SPECIAL_DIV_ASSIGN
,
550 SPECIAL_MOD_ASSIGN
, SPECIAL_SHL_ASSIGN
,
551 SPECIAL_SHR_ASSIGN
, SPECIAL_AND_ASSIGN
,
552 SPECIAL_OR_ASSIGN
, SPECIAL_XOR_ASSIGN
};
553 int i
, op
= token
->special
;
554 for (i
= 0; i
< sizeof(assignments
)/sizeof(int); i
++)
555 if (assignments
[i
] == op
) {
556 struct expression
* expr
= alloc_expression(token
->pos
, EXPR_ASSIGNMENT
);
560 return assignment_expression(token
->next
, &expr
->right
);
566 static struct token
*comma_expression(struct token
*token
, struct expression
**tree
)
568 return lr_binop_expression(token
, tree
, EXPR_COMMA
, assignment_expression
, ',', 0);
571 struct token
*parse_expression(struct token
*token
, struct expression
**tree
)
573 return comma_expression(token
,tree
);