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