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         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