parse.c

   1 /*
   2  * Stupid C parser, version 1e-6.
   3  *
   4  * Let's see how hard this is to do.
   5  *
   6  * Copyright (C) 2003 Linus Torvalds, all rights reserved.
   7  */
   8
   9 #include <stdarg.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <ctype.h>
  14 #include <unistd.h>
  15 #include <fcntl.h>
  16
  17 #include "lib.h"
  18 #include "token.h"
  19 #include "parse.h"
  20 #include "symbol.h"
  21 #include "scope.h"
  22 #include "expression.h"
  23
  24 struct statement *alloc_statement(struct token * token, int type)
  25 {
  26         struct statement *stmt = __alloc_statement(0);
  27         stmt->type = type;
  28         return stmt;
  29 }
  30
  31 static struct token *struct_declaration_list(struct token *token, struct symbol_list **list);
  32
  33 static struct symbol * indirect(struct position pos, struct ctype *ctype, int type)
  34 {
  35         struct symbol *sym = alloc_symbol(pos, type);
  36
  37         sym->ctype.base_type = ctype->base_type;
  38         sym->ctype.modifiers = ctype->modifiers & ~MOD_STORAGE;
  39
  40         ctype->base_type = sym;
  41         ctype->modifiers &= MOD_STORAGE;
  42         return sym;
  43 }
  44
  45 static struct symbol *lookup_or_create_symbol(enum namespace ns, enum type type, struct token *token)
  46 {
  47         struct symbol *sym = lookup_symbol(token->ident, ns);
  48         if (!sym) {
  49                 sym = alloc_symbol(token->pos, type);
  50                 sym->ident = token->ident;
  51                 bind_symbol(sym, token->ident, ns);
  52         }
  53         return sym;
  54 }
  55
  56 struct token *struct_union_enum_specifier(enum namespace ns, enum type type,
  57         struct token *token, struct ctype *ctype,
  58         struct token *(*parse)(struct token *, struct symbol *))
  59 {
  60         struct symbol *sym;
  61
  62         ctype->modifiers = 0;
  63         if (token_type(token) == TOKEN_IDENT) {
  64                 sym = lookup_or_create_symbol(ns, type, token);
  65                 token = token->next;
  66                 ctype->base_type = sym;
  67                 if (match_op(token, '{')) {
  68                         token = parse(token->next, sym);
  69                         token = expect(token, '}', "at end of struct-union-enum-specifier");
  70                 }
  71                 return token;
  72         }
  73
  74         // private struct/union/enum type
  75         if (!match_op(token, '{')) {
  76                 warn(token->pos, "expected declaration");
  77                 ctype->base_type = &bad_type;
  78                 return token;
  79         }
  80
  81         sym = alloc_symbol(token->pos, type);
  82         token = parse(token->next, sym);
  83         ctype->base_type = sym;
  84         return expect(token, '}', "at end of specifier");
  85 }
  86
  87 static struct token *parse_struct_declaration(struct token *token, struct symbol *sym)
  88 {
  89         return struct_declaration_list(token, &sym->symbol_list);
  90 }
  91
  92 struct token *struct_or_union_specifier(enum type type, struct token *token, struct ctype *ctype)
  93 {
  94         return struct_union_enum_specifier(NS_STRUCT, type, token, ctype, parse_struct_declaration);
  95 }
  96
  97 static struct token *parse_enum_declaration(struct token *token, struct symbol *parent)
  98 {
  99         int nextval = 0;
 100         while (token_type(token) == TOKEN_IDENT) {
 101                 struct token *next = token->next;
 102                 struct symbol *sym;
 103
 104                 sym = alloc_symbol(token->pos, SYM_NODE);
 105                 bind_symbol(sym, token->ident, NS_SYMBOL);
 106                 sym->ctype.base_type = parent;
 107
 108                 if (match_op(next, '=')) {
 109                         struct expression *expr;
 110                         next = constant_expression(next->next, &expr);
 111                         nextval = get_expression_value(expr);
 112                 }
 113                 sym->value = nextval;
 114
 115                 token = next;
 116                 if (!match_op(token, ','))
 117                         break;
 118                 token = token->next;
 119                 nextval = nextval + 1;
 120         }
 121         return token;
 122 }
 123
 124 struct token *enum_specifier(struct token *token, struct ctype *ctype)
 125 {
 126         return struct_union_enum_specifier(NS_ENUM, SYM_ENUM, token, ctype, parse_enum_declaration);
 127 }
 128
 129 struct token *typeof_specifier(struct token *token, struct ctype *ctype)
 130 {
 131         struct symbol *sym;
 132         struct expression *expr;
 133
 134         if (!match_op(token, '(')) {
 135                 warn(token->pos, "expected '(' after typeof");
 136                 return token;
 137         }
 138         if (lookup_type(token->next)) {
 139                 token = typename(token->next, &sym);
 140                 *ctype = sym->ctype;
 141         } else {
 142                 token = parse_expression(token->next, &expr);
 143                 /* Leave ctype at NULL, we'll evaluate it lazily later.. */
 144                 ctype->modifiers = 0;
 145                 ctype->base_type = NULL;
 146         }
 147         return expect(token, ')', "after typeof");
 148 }
 149
 150 struct token *attribute_specifier(struct token *token, struct ctype *ctype)
 151 {
 152         int parens = 0;
 153
 154         token = expect(token, '(', "after attribute");
 155         token = expect(token, '(', "after attribute");
 156
 157         for (;;) {
 158                 if (eof_token(token))
 159                         break;
 160                 if (match_op(token, ';'))
 161                         break;
 162                 if (match_op(token, ')')) {
 163                         if (!parens)
 164                                 break;
 165                         parens--;
 166                 }
 167                 if (match_op(token, '('))
 168                         parens++;
 169                 token = token->next;
 170         }
 171
 172         token = expect(token, ')', "after attribute");
 173         token = expect(token, ')', "after attribute");
 174         return token;
 175 }
 176
 177 #define MOD_SPECIALBITS (MOD_STRUCTOF | MOD_UNIONOF | MOD_ENUMOF | MOD_ATTRIBUTE | MOD_TYPEOF)
 178
 179 static struct token *type_qualifiers(struct token *next, struct ctype *ctype)
 180 {
 181         struct token *token;
 182         while ( (token = next) != NULL ) {
 183                 struct symbol *s, *base_type;
 184                 unsigned long mod;
 185
 186                 next = token->next;
 187                 if (token_type(token) != TOKEN_IDENT)
 188                         break;
 189                 s = lookup_symbol(token->ident, NS_TYPEDEF);
 190                 if (!s)
 191                         break;
 192                 mod = s->ctype.modifiers;
 193                 base_type = s->ctype.base_type;
 194                 if (base_type)
 195                         break;
 196                 if (mod & ~(MOD_CONST | MOD_VOLATILE))
 197                         break;
 198                 ctype->modifiers |= mod;
 199         }
 200         return token;
 201 }
 202
 203 #define MOD_SPECIFIER (MOD_CHAR | MOD_SHORT | MOD_LONG | MOD_LONGLONG | MOD_SIGNED | MOD_UNSIGNED)
 204
 205 struct symbol * ctype_integer(unsigned int spec)
 206 {
 207         static struct symbol *const integer_ctypes[][2] = {
 208                 { &llong_ctype, &ullong_ctype },
 209                 { &long_ctype,  &ulong_ctype  },
 210                 { &short_ctype, &ushort_ctype },
 211                 { &char_ctype,  &uchar_ctype  },
 212                 { &int_ctype,   &uint_ctype   },
 213         };
 214         struct symbol *const (*ctype)[2];
 215
 216         ctype = integer_ctypes;
 217         if (!(spec & MOD_LONGLONG)) {
 218                 ctype++;
 219                 if (!(spec & MOD_LONG)) {
 220                         ctype++;
 221                         if (!(spec & MOD_SHORT)) {
 222                                 ctype++;
 223                                 if (!(spec & MOD_CHAR))
 224                                         ctype++;
 225                         }
 226                 }
 227         }
 228         return ctype[0][(spec & MOD_UNSIGNED) != 0];
 229 }
 230
 231 struct symbol * ctype_fp(unsigned int spec)
 232 {
 233         if (spec & MOD_LONGLONG)
 234                 return &ldouble_ctype;
 235         if (spec & MOD_LONG)
 236                 return &double_ctype;
 237         return &float_ctype;
 238 }
 239
 240 static struct token *declaration_specifiers(struct token *next, struct ctype *ctype)
 241 {
 242         struct token *token;
 243
 244         while ( (token = next) != NULL ) {
 245                 struct ctype thistype;
 246                 struct ident *ident;
 247                 struct symbol *s, *type;
 248                 unsigned long mod;
 249
 250                 next = token->next;
 251                 if (token_type(token) != TOKEN_IDENT)
 252                         break;
 253                 ident = token->ident;
 254
 255                 s = lookup_symbol(ident, NS_TYPEDEF);
 256                 if (!s)
 257                         break;
 258                 thistype = s->ctype;
 259                 mod = thistype.modifiers;
 260                 if (mod & MOD_SPECIALBITS) {
 261                         if (mod & MOD_STRUCTOF)
 262                                 next = struct_or_union_specifier(SYM_STRUCT, next, &thistype);
 263                         else if (mod & MOD_UNIONOF)
 264                                 next = struct_or_union_specifier(SYM_UNION, next, &thistype);
 265                         else if (mod & MOD_ENUMOF)
 266                                 next = enum_specifier(next, &thistype);
 267                         else if (mod & MOD_ATTRIBUTE)
 268                                 next = attribute_specifier(next, &thistype);
 269                         else if (mod & MOD_TYPEOF)
 270                                 next = typeof_specifier(next, &thistype);
 271                         mod = thistype.modifiers;
 272                 }
 273
 274                 type = thistype.base_type;
 275                 if (type) {
 276                         if (type != ctype->base_type) {
 277                                 if (ctype->base_type) {
 278                                         warn(token->pos, "Strange mix of types");
 279                                         continue;
 280                                 }
 281                                 ctype->base_type = type;
 282                         }
 283                 }
 284                 if (mod) {
 285                         unsigned long old = ctype->modifiers;
 286                         unsigned long extra = 0, dup;
 287
 288                         if (mod & old & MOD_LONG) {
 289                                 extra = MOD_LONGLONG | MOD_LONG;
 290                                 mod &= ~MOD_LONG;
 291                                 old &= ~MOD_LONG;
 292                         }
 293                         dup = (mod & old) | (extra & old) | (extra & mod);
 294                         if (dup)
 295                                 warn(token->pos, "Just how %s do you want this type to be?",
 296                                         modifier_string(dup));
 297                         ctype->modifiers = old | mod | extra;
 298                 }
 299         }
 300
 301         /* Turn the "virtual types" into real types with real sizes etc */
 302         if (!ctype->base_type && (ctype->modifiers & MOD_SPECIFIER))
 303                 ctype->base_type = &int_type;
 304
 305         if (ctype->base_type == &int_type) {
 306                 ctype->base_type = ctype_integer(ctype->modifiers & MOD_SPECIFIER);
 307                 ctype->modifiers &= ~MOD_SPECIFIER;
 308                 return token;
 309         }
 310         if (ctype->base_type == &fp_type) {
 311                 ctype->base_type = ctype_fp(ctype->modifiers & MOD_SPECIFIER);
 312                 ctype->modifiers &= ~MOD_SPECIFIER;
 313                 return token;
 314         }
 315         return token;
 316 }
 317
 318 static struct token *abstract_array_declarator(struct token *token, struct symbol *sym)
 319 {
 320         struct expression *expr = NULL;
 321
 322         token = parse_expression(token, &expr);
 323         if (expr)
 324                 sym->array_size = get_expression_value(expr);
 325         else
 326                 sym->array_size = -1;
 327         return token;
 328 }
 329
 330 static struct token *parameter_type_list(struct token *, struct symbol *);
 331 static struct token *declarator(struct token *token, struct symbol **tree, struct ident **p);
 332
 333 static struct token *direct_declarator(struct token *token, struct symbol **tree, struct ident **p)
 334 {
 335         struct ctype *ctype = &(*tree)->ctype;
 336
 337         if (p && token_type(token) == TOKEN_IDENT) {
 338                 *p = token->ident;
 339                 token = token->next;
 340         }
 341
 342         for (;;) {
 343                 if (match_ident(token, &__attribute___ident) || match_ident(token, &__attribute_ident)) {
 344                         struct ctype ctype = { 0, };
 345                         token = attribute_specifier(token->next, &ctype);
 346                         continue;
 347                 }
 348                 if (token_type(token) != TOKEN_SPECIAL)
 349                         return token;
 350
 351                 /*
 352                  * This can be either a parameter list or a grouping.
 353                  * For the direct (non-abstract) case, we know if must be
 354                  * a paramter list if we already saw the identifier.
 355                  * For the abstract case, we know if must be a parameter
 356                  * list if it is empty or starts with a type.
 357                  */
 358                 if (token->special == '(') {
 359                         struct symbol *sym;
 360                         struct token *next = token->next;
 361                         int fn = (p && *p) || match_op(next, ')') || lookup_type(next);
 362
 363                         if (!fn) {
 364                                 struct symbol *base_type = ctype->base_type;
 365                                 token = declarator(next, tree, p);
 366                                 token = expect(token, ')', "in nested declarator");
 367                                 while (ctype->base_type != base_type)
 368                                         ctype = &ctype->base_type->ctype;
 369                                 p = NULL;
 370                                 continue;
 371                         }
 372
 373                         sym = indirect(token->pos, ctype, SYM_FN);
 374                         token = parameter_type_list(next, sym);
 375                         token = expect(token, ')', "in function declarator");
 376                         continue;
 377                 }
 378                 if (token->special == '[') {
 379                         struct symbol *array = indirect(token->pos, ctype, SYM_ARRAY);
 380                         token = abstract_array_declarator(token->next, array);
 381                         token = expect(token, ']', "in abstract_array_declarator");
 382                         continue;
 383                 }
 384                 if (token->special == ':') {
 385                         struct symbol *bitfield;
 386                         struct expression *expr;
 387                         bitfield = indirect(token->pos, ctype, SYM_BITFIELD);
 388                         token = conditional_expression(token->next, &expr);
 389                         bitfield->fieldwidth = get_expression_value(expr);
 390                         continue;
 391                 }
 392                 break;
 393         }
 394         if (p) {
 395                 (*tree)->ident = *p;
 396         }
 397         return token;
 398 }
 399
 400 static struct token *pointer(struct token *token, struct ctype *ctype)
 401 {
 402         unsigned long modifiers;
 403         struct symbol *base_type;
 404
 405         modifiers = ctype->modifiers & ~(MOD_TYPEDEF | MOD_ATTRIBUTE);
 406         base_type = ctype->base_type;
 407
 408         while (match_op(token,'*')) {
 409                 struct symbol *ptr = alloc_symbol(token->pos, SYM_PTR);
 410                 ptr->ctype.modifiers = modifiers & ~MOD_STORAGE;
 411                 ptr->ctype.base_type = base_type;
 412
 413                 base_type = ptr;
 414                 modifiers &= MOD_STORAGE;
 415                 ctype->base_type = base_type;
 416
 417                 token = type_qualifiers(token->next, ctype);
 418         }
 419         ctype->modifiers = modifiers;
 420         return token;
 421 }
 422
 423 static struct token *declarator(struct token *token, struct symbol **tree, struct ident **p)
 424 {
 425         token = pointer(token, &(*tree)->ctype);
 426         return direct_declarator(token, tree, p);
 427 }
 428
 429 static struct token *struct_declaration_list(struct token *token, struct symbol_list **list)
 430 {
 431         while (!match_op(token, '}')) {
 432                 struct ctype ctype = {0, };
 433
 434                 token = declaration_specifiers(token, &ctype);
 435                 for (;;) {
 436                         struct ident *ident = NULL;
 437                         struct symbol *decl = alloc_symbol(token->pos, SYM_NODE);
 438                         decl->ctype = ctype;
 439                         token = pointer(token, &decl->ctype);
 440                         token = direct_declarator(token, &decl, &ident);
 441                         if (match_op(token, ':')) {
 442                                 struct expression *expr;
 443                                 token = parse_expression(token->next, &expr);
 444                         }
 445                         add_symbol(list, decl);
 446                         if (!match_op(token, ','))
 447                                 break;
 448                         token = token->next;
 449                 }
 450                 if (!match_op(token, ';'))
 451                         break;
 452                 token = token->next;
 453         }
 454         return token;
 455 }
 456
 457 static struct token *parameter_declaration(struct token *token, struct symbol **tree)
 458 {
 459         struct ident *ident = NULL;
 460         struct symbol *sym;
 461         struct ctype ctype = { 0, };
 462
 463         token = declaration_specifiers(token, &ctype);
 464         sym = alloc_symbol(token->pos, SYM_NODE);
 465         sym->ctype = ctype;
 466         *tree = sym;
 467         token = pointer(token, &sym->ctype);
 468         token = direct_declarator(token, tree, &ident);
 469         return token;
 470 }
 471
 472 struct token *typename(struct token *token, struct symbol **p)
 473 {
 474         struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
 475         *p = sym;
 476         token = declaration_specifiers(token, &sym->ctype);
 477         return declarator(token, &sym, NULL);
 478 }
 479
 480 struct token *expression_statement(struct token *token, struct expression **tree)
 481 {
 482         token = parse_expression(token, tree);
 483         return expect(token, ';', "at end of statement");
 484 }
 485
 486 static struct token *parse_asm_operands(struct token *token, struct statement *stmt)
 487 {
 488         struct expression *expr;
 489
 490         /* Allow empty operands */
 491         if (match_op(token->next, ':') || match_op(token->next, ')'))
 492                 return token->next;
 493         do {
 494                 token = primary_expression(token->next, &expr);
 495                 token = parens_expression(token, &expr, "in asm parameter");
 496         } while (match_op(token, ','));
 497         return token;
 498 }
 499
 500 static struct token *parse_asm_clobbers(struct token *token, struct statement *stmt)
 501 {
 502         struct expression *expr;
 503
 504         do {
 505                 token = primary_expression(token->next, &expr);
 506         } while (match_op(token, ','));
 507         return token;
 508 }
 509
 510 /* Make a statement out of an expression */
 511 static struct statement *make_statement(struct expression *expr)
 512 {
 513         struct statement *stmt;
 514
 515         if (!expr)
 516                 return NULL;
 517         stmt = alloc_statement(expr->token, STMT_EXPRESSION);
 518         stmt->expression = expr;
 519         return stmt;
 520 }
 521
 522 struct token *statement(struct token *token, struct statement **tree)
 523 {
 524         struct statement *stmt = alloc_statement(token, STMT_NONE);
 525
 526         *tree = stmt;
 527         if (token_type(token) == TOKEN_IDENT) {
 528                 if (token->ident == &if_ident) {
 529                         stmt->type = STMT_IF;
 530                         token = parens_expression(token->next, &stmt->if_conditional, "after if");
 531                         token = statement(token, &stmt->if_true);
 532                         if (token_type(token) != TOKEN_IDENT)
 533                                 return token;
 534                         if (token->ident != &else_ident)
 535                                 return token;
 536                         return statement(token->next, &stmt->if_false);
 537                 }
 538                 if (token->ident == &return_ident) {
 539                         stmt->type = STMT_RETURN;
 540                         return expression_statement(token->next, &stmt->expression);
 541                 }
 542                 if (token->ident == &break_ident) {
 543                         stmt->type = STMT_BREAK;
 544                         return expect(token->next, ';', "at end of statement");
 545                 }
 546                 if (token->ident == &continue_ident) {
 547                         stmt->type = STMT_CONTINUE;
 548                         return expect(token->next, ';', "at end of statement");
 549                 }
 550                 if (token->ident == &default_ident) {
 551                         token = token->next;
 552                         goto default_statement;
 553                 }
 554                 if (token->ident == &case_ident) {
 555                         token = parse_expression(token->next, &stmt->case_expression);
 556                         if (match_op(token, SPECIAL_ELLIPSIS))
 557                                 token = parse_expression(token->next, &stmt->case_to);
 558 default_statement:
 559                         stmt->type = STMT_CASE;
 560                         token = expect(token, ':', "after default/case");
 561                         return statement(token, &stmt->case_statement);
 562                 }
 563                 if (token->ident == &switch_ident) {
 564                         stmt->type = STMT_SWITCH;
 565                         token = parens_expression(token->next, &stmt->switch_expression, "after 'switch'");
 566                         return statement(token, &stmt->switch_statement);
 567                 }
 568                 if (token->ident == &for_ident) {
 569                         struct expression *e1, *e2, *e3;
 570                         struct statement *iterator;
 571
 572                         token = expect(token->next, '(', "after 'for'");
 573                         token = parse_expression(token, &e1);
 574                         token = expect(token, ';', "in 'for'");
 575                         token = parse_expression(token, &e2);
 576                         token = expect(token, ';', "in 'for'");
 577                         token = parse_expression(token, &e3);
 578                         token = expect(token, ')', "in 'for'");
 579                         token = statement(token, &iterator);
 580
 581                         stmt->type = STMT_ITERATOR;
 582                         stmt->iterator_pre_statement = make_statement(e1);
 583                         stmt->iterator_pre_condition = e2;
 584                         stmt->iterator_post_statement = make_statement(e3);
 585                         stmt->iterator_post_condition = e2;
 586                         stmt->iterator_statement = iterator;
 587
 588                         return token;
 589                 }
 590                 if (token->ident == &while_ident) {
 591                         struct expression *expr;
 592                         struct statement *iterator;
 593
 594                         token = parens_expression(token->next, &expr, "after 'while'");
 595                         token = statement(token, &iterator);
 596
 597                         stmt->type = STMT_ITERATOR;
 598                         stmt->iterator_pre_condition = expr;
 599                         stmt->iterator_post_condition = expr;
 600                         stmt->iterator_statement = iterator;
 601
 602                         return token;
 603                 }
 604                 if (token->ident == &do_ident) {
 605                         struct expression *expr;
 606                         struct statement *iterator;
 607
 608                         token = statement(token->next, &iterator);
 609                         if (token_type(token) == TOKEN_IDENT && token->ident == &while_ident)
 610                                 token = token->next;
 611                         else
 612                                 warn(token->pos, "expected 'while' after 'do'");
 613                         token = parens_expression(token, &expr, "after 'do-while'");
 614
 615                         stmt->type = STMT_ITERATOR;
 616                         stmt->iterator_post_condition = expr;
 617                         stmt->iterator_statement = iterator;
 618
 619                         return expect(token, ';', "after statement");
 620                 }
 621                 if (token->ident == &goto_ident) {
 622                         stmt->type = STMT_GOTO;
 623                         token = token->next;
 624                         if (token_type(token) == TOKEN_IDENT) {
 625                                 stmt->goto_label = token;
 626                                 token = token->next;
 627                         } else
 628                                 warn(token->pos, "invalid label");
 629                         return expect(token, ';', "at end of statement");
 630                 }
 631                 if (token->ident == &asm_ident || token->ident == &__asm___ident || token->ident == &__asm_ident) {
 632                         struct expression *expr;
 633                         stmt->type = STMT_ASM;
 634                         token = token->next;
 635                         if (token_type(token) == TOKEN_IDENT) {
 636                                 if (token->ident == &__volatile___ident || token->ident == &volatile_ident)
 637                                         token = token->next;
 638                         }
 639                         token = expect(token, '(', "after asm");
 640                         token = parse_expression(token->next, &expr);
 641                         if (match_op(token, ':'))
 642                                 token = parse_asm_operands(token, stmt);
 643                         if (match_op(token, ':'))
 644                                 token = parse_asm_operands(token, stmt);
 645                         if (match_op(token, ':'))
 646                                 token = parse_asm_clobbers(token, stmt);
 647                         token = expect(token, ')', "after asm");
 648                         return expect(token, ';', "at end of asm-statement");
 649                 }
 650                 if (match_op(token->next, ':')) {
 651                         stmt->type = STMT_LABEL;
 652                         stmt->label_identifier = token;
 653                         return statement(token->next->next, &stmt->label_statement);
 654                 }
 655         }
 656
 657         if (match_op(token, '{')) {
 658                 stmt->type = STMT_COMPOUND;
 659                 start_symbol_scope();
 660                 token = compound_statement(token->next, stmt);
 661                 end_symbol_scope();
 662
 663                 return expect(token, '}', "at end of compound statement");
 664         }
 665
 666         stmt->type = STMT_EXPRESSION;
 667         return expression_statement(token, &stmt->expression);
 668 }
 669
 670 struct token * statement_list(struct token *token, struct statement_list **list)
 671 {
 672         for (;;) {
 673                 struct statement * stmt;
 674                 if (eof_token(token))
 675                         break;
 676                 if (match_op(token, '}'))
 677                         break;
 678                 token = statement(token, &stmt);
 679                 add_statement(list, stmt);
 680         }
 681         return token;
 682 }
 683
 684 static struct token *parameter_type_list(struct token *token, struct symbol *fn)
 685 {
 686         struct symbol_list **list = &fn->arguments;
 687         for (;;) {
 688                 struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
 689
 690                 if (match_op(token, SPECIAL_ELLIPSIS)) {
 691                         fn->variadic = 1;
 692                         token = token->next;
 693                         break;
 694                 }
 695
 696                 token = parameter_declaration(token, &sym);
 697                 /* Special case: (void) */
 698                 if (!*list && !sym->ident && sym->ctype.base_type == &void_ctype)
 699                         break;
 700                 add_symbol(list, sym);
 701                 if (!match_op(token, ','))
 702                         break;
 703                 token = token->next;
 704
 705         }
 706         return token;
 707 }
 708
 709 static struct token *external_declaration(struct token *token, struct symbol_list **list);
 710
 711 struct token *compound_statement(struct token *token, struct statement *stmt)
 712 {
 713         while (!eof_token(token)) {
 714                 if (!lookup_type(token))
 715                         break;
 716                 token = external_declaration(token, &stmt->syms);
 717         }
 718         token = statement_list(token, &stmt->stmts);
 719         return token;
 720 }
 721
 722 static struct token *initializer_list(struct token *token, struct ctype *type)
 723 {
 724         for (;;) {
 725                 token = initializer(token, type);
 726                 if (!match_op(token, ','))
 727                         break;
 728                 token = token->next;
 729         }
 730         return token;
 731 }
 732
 733 struct token *parse_named_initializer(struct token *id, struct token *token)
 734 {
 735         struct expression *expr;
 736
 737         return assignment_expression(token, &expr);
 738 }
 739
 740 struct token *initializer(struct token *token, struct ctype *type)
 741 {
 742         struct expression *expr;
 743         struct token *next, *name = NULL;
 744
 745         next = token->next;
 746         if (match_op(token, '.') && (token_type(next) == TOKEN_IDENT) && match_op(next->next, '=')) {
 747                 name = next;
 748                 token = next->next->next;
 749         } else if ((token_type(token) == TOKEN_IDENT) && match_op(next, ':')) {
 750                 name = token;
 751                 token = next->next;
 752         }
 753
 754         if (match_op(token, '{')) {
 755                 token = initializer_list(token->next, type);
 756                 return expect(token, '}', "at end of initializer");
 757         }
 758         return assignment_expression(token, &expr);
 759 }
 760
 761 static void declare_argument(struct symbol *sym, void *data, int flags)
 762 {
 763         struct symbol *decl = data;
 764
 765         if (!sym->ident) {
 766                 warn(decl->pos, "no identifier for function argument");
 767                 return;
 768         }
 769         bind_symbol(sym, sym->ident, NS_SYMBOL);
 770 }
 771
 772 static struct token *external_declaration(struct token *token, struct symbol_list **list)
 773 {
 774         struct ident *ident = NULL;
 775         struct symbol *decl;
 776         struct ctype ctype = { 0, };
 777         struct symbol *base_type;
 778
 779         /* Parse declaration-specifiers, if any */
 780         token = declaration_specifiers(token, &ctype);
 781         decl = alloc_symbol(token->pos, SYM_NODE);
 782         decl->ctype = ctype;
 783         token = pointer(token, &decl->ctype);
 784         token = declarator(token, &decl, &ident);
 785
 786         /* Just a type declaration? */
 787         if (!ident)
 788                 return expect(token, ';', "end of type declaration");
 789
 790         decl->ident = ident;
 791
 792         /* type define declaration? */
 793         if (ctype.modifiers & MOD_TYPEDEF) {
 794                 bind_symbol(decl, ident, NS_TYPEDEF);
 795         } else {
 796                 add_symbol(list, decl);
 797                 bind_symbol(decl, ident, NS_SYMBOL);
 798         }
 799
 800         base_type = decl->ctype.base_type;
 801         if (base_type && base_type->type == SYM_FN && match_op(token, '{')) {
 802                 base_type->stmt = alloc_statement(token, STMT_COMPOUND);
 803                 start_symbol_scope();
 804                 symbol_iterate(base_type->arguments, declare_argument, decl);
 805                 token = compound_statement(token->next, base_type->stmt);
 806                 end_symbol_scope();
 807                 return expect(token, '}', "at end of function");
 808         }
 809
 810         for (;;) {
 811                 if (match_op(token, '='))
 812                         token = initializer(token->next, &decl->ctype);
 813                 if (!match_op(token, ','))
 814                         break;
 815
 816                 ident = NULL;
 817                 decl = alloc_symbol(token->pos, SYM_NODE);
 818                 decl->ctype = ctype;
 819                 token = pointer(token, &decl->ctype);
 820                 token = declarator(token->next, &decl, &ident);
 821                 if (!ident) {
 822                         warn(token->pos, "expected identifier name in type definition");
 823                         return token;
 824                 }
 825
 826                 if (ctype.modifiers & MOD_TYPEDEF) {
 827                         bind_symbol(decl, ident, NS_TYPEDEF);
 828                 } else {
 829                         add_symbol(list, decl);
 830                         bind_symbol(decl, ident, NS_SYMBOL);
 831                 }
 832         }
 833         return expect(token, ';', "at end of declaration");
 834 }
 835
 836 void translation_unit(struct token *token, struct symbol_list **list)
 837 {
 838         while (!eof_token(token))
 839                 token = external_declaration(token, list);
 840 }