expression.c

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