nsz Git - cparser/blob - parser.c

   1 #include <config.h>
   2
   3 #include <assert.h>
   4 #include <stdarg.h>
   5
   6 #include "parser.h"
   7 #include "lexer_t.h"
   8 #include "token_t.h"
   9 #include "type_t.h"
  10 #include "type_hash.h"
  11 #include "ast_t.h"
  12 #include "adt/bitfiddle.h"
  13 #include "adt/error.h"
  14 #include "adt/array.h"
  15
  16 #define PRINT_TOKENS
  17
  18 struct environment_entry_t {
  19         symbol_t            *symbol;
  20         environment_entry_t *old_entry;
  21         declaration_t       *declaration;
  22         unsigned short       old_symbol_ID;
  23 };
  24
  25 static token_t               token;
  26 static struct obstack        environment_obstack;
  27 static environment_entry_t **environment_stack = NULL;
  28 static translation_unit_t   *translation_unit  = NULL;
  29 static block_statement_t    *context           = NULL;
  30
  31 static
  32 statement_t *parse_compound_statement(void);
  33 static
  34 statement_t *parse_statement(void);
  35
  36 static
  37 expression_t *parse_sub_expression(unsigned precedence);
  38 static
  39 expression_t *parse_expression(void);
  40
  41 static inline
  42 void *allocate_ast_zero(size_t size)
  43 {
  44         void *res = allocate_ast(size);
  45         memset(res, 0, size);
  46         return res;
  47 }
  48
  49 static inline
  50 void *allocate_type_zero(size_t size)
  51 {
  52         void *res = obstack_alloc(type_obst, size);
  53         memset(res, 0, size);
  54         return res;
  55 }
  56
  57 /**
  58  * pushs an environment_entry on the environment stack and links the
  59  * corresponding symbol to the new entry
  60  */
  61 static inline
  62 environment_entry_t *environment_push(symbol_t *symbol)
  63 {
  64         environment_entry_t *entry
  65                 = obstack_alloc(&environment_obstack, sizeof(entry[0]));
  66         memset(entry, 0, sizeof(entry[0]));
  67
  68         int top = ARR_LEN(environment_stack);
  69         ARR_RESIZE(environment_stack, top + 1);
  70         environment_stack[top] = entry;
  71
  72         entry->old_entry = symbol->thing;
  73         entry->symbol    = symbol;
  74         symbol->thing    = entry;
  75
  76         return entry;
  77 }
  78
  79 /**
  80  * pops symbols from the environment stack until @p new_top is the top element
  81  */
  82 static inline
  83 void environment_pop_to(size_t new_top)
  84 {
  85         environment_entry_t *entry = NULL;
  86         size_t top = ARR_LEN(environment_stack);
  87         size_t i;
  88
  89         if(new_top == top)
  90                 return;
  91
  92         assert(new_top < top);
  93         i = top;
  94         do {
  95                 entry = environment_stack[i - 1];
  96
  97                 symbol_t *symbol = entry->symbol;
  98
  99 #if 0
 100                 if(entry->type == ENTRY_LOCAL_VARIABLE
 101                                 && entry->e.variable->refs == 0) {
 102                         variable_declaration_statement_t *variable = entry->e.variable;
 103                         print_warning_prefix(env, variable->statement.source_position);
 104                         fprintf(stderr, "variable '%s' was declared but never read\n",
 105                                 symbol->string);
 106                 }
 107 #endif
 108
 109                 if(entry->declaration->storage_class == STORAGE_CLASS_TYPEDEF) {
 110                         fprintf(stderr, "pop typename '%s'\n", entry->symbol->string);
 111                         symbol->ID = entry->old_symbol_ID;
 112                 }
 113
 114                 assert(symbol->thing == entry);
 115                 symbol->thing = entry->old_entry;
 116
 117                 --i;
 118         } while(i != new_top);
 119         obstack_free(&environment_obstack, entry);
 120
 121         ARR_SHRINKLEN(environment_stack, (int) new_top);
 122 }
 123
 124 /**
 125  * returns the top element of the environment stack
 126  */
 127 static inline
 128 size_t environment_top()
 129 {
 130         return ARR_LEN(environment_stack);
 131 }
 132
 133
 134
 135 static inline
 136 void next_token(void)
 137 {
 138         lexer_next_token(&token);
 139
 140 #ifdef PRINT_TOKENS
 141         print_token(stderr, &token);
 142         fprintf(stderr, "\n");
 143 #endif
 144 }
 145
 146 static inline
 147 void eat(token_type_t type)
 148 {
 149         assert(token.type == type);
 150         next_token();
 151 }
 152
 153 void parser_print_error_prefix(void)
 154 {
 155     fputs(source_position.input_name, stderr);
 156     fputc(':', stderr);
 157     fprintf(stderr, "%d", source_position.linenr);
 158     fputs(": error: ", stderr);
 159 }
 160
 161 static
 162 void parse_error(const char *message)
 163 {
 164         parser_print_error_prefix();
 165         fprintf(stderr, "parse error: %s\n", message);
 166 }
 167
 168 static
 169 void parse_error_expected(const char *message, ...)
 170 {
 171         va_list args;
 172         int first = 1;
 173
 174         if(message != NULL) {
 175                 parser_print_error_prefix();
 176                 fprintf(stderr, "%s\n", message);
 177         }
 178         parser_print_error_prefix();
 179         fputs("Parse error: got ", stderr);
 180         print_token(stderr, &token);
 181         fputs(", expected ", stderr);
 182
 183         va_start(args, message);
 184         token_type_t token_type = va_arg(args, token_type_t);
 185         while(token_type != 0) {
 186                 if(first == 1) {
 187                         first = 0;
 188                 } else {
 189                         fprintf(stderr, ", ");
 190                 }
 191                 print_token_type(stderr, token_type);
 192                 token_type = va_arg(args, token_type_t);
 193         }
 194         va_end(args);
 195         fprintf(stderr, "\n");
 196 }
 197
 198 static
 199 void eat_until_semi(void)
 200 {
 201         while(token.type != ';') {
 202                 next_token();
 203                 if(token.type == T_EOF)
 204                         return;
 205         }
 206         next_token();
 207 }
 208
 209 #define expect(expected)                           \
 210     if(UNLIKELY(token.type != (expected))) {       \
 211         parse_error_expected(NULL, (expected), 0); \
 212         eat_until_semi();                          \
 213         return NULL;                               \
 214     }                                              \
 215     next_token();
 216
 217 #define expect_void(expected)                      \
 218     if(UNLIKELY(token.type != (expected))) {       \
 219         parse_error_expected(NULL, (expected), 0); \
 220         eat_until_semi();                          \
 221         return;                                    \
 222     }                                              \
 223     next_token();
 224
 225 static expression_t *parse_constant_expression(void)
 226 {
 227         /* TODO: not correct yet */
 228         return parse_expression();
 229 }
 230
 231 static compound_entry_t *parse_compound_type_entries(void);
 232
 233 typedef struct declaration_specifiers_t  declaration_specifiers_t;
 234 struct declaration_specifiers_t {
 235         storage_class_t  storage_class;
 236         type_t          *type;
 237 };
 238
 239 static type_t *parse_struct_specifier(void)
 240 {
 241         eat(T_struct);
 242
 243         compound_type_t *struct_type = allocate_type_zero(sizeof(struct_type[0]));
 244         struct_type->type.type       = TYPE_COMPOUND_STRUCT;
 245         struct_type->source_position = source_position;
 246
 247         if(token.type == T_IDENTIFIER) {
 248                 /* TODO */
 249                 next_token();
 250                 if(token.type == '{') {
 251                         parse_compound_type_entries();
 252                 }
 253         } else if(token.type == '{') {
 254                 parse_compound_type_entries();
 255         } else {
 256                 parse_error_expected("problem while parsing struct type specifiers",
 257                                      T_IDENTIFIER, '{');
 258                 return NULL;
 259         }
 260
 261         return (type_t*) struct_type;
 262 }
 263
 264 static type_t *parse_union_specifier(void)
 265 {
 266         eat(T_union);
 267
 268         compound_type_t *union_type = allocate_type_zero(sizeof(union_type[0]));
 269         union_type->type.type       = TYPE_COMPOUND_UNION;
 270         union_type->source_position = source_position;
 271
 272         if(token.type == T_IDENTIFIER) {
 273                 /* TODO */
 274                 next_token();
 275                 if(token.type == '{') {
 276                         parse_compound_type_entries();
 277                 }
 278         } else if(token.type == '{') {
 279                 parse_compound_type_entries();
 280         } else {
 281                 parse_error_expected("problem while parsing union type specifiers",
 282                                      T_IDENTIFIER, '{');
 283         }
 284
 285         return (type_t*) union_type;
 286 }
 287
 288 typedef enum {
 289         SPECIFIER_SIGNED    = 1 << 0,
 290         SPECIFIER_UNSIGNED  = 1 << 1,
 291         SPECIFIER_LONG      = 1 << 2,
 292         SPECIFIER_INT       = 1 << 3,
 293         SPECIFIER_DOUBLE    = 1 << 4,
 294         SPECIFIER_CHAR      = 1 << 5,
 295         SPECIFIER_SHORT     = 1 << 6,
 296         SPECIFIER_LONG_LONG = 1 << 7,
 297         SPECIFIER_FLOAT     = 1 << 8,
 298         SPECIFIER_BOOL      = 1 << 9,
 299         SPECIFIER_VOID      = 1 << 10,
 300 #ifdef PROVIDE_COMPLEX
 301         SPECIFIER_COMPLEX   = 1 << 11,
 302 #endif
 303 #ifdef PROVIDE_IMAGINARY
 304         SPECIFIER_IMAGINARY = 1 << 12,
 305 #endif
 306 } specifiers_t;
 307
 308 #define STORAGE_CLASSES     \
 309         case T_typedef:         \
 310         case T_extern:          \
 311         case T_static:          \
 312         case T_auto:            \
 313         case T_register:
 314
 315 #define TYPE_QUALIFIERS     \
 316         case T_const:           \
 317         case T_restrict:        \
 318         case T_volatile:        \
 319         case T_inline:          \
 320         case T___extension__:   \
 321         case T___attribute__:
 322
 323 #ifdef PROVIDE_COMPLEX
 324 #define COMPLEX_SPECIFIERS  \
 325         case T__Complex:
 326 #else
 327 #define COMPLEX_SPECIFIERS
 328 #endif
 329
 330 #ifdef PROVIDE_IMAGINARY
 331 #define IMAGINARY_SPECIFIERS \
 332         case T__Imaginary:
 333 #else
 334 #define IMAGINARY_SPECIFIERS
 335 #endif
 336
 337 #define TYPE_SPECIFIERS     \
 338         case T_TYPENAME:        \
 339         case T_void:            \
 340         case T_char:            \
 341         case T_short:           \
 342         case T_int:             \
 343         case T_long:            \
 344         case T_float:           \
 345         case T_double:          \
 346         case T_signed:          \
 347         case T_unsigned:        \
 348         case T__Bool:           \
 349         case T_struct:          \
 350         case T_union:           \
 351         case T_enum:            \
 352         case T___quad_t:        \
 353         case T___u_quad_t:      \
 354         COMPLEX_SPECIFIERS      \
 355         IMAGINARY_SPECIFIERS
 356
 357 static
 358 void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
 359 {
 360         type_t             *type            = NULL;
 361         unsigned            type_qualifiers = 0;
 362         unsigned            type_specifiers = 0;
 363
 364         while(1) {
 365                 switch(token.type) {
 366
 367                 /* storage class */
 368 #define MATCH_STORAGE_CLASS(token, class)                                \
 369                 case token:                                                      \
 370                         if(specifiers->storage_class != STORAGE_CLASS_NONE) {        \
 371                                 parse_error("multiple storage classes in declaration "   \
 372                                             "specifiers");                               \
 373                         }                                                            \
 374                         specifiers->storage_class = class;                           \
 375                         next_token();                                                \
 376                         break;
 377
 378                 MATCH_STORAGE_CLASS(T_typedef,  STORAGE_CLASS_TYPEDEF)
 379                 MATCH_STORAGE_CLASS(T_extern,   STORAGE_CLASS_EXTERN)
 380                 MATCH_STORAGE_CLASS(T_static,   STORAGE_CLASS_STATIC)
 381                 MATCH_STORAGE_CLASS(T_auto,     STORAGE_CLASS_AUTO)
 382                 MATCH_STORAGE_CLASS(T_register, STORAGE_CLASS_REGISTER)
 383
 384                 /* type qualifiers */
 385 #define MATCH_TYPE_QUALIFIER(token, qualifier)                          \
 386                 case token:                                                     \
 387                         type_qualifiers |= qualifier;                               \
 388                         next_token();                                               \
 389                         break;
 390
 391                 MATCH_TYPE_QUALIFIER(T_const,    TYPE_QUALIFIER_CONST);
 392                 MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
 393                 MATCH_TYPE_QUALIFIER(T_volatile, TYPE_QUALIFIER_VOLATILE);
 394                 MATCH_TYPE_QUALIFIER(T_inline,   TYPE_QUALIFIER_INLINE);
 395
 396                 case T___extension__:
 397                         /* TODO */
 398                         next_token();
 399                         break;
 400
 401                 case T___attribute__:
 402                         fprintf(stderr, "TODO: __attribute__ not handled yet\n");
 403                         next_token();
 404                         break;
 405
 406                 /* type specifiers */
 407 #define MATCH_SPECIFIER(token, specifier, name)                         \
 408                 case token:                                                     \
 409                         next_token();                                               \
 410                         if(type_specifiers & specifier) {                           \
 411                                 parse_error("multiple " name " type specifiers given"); \
 412                         } else {                                                    \
 413                                 type_specifiers |= specifier;                           \
 414                         }                                                           \
 415                         break;
 416
 417                 MATCH_SPECIFIER(T_void,       SPECIFIER_VOID,      "void")
 418                 MATCH_SPECIFIER(T_char,       SPECIFIER_CHAR,      "char")
 419                 MATCH_SPECIFIER(T_short,      SPECIFIER_SHORT,     "short")
 420                 MATCH_SPECIFIER(T_int,        SPECIFIER_INT,       "int")
 421                 MATCH_SPECIFIER(T_float,      SPECIFIER_FLOAT,     "float")
 422                 MATCH_SPECIFIER(T_double,     SPECIFIER_DOUBLE,    "double")
 423                 MATCH_SPECIFIER(T_signed,     SPECIFIER_SIGNED,    "signed")
 424                 MATCH_SPECIFIER(T_unsigned,   SPECIFIER_UNSIGNED,  "unsigned")
 425                 MATCH_SPECIFIER(T__Bool,      SPECIFIER_BOOL,      "_Bool")
 426 #ifdef PROVIDE_COMPLEX
 427                 MATCH_SPECIFIER(T__Complex,   SPECIFIER_COMPLEX,   "_Complex")
 428 #endif
 429 #ifdef PROVIDE_IMAGINARY
 430                 MATCH_SPECIFIER(T__Imaginary, SPECIFIER_IMAGINARY, "_Imaginary")
 431 #endif
 432                 case T_long:
 433                         next_token();
 434                         if(type_specifiers & SPECIFIER_LONG_LONG) {
 435                                 parse_error("multiple type specifiers given");
 436                         } else if(type_specifiers & SPECIFIER_LONG) {
 437                                 type_specifiers |= SPECIFIER_LONG_LONG;
 438                         } else {
 439                                 type_specifiers |= SPECIFIER_LONG;
 440                         }
 441                         break;
 442
 443                 case T___quad_t:
 444                         next_token();
 445                         if(type_specifiers & SPECIFIER_LONG_LONG ||
 446                                         type_specifiers & SPECIFIER_LONG) {
 447                                 parse_error("multiple type specifiers given");
 448                         } else {
 449                                 type_specifiers |= SPECIFIER_LONG_LONG;
 450                         }
 451                         break;
 452
 453                 case T___u_quad_t:
 454                         next_token();
 455                         if(type_specifiers & SPECIFIER_LONG_LONG ||
 456                                         type_specifiers & SPECIFIER_LONG ||
 457                                         type_specifiers & SPECIFIER_UNSIGNED) {
 458                                 parse_error("multiple type specifiers given");
 459                         } else {
 460                                 type_specifiers |= SPECIFIER_LONG_LONG | SPECIFIER_UNSIGNED;
 461                         }
 462                         break;
 463
 464                 case T_struct:
 465                         type = parse_struct_specifier();
 466                         break;
 467                 case T_union:
 468                         type = parse_union_specifier();
 469                         break;
 470                 case T_enum:
 471                         /* TODO */
 472                         assert(0);
 473                         break;
 474
 475                 case T_TYPENAME:
 476                         if(type != NULL || type_specifiers != 0) {
 477                                 goto finish_specifiers;
 478                         }
 479
 480                         type = token.v.symbol->thing->declaration->type;
 481                         assert(type != NULL);
 482                         next_token();
 483                         break;
 484
 485                 /* function specifier */
 486                 default:
 487                         goto finish_specifiers;
 488                 }
 489         }
 490
 491 finish_specifiers:
 492
 493         if(type == NULL) {
 494                 atomic_type_type_t atomic_type;
 495
 496                 /* match valid basic types */
 497                 switch(type_specifiers) {
 498                 case SPECIFIER_VOID:
 499                         atomic_type = ATOMIC_TYPE_VOID;
 500                         break;
 501                 case SPECIFIER_CHAR:
 502                         atomic_type = ATOMIC_TYPE_CHAR;
 503                         break;
 504                 case SPECIFIER_SIGNED | SPECIFIER_CHAR:
 505                         atomic_type = ATOMIC_TYPE_SCHAR;
 506                         break;
 507                 case SPECIFIER_UNSIGNED | SPECIFIER_CHAR:
 508                         atomic_type = ATOMIC_TYPE_UCHAR;
 509                         break;
 510                 case SPECIFIER_SHORT:
 511                 case SPECIFIER_SIGNED | SPECIFIER_SHORT:
 512                 case SPECIFIER_SHORT | SPECIFIER_INT:
 513                 case SPECIFIER_SIGNED | SPECIFIER_SHORT | SPECIFIER_INT:
 514                         atomic_type = ATOMIC_TYPE_SHORT;
 515                         break;
 516                 case SPECIFIER_UNSIGNED | SPECIFIER_SHORT:
 517                 case SPECIFIER_UNSIGNED | SPECIFIER_SHORT | SPECIFIER_INT:
 518                         atomic_type = ATOMIC_TYPE_USHORT;
 519                         break;
 520                 case SPECIFIER_INT:
 521                 case SPECIFIER_SIGNED:
 522                 case SPECIFIER_SIGNED | SPECIFIER_INT:
 523                         atomic_type = ATOMIC_TYPE_INT;
 524                         break;
 525                 case SPECIFIER_UNSIGNED:
 526                 case SPECIFIER_UNSIGNED | SPECIFIER_INT:
 527                         atomic_type = ATOMIC_TYPE_UINT;
 528                         break;
 529                 case SPECIFIER_LONG:
 530                 case SPECIFIER_SIGNED | SPECIFIER_LONG:
 531                 case SPECIFIER_LONG | SPECIFIER_INT:
 532                 case SPECIFIER_SIGNED | SPECIFIER_LONG | SPECIFIER_INT:
 533                         atomic_type = ATOMIC_TYPE_LONG;
 534                         break;
 535                 case SPECIFIER_UNSIGNED | SPECIFIER_LONG:
 536                 case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_INT:
 537                         atomic_type = ATOMIC_TYPE_ULONG;
 538                         break;
 539                 case SPECIFIER_LONG_LONG:
 540                 case SPECIFIER_SIGNED | SPECIFIER_LONG_LONG:
 541                 case SPECIFIER_LONG_LONG | SPECIFIER_INT:
 542                 case SPECIFIER_SIGNED | SPECIFIER_LONG_LONG | SPECIFIER_INT:
 543                         atomic_type = ATOMIC_TYPE_LONGLONG;
 544                         break;
 545                 case SPECIFIER_UNSIGNED | SPECIFIER_LONG_LONG:
 546                 case SPECIFIER_UNSIGNED | SPECIFIER_LONG_LONG | SPECIFIER_INT:
 547                         atomic_type = ATOMIC_TYPE_ULONGLONG;
 548                         break;
 549                 case SPECIFIER_FLOAT:
 550                         atomic_type = ATOMIC_TYPE_FLOAT;
 551                         break;
 552                 case SPECIFIER_DOUBLE:
 553                         atomic_type = ATOMIC_TYPE_DOUBLE;
 554                         break;
 555                 case SPECIFIER_LONG | SPECIFIER_DOUBLE:
 556                         atomic_type = ATOMIC_TYPE_LONG_DOUBLE;
 557                         break;
 558                 case SPECIFIER_BOOL:
 559                         atomic_type = ATOMIC_TYPE_BOOL;
 560                         break;
 561 #ifdef PROVIDE_COMPLEX
 562                 case SPECIFIER_FLOAT | SPECIFIER_COMPLEX:
 563                         atomic_type = ATOMIC_TYPE_FLOAT_COMPLEX;
 564                         break;
 565                 case SPECIFIER_DOUBLE | SPECIFIER_COMPLEX:
 566                         atomic_type = ATOMIC_TYPE_DOUBLE_COMPLEX;
 567                         break;
 568                 case SPECIFIER_LONG | SPECIFIER_DOUBLE | SPECIFIER_COMPLEX:
 569                         atomic_type = ATOMIC_TYPE_LONG_DOUBLE_COMPLEX;
 570                         break;
 571 #endif
 572 #ifdef PROVIDE_IMAGINARY
 573                 case SPECIFIER_FLOAT | SPECIFIER_IMAGINARY:
 574                         atomic_type = ATOMIC_TYPE_FLOAT_IMAGINARY;
 575                         break;
 576                 case SPECIFIER_DOUBLE | SPECIFIER_IMAGINARY:
 577                         atomic_type = ATOMIC_TYPE_DOUBLE_IMAGINARY;
 578                         break;
 579                 case SPECIFIER_LONG | SPECIFIER_DOUBLE | SPECIFIER_IMAGINARY:
 580                         atomic_type = ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY;
 581                         break;
 582 #endif
 583                 default:
 584                         /* invalid specifier combination, give an error message */
 585                         if(type_specifiers == 0) {
 586                                 parse_error("no type specifiers given in declaration");
 587                         } else if((type_specifiers & SPECIFIER_SIGNED) &&
 588                                   (type_specifiers & SPECIFIER_UNSIGNED)) {
 589                                 parse_error("signed and unsigned specifiers gives");
 590                         } else if(type_specifiers & (SPECIFIER_SIGNED | SPECIFIER_UNSIGNED)) {
 591                                 parse_error("only integer types can be signed or unsigned");
 592                         } else {
 593                                 parse_error("multiple datatypes in declaration");
 594                         }
 595                         atomic_type = ATOMIC_TYPE_INVALID;
 596                 }
 597
 598                 atomic_type_t *atype = allocate_type_zero(sizeof(atype[0]));
 599                 atype->type.type     = TYPE_ATOMIC;
 600                 atype->atype         = atomic_type;
 601
 602                 type = (type_t*) atype;
 603         } else {
 604                 if(type_specifiers != 0) {
 605                         parse_error("multiple datatypes in declaration");
 606                 }
 607         }
 608
 609         type->qualifiers = type_qualifiers;
 610
 611         type_t *result = typehash_insert(type);
 612         if(result != (type_t*) type) {
 613                 obstack_free(type_obst, type);
 614         }
 615
 616         specifiers->type = result;
 617
 618         fprintf(stderr, "Specifiers type: ");
 619         print_type(stderr, result);
 620         fprintf(stderr, "\n");
 621 }
 622
 623 static
 624 unsigned parse_type_qualifiers()
 625 {
 626         unsigned type_qualifiers = 0;
 627
 628         while(1) {
 629                 switch(token.type) {
 630                 /* type qualifiers */
 631                 MATCH_TYPE_QUALIFIER(T_const,    TYPE_QUALIFIER_CONST);
 632                 MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
 633                 MATCH_TYPE_QUALIFIER(T_volatile, TYPE_QUALIFIER_VOLATILE);
 634                 MATCH_TYPE_QUALIFIER(T_inline,   TYPE_QUALIFIER_INLINE);
 635
 636                 default:
 637                         return type_qualifiers;
 638                 }
 639         }
 640 }
 641
 642 static
 643 void parse_declarator(declaration_t *declaration, storage_class_t storage_class,
 644                       type_t *type)
 645 {
 646         while(token.type == '*') {
 647                 /* pointer */
 648                 next_token();
 649
 650                 pointer_type_t *pointer_type
 651                         = allocate_type_zero(sizeof(pointer_type[0]));
 652                 pointer_type->type.type = TYPE_POINTER;
 653                 pointer_type->points_to = type;
 654
 655                 pointer_type->type.qualifiers = parse_type_qualifiers();
 656
 657                 type_t *result = typehash_insert((type_t*) pointer_type);
 658                 if(result != (type_t*) pointer_type) {
 659                         obstack_free(type_obst, pointer_type);
 660                 }
 661
 662                 type = result;
 663         }
 664         declaration->storage_class = storage_class;
 665         declaration->type          = type;
 666
 667         switch(token.type) {
 668         case T_TYPENAME:
 669         case T_IDENTIFIER:
 670                 declaration->symbol = token.v.symbol;
 671                 next_token();
 672                 break;
 673         case '(':
 674                 next_token();
 675                 parse_declarator(declaration, storage_class, type);
 676                 expect_void(')');
 677                 break;
 678         default:
 679                 parse_error("problem while parsing declarator");
 680         }
 681
 682         if(token.type == '(') {
 683                 next_token();
 684
 685                 /* parse parameter-type-list or identifier-list */
 686
 687                 expect_void(')');
 688         } else if(token.type == '[') {
 689                 next_token();
 690
 691                 /* multiple type qualifiers, and static */
 692
 693                 /* assignment_expression or '*' or nothing */
 694
 695                 expect_void(']');
 696         }
 697
 698         fprintf(stderr, "Declarator type: ");
 699         print_type(stderr, type);
 700         fprintf(stderr, "\n");
 701
 702         symbol_t *symbol = declaration->symbol;
 703
 704         environment_entry_t *entry = environment_push(symbol);
 705         entry->declaration         = declaration;
 706         entry->old_symbol_ID       = symbol->ID;
 707
 708         if(storage_class == STORAGE_CLASS_TYPEDEF) {
 709                 symbol->ID       = T_TYPENAME;
 710         } else {
 711                 symbol->ID       = T_IDENTIFIER;
 712         }
 713 }
 714
 715 static
 716 void parse_init_declarators(const declaration_specifiers_t *specifiers)
 717 {
 718         while(1) {
 719                 declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
 720
 721                 parse_declarator(declaration, specifiers->storage_class,
 722                                  specifiers->type);
 723                 if(token.type == '=') {
 724                         next_token();
 725                         // parse_initializer TODO
 726                 } else if(token.type == '{') {
 727                         parse_compound_statement();
 728                         return;
 729                 }
 730
 731                 if(token.type != ',')
 732                         break;
 733                 next_token();
 734         }
 735         expect_void(';');
 736 }
 737
 738 static
 739 void parse_struct_declarators(const declaration_specifiers_t *specifiers)
 740 {
 741         while(1) {
 742                 declaration_t declaration;
 743                 compound_entry_t *entry = allocate_ast_zero(sizeof(entry[0]));
 744
 745                 if(token.type == ':') {
 746                         next_token();
 747                         parse_constant_expression();
 748                         /* TODO */
 749                 } else {
 750                         parse_declarator(&declaration, specifiers->storage_class,
 751                                          specifiers->type);
 752
 753                         if(token.type == ':') {
 754                                 next_token();
 755                                 parse_constant_expression();
 756                                 /* TODO */
 757                         }
 758                 }
 759
 760                 if(token.type != ',')
 761                         break;
 762                 next_token();
 763         }
 764         expect_void(';');
 765 }
 766
 767 static compound_entry_t *parse_compound_type_entries(void)
 768 {
 769         eat('{');
 770
 771         compound_entry_t *entries = NULL;
 772
 773         while(token.type != '}' && token.type != T_EOF) {
 774                 declaration_specifiers_t specifiers;
 775                 memset(&specifiers, 0, sizeof(specifiers));
 776                 /* TODO not correct as this allows storage class stuff... but only
 777                  * specifiers and qualifiers sould be allowed here */
 778                 parse_declaration_specifiers(&specifiers);
 779
 780                 parse_struct_declarators(&specifiers);
 781         }
 782         next_token();
 783
 784         return entries;
 785 }
 786
 787 void parse_declaration(void)
 788 {
 789         declaration_specifiers_t specifiers;
 790         memset(&specifiers, 0, sizeof(specifiers));
 791         parse_declaration_specifiers(&specifiers);
 792
 793         if(token.type == ';') {
 794                 next_token();
 795                 return;
 796         }
 797         parse_init_declarators(&specifiers);
 798 }
 799
 800
 801
 802 typedef expression_t* (*parse_expression_function) (unsigned precedence);
 803 typedef expression_t* (*parse_expression_infix_function) (unsigned precedence,
 804                                                           expression_t *left);
 805
 806 typedef struct expression_parser_function_t expression_parser_function_t;
 807 struct expression_parser_function_t {
 808         unsigned                         precedence;
 809         parse_expression_function        parser;
 810         unsigned                         infix_precedence;
 811         parse_expression_infix_function  infix_parser;
 812 };
 813
 814 expression_parser_function_t expression_parsers[T_LAST_TOKEN];
 815
 816 static
 817 expression_t *expected_expression_error(void)
 818 {
 819         parser_print_error_prefix();
 820         fprintf(stderr, "expected expression, got token ");
 821         print_token(stderr, & token);
 822         fprintf(stderr, "\n");
 823
 824         expression_t *expression = allocate_ast_zero(sizeof(expression[0]));
 825         expression->type = EXPR_INVALID;
 826         next_token();
 827
 828         return expression;
 829 }
 830
 831 static
 832 expression_t *parse_string_const(void)
 833 {
 834         string_literal_t *cnst = allocate_ast_zero(sizeof(cnst[0]));
 835
 836         cnst->expression.type = EXPR_STRING_LITERAL;
 837         cnst->value           = token.v.string;
 838
 839         next_token();
 840
 841         return (expression_t*) cnst;
 842 }
 843
 844 static
 845 expression_t *parse_int_const(void)
 846 {
 847         const_t *cnst = allocate_ast_zero(sizeof(cnst[0]));
 848
 849         cnst->expression.type = EXPR_CONST;
 850         cnst->value           = token.v.intvalue;
 851
 852         next_token();
 853
 854         return (expression_t*) cnst;
 855 }
 856
 857 static
 858 expression_t *parse_reference(void)
 859 {
 860         reference_expression_t *ref = allocate_ast_zero(sizeof(ref[0]));
 861
 862         ref->expression.type            = EXPR_REFERENCE;
 863         ref->symbol                     = token.v.symbol;
 864
 865         next_token();
 866
 867         return (expression_t*) ref;
 868 }
 869
 870 static
 871 expression_t *parse_brace_expression(void)
 872 {
 873         eat('(');
 874
 875         expression_t *result = parse_expression();
 876         expect(')');
 877
 878         return result;
 879 }
 880
 881 static
 882 expression_t *parse_primary_expression(void)
 883 {
 884         switch(token.type) {
 885         case T_INTEGER:
 886                 return parse_int_const();
 887         case T_STRING_LITERAL:
 888                 return parse_string_const();
 889         case T_IDENTIFIER:
 890                 return parse_reference();
 891         case '(':
 892                 return parse_brace_expression();
 893         }
 894
 895         /* TODO: error message */
 896         return NULL;
 897 }
 898
 899 static
 900 expression_t *parse_array_expression(unsigned precedence,
 901                                      expression_t *array_ref)
 902 {
 903         (void) precedence;
 904
 905         eat('[');
 906
 907         array_access_expression_t *array_access
 908                 = allocate_ast_zero(sizeof(array_access[0]));
 909
 910         array_access->expression.type = EXPR_ARRAY_ACCESS;
 911         array_access->array_ref       = array_ref;
 912         array_access->index           = parse_expression();
 913
 914         if(token.type != ']') {
 915                 parse_error_expected("Problem while parsing array access", ']', 0);
 916                 return NULL;
 917         }
 918         next_token();
 919
 920         return (expression_t*) array_access;
 921 }
 922
 923 static
 924 expression_t *parse_sizeof(unsigned precedence)
 925 {
 926         (void) precedence;
 927         eat(T_sizeof);
 928         /* TODO... */
 929
 930         return NULL;
 931 }
 932
 933 static
 934 expression_t *parse_select_expression(unsigned precedence,
 935                                       expression_t *compound)
 936 {
 937         (void) precedence;
 938
 939         assert(token.type == '.' || token.type == T_SELECT);
 940         next_token();
 941
 942         select_expression_t *select = allocate_ast_zero(sizeof(select[0]));
 943
 944         select->expression.type = EXPR_SELECT;
 945         select->compound        = compound;
 946
 947         if(token.type != T_IDENTIFIER) {
 948                 parse_error_expected("Problem while parsing compound select",
 949                                      T_IDENTIFIER, 0);
 950                 return NULL;
 951         }
 952         select->symbol = token.v.symbol;
 953         next_token();
 954
 955         return (expression_t*) select;
 956 }
 957
 958 static
 959 expression_t *parse_call_expression(unsigned precedence,
 960                                     expression_t *expression)
 961 {
 962         (void) precedence;
 963         call_expression_t *call = allocate_ast_zero(sizeof(call[0]));
 964
 965         call->expression.type            = EXPR_CALL;
 966         call->method                     = expression;
 967
 968         /* parse arguments */
 969         eat('(');
 970
 971         if(token.type != ')') {
 972                 call_argument_t *last_argument = NULL;
 973
 974                 while(1) {
 975                         call_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
 976
 977                         argument->expression = parse_expression();
 978                         if(last_argument == NULL) {
 979                                 call->arguments = argument;
 980                         } else {
 981                                 last_argument->next = argument;
 982                         }
 983                         last_argument = argument;
 984
 985                         if(token.type != ',')
 986                                 break;
 987                         next_token();
 988                 }
 989         }
 990         expect(')');
 991
 992         return (expression_t*) call;
 993 }
 994
 995 #define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type)     \
 996 static                                                                    \
 997 expression_t *parse_##unexpression_type(unsigned precedence)              \
 998 {                                                                         \
 999         eat(token_type);                                                      \
1000                                                                           \
1001         unary_expression_t *unary_expression                                  \
1002                 = allocate_ast_zero(sizeof(unary_expression[0]));                 \
1003         unary_expression->expression.type = EXPR_UNARY;                       \
1004         unary_expression->type            = unexpression_type;                \
1005         unary_expression->value           = parse_sub_expression(precedence); \
1006                                                                           \
1007         return (expression_t*) unary_expression;                              \
1008 }
1009
1010 CREATE_UNARY_EXPRESSION_PARSER('-', UNEXPR_NEGATE)
1011 CREATE_UNARY_EXPRESSION_PARSER('+', UNEXPR_PLUS)
1012 CREATE_UNARY_EXPRESSION_PARSER('!', UNEXPR_NOT)
1013 CREATE_UNARY_EXPRESSION_PARSER('*', UNEXPR_DEREFERENCE)
1014 CREATE_UNARY_EXPRESSION_PARSER('&', UNEXPR_TAKE_ADDRESS)
1015 CREATE_UNARY_EXPRESSION_PARSER('~', UNEXPR_BITWISE_NEGATE)
1016 CREATE_UNARY_EXPRESSION_PARSER(T_PLUSPLUS,   UNEXPR_PREFIX_INCREMENT)
1017 CREATE_UNARY_EXPRESSION_PARSER(T_MINUSMINUS, UNEXPR_PREFIX_DECREMENT)
1018
1019 #define CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(token_type, unexpression_type) \
1020 static                                                                        \
1021 expression_t *parse_##unexpression_type(unsigned precedence,                  \
1022                                         expression_t *left)                   \
1023 {                                                                             \
1024         (void) precedence;                                                        \
1025         eat(token_type);                                                          \
1026                                                                               \
1027         unary_expression_t *unary_expression                                      \
1028                 = allocate_ast_zero(sizeof(unary_expression[0]));                     \
1029         unary_expression->expression.type = EXPR_UNARY;                           \
1030         unary_expression->type            = unexpression_type;                    \
1031         unary_expression->value           = left;                                 \
1032                                                                               \
1033         return (expression_t*) unary_expression;                                  \
1034 }
1035
1036 CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(T_PLUSPLUS,   UNEXPR_POSTFIX_INCREMENT)
1037 CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(T_MINUSMINUS, UNEXPR_POSTFIX_DECREMENT)
1038
1039 #define CREATE_BINEXPR_PARSER(token_type, binexpression_type)    \
1040 static                                                           \
1041 expression_t *parse_##binexpression_type(unsigned precedence,    \
1042                                          expression_t *left)     \
1043 {                                                                \
1044         eat(token_type);                                             \
1045                                                                  \
1046         expression_t *right = parse_sub_expression(precedence);      \
1047                                                                  \
1048         binary_expression_t *binexpr                                 \
1049                 = allocate_ast_zero(sizeof(binexpr[0]));                 \
1050         binexpr->expression.type            = EXPR_BINARY;           \
1051         binexpr->type                       = binexpression_type;    \
1052         binexpr->left                       = left;                  \
1053         binexpr->right                      = right;                 \
1054                                                                  \
1055         return (expression_t*) binexpr;                              \
1056 }
1057
1058 CREATE_BINEXPR_PARSER('*', BINEXPR_MUL)
1059 CREATE_BINEXPR_PARSER('/', BINEXPR_DIV)
1060 CREATE_BINEXPR_PARSER('+', BINEXPR_ADD)
1061 CREATE_BINEXPR_PARSER('-', BINEXPR_SUB)
1062 CREATE_BINEXPR_PARSER('<', BINEXPR_LESS)
1063 CREATE_BINEXPR_PARSER('>', BINEXPR_GREATER)
1064 CREATE_BINEXPR_PARSER('=', BINEXPR_ASSIGN)
1065 CREATE_BINEXPR_PARSER(T_EQUALEQUAL, BINEXPR_EQUAL)
1066 CREATE_BINEXPR_PARSER(T_SLASHEQUAL, BINEXPR_NOTEQUAL)
1067 CREATE_BINEXPR_PARSER(T_LESSEQUAL, BINEXPR_LESSEQUAL)
1068 CREATE_BINEXPR_PARSER(T_GREATEREQUAL, BINEXPR_GREATEREQUAL)
1069 CREATE_BINEXPR_PARSER('&', BINEXPR_BITWISE_AND)
1070 CREATE_BINEXPR_PARSER('|', BINEXPR_BITWISE_OR)
1071 CREATE_BINEXPR_PARSER('^', BINEXPR_BITWISE_XOR)
1072 CREATE_BINEXPR_PARSER(T_LESSLESS, BINEXPR_SHIFTLEFT)
1073 CREATE_BINEXPR_PARSER(T_GREATERGREATER, BINEXPR_SHIFTRIGHT)
1074
1075 static
1076 expression_t *parse_sub_expression(unsigned precedence)
1077 {
1078         if(token.type < 0) {
1079                 return expected_expression_error();
1080         }
1081
1082         expression_parser_function_t *parser
1083                 = &expression_parsers[token.type];
1084         source_position_t             source_position = source_position;
1085         expression_t                 *left;
1086
1087         if(parser->parser != NULL) {
1088                 left = parser->parser(parser->precedence);
1089         } else {
1090                 left = parse_primary_expression();
1091         }
1092         if(left != NULL)
1093                 left->source_position = source_position;
1094
1095         while(1) {
1096                 if(token.type < 0) {
1097                         return expected_expression_error();
1098                 }
1099
1100                 parser = &expression_parsers[token.type];
1101                 if(parser->infix_parser == NULL)
1102                         break;
1103                 if(parser->infix_precedence < precedence)
1104                         break;
1105
1106                 left = parser->infix_parser(parser->infix_precedence, left);
1107                 if(left != NULL)
1108                         left->source_position = source_position;
1109         }
1110
1111         return left;
1112 }
1113
1114 static
1115 expression_t *parse_expression(void)
1116 {
1117         return parse_sub_expression(1);
1118 }
1119
1120
1121
1122 void register_expression_parser(parse_expression_function parser,
1123                                 int token_type, unsigned precedence)
1124 {
1125         expression_parser_function_t *entry = &expression_parsers[token_type];
1126
1127         if(entry->parser != NULL) {
1128                 fprintf(stderr, "for token ");
1129                 print_token_type(stderr, token_type);
1130                 fprintf(stderr, "\n");
1131                 panic("trying to register multiple expression parsers for a token");
1132         }
1133         entry->parser     = parser;
1134         entry->precedence = precedence;
1135 }
1136
1137 void register_expression_infix_parser(parse_expression_infix_function parser,
1138                                       int token_type, unsigned precedence)
1139 {
1140         expression_parser_function_t *entry = &expression_parsers[token_type];
1141
1142         if(entry->infix_parser != NULL) {
1143                 fprintf(stderr, "for token ");
1144                 print_token_type(stderr, token_type);
1145                 fprintf(stderr, "\n");
1146                 panic("trying to register multiple infix expression parsers for a "
1147                       "token");
1148         }
1149         entry->infix_parser     = parser;
1150         entry->infix_precedence = precedence;
1151 }
1152
1153 static
1154 void init_expression_parsers(void)
1155 {
1156         memset(&expression_parsers, 0, sizeof(expression_parsers));
1157
1158         register_expression_infix_parser(parse_BINEXPR_MUL,       '*', 16);
1159         register_expression_infix_parser(parse_BINEXPR_DIV,       '/', 16);
1160         register_expression_infix_parser(parse_BINEXPR_SHIFTLEFT,
1161                                    T_LESSLESS, 16);
1162         register_expression_infix_parser(parse_BINEXPR_SHIFTRIGHT,
1163                                    T_GREATERGREATER, 16);
1164         register_expression_infix_parser(parse_BINEXPR_ADD,       '+', 15);
1165         register_expression_infix_parser(parse_BINEXPR_SUB,       '-', 15);
1166         register_expression_infix_parser(parse_BINEXPR_LESS,      '<', 14);
1167         register_expression_infix_parser(parse_BINEXPR_GREATER,   '>', 14);
1168         register_expression_infix_parser(parse_BINEXPR_LESSEQUAL, T_LESSEQUAL, 14);
1169         register_expression_infix_parser(parse_BINEXPR_GREATEREQUAL,
1170                                    T_GREATEREQUAL, 14);
1171         register_expression_infix_parser(parse_BINEXPR_EQUAL,     T_EQUALEQUAL, 13);
1172         register_expression_infix_parser(parse_BINEXPR_NOTEQUAL,
1173                                          T_EXCLAMATIONMARKEQUAL, 13);
1174         register_expression_infix_parser(parse_BINEXPR_BITWISE_AND, '&',        12);
1175         register_expression_infix_parser(parse_BINEXPR_BITWISE_XOR, '^',        11);
1176         register_expression_infix_parser(parse_BINEXPR_BITWISE_OR,  '|',        10);
1177         register_expression_infix_parser(parse_BINEXPR_ASSIGN,      T_EQUAL,     2);
1178
1179         register_expression_infix_parser(parse_array_expression,        '[',    30);
1180         register_expression_infix_parser(parse_call_expression,         '(',    30);
1181         register_expression_infix_parser(parse_select_expression,       '.',    30);
1182         register_expression_infix_parser(parse_select_expression,  T_SELECT,    30);
1183         register_expression_infix_parser(parse_UNEXPR_POSTFIX_INCREMENT,
1184                                          T_PLUSPLUS, 30);
1185         register_expression_infix_parser(parse_UNEXPR_POSTFIX_DECREMENT,
1186                                          T_MINUSMINUS, 30);
1187
1188         register_expression_parser(parse_UNEXPR_NEGATE,           '-',          25);
1189         register_expression_parser(parse_UNEXPR_PLUS,             '+',          25);
1190         register_expression_parser(parse_UNEXPR_NOT,              '!',          25);
1191         register_expression_parser(parse_UNEXPR_BITWISE_NEGATE,   '~',          25);
1192         register_expression_parser(parse_UNEXPR_DEREFERENCE,      '*',          25);
1193         register_expression_parser(parse_UNEXPR_TAKE_ADDRESS,     '&',          25);
1194         register_expression_parser(parse_UNEXPR_PREFIX_INCREMENT, T_PLUSPLUS,   25);
1195         register_expression_parser(parse_UNEXPR_PREFIX_DECREMENT, T_MINUSMINUS, 25);
1196         register_expression_parser(parse_sizeof,                  T_sizeof,     25);
1197 }
1198
1199
1200 static
1201 statement_t *parse_case_statement(void)
1202 {
1203         eat(T_case);
1204         parse_expression();
1205         expect(':');
1206         parse_statement();
1207
1208         return NULL;
1209 }
1210
1211 static
1212 statement_t *parse_default_statement(void)
1213 {
1214         eat(T_default);
1215         expect(':');
1216         parse_statement();
1217
1218         return NULL;
1219 }
1220
1221 static
1222 statement_t *parse_label_statement(void)
1223 {
1224         eat(T_IDENTIFIER);
1225         expect(';');
1226         parse_statement();
1227
1228         return NULL;
1229 }
1230
1231 static
1232 statement_t *parse_if(void)
1233 {
1234         eat(T_if);
1235         expect('(');
1236         parse_expression();
1237         expect(')');
1238
1239         parse_statement();
1240         if(token.type == T_else) {
1241                 next_token();
1242                 parse_statement();
1243         }
1244
1245         return NULL;
1246 }
1247
1248 static
1249 statement_t *parse_switch(void)
1250 {
1251         eat(T_switch);
1252         expect('(');
1253         parse_expression();
1254         expect(')');
1255         parse_statement();
1256
1257         return NULL;
1258 }
1259
1260 static
1261 statement_t *parse_while(void)
1262 {
1263         eat(T_while);
1264         expect('(');
1265         parse_expression();
1266         expect(')');
1267         parse_statement();
1268
1269         return NULL;
1270 }
1271
1272 static
1273 statement_t *parse_do(void)
1274 {
1275         eat(T_do);
1276         parse_statement();
1277         expect(T_while);
1278         expect('(');
1279         parse_expression();
1280         expect(')');
1281
1282         return NULL;
1283 }
1284
1285 static
1286 statement_t *parse_for(void)
1287 {
1288         eat(T_for);
1289         expect('(');
1290         if(token.type != ';') {
1291                 /* TODO not correct... this could also be a declaration */
1292                 parse_expression();
1293         }
1294         expect(';');
1295         if(token.type != ';') {
1296                 parse_expression();
1297         }
1298         expect(';');
1299         if(token.type != ')') {
1300                 parse_expression();
1301         }
1302         expect(')');
1303         parse_statement();
1304
1305         return NULL;
1306 }
1307
1308 static
1309 statement_t *parse_goto(void)
1310 {
1311         eat(T_goto);
1312         expect(T_IDENTIFIER);
1313         expect(';');
1314
1315         return NULL;
1316 }
1317
1318 static
1319 statement_t *parse_continue(void)
1320 {
1321         eat(T_continue);
1322         expect(';');
1323
1324         return NULL;
1325 }
1326
1327 static
1328 statement_t *parse_break(void)
1329 {
1330         eat(T_break);
1331         expect(';');
1332
1333         return NULL;
1334 }
1335
1336 static
1337 statement_t *parse_return(void)
1338 {
1339         eat(T_return);
1340         parse_expression();
1341         expect(';');
1342
1343         return NULL;
1344 }
1345
1346 static
1347 statement_t *parse_declaration_statement(void)
1348 {
1349         parse_declaration();
1350         return NULL;
1351 }
1352
1353 static
1354 statement_t *parse_statement(void)
1355 {
1356         statement_t *statement = NULL;
1357
1358         /* declaration or statement */
1359         switch(token.type) {
1360         case T_case:
1361                 statement = parse_case_statement();
1362                 break;
1363
1364         case T_default:
1365                 statement = parse_default_statement();
1366                 break;
1367
1368         case T_IDENTIFIER:
1369                 statement = parse_label_statement();
1370                 break;
1371
1372         case '{':
1373                 statement = parse_compound_statement();
1374                 break;
1375
1376         case T_if:
1377                 statement = parse_if();
1378                 break;
1379
1380         case T_switch:
1381                 statement = parse_switch();
1382                 break;
1383
1384         case T_while:
1385                 statement = parse_while();
1386                 break;
1387
1388         case T_do:
1389                 statement = parse_do();
1390                 break;
1391
1392         case T_for:
1393                 statement = parse_for();
1394                 break;
1395
1396         case T_goto:
1397                 statement = parse_goto();
1398                 break;
1399
1400         case T_continue:
1401                 statement = parse_continue();
1402                 break;
1403
1404         case T_break:
1405                 statement = parse_break();
1406                 break;
1407
1408         case T_return:
1409                 statement = parse_return();
1410                 break;
1411
1412         case ';':
1413                 statement = NULL;
1414                 break;
1415
1416         STORAGE_CLASSES
1417         TYPE_QUALIFIERS
1418         TYPE_SPECIFIERS
1419                 statement = parse_declaration_statement();
1420                 break;
1421         }
1422
1423         return statement;
1424 }
1425
1426 static
1427 statement_t *parse_compound_statement(void)
1428 {
1429         eat('{');
1430
1431         int top = environment_top();
1432
1433         while(token.type != '}') {
1434                 parse_statement();
1435         }
1436
1437         environment_pop_to(top);
1438
1439         next_token();
1440
1441         return NULL;
1442 }
1443
1444 static
1445 translation_unit_t *parse_translation_unit(void)
1446 {
1447         translation_unit_t *unit = allocate_ast_zero(sizeof(unit[0]));
1448
1449         assert(translation_unit == NULL);
1450         assert(context == NULL);
1451         translation_unit = unit;
1452
1453         while(token.type != T_EOF) {
1454                 parse_declaration();
1455         }
1456
1457         translation_unit = NULL;
1458         return unit;
1459 }
1460
1461 translation_unit_t *parse(void)
1462 {
1463         obstack_init(&environment_obstack);
1464         environment_stack = NEW_ARR_F(environment_entry_t*, 0);
1465
1466         next_token();
1467         translation_unit_t *unit = parse_translation_unit();
1468
1469         DEL_ARR_F(environment_stack);
1470         obstack_free(&environment_obstack, NULL);
1471
1472         return unit;
1473 }
1474
1475 void init_parser(void)
1476 {
1477         init_expression_parsers();
1478 }
1479
1480 void exit_parser(void)
1481 {
1482 }