10 #include "adt/bitfiddle.h"
11 #include "adt/error.h"
18 void *allocate_ast_zero(size_t size)
20 void *res = allocate_ast(size);
28 lexer_next_token(&token);
31 print_token(stderr, &token);
32 fprintf(stderr, "\n");
37 void eat(token_type_t type)
39 assert(token.type == type);
43 void parser_print_error_prefix(void)
45 fputs(source_position.input_name, stderr);
47 fprintf(stderr, "%d", source_position.linenr);
48 fputs(": error: ", stderr);
52 void parse_error(const char *message)
54 parser_print_error_prefix();
55 fprintf(stderr, "parse error: %s\n", message);
59 void parse_error_expected(const char *message, ...)
65 parser_print_error_prefix();
66 fprintf(stderr, "%s\n", message);
68 parser_print_error_prefix();
69 fputs("Parse error: got ", stderr);
70 print_token(stderr, &token);
71 fputs(", expected ", stderr);
73 va_start(args, message);
74 token_type_t token_type = va_arg(args, token_type_t);
75 while(token_type != 0) {
79 fprintf(stderr, ", ");
81 print_token_type(stderr, token_type);
82 token_type = va_arg(args, token_type_t);
85 fprintf(stderr, "\n");
89 void eat_until_semi(void)
91 while(token.type != ';') {
93 if(token.type == T_EOF)
99 #define expect(expected) \
100 if(UNLIKELY(token.type != (expected))) { \
101 parse_error_expected(NULL, (expected), 0); \
108 SPECIFIER_SIGNED = 1 << 0,
109 SPECIFIER_UNSIGNED = 1 << 1,
110 SPECIFIER_LONG = 1 << 2,
111 SPECIFIER_INT = 1 << 3,
112 SPECIFIER_DOUBLE = 1 << 4,
113 SPECIFIER_CHAR = 1 << 5,
114 SPECIFIER_SHORT = 1 << 6,
115 SPECIFIER_LONG_LONG = 1 << 7,
116 SPECIFIER_FLOAT = 1 << 8,
117 SPECIFIER_BOOL = 1 << 9,
118 SPECIFIER_VOID = 1 << 10,
119 #ifdef PROVIDE_COMPLEX
120 SPECIFIER_COMPLEX = 1 << 11,
122 #ifdef PROVIDE_IMAGINARY
123 SPECIFIER_IMAGINARY = 1 << 12,
128 TYPE_QUALIFIER_CONST = 1 << 0,
129 TYPE_QUALIFIER_RESTRICT = 1 << 1,
130 TYPE_QUALIFIER_VOLATILE = 1 << 2,
131 TYPE_QUALIFIER_INLINE = 1 << 3,
136 STORAGE_CLASS_TYPEDEF,
137 STORAGE_CLASS_EXTERN,
138 STORAGE_CLASS_STATIC,
140 STORAGE_CLASS_REGISTER
143 typedef struct declaration_specifiers_t declaration_specifiers_t;
144 struct declaration_specifiers_t {
145 storage_class_t storage_class;
150 void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
152 type_type_t type_type = TYPE_INVALID;
153 atomic_type_type_t atomic_type = ATOMIC_TYPE_INVALID;
154 unsigned type_specifiers = 0;
160 #define MATCH_STORAGE_CLASS(token, class) \
162 if(specifiers->storage_class != STORAGE_CLASS_NONE) { \
163 parse_error("multiple storage classes in declaration " \
166 specifiers->storage_class = class; \
170 MATCH_STORAGE_CLASS(T_typedef, STORAGE_CLASS_TYPEDEF)
171 MATCH_STORAGE_CLASS(T_extern, STORAGE_CLASS_EXTERN)
172 MATCH_STORAGE_CLASS(T_static, STORAGE_CLASS_STATIC)
173 MATCH_STORAGE_CLASS(T_auto, STORAGE_CLASS_AUTO)
174 MATCH_STORAGE_CLASS(T_register, STORAGE_CLASS_REGISTER)
176 /* type qualifiers */
177 #define MATCH_TYPE_QUALIFIER(token, qualifier) \
179 specifiers->type_qualifiers |= qualifier; \
183 MATCH_TYPE_QUALIFIER(T_const, TYPE_QUALIFIER_CONST);
184 MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
185 MATCH_TYPE_QUALIFIER(T_volatile, TYPE_QUALIFIER_VOLATILE);
186 MATCH_TYPE_QUALIFIER(T_inline, TYPE_QUALIFIER_INLINE);
188 /* type specifiers */
189 #define MATCH_SPECIFIER(token, specifier, name) \
192 if(type_specifiers & specifier) { \
193 parse_error("multiple " name " type specifiers given"); \
195 type_specifiers |= specifier; \
199 MATCH_SPECIFIER(T_void, SPECIFIER_VOID, "void")
200 MATCH_SPECIFIER(T_char, SPECIFIER_CHAR, "char")
201 MATCH_SPECIFIER(T_short, SPECIFIER_SHORT, "short")
202 MATCH_SPECIFIER(T_int, SPECIFIER_INT, "int")
203 MATCH_SPECIFIER(T_float, SPECIFIER_FLOAT, "float")
204 MATCH_SPECIFIER(T_double, SPECIFIER_DOUBLE, "double")
205 MATCH_SPECIFIER(T_signed, SPECIFIER_SIGNED, "signed")
206 MATCH_SPECIFIER(T_unsigned, SPECIFIER_UNSIGNED, "unsigned")
207 MATCH_SPECIFIER(T__Bool, SPECIFIER_BOOL, "_Bool")
208 #ifdef PROVIDE_COMPLEX
209 MATCH_SPECIFIER(T__Complex, SPECIFIER_COMPLEX, "_Complex")
211 #ifdef PROVIDE_IMAGINARY
212 MATCH_SPECIFIER(T__Imaginary, SPECIFIER_IMAGINARY, "_Imaginary")
216 if(type_specifiers & SPECIFIER_LONG_LONG) {
217 parse_error("too many long type specifiers given");
218 } else if(type_specifiers & SPECIFIER_LONG) {
219 type_specifiers |= SPECIFIER_LONG_LONG;
221 type_specifiers |= SPECIFIER_LONG;
231 /* function specifier */
237 if(type_type == TYPE_INVALID) {
238 /* match valid basic types */
239 switch(type_specifiers) {
241 atomic_type = ATOMIC_TYPE_VOID;
244 atomic_type = ATOMIC_TYPE_CHAR;
246 case SPECIFIER_SIGNED | SPECIFIER_CHAR:
247 atomic_type = ATOMIC_TYPE_SCHAR;
249 case SPECIFIER_UNSIGNED | SPECIFIER_CHAR:
250 atomic_type = ATOMIC_TYPE_UCHAR;
252 case SPECIFIER_SHORT:
253 case SPECIFIER_SIGNED | SPECIFIER_SHORT:
254 case SPECIFIER_SHORT | SPECIFIER_INT:
255 case SPECIFIER_SIGNED | SPECIFIER_SHORT | SPECIFIER_INT:
256 atomic_type = ATOMIC_TYPE_SHORT;
258 case SPECIFIER_UNSIGNED | SPECIFIER_SHORT:
259 case SPECIFIER_UNSIGNED | SPECIFIER_SHORT | SPECIFIER_INT:
260 atomic_type = ATOMIC_TYPE_USHORT;
263 case SPECIFIER_SIGNED:
264 case SPECIFIER_SIGNED | SPECIFIER_INT:
265 atomic_type = ATOMIC_TYPE_INT;
267 case SPECIFIER_UNSIGNED:
268 case SPECIFIER_UNSIGNED | SPECIFIER_INT:
269 atomic_type = ATOMIC_TYPE_UINT;
272 case SPECIFIER_SIGNED | SPECIFIER_LONG:
273 case SPECIFIER_LONG | SPECIFIER_INT:
274 case SPECIFIER_SIGNED | SPECIFIER_LONG | SPECIFIER_INT:
275 atomic_type = ATOMIC_TYPE_LONG;
277 case SPECIFIER_UNSIGNED | SPECIFIER_LONG:
278 case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_INT:
279 atomic_type = ATOMIC_TYPE_ULONG;
281 case SPECIFIER_LONG_LONG:
282 case SPECIFIER_SIGNED | SPECIFIER_LONG_LONG:
283 case SPECIFIER_LONG_LONG | SPECIFIER_INT:
284 case SPECIFIER_SIGNED | SPECIFIER_LONG_LONG | SPECIFIER_INT:
285 atomic_type = ATOMIC_TYPE_LONGLONG;
287 case SPECIFIER_UNSIGNED | SPECIFIER_LONG_LONG:
288 case SPECIFIER_UNSIGNED | SPECIFIER_LONG_LONG | SPECIFIER_INT:
289 atomic_type = ATOMIC_TYPE_ULONGLONG;
291 case SPECIFIER_FLOAT:
292 atomic_type = ATOMIC_TYPE_FLOAT;
294 case SPECIFIER_DOUBLE:
295 atomic_type = ATOMIC_TYPE_DOUBLE;
297 case SPECIFIER_LONG | SPECIFIER_DOUBLE:
298 atomic_type = ATOMIC_TYPE_LONG_DOUBLE;
301 atomic_type = ATOMIC_TYPE_BOOL;
303 #ifdef PROVIDE_COMPLEX
304 case SPECIFIER_FLOAT | SPECIFIER_COMPLEX:
305 atomic_type = ATOMIC_TYPE_FLOAT_COMPLEX;
307 case SPECIFIER_DOUBLE | SPECIFIER_COMPLEX:
308 atomic_type = ATOMIC_TYPE_DOUBLE_COMPLEX;
310 case SPECIFIER_LONG | SPECIFIER_DOUBLE | SPECIFIER_COMPLEX:
311 atomic_type = ATOMIC_TYPE_LONG_DOUBLE_COMPLEX;
314 #ifdef PROVIDE_IMAGINARY
315 case SPECIFIER_FLOAT | SPECIFIER_IMAGINARY:
316 atomic_type = ATOMIC_TYPE_FLOAT_IMAGINARY;
318 case SPECIFIER_DOUBLE | SPECIFIER_IMAGINARY:
319 atomic_type = ATOMIC_TYPE_DOUBLE_IMAGINARY;
321 case SPECIFIER_LONG | SPECIFIER_DOUBLE | SPECIFIER_IMAGINARY:
322 atomic_type = ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY;
326 /* invalid specifier combination, give an error message */
327 if(type_specifiers == 0) {
328 parse_error("no type specifiers given in declaration");
329 } else if((type_specifiers & SPECIFIER_SIGNED) &&
330 (type_specifiers & SPECIFIER_UNSIGNED)) {
331 parse_error("signed and unsigned specifiers gives");
332 } else if(type_specifiers & (SPECIFIER_SIGNED | SPECIFIER_UNSIGNED)) {
333 parse_error("only integer types can be signed or unsigned");
335 parse_error("multiple datatypes in declaration");
339 if(type_specifiers != 0) {
340 parse_error("multiple datatypes in declaration");
345 typedef struct declarator_t declarator_t;
346 struct declarator_t {
347 /* pointer stuff... */
353 declarator_t *parse_declarator(void)
355 while(token.type == '*') {
358 //parse_type_qualifiers();
361 declarator_t *declarator;
365 declarator = allocate_ast_zero(sizeof(declarator[0]));
366 declarator->symbol = token.v.symbol;
371 declarator = parse_declarator();
375 parse_error("problem while parsing declarator");
378 if(token.type == '(') {
381 /* parse parameter-type-list or identifier-list */
384 } else if(token.type == '[') {
387 /* multiple type qualifiers, and static */
389 /* assignment_expression or '*' or nothing */
397 void parse_init_declarators(const declaration_specifiers_t *specifiers)
400 declarator_t *declarator = parse_declarator();
401 if(token.type == '=') {
403 //parse_initialize();
408 typedef struct declaration_t declaration_t;
409 struct declaration_t {
410 declaration_specifiers_t specifiers;
411 declaration_t *declarators;
414 void parse_declaration(void)
416 declaration_specifiers_t specifiers;
417 memset(&specifiers, 0, sizeof(specifiers));
418 parse_declaration_specifiers(&specifiers);
420 parse_init_declarators(&specifiers);
424 namespace_t *parse(FILE *in, const char *input_name)
426 namespace_t *namespace = parse_namespace();
435 expression_t *parse_sub_expression(unsigned precedence);
437 expression_t *parse_expression(void);
439 typedef expression_t* (*parse_expression_function) (unsigned precedence);
440 typedef expression_t* (*parse_expression_infix_function) (unsigned precedence,
443 typedef struct expression_parser_function_t expression_parser_function_t;
444 struct expression_parser_function_t {
446 parse_expression_function parser;
447 unsigned infix_precedence;
448 parse_expression_infix_function infix_parser;
451 expression_parser_function_t expression_parsers[T_LAST_TOKEN];
454 expression_t *expected_expression_error(void)
456 parser_print_error_prefix();
457 fprintf(stderr, "expected expression, got token ");
458 print_token(stderr, & token);
459 fprintf(stderr, "\n");
461 expression_t *expression = allocate_ast_zero(sizeof(expression[0]));
462 expression->type = EXPR_INVALID;
469 expression_t *parse_string_const(void)
471 string_literal_t *cnst = allocate_ast_zero(sizeof(cnst[0]));
473 cnst->expression.type = EXPR_STRING_LITERAL;
474 cnst->value = token.v.string;
478 return (expression_t*) cnst;
482 expression_t *parse_int_const(void)
484 const_t *cnst = allocate_ast_zero(sizeof(cnst[0]));
486 cnst->expression.type = EXPR_CONST;
487 cnst->value = token.v.intvalue;
491 return (expression_t*) cnst;
495 expression_t *parse_reference(void)
497 reference_expression_t *ref = allocate_ast_zero(sizeof(ref[0]));
499 ref->expression.type = EXPR_REFERENCE;
500 ref->symbol = token.v.symbol;
504 return (expression_t*) ref;
508 expression_t *parse_brace_expression(void)
512 expression_t *result = parse_expression();
519 expression_t *parse_primary_expression(void)
523 return parse_int_const();
524 case T_STRING_LITERAL:
525 return parse_string_const();
527 return parse_reference();
529 return parse_brace_expression();
532 /* TODO: error message */
537 expression_t *parse_array_expression(unsigned precedence,
538 expression_t *array_ref)
544 array_access_expression_t *array_access
545 = allocate_ast_zero(sizeof(array_access[0]));
547 array_access->expression.type = EXPR_ARRAY_ACCESS;
548 array_access->array_ref = array_ref;
549 array_access->index = parse_expression();
551 if(token.type != ']') {
552 parse_error_expected("Problem while parsing array access", ']', 0);
557 return (expression_t*) array_access;
561 expression_t *parse_sizeof(unsigned precedence)
571 expression_t *parse_select_expression(unsigned precedence,
572 expression_t *compound)
576 assert(token.type == '.' || token.type == T_SELECT);
579 select_expression_t *select = allocate_ast_zero(sizeof(select[0]));
581 select->expression.type = EXPR_SELECT;
582 select->compound = compound;
584 if(token.type != T_IDENTIFIER) {
585 parse_error_expected("Problem while parsing compound select",
589 select->symbol = token.v.symbol;
592 return (expression_t*) select;
596 expression_t *parse_call_expression(unsigned precedence,
597 expression_t *expression)
600 call_expression_t *call = allocate_ast_zero(sizeof(call[0]));
602 call->expression.type = EXPR_CALL;
603 call->method = expression;
605 /* parse arguments */
608 if(token.type != ')') {
609 call_argument_t *last_argument = NULL;
612 call_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
614 argument->expression = parse_expression();
615 if(last_argument == NULL) {
616 call->arguments = argument;
618 last_argument->next = argument;
620 last_argument = argument;
622 if(token.type != ',')
629 return (expression_t*) call;
632 #define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type) \
634 expression_t *parse_##unexpression_type(unsigned precedence) \
638 unary_expression_t *unary_expression \
639 = allocate_ast_zero(sizeof(unary_expression[0])); \
640 unary_expression->expression.type = EXPR_UNARY; \
641 unary_expression->type = unexpression_type; \
642 unary_expression->value = parse_sub_expression(precedence); \
644 return (expression_t*) unary_expression; \
647 CREATE_UNARY_EXPRESSION_PARSER('-', UNEXPR_NEGATE);
648 CREATE_UNARY_EXPRESSION_PARSER('+', UNEXPR_PLUS);
649 CREATE_UNARY_EXPRESSION_PARSER('!', UNEXPR_NOT);
650 CREATE_UNARY_EXPRESSION_PARSER('*', UNEXPR_DEREFERENCE);
651 CREATE_UNARY_EXPRESSION_PARSER('&', UNEXPR_TAKE_ADDRESS);
652 CREATE_UNARY_EXPRESSION_PARSER('~', UNEXPR_BITWISE_NEGATE);
653 CREATE_UNARY_EXPRESSION_PARSER(T_PLUSPLUS, UNEXPR_PREFIX_INCREMENT);
654 CREATE_UNARY_EXPRESSION_PARSER(T_MINUSMINUS, UNEXPR_PREFIX_DECREMENT);
656 #define CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(token_type, unexpression_type) \
658 expression_t *parse_##unexpression_type(unsigned precedence, \
659 expression_t *left) \
664 unary_expression_t *unary_expression \
665 = allocate_ast_zero(sizeof(unary_expression[0])); \
666 unary_expression->expression.type = EXPR_UNARY; \
667 unary_expression->type = unexpression_type; \
668 unary_expression->value = left; \
670 return (expression_t*) unary_expression; \
673 CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(T_PLUSPLUS, UNEXPR_POSTFIX_INCREMENT);
674 CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(T_MINUSMINUS, UNEXPR_POSTFIX_DECREMENT);
676 #define CREATE_BINEXPR_PARSER(token_type, binexpression_type) \
678 expression_t *parse_##binexpression_type(unsigned precedence, \
679 expression_t *left) \
683 expression_t *right = parse_sub_expression(precedence); \
685 binary_expression_t *binexpr \
686 = allocate_ast_zero(sizeof(binexpr[0])); \
687 binexpr->expression.type = EXPR_BINARY; \
688 binexpr->type = binexpression_type; \
689 binexpr->left = left; \
690 binexpr->right = right; \
692 return (expression_t*) binexpr; \
695 CREATE_BINEXPR_PARSER('*', BINEXPR_MUL);
696 CREATE_BINEXPR_PARSER('/', BINEXPR_DIV);
697 CREATE_BINEXPR_PARSER('+', BINEXPR_ADD);
698 CREATE_BINEXPR_PARSER('-', BINEXPR_SUB);
699 CREATE_BINEXPR_PARSER('<', BINEXPR_LESS);
700 CREATE_BINEXPR_PARSER('>', BINEXPR_GREATER);
701 CREATE_BINEXPR_PARSER('=', BINEXPR_ASSIGN);
702 CREATE_BINEXPR_PARSER(T_EQUALEQUAL, BINEXPR_EQUAL);
703 CREATE_BINEXPR_PARSER(T_SLASHEQUAL, BINEXPR_NOTEQUAL);
704 CREATE_BINEXPR_PARSER(T_LESSEQUAL, BINEXPR_LESSEQUAL);
705 CREATE_BINEXPR_PARSER(T_GREATEREQUAL, BINEXPR_GREATEREQUAL);
706 CREATE_BINEXPR_PARSER('&', BINEXPR_BITWISE_AND);
707 CREATE_BINEXPR_PARSER('|', BINEXPR_BITWISE_OR);
708 CREATE_BINEXPR_PARSER('^', BINEXPR_BITWISE_XOR);
709 CREATE_BINEXPR_PARSER(T_LESSLESS, BINEXPR_SHIFTLEFT);
710 CREATE_BINEXPR_PARSER(T_GREATERGREATER, BINEXPR_SHIFTRIGHT);
713 expression_t *parse_sub_expression(unsigned precedence)
716 return expected_expression_error();
719 expression_parser_function_t *parser
720 = &expression_parsers[token.type];
721 source_position_t source_position = source_position;
724 if(parser->parser != NULL) {
725 left = parser->parser(parser->precedence);
727 left = parse_primary_expression();
730 left->source_position = source_position;
734 return expected_expression_error();
737 parser = &expression_parsers[token.type];
738 if(parser->infix_parser == NULL)
740 if(parser->infix_precedence < precedence)
743 left = parser->infix_parser(parser->infix_precedence, left);
745 left->source_position = source_position;
752 expression_t *parse_expression(void)
754 return parse_sub_expression(1);
759 void register_expression_parser(parse_expression_function parser,
760 int token_type, unsigned precedence)
762 expression_parser_function_t *entry = &expression_parsers[token_type];
764 if(entry->parser != NULL) {
765 fprintf(stderr, "for token ");
766 print_token_type(stderr, token_type);
767 fprintf(stderr, "\n");
768 panic("trying to register multiple expression parsers for a token");
770 entry->parser = parser;
771 entry->precedence = precedence;
774 void register_expression_infix_parser(parse_expression_infix_function parser,
775 int token_type, unsigned precedence)
777 expression_parser_function_t *entry = &expression_parsers[token_type];
779 if(entry->infix_parser != NULL) {
780 fprintf(stderr, "for token ");
781 print_token_type(stderr, token_type);
782 fprintf(stderr, "\n");
783 panic("trying to register multiple infix expression parsers for a "
786 entry->infix_parser = parser;
787 entry->infix_precedence = precedence;
791 void init_expression_parsers(void)
793 memset(&expression_parsers, 0, sizeof(expression_parsers));
795 register_expression_infix_parser(parse_BINEXPR_MUL, '*', 16);
796 register_expression_infix_parser(parse_BINEXPR_DIV, '/', 16);
797 register_expression_infix_parser(parse_BINEXPR_SHIFTLEFT,
799 register_expression_infix_parser(parse_BINEXPR_SHIFTRIGHT,
800 T_GREATERGREATER, 16);
801 register_expression_infix_parser(parse_BINEXPR_ADD, '+', 15);
802 register_expression_infix_parser(parse_BINEXPR_SUB, '-', 15);
803 register_expression_infix_parser(parse_BINEXPR_LESS, '<', 14);
804 register_expression_infix_parser(parse_BINEXPR_GREATER, '>', 14);
805 register_expression_infix_parser(parse_BINEXPR_LESSEQUAL, T_LESSEQUAL, 14);
806 register_expression_infix_parser(parse_BINEXPR_GREATEREQUAL,
808 register_expression_infix_parser(parse_BINEXPR_EQUAL, T_EQUALEQUAL, 13);
809 register_expression_infix_parser(parse_BINEXPR_NOTEQUAL,
810 T_EXCLAMATIONMARKEQUAL, 13);
811 register_expression_infix_parser(parse_BINEXPR_BITWISE_AND, '&', 12);
812 register_expression_infix_parser(parse_BINEXPR_BITWISE_XOR, '^', 11);
813 register_expression_infix_parser(parse_BINEXPR_BITWISE_OR, '|', 10);
814 register_expression_infix_parser(parse_BINEXPR_ASSIGN, T_EQUAL, 2);
816 register_expression_infix_parser(parse_array_expression, '[', 30);
817 register_expression_infix_parser(parse_call_expression, '(', 30);
818 register_expression_infix_parser(parse_select_expression, '.', 30);
819 register_expression_infix_parser(parse_select_expression, T_SELECT, 30);
820 register_expression_infix_parser(parse_UNEXPR_POSTFIX_INCREMENT,
822 register_expression_infix_parser(parse_UNEXPR_POSTFIX_DECREMENT,
825 register_expression_parser(parse_UNEXPR_NEGATE, '-', 25);
826 register_expression_parser(parse_UNEXPR_PLUS, '+', 25);
827 register_expression_parser(parse_UNEXPR_NOT, '!', 25);
828 register_expression_parser(parse_UNEXPR_BITWISE_NEGATE, '~', 25);
829 register_expression_parser(parse_UNEXPR_DEREFERENCE, '*', 25);
830 register_expression_parser(parse_UNEXPR_TAKE_ADDRESS, '&', 25);
831 register_expression_parser(parse_UNEXPR_PREFIX_INCREMENT, T_PLUSPLUS, 25);
832 register_expression_parser(parse_UNEXPR_PREFIX_DECREMENT, T_MINUSMINUS, 25);
833 register_expression_parser(parse_sizeof, T_sizeof, 25);
838 statement_t *parse_compound_statement(void);
841 statement_t *parse_statement(void);
844 statement_t *parse_case_statement(void)
855 statement_t *parse_default_statement(void)
865 statement_t *parse_label_statement(void)
875 statement_t *parse_if(void)
883 if(token.type == T_else) {
892 statement_t *parse_switch(void)
904 statement_t *parse_while(void)
916 statement_t *parse_do(void)
929 statement_t *parse_for(void)
933 if(token.type != ';') {
934 /* TODO not correct... this could also be a declaration */
938 if(token.type != ';') {
942 if(token.type != ')') {
952 statement_t *parse_goto(void)
955 expect(T_IDENTIFIER);
962 statement_t *parse_continue(void)
971 statement_t *parse_break(void)
980 statement_t *parse_return(void)
990 statement_t *parse_statement(void)
992 statement_t *statement = NULL;
994 /* declaration or statement */
997 statement = parse_case_statement();
1001 statement = parse_default_statement();
1005 statement = parse_label_statement();
1009 statement = parse_compound_statement();
1013 statement = parse_if();
1017 statement = parse_switch();
1021 statement = parse_while();
1025 statement = parse_do();
1029 statement = parse_for();
1033 statement = parse_goto();
1037 statement = parse_continue();
1041 statement = parse_break();
1045 statement = parse_return();
1057 statement_t *parse_compound_statement(void)
1061 while(token.type != '}') {
1070 void parse_translation_unit(void)
1072 declaration_specifiers_t specifiers;
1073 memset(&specifiers, 0, sizeof(specifiers));
1074 parse_declaration_specifiers(&specifiers);
1076 while(token.type != T_EOF) {
1077 if(token.type == '{') {
1082 parse_declaration();
1083 /* multiple declarations? */
1085 if(token.type == '{') {
1086 parse_compound_statement();
1087 } else if(token.type == ';') {
1090 parse_error_expected("while parsing declarations", '{', ';', 0);
1098 parse_translation_unit();
1101 void init_parser(void)
1103 init_expression_parsers();
1106 void exit_parser(void)