Print this page
new smatch
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/smatch/src/expression.c
+++ new/usr/src/tools/smatch/src/expression.c
1 1 /*
2 2 * sparse/expression.c
3 3 *
4 4 * Copyright (C) 2003 Transmeta Corp.
5 5 * 2003-2004 Linus Torvalds
6 6 *
7 7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 8 * of this software and associated documentation files (the "Software"), to deal
9 9 * in the Software without restriction, including without limitation the rights
10 10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 11 * copies of the Software, and to permit persons to whom the Software is
12 12 * furnished to do so, subject to the following conditions:
13 13 *
14 14 * The above copyright notice and this permission notice shall be included in
15 15 * all copies or substantial portions of the Software.
16 16 *
17 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 23 * THE SOFTWARE.
24 24 *
25 25 * This is the expression parsing part of parsing C.
26 26 */
27 27 #include <stdarg.h>
28 28 #include <stdlib.h>
29 29 #include <stdio.h>
30 30 #include <string.h>
31 31 #include <ctype.h>
32 32 #include <unistd.h>
33 33 #include <fcntl.h>
34 34 #include <errno.h>
35 35 #include <limits.h>
36 36
37 37 #include "lib.h"
38 38 #include "allocate.h"
39 39 #include "token.h"
40 40 #include "parse.h"
41 41 #include "symbol.h"
42 42 #include "scope.h"
43 43 #include "expression.h"
44 44 #include "target.h"
45 45 #include "char.h"
46 46
47 47 static int match_oplist(int op, ...)
48 48 {
49 49 va_list args;
50 50 int nextop;
51 51
52 52 va_start(args, op);
53 53 do {
54 54 nextop = va_arg(args, int);
|
↓ open down ↓ |
54 lines elided |
↑ open up ↑ |
55 55 } while (nextop != 0 && nextop != op);
56 56 va_end(args);
57 57
58 58 return nextop != 0;
59 59 }
60 60
61 61 static struct token *comma_expression(struct token *, struct expression **);
62 62
63 63 struct token *parens_expression(struct token *token, struct expression **expr, const char *where)
64 64 {
65 + struct token *p;
66 +
65 67 token = expect(token, '(', where);
68 + p = token;
66 69 if (match_op(token, '{')) {
67 70 struct expression *e = alloc_expression(token->pos, EXPR_STATEMENT);
68 71 struct statement *stmt = alloc_statement(token->pos, STMT_COMPOUND);
69 72 *expr = e;
70 73 e->statement = stmt;
71 74 start_symbol_scope(e->pos);
72 75 token = compound_statement(token->next, stmt);
73 76 end_symbol_scope();
74 77 token = expect(token, '}', "at end of statement expression");
75 78 } else
76 79 token = parse_expression(token, expr);
80 +
81 + if (token == p)
82 + sparse_error(token->pos, "an expression is expected before ')'");
77 83 return expect(token, ')', where);
78 84 }
79 85
80 86 /*
81 87 * Handle __func__, __FUNCTION__ and __PRETTY_FUNCTION__ token
82 88 * conversion
83 89 */
84 90 static struct symbol *handle_func(struct token *token)
85 91 {
86 92 struct ident *ident = token->ident;
87 93 struct symbol *decl, *array;
88 94 struct string *string;
89 95 int len;
90 96
91 97 if (ident != &__func___ident &&
92 98 ident != &__FUNCTION___ident &&
93 99 ident != &__PRETTY_FUNCTION___ident)
94 100 return NULL;
95 101
96 102 if (!current_fn || !current_fn->ident)
97 103 return NULL;
98 104
99 105 /* OK, it's one of ours */
100 106 array = alloc_symbol(token->pos, SYM_ARRAY);
101 107 array->ctype.base_type = &char_ctype;
102 108 array->ctype.alignment = 1;
103 109 array->endpos = token->pos;
104 110 decl = alloc_symbol(token->pos, SYM_NODE);
105 111 decl->ctype.base_type = array;
106 112 decl->ctype.alignment = 1;
107 113 decl->ctype.modifiers = MOD_STATIC;
108 114 decl->endpos = token->pos;
109 115
110 116 /* function-scope, but in NS_SYMBOL */
111 117 bind_symbol(decl, ident, NS_LABEL);
112 118 decl->namespace = NS_SYMBOL;
113 119
114 120 len = current_fn->ident->len;
115 121 string = __alloc_string(len + 1);
116 122 memcpy(string->data, current_fn->ident->name, len);
117 123 string->data[len] = 0;
118 124 string->length = len + 1;
119 125
120 126 decl->initializer = alloc_expression(token->pos, EXPR_STRING);
121 127 decl->initializer->string = string;
122 128 decl->initializer->ctype = decl;
123 129 decl->array_size = alloc_const_expression(token->pos, len + 1);
124 130 array->array_size = decl->array_size;
125 131 decl->bit_size = array->bit_size = bytes_to_bits(len + 1);
126 132
127 133 return decl;
128 134 }
129 135
130 136 static struct token *parse_type(struct token *token, struct expression **tree)
131 137 {
132 138 struct symbol *sym;
133 139 *tree = alloc_expression(token->pos, EXPR_TYPE);
134 140 token = typename(token, &sym, NULL);
135 141 if (sym->ident)
136 142 sparse_error(token->pos,
137 143 "type expression should not include identifier "
138 144 "\"%s\"", sym->ident->name);
139 145 (*tree)->symbol = sym;
140 146 return token;
141 147 }
142 148
143 149 static struct token *builtin_types_compatible_p_expr(struct token *token,
144 150 struct expression **tree)
145 151 {
146 152 struct expression *expr = alloc_expression(
147 153 token->pos, EXPR_COMPARE);
148 154 expr->op = SPECIAL_EQUAL;
149 155 token = token->next;
150 156 if (!match_op(token, '('))
151 157 return expect(token, '(',
152 158 "after __builtin_types_compatible_p");
153 159 token = token->next;
154 160 token = parse_type(token, &expr->left);
155 161 if (!match_op(token, ','))
156 162 return expect(token, ',',
157 163 "in __builtin_types_compatible_p");
158 164 token = token->next;
159 165 token = parse_type(token, &expr->right);
160 166 if (!match_op(token, ')'))
161 167 return expect(token, ')',
162 168 "at end of __builtin_types_compatible_p");
163 169 token = token->next;
164 170
165 171 *tree = expr;
166 172 return token;
167 173 }
168 174
169 175 static struct token *builtin_offsetof_expr(struct token *token,
170 176 struct expression **tree)
171 177 {
172 178 struct expression *expr = NULL;
173 179 struct expression **p = &expr;
174 180 struct symbol *sym;
175 181 int op = '.';
176 182
177 183 token = token->next;
178 184 if (!match_op(token, '('))
179 185 return expect(token, '(', "after __builtin_offset");
180 186
181 187 token = token->next;
182 188 token = typename(token, &sym, NULL);
183 189 if (sym->ident)
184 190 sparse_error(token->pos,
185 191 "type expression should not include identifier "
186 192 "\"%s\"", sym->ident->name);
187 193
188 194 if (!match_op(token, ','))
189 195 return expect(token, ',', "in __builtin_offset");
190 196
191 197 while (1) {
192 198 struct expression *e;
193 199 switch (op) {
194 200 case ')':
195 201 expr->in = sym;
196 202 *tree = expr;
197 203 default:
198 204 return expect(token, ')', "at end of __builtin_offset");
199 205 case SPECIAL_DEREFERENCE:
200 206 e = alloc_expression(token->pos, EXPR_OFFSETOF);
201 207 e->op = '[';
202 208 *p = e;
203 209 p = &e->down;
204 210 /* fall through */
205 211 case '.':
206 212 token = token->next;
207 213 e = alloc_expression(token->pos, EXPR_OFFSETOF);
208 214 e->op = '.';
209 215 if (token_type(token) != TOKEN_IDENT) {
210 216 sparse_error(token->pos, "Expected member name");
211 217 return token;
212 218 }
213 219 e->ident = token->ident;
214 220 token = token->next;
215 221 break;
216 222 case '[':
217 223 token = token->next;
218 224 e = alloc_expression(token->pos, EXPR_OFFSETOF);
219 225 e->op = '[';
220 226 token = parse_expression(token, &e->index);
221 227 token = expect(token, ']',
222 228 "at end of array dereference");
223 229 if (!e->index)
224 230 return token;
225 231 }
226 232 *p = e;
227 233 p = &e->down;
228 234 op = token_type(token) == TOKEN_SPECIAL ? token->special : 0;
229 235 }
230 236 }
231 237
232 238 #ifndef ULLONG_MAX
233 239 #define ULLONG_MAX (~0ULL)
234 240 #endif
235 241
236 242 static unsigned long long parse_num(const char *nptr, char **end)
237 243 {
238 244 if (nptr[0] == '0' && tolower((unsigned char)nptr[1]) == 'b')
239 245 return strtoull(&nptr[2], end, 2);
240 246 return strtoull(nptr, end, 0);
241 247 }
242 248
243 249 static void get_number_value(struct expression *expr, struct token *token)
244 250 {
245 251 const char *str = token->number;
246 252 unsigned long long value;
247 253 char *end;
248 254 int size = 0, want_unsigned = 0;
249 255 int overflow = 0, do_warn = 0;
250 256 int try_unsigned = 1;
251 257 int bits;
252 258
253 259 errno = 0;
254 260 value = parse_num(str, &end);
255 261 if (end == str)
256 262 goto Float;
257 263 if (value == ULLONG_MAX && errno == ERANGE)
258 264 overflow = 1;
259 265 while (1) {
260 266 char c = *end++;
261 267 if (!c) {
262 268 break;
263 269 } else if (c == 'u' || c == 'U') {
264 270 if (want_unsigned)
265 271 goto Enoint;
266 272 want_unsigned = 1;
267 273 } else if (c == 'l' || c == 'L') {
268 274 if (size)
269 275 goto Enoint;
270 276 size = 1;
271 277 if (*end == c) {
272 278 size = 2;
273 279 end++;
274 280 }
275 281 } else
276 282 goto Float;
277 283 }
278 284 if (overflow)
279 285 goto Eoverflow;
280 286 /* OK, it's a valid integer */
281 287 /* decimals can be unsigned only if directly specified as such */
282 288 if (str[0] != '0' && !want_unsigned)
283 289 try_unsigned = 0;
284 290 if (!size) {
285 291 bits = bits_in_int - 1;
286 292 if (!(value & (~1ULL << bits))) {
287 293 if (!(value & (1ULL << bits))) {
288 294 goto got_it;
289 295 } else if (try_unsigned) {
290 296 want_unsigned = 1;
291 297 goto got_it;
292 298 }
293 299 }
294 300 size = 1;
295 301 do_warn = 1;
296 302 }
297 303 if (size < 2) {
298 304 bits = bits_in_long - 1;
299 305 if (!(value & (~1ULL << bits))) {
300 306 if (!(value & (1ULL << bits))) {
301 307 goto got_it;
302 308 } else if (try_unsigned) {
303 309 want_unsigned = 1;
304 310 goto got_it;
305 311 }
306 312 do_warn |= 2;
307 313 }
308 314 size = 2;
309 315 do_warn |= 1;
310 316 }
311 317 bits = bits_in_longlong - 1;
312 318 if (value & (~1ULL << bits))
313 319 goto Eoverflow;
314 320 if (!(value & (1ULL << bits)))
315 321 goto got_it;
316 322 if (!try_unsigned)
317 323 warning(expr->pos, "decimal constant %s is too big for long long",
318 324 show_token(token));
319 325 want_unsigned = 1;
320 326 got_it:
321 327 if (do_warn && Wconstant_suffix)
322 328 warning(expr->pos, "constant %s is so big it is%s%s%s",
323 329 show_token(token),
324 330 want_unsigned ? " unsigned":"",
325 331 size > 0 ? " long":"",
326 332 size > 1 ? " long":"");
327 333 if (do_warn & 2)
328 334 warning(expr->pos,
329 335 "decimal constant %s is between LONG_MAX and ULONG_MAX."
330 336 " For C99 that means long long, C90 compilers are very "
331 337 "likely to produce unsigned long (and a warning) here",
332 338 show_token(token));
333 339 expr->type = EXPR_VALUE;
334 340 expr->flags = CEF_SET_INT;
335 341 expr->ctype = ctype_integer(size, want_unsigned);
336 342 expr->value = value;
337 343 return;
338 344 Eoverflow:
339 345 error_die(expr->pos, "constant %s is too big even for unsigned long long",
340 346 show_token(token));
341 347 return;
342 348 Float:
343 349 expr->fvalue = string_to_ld(str, &end);
344 350 if (str == end)
345 351 goto Enoint;
346 352
347 353 if (*end && end[1])
348 354 goto Enoint;
349 355
350 356 if (*end == 'f' || *end == 'F')
351 357 expr->ctype = &float_ctype;
352 358 else if (*end == 'l' || *end == 'L')
353 359 expr->ctype = &ldouble_ctype;
354 360 else if (!*end)
355 361 expr->ctype = &double_ctype;
356 362 else
357 363 goto Enoint;
358 364
359 365 expr->flags = CEF_SET_FLOAT;
360 366 expr->type = EXPR_FVALUE;
361 367 return;
362 368
363 369 Enoint:
364 370 error_die(expr->pos, "constant %s is not a valid number", show_token(token));
365 371 }
366 372
367 373 struct token *primary_expression(struct token *token, struct expression **tree)
368 374 {
369 375 struct expression *expr = NULL;
370 376
371 377 switch (token_type(token)) {
372 378 case TOKEN_CHAR ... TOKEN_WIDE_CHAR_EMBEDDED_3:
373 379 expr = alloc_expression(token->pos, EXPR_VALUE);
374 380 expr->flags = CEF_SET_CHAR;
375 381 expr->ctype = token_type(token) < TOKEN_WIDE_CHAR ? &int_ctype : &long_ctype;
376 382 get_char_constant(token, &expr->value);
377 383 token = token->next;
378 384 break;
379 385
380 386 case TOKEN_NUMBER:
381 387 expr = alloc_expression(token->pos, EXPR_VALUE);
382 388 get_number_value(expr, token); /* will see if it's an integer */
383 389 token = token->next;
384 390 break;
385 391
386 392 case TOKEN_ZERO_IDENT: {
387 393 expr = alloc_expression(token->pos, EXPR_SYMBOL);
388 394 expr->flags = CEF_SET_INT;
389 395 expr->ctype = &int_ctype;
390 396 expr->symbol = &zero_int;
391 397 expr->symbol_name = token->ident;
392 398 token = token->next;
393 399 break;
394 400 }
395 401
396 402 case TOKEN_IDENT: {
397 403 struct symbol *sym = lookup_symbol(token->ident, NS_SYMBOL | NS_TYPEDEF);
398 404 struct token *next = token->next;
399 405
400 406 if (!sym) {
401 407 sym = handle_func(token);
402 408 if (token->ident == &__builtin_types_compatible_p_ident) {
403 409 token = builtin_types_compatible_p_expr(token, &expr);
404 410 break;
405 411 }
406 412 if (token->ident == &__builtin_offsetof_ident) {
407 413 token = builtin_offsetof_expr(token, &expr);
408 414 break;
409 415 }
410 416 } else if (sym->enum_member) {
411 417 expr = alloc_expression(token->pos, EXPR_VALUE);
412 418 *expr = *sym->initializer;
413 419 /* we want the right position reported, thus the copy */
414 420 expr->pos = token->pos;
415 421 expr->flags = CEF_SET_ENUM;
416 422 token = next;
417 423 break;
418 424 }
419 425
420 426 expr = alloc_expression(token->pos, EXPR_SYMBOL);
421 427
422 428 /*
423 429 * We support types as real first-class citizens, with type
424 430 * comparisons etc:
425 431 *
426 432 * if (typeof(a) == int) ..
427 433 */
428 434 if (sym && sym->namespace == NS_TYPEDEF) {
429 435 sparse_error(token->pos, "typename in expression");
430 436 sym = NULL;
431 437 }
432 438 expr->symbol_name = token->ident;
433 439 expr->symbol = sym;
434 440
435 441 /*
436 442 * A pointer to an lvalue designating a static storage
437 443 * duration object is an address constant [6.6(9)].
438 444 */
439 445 if (sym && (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_STATIC)))
440 446 expr->flags = CEF_ADDR;
441 447
442 448 token = next;
443 449 break;
444 450 }
445 451
446 452 case TOKEN_STRING:
447 453 case TOKEN_WIDE_STRING:
448 454 expr = alloc_expression(token->pos, EXPR_STRING);
449 455 token = get_string_constant(token, expr);
450 456 break;
451 457
452 458 case TOKEN_SPECIAL:
453 459 if (token->special == '(') {
454 460 expr = alloc_expression(token->pos, EXPR_PREOP);
455 461 expr->op = '(';
456 462 token = parens_expression(token, &expr->unop, "in expression");
457 463 break;
458 464 }
459 465 if (token->special == '[' && lookup_type(token->next)) {
460 466 expr = alloc_expression(token->pos, EXPR_TYPE);
461 467 token = typename(token->next, &expr->symbol, NULL);
462 468 token = expect(token, ']', "in type expression");
463 469 break;
464 470 }
465 471
466 472 default:
467 473 ;
468 474 }
469 475 *tree = expr;
470 476 return token;
471 477 }
472 478
473 479 static struct token *expression_list(struct token *token, struct expression_list **list)
474 480 {
475 481 while (!match_op(token, ')')) {
476 482 struct expression *expr = NULL;
477 483 token = assignment_expression(token, &expr);
478 484 if (!expr)
479 485 break;
480 486 add_expression(list, expr);
481 487 if (!match_op(token, ','))
482 488 break;
483 489 token = token->next;
484 490 }
485 491 return token;
486 492 }
487 493
488 494 /*
489 495 * extend to deal with the ambiguous C grammar for parsing
490 496 * a cast expressions followed by an initializer.
491 497 */
492 498 static struct token *postfix_expression(struct token *token, struct expression **tree, struct expression *cast_init_expr)
493 499 {
494 500 struct expression *expr = cast_init_expr;
495 501
496 502 if (!expr)
497 503 token = primary_expression(token, &expr);
498 504
499 505 while (expr && token_type(token) == TOKEN_SPECIAL) {
500 506 switch (token->special) {
501 507 case '[': { /* Array dereference */
502 508 struct expression *deref = alloc_expression(token->pos, EXPR_PREOP);
503 509 struct expression *add = alloc_expression(token->pos, EXPR_BINOP);
504 510
505 511 deref->op = '*';
506 512 deref->unop = add;
507 513
508 514 add->op = '+';
509 515 add->left = expr;
510 516 token = parse_expression(token->next, &add->right);
511 517 token = expect(token, ']', "at end of array dereference");
512 518 expr = deref;
513 519 continue;
514 520 }
515 521 case SPECIAL_INCREMENT: /* Post-increment */
516 522 case SPECIAL_DECREMENT: { /* Post-decrement */
517 523 struct expression *post = alloc_expression(token->pos, EXPR_POSTOP);
518 524 post->op = token->special;
519 525 post->unop = expr;
520 526 expr = post;
521 527 token = token->next;
522 528 continue;
523 529 }
524 530 case SPECIAL_DEREFERENCE: { /* Structure pointer member dereference */
525 531 /* "x->y" is just shorthand for "(*x).y" */
526 532 struct expression *inner = alloc_expression(token->pos, EXPR_PREOP);
527 533 inner->op = '*';
528 534 inner->unop = expr;
529 535 expr = inner;
530 536 }
531 537 /* Fall through!! */
532 538 case '.': { /* Structure member dereference */
533 539 struct expression *deref = alloc_expression(token->pos, EXPR_DEREF);
534 540 deref->op = '.';
535 541 deref->deref = expr;
536 542 token = token->next;
537 543 if (token_type(token) != TOKEN_IDENT) {
538 544 sparse_error(token->pos, "Expected member name");
539 545 break;
540 546 }
541 547 deref->member = token->ident;
542 548 deref->member_offset = -1;
543 549 token = token->next;
544 550 expr = deref;
545 551 continue;
546 552 }
547 553
548 554 case '(': { /* Function call */
549 555 struct expression *call = alloc_expression(token->pos, EXPR_CALL);
550 556 call->op = '(';
551 557 call->fn = expr;
552 558 token = expression_list(token->next, &call->args);
553 559 token = expect(token, ')', "in function call");
554 560 expr = call;
555 561 continue;
556 562 }
557 563
558 564 default:
559 565 break;
560 566 }
561 567 break;
562 568 }
563 569 *tree = expr;
564 570 return token;
565 571 }
566 572
567 573 static struct token *cast_expression(struct token *token, struct expression **tree);
568 574 static struct token *unary_expression(struct token *token, struct expression **tree);
569 575
570 576 static struct token *type_info_expression(struct token *token,
571 577 struct expression **tree, int type)
572 578 {
573 579 struct expression *expr = alloc_expression(token->pos, type);
574 580 struct token *p;
575 581
576 582 *tree = expr;
577 583 expr->flags = CEF_SET_ICE; /* XXX: VLA support will need that changed */
578 584 token = token->next;
579 585 if (!match_op(token, '(') || !lookup_type(token->next))
580 586 return unary_expression(token, &expr->cast_expression);
581 587 p = token;
582 588 token = typename(token->next, &expr->cast_type, NULL);
583 589
584 590 if (!match_op(token, ')')) {
585 591 static const char * error[] = {
586 592 [EXPR_SIZEOF] = "at end of sizeof",
587 593 [EXPR_ALIGNOF] = "at end of __alignof__",
588 594 [EXPR_PTRSIZEOF] = "at end of __sizeof_ptr__"
589 595 };
590 596 return expect(token, ')', error[type]);
591 597 }
592 598
593 599 token = token->next;
594 600 /*
595 601 * C99 ambiguity: the typename might have been the beginning
596 602 * of a typed initializer expression..
597 603 */
598 604 if (match_op(token, '{')) {
599 605 struct expression *cast = alloc_expression(p->pos, EXPR_CAST);
600 606 cast->cast_type = expr->cast_type;
601 607 expr->cast_type = NULL;
602 608 expr->cast_expression = cast;
603 609 token = initializer(&cast->cast_expression, token);
604 610 token = postfix_expression(token, &expr->cast_expression, cast);
605 611 }
606 612 return token;
607 613 }
608 614
609 615 static struct token *unary_expression(struct token *token, struct expression **tree)
610 616 {
611 617 if (token_type(token) == TOKEN_IDENT) {
612 618 struct ident *ident = token->ident;
613 619 if (ident->reserved) {
614 620 static const struct {
615 621 struct ident *id;
616 622 int type;
617 623 } type_information[] = {
618 624 { &sizeof_ident, EXPR_SIZEOF },
619 625 { &__alignof___ident, EXPR_ALIGNOF },
620 626 { &__alignof_ident, EXPR_ALIGNOF },
621 627 { &_Alignof_ident, EXPR_ALIGNOF },
622 628 { &__sizeof_ptr___ident, EXPR_PTRSIZEOF },
623 629 };
624 630 int i;
625 631 for (i = 0; i < ARRAY_SIZE(type_information); i++) {
626 632 if (ident == type_information[i].id)
627 633 return type_info_expression(token, tree, type_information[i].type);
628 634 }
629 635 }
630 636 }
631 637
632 638 if (token_type(token) == TOKEN_SPECIAL) {
633 639 if (match_oplist(token->special,
634 640 SPECIAL_INCREMENT, SPECIAL_DECREMENT,
635 641 '&', '*', 0)) {
636 642 struct expression *unop;
637 643 struct expression *unary;
638 644 struct token *next;
639 645
640 646 next = cast_expression(token->next, &unop);
641 647 if (!unop) {
642 648 sparse_error(token->pos, "Syntax error in unary expression");
643 649 *tree = NULL;
644 650 return next;
645 651 }
646 652 unary = alloc_expression(token->pos, EXPR_PREOP);
647 653 unary->op = token->special;
648 654 unary->unop = unop;
649 655 *tree = unary;
650 656 return next;
651 657 }
652 658 /* possibly constant ones */
653 659 if (match_oplist(token->special, '+', '-', '~', '!', 0)) {
654 660 struct expression *unop;
655 661 struct expression *unary;
656 662 struct token *next;
657 663
658 664 next = cast_expression(token->next, &unop);
659 665 if (!unop) {
660 666 sparse_error(token->pos, "Syntax error in unary expression");
661 667 *tree = NULL;
662 668 return next;
663 669 }
664 670 unary = alloc_expression(token->pos, EXPR_PREOP);
665 671 unary->op = token->special;
666 672 unary->unop = unop;
667 673 *tree = unary;
668 674 return next;
669 675 }
670 676 /* Gcc extension: &&label gives the address of a label */
671 677 if (match_op(token, SPECIAL_LOGICAL_AND) &&
672 678 token_type(token->next) == TOKEN_IDENT) {
673 679 struct expression *label = alloc_expression(token->pos, EXPR_LABEL);
674 680 struct symbol *sym = label_symbol(token->next);
675 681 if (!(sym->ctype.modifiers & MOD_ADDRESSABLE)) {
676 682 sym->ctype.modifiers |= MOD_ADDRESSABLE;
677 683 add_symbol(&function_computed_target_list, sym);
678 684 }
679 685 label->flags = CEF_ADDR;
680 686 label->label_symbol = sym;
681 687 *tree = label;
682 688 return token->next->next;
683 689 }
684 690
685 691 }
686 692
687 693 return postfix_expression(token, tree, NULL);
688 694 }
689 695
690 696 /*
691 697 * Ambiguity: a '(' can be either a cast-expression or
692 698 * a primary-expression depending on whether it is followed
693 699 * by a type or not.
694 700 *
695 701 * additional ambiguity: a "cast expression" followed by
696 702 * an initializer is really a postfix-expression.
697 703 */
698 704 static struct token *cast_expression(struct token *token, struct expression **tree)
699 705 {
700 706 if (match_op(token, '(')) {
701 707 struct token *next = token->next;
702 708 if (lookup_type(next)) {
703 709 struct expression *cast = alloc_expression(next->pos, EXPR_CAST);
704 710 struct expression *v;
705 711 struct symbol *sym;
706 712 int is_force;
707 713
708 714 token = typename(next, &sym, &is_force);
709 715 cast->cast_type = sym;
710 716 token = expect(token, ')', "at end of cast operator");
711 717 if (match_op(token, '{')) {
712 718 if (toplevel(block_scope))
713 719 sym->ctype.modifiers |= MOD_TOPLEVEL;
714 720 if (is_force)
715 721 warning(sym->pos,
716 722 "[force] in compound literal");
717 723 token = initializer(&cast->cast_expression, token);
718 724 return postfix_expression(token, tree, cast);
719 725 }
720 726 *tree = cast;
721 727 if (is_force)
722 728 cast->type = EXPR_FORCE_CAST;
723 729 token = cast_expression(token, &v);
724 730 if (!v)
725 731 return token;
726 732 cast->cast_expression = v;
727 733 return token;
728 734 }
729 735 }
730 736 return unary_expression(token, tree);
731 737 }
732 738
733 739 /*
734 740 * Generic left-to-right binop parsing
735 741 *
736 742 * This _really_ needs to be inlined, because that makes the inner
737 743 * function call statically deterministic rather than a totally
738 744 * unpredictable indirect call. But gcc-3 is so "clever" that it
739 745 * doesn't do so by default even when you tell it to inline it.
740 746 *
741 747 * Making it a macro avoids the inlining problem, and also means
742 748 * that we can pass in the op-comparison as an expression rather
743 749 * than create a data structure for it.
744 750 */
745 751
746 752 #define LR_BINOP_EXPRESSION(__token, tree, type, inner, compare) \
747 753 struct expression *left = NULL; \
748 754 struct token * next = inner(__token, &left); \
749 755 \
750 756 if (left) { \
751 757 while (token_type(next) == TOKEN_SPECIAL) { \
752 758 struct expression *top, *right = NULL; \
753 759 int op = next->special; \
754 760 \
755 761 if (!(compare)) \
756 762 goto out; \
757 763 top = alloc_expression(next->pos, type); \
758 764 next = inner(next->next, &right); \
759 765 if (!right) { \
760 766 sparse_error(next->pos, "No right hand side of '%s'-expression", show_special(op)); \
761 767 break; \
762 768 } \
763 769 top->op = op; \
764 770 top->left = left; \
765 771 top->right = right; \
766 772 left = top; \
767 773 } \
768 774 } \
769 775 out: \
770 776 *tree = left; \
771 777 return next; \
772 778
773 779 static struct token *multiplicative_expression(struct token *token, struct expression **tree)
774 780 {
775 781 LR_BINOP_EXPRESSION(
776 782 token, tree, EXPR_BINOP, cast_expression,
777 783 (op == '*') || (op == '/') || (op == '%')
778 784 );
779 785 }
780 786
781 787 static struct token *additive_expression(struct token *token, struct expression **tree)
782 788 {
783 789 LR_BINOP_EXPRESSION(
784 790 token, tree, EXPR_BINOP, multiplicative_expression,
785 791 (op == '+') || (op == '-')
786 792 );
787 793 }
788 794
789 795 static struct token *shift_expression(struct token *token, struct expression **tree)
790 796 {
791 797 LR_BINOP_EXPRESSION(
792 798 token, tree, EXPR_BINOP, additive_expression,
793 799 (op == SPECIAL_LEFTSHIFT) || (op == SPECIAL_RIGHTSHIFT)
794 800 );
795 801 }
796 802
797 803 static struct token *relational_expression(struct token *token, struct expression **tree)
798 804 {
799 805 LR_BINOP_EXPRESSION(
800 806 token, tree, EXPR_COMPARE, shift_expression,
801 807 (op == '<') || (op == '>') ||
802 808 (op == SPECIAL_LTE) || (op == SPECIAL_GTE)
803 809 );
804 810 }
805 811
806 812 static struct token *equality_expression(struct token *token, struct expression **tree)
807 813 {
808 814 LR_BINOP_EXPRESSION(
809 815 token, tree, EXPR_COMPARE, relational_expression,
810 816 (op == SPECIAL_EQUAL) || (op == SPECIAL_NOTEQUAL)
811 817 );
812 818 }
813 819
814 820 static struct token *bitwise_and_expression(struct token *token, struct expression **tree)
815 821 {
816 822 LR_BINOP_EXPRESSION(
817 823 token, tree, EXPR_BINOP, equality_expression,
818 824 (op == '&')
819 825 );
820 826 }
821 827
822 828 static struct token *bitwise_xor_expression(struct token *token, struct expression **tree)
823 829 {
824 830 LR_BINOP_EXPRESSION(
825 831 token, tree, EXPR_BINOP, bitwise_and_expression,
826 832 (op == '^')
827 833 );
828 834 }
829 835
830 836 static struct token *bitwise_or_expression(struct token *token, struct expression **tree)
831 837 {
832 838 LR_BINOP_EXPRESSION(
833 839 token, tree, EXPR_BINOP, bitwise_xor_expression,
834 840 (op == '|')
835 841 );
836 842 }
837 843
838 844 static struct token *logical_and_expression(struct token *token, struct expression **tree)
839 845 {
840 846 LR_BINOP_EXPRESSION(
841 847 token, tree, EXPR_LOGICAL, bitwise_or_expression,
842 848 (op == SPECIAL_LOGICAL_AND)
843 849 );
844 850 }
845 851
846 852 static struct token *logical_or_expression(struct token *token, struct expression **tree)
847 853 {
848 854 LR_BINOP_EXPRESSION(
849 855 token, tree, EXPR_LOGICAL, logical_and_expression,
850 856 (op == SPECIAL_LOGICAL_OR)
851 857 );
852 858 }
853 859
854 860 struct token *conditional_expression(struct token *token, struct expression **tree)
855 861 {
856 862 token = logical_or_expression(token, tree);
857 863 if (*tree && match_op(token, '?')) {
858 864 struct expression *expr = alloc_expression(token->pos, EXPR_CONDITIONAL);
859 865 expr->op = token->special;
860 866 expr->left = *tree;
861 867 *tree = expr;
862 868 token = parse_expression(token->next, &expr->cond_true);
863 869 token = expect(token, ':', "in conditional expression");
864 870 token = conditional_expression(token, &expr->cond_false);
865 871 }
866 872 return token;
867 873 }
868 874
869 875 struct token *assignment_expression(struct token *token, struct expression **tree)
870 876 {
871 877 token = conditional_expression(token, tree);
872 878 if (*tree && token_type(token) == TOKEN_SPECIAL) {
873 879 static const int assignments[] = {
874 880 '=',
875 881 SPECIAL_ADD_ASSIGN, SPECIAL_SUB_ASSIGN,
876 882 SPECIAL_MUL_ASSIGN, SPECIAL_DIV_ASSIGN,
877 883 SPECIAL_MOD_ASSIGN, SPECIAL_SHL_ASSIGN,
878 884 SPECIAL_SHR_ASSIGN, SPECIAL_AND_ASSIGN,
879 885 SPECIAL_OR_ASSIGN, SPECIAL_XOR_ASSIGN };
880 886 int i, op = token->special;
881 887 for (i = 0; i < ARRAY_SIZE(assignments); i++)
882 888 if (assignments[i] == op) {
883 889 struct expression * expr = alloc_expression(token->pos, EXPR_ASSIGNMENT);
884 890 expr->left = *tree;
885 891 expr->op = op;
886 892 *tree = expr;
887 893 return assignment_expression(token->next, &expr->right);
888 894 }
889 895 }
890 896 return token;
891 897 }
892 898
893 899 static struct token *comma_expression(struct token *token, struct expression **tree)
894 900 {
895 901 LR_BINOP_EXPRESSION(
896 902 token, tree, EXPR_COMMA, assignment_expression,
897 903 (op == ',')
898 904 );
899 905 }
900 906
901 907 struct token *parse_expression(struct token *token, struct expression **tree)
902 908 {
903 909 return comma_expression(token,tree);
904 910 }
905 911
906 912
|
↓ open down ↓ |
820 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX