nsz Git - cparser/blob - ast.c

   1 #include <config.h>
   2
   3 #include "ast_t.h"
   4 #include "type_t.h"
   5
   6 #include <assert.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <ctype.h>
  10
  11 #include "adt/error.h"
  12
  13 struct obstack ast_obstack;
  14
  15 static FILE *out;
  16 static int   indent;
  17
  18 static void print_statement(const statement_t *statement);
  19
  20 void change_indent(int delta)
  21 {
  22         indent += delta;
  23         assert(indent >= 0);
  24 }
  25
  26 void print_indent(void)
  27 {
  28         for(int i = 0; i < indent; ++i)
  29                 fprintf(out, "\t");
  30 }
  31
  32 static void print_const(const const_expression_t *cnst)
  33 {
  34         if(cnst->expression.datatype == NULL)
  35                 return;
  36
  37         if(is_type_integer(cnst->expression.datatype)) {
  38                 fprintf(out, "%lld", cnst->v.int_value);
  39         } else if(is_type_floating(cnst->expression.datatype)) {
  40                 fprintf(out, "%Lf", cnst->v.float_value);
  41         }
  42 }
  43
  44 static void print_quoted_string(const char *string)
  45 {
  46         fputc('"', out);
  47         for(const char *c = string; *c != '\0'; ++c) {
  48                 switch(*c) {
  49                 case '\"':  fputs("\\\"", out); break;
  50                 case '\\':  fputs("\\\\", out); break;
  51                 case '\a':  fputs("\\a", out); break;
  52                 case '\b':  fputs("\\b", out); break;
  53                 case '\f':  fputs("\\f", out); break;
  54                 case '\n':  fputs("\\n", out); break;
  55                 case '\r':  fputs("\\r", out); break;
  56                 case '\t':  fputs("\\t", out); break;
  57                 case '\v':  fputs("\\v", out); break;
  58                 case '\?':  fputs("\\?", out); break;
  59                 default:
  60                         if(!isprint(*c)) {
  61                                 fprintf(out, "\\x%x", *c);
  62                                 break;
  63                         }
  64                         fputc(*c, out);
  65                         break;
  66                 }
  67         }
  68         fputc('"', out);
  69 }
  70
  71 static void print_string_literal(
  72                 const string_literal_expression_t *string_literal)
  73 {
  74         print_quoted_string(string_literal->value);
  75 }
  76
  77 static void print_wide_string_literal(
  78         const wide_string_literal_expression_t *const wstr)
  79 {
  80         fputs("L\"", out);
  81         for (const wchar_rep_t *c   = wstr->value.begin,
  82                                *end = c + wstr->value.size;
  83              c != end; ++c) {
  84                 switch (*c) {
  85                         case L'\"':  fputs("\\\"", out); break;
  86                         case L'\\':  fputs("\\\\", out); break;
  87                         case L'\a':  fputs("\\a",  out); break;
  88                         case L'\b':  fputs("\\b",  out); break;
  89                         case L'\f':  fputs("\\f",  out); break;
  90                         case L'\n':  fputs("\\n",  out); break;
  91                         case L'\r':  fputs("\\r",  out); break;
  92                         case L'\t':  fputs("\\t",  out); break;
  93                         case L'\v':  fputs("\\v",  out); break;
  94                         case L'\?':  fputs("\\?",  out); break;
  95                         default: {
  96                                 const unsigned tc = *c;
  97                                 if (tc < 0x80U) {
  98                                         if (!isprint(*c))  {
  99                                                 fprintf(out, "\\%03o", (char)*c);
 100                                         } else {
 101                                                 fputc(*c, out);
 102                                         }
 103                                 } else if (tc < 0x800) {
 104                                         fputc(0xC0 | (tc >> 6),   out);
 105                                         fputc(0x80 | (tc & 0x3F), out);
 106                                 } else if (tc < 0x10000) {
 107                                         fputc(0xE0 | ( tc >> 12),         out);
 108                                         fputc(0x80 | ((tc >>  6) & 0x3F), out);
 109                                         fputc(0x80 | ( tc        & 0x3F), out);
 110                                 } else {
 111                                         fputc(0xF0 | ( tc >> 18),         out);
 112                                         fputc(0x80 | ((tc >> 12) & 0x3F), out);
 113                                         fputc(0x80 | ((tc >>  6) & 0x3F), out);
 114                                         fputc(0x80 | ( tc        & 0x3F), out);
 115                                 }
 116                         }
 117                 }
 118         }
 119         fputc('"', out);
 120 }
 121
 122 static void print_call_expression(const call_expression_t *call)
 123 {
 124         print_expression(call->function);
 125         fprintf(out, "(");
 126         call_argument_t *argument = call->arguments;
 127         int              first    = 1;
 128         while(argument != NULL) {
 129                 if(!first) {
 130                         fprintf(out, ", ");
 131                 } else {
 132                         first = 0;
 133                 }
 134                 print_expression(argument->expression);
 135
 136                 argument = argument->next;
 137         }
 138         fprintf(out, ")");
 139 }
 140
 141 static void print_binary_expression(const binary_expression_t *binexpr)
 142 {
 143         if(binexpr->expression.kind == EXPR_BINARY_BUILTIN_EXPECT) {
 144                 fputs("__builtin_expect(", out);
 145                 print_expression(binexpr->left);
 146                 fputs(", ", out);
 147                 print_expression(binexpr->right);
 148                 fputs(")", out);
 149                 return;
 150         }
 151
 152         fprintf(out, "(");
 153         print_expression(binexpr->left);
 154         fprintf(out, " ");
 155         switch(binexpr->expression.kind) {
 156         case EXPR_BINARY_COMMA:              fputs(",", out);     break;
 157         case EXPR_BINARY_ASSIGN:             fputs("=", out);     break;
 158         case EXPR_BINARY_ADD:                fputs("+", out);     break;
 159         case EXPR_BINARY_SUB:                fputs("-", out);     break;
 160         case EXPR_BINARY_MUL:                fputs("*", out);     break;
 161         case EXPR_BINARY_MOD:                fputs("%", out);     break;
 162         case EXPR_BINARY_DIV:                fputs("/", out);     break;
 163         case EXPR_BINARY_BITWISE_OR:         fputs("|", out);     break;
 164         case EXPR_BINARY_BITWISE_AND:        fputs("&", out);     break;
 165         case EXPR_BINARY_BITWISE_XOR:        fputs("^", out);     break;
 166         case EXPR_BINARY_LOGICAL_OR:         fputs("||", out);    break;
 167         case EXPR_BINARY_LOGICAL_AND:        fputs("&&", out);    break;
 168         case EXPR_BINARY_NOTEQUAL:           fputs("!=", out);    break;
 169         case EXPR_BINARY_EQUAL:              fputs("==", out);    break;
 170         case EXPR_BINARY_LESS:               fputs("<", out);     break;
 171         case EXPR_BINARY_LESSEQUAL:          fputs("<=", out);    break;
 172         case EXPR_BINARY_GREATER:            fputs(">", out);     break;
 173         case EXPR_BINARY_GREATEREQUAL:       fputs(">=", out);    break;
 174         case EXPR_BINARY_SHIFTLEFT:          fputs("<<", out);    break;
 175         case EXPR_BINARY_SHIFTRIGHT:         fputs(">>", out);    break;
 176
 177         case EXPR_BINARY_ADD_ASSIGN:         fputs("+=", out);    break;
 178         case EXPR_BINARY_SUB_ASSIGN:         fputs("-=", out);    break;
 179         case EXPR_BINARY_MUL_ASSIGN:         fputs("*=", out);    break;
 180         case EXPR_BINARY_MOD_ASSIGN:         fputs("%=", out);    break;
 181         case EXPR_BINARY_DIV_ASSIGN:         fputs("/=", out);    break;
 182         case EXPR_BINARY_BITWISE_OR_ASSIGN:  fputs("|=", out);    break;
 183         case EXPR_BINARY_BITWISE_AND_ASSIGN: fputs("&=", out);    break;
 184         case EXPR_BINARY_BITWISE_XOR_ASSIGN: fputs("^=", out);    break;
 185         case EXPR_BINARY_SHIFTLEFT_ASSIGN:   fputs("<<=", out);   break;
 186         case EXPR_BINARY_SHIFTRIGHT_ASSIGN:  fputs(">>=", out);   break;
 187         default: panic("invalid binexpression found");
 188         }
 189         fprintf(out, " ");
 190         print_expression(binexpr->right);
 191         fprintf(out, ")");
 192 }
 193
 194 static void print_unary_expression(const unary_expression_t *unexpr)
 195 {
 196         switch(unexpr->expression.kind) {
 197         case EXPR_UNARY_NEGATE:           fputs("-", out);  break;
 198         case EXPR_UNARY_PLUS:             fputs("+", out);  break;
 199         case EXPR_UNARY_NOT:              fputs("!", out);  break;
 200         case EXPR_UNARY_BITWISE_NEGATE:   fputs("~", out);  break;
 201         case EXPR_UNARY_PREFIX_INCREMENT: fputs("++", out); break;
 202         case EXPR_UNARY_PREFIX_DECREMENT: fputs("--", out); break;
 203         case EXPR_UNARY_DEREFERENCE:      fputs("*", out);  break;
 204         case EXPR_UNARY_TAKE_ADDRESS:     fputs("&", out);  break;
 205
 206         case EXPR_UNARY_POSTFIX_INCREMENT:
 207                 fputs("(", out);
 208                 print_expression(unexpr->value);
 209                 fputs(")", out);
 210                 fputs("++", out);
 211                 return;
 212         case EXPR_UNARY_POSTFIX_DECREMENT:
 213                 fputs("(", out);
 214                 print_expression(unexpr->value);
 215                 fputs(")", out);
 216                 fputs("--", out);
 217                 return;
 218         case EXPR_UNARY_CAST:
 219                 fputs("(", out);
 220                 print_type(unexpr->expression.datatype);
 221                 fputs(")", out);
 222                 break;
 223         case EXPR_UNARY_CAST_IMPLICIT:
 224                 print_expression(unexpr->value);
 225                 return;
 226         case EXPR_UNARY_ASSUME:
 227                 fputs("__assume", out);
 228                 break;
 229         default:
 230                 panic("invalid unary expression found");
 231         }
 232         fputs("(", out);
 233         print_expression(unexpr->value);
 234         fputs(")", out);
 235 }
 236
 237 static void print_reference_expression(const reference_expression_t *ref)
 238 {
 239         fprintf(out, "%s", ref->declaration->symbol->string);
 240 }
 241
 242 static void print_array_expression(const array_access_expression_t *expression)
 243 {
 244         if(!expression->flipped) {
 245                 fputs("(", out);
 246                 print_expression(expression->array_ref);
 247                 fputs(")[", out);
 248                 print_expression(expression->index);
 249                 fputs("]", out);
 250         } else {
 251                 fputs("(", out);
 252                 print_expression(expression->index);
 253                 fputs(")[", out);
 254                 print_expression(expression->array_ref);
 255                 fputs("]", out);
 256         }
 257 }
 258
 259 static void print_sizeof_expression(const sizeof_expression_t *expression)
 260 {
 261         fputs("sizeof", out);
 262         if(expression->size_expression != NULL) {
 263                 fputc('(', out);
 264                 print_expression(expression->size_expression);
 265                 fputc(')', out);
 266         } else {
 267                 fputc('(', out);
 268                 print_type(expression->type);
 269                 fputc(')', out);
 270         }
 271 }
 272
 273 static void print_alignof_expression(const alignof_expression_t *expression)
 274 {
 275         fputs("__alignof__(", out);
 276         print_type(expression->type);
 277         fputc(')', out);
 278 }
 279
 280 static void print_builtin_symbol(const builtin_symbol_expression_t *expression)
 281 {
 282         fputs(expression->symbol->string, out);
 283 }
 284
 285 static void print_builtin_constant(const builtin_constant_expression_t *expression)
 286 {
 287         fputs("__builtin_constant_p(", out);
 288         print_expression(expression->value);
 289         fputc(')', out);
 290 }
 291
 292 static void print_builtin_prefetch(const builtin_prefetch_expression_t *expression)
 293 {
 294         fputs("__builtin_prefetch(", out);
 295         print_expression(expression->adr);
 296         if (expression->rw) {
 297                 fputc(',', out);
 298                 print_expression(expression->rw);
 299         }
 300         if (expression->locality) {
 301                 fputc(',', out);
 302                 print_expression(expression->locality);
 303         }
 304         fputc(')', out);
 305 }
 306
 307 static void print_conditional(const conditional_expression_t *expression)
 308 {
 309         fputs("(", out);
 310         print_expression(expression->condition);
 311         fputs(" ? ", out);
 312         print_expression(expression->true_expression);
 313         fputs(" : ", out);
 314         print_expression(expression->false_expression);
 315         fputs(")", out);
 316 }
 317
 318 static void print_va_start(const va_start_expression_t *const expression)
 319 {
 320         fputs("__builtin_va_start(", out);
 321         print_expression(expression->ap);
 322         fputs(", ", out);
 323         fputs(expression->parameter->symbol->string, out);
 324         fputs(")", out);
 325 }
 326
 327 static void print_va_arg(const va_arg_expression_t *expression)
 328 {
 329         fputs("__builtin_va_arg(", out);
 330         print_expression(expression->ap);
 331         fputs(", ", out);
 332         print_type(expression->expression.datatype);
 333         fputs(")", out);
 334 }
 335
 336 static void print_select(const select_expression_t *expression)
 337 {
 338         print_expression(expression->compound);
 339         if(expression->compound->base.datatype == NULL ||
 340                         expression->compound->base.datatype->kind == TYPE_POINTER) {
 341                 fputs("->", out);
 342         } else {
 343                 fputc('.', out);
 344         }
 345         fputs(expression->symbol->string, out);
 346 }
 347
 348 static void print_classify_type_expression(
 349         const classify_type_expression_t *const expr)
 350 {
 351         fputs("__builtin_classify_type(", out);
 352         print_expression(expr->type_expression);
 353         fputc(')', out);
 354 }
 355
 356 static void print_designator(const designator_t *designator)
 357 {
 358         fputs(designator->symbol->string, out);
 359         for (designator = designator->next; designator != NULL; designator = designator->next) {
 360                 if (designator->array_access) {
 361                         fputc('[', out);
 362                         print_expression(designator->array_access);
 363                         fputc(']', out);
 364                 } else {
 365                         fputc('.', out);
 366                         fputs(designator->symbol->string, out);
 367                 }
 368         }
 369 }
 370
 371 static void print_offsetof_expression(const offsetof_expression_t *expression)
 372 {
 373         fputs("__builtin_offsetof", out);
 374         fputc('(', out);
 375         print_type(expression->type);
 376         fputc(',', out);
 377         print_designator(expression->designator);
 378         fputc(')', out);
 379 }
 380
 381 static void print_statement_expression(const statement_expression_t *expression)
 382 {
 383         fputc('(', out);
 384         print_statement(expression->statement);
 385         fputc(')', out);
 386 }
 387
 388 void print_expression(const expression_t *expression)
 389 {
 390         switch(expression->kind) {
 391         case EXPR_UNKNOWN:
 392         case EXPR_INVALID:
 393                 fprintf(out, "*invalid expression*");
 394                 break;
 395         case EXPR_CONST:
 396                 print_const(&expression->conste);
 397                 break;
 398         case EXPR_FUNCTION:
 399         case EXPR_PRETTY_FUNCTION:
 400         case EXPR_STRING_LITERAL:
 401                 print_string_literal(&expression->string);
 402                 break;
 403         case EXPR_WIDE_STRING_LITERAL:
 404                 print_wide_string_literal(&expression->wide_string);
 405                 break;
 406         case EXPR_CALL:
 407                 print_call_expression(&expression->call);
 408                 break;
 409         EXPR_BINARY_CASES
 410                 print_binary_expression(&expression->binary);
 411                 break;
 412         case EXPR_REFERENCE:
 413                 print_reference_expression(&expression->reference);
 414                 break;
 415         case EXPR_ARRAY_ACCESS:
 416                 print_array_expression(&expression->array_access);
 417                 break;
 418         EXPR_UNARY_CASES
 419                 print_unary_expression(&expression->unary);
 420                 break;
 421         case EXPR_SIZEOF:
 422                 print_sizeof_expression(&expression->sizeofe);
 423                 break;
 424         case EXPR_ALIGNOF:
 425                 print_alignof_expression(&expression->alignofe);
 426                 break;
 427         case EXPR_BUILTIN_SYMBOL:
 428                 print_builtin_symbol(&expression->builtin_symbol);
 429                 break;
 430         case EXPR_BUILTIN_CONSTANT_P:
 431                 print_builtin_constant(&expression->builtin_constant);
 432                 break;
 433         case EXPR_BUILTIN_PREFETCH:
 434                 print_builtin_prefetch(&expression->builtin_prefetch);
 435                 break;
 436         case EXPR_CONDITIONAL:
 437                 print_conditional(&expression->conditional);
 438                 break;
 439         case EXPR_VA_START:
 440                 print_va_start(&expression->va_starte);
 441                 break;
 442         case EXPR_VA_ARG:
 443                 print_va_arg(&expression->va_arge);
 444                 break;
 445         case EXPR_SELECT:
 446                 print_select(&expression->select);
 447                 break;
 448         case EXPR_CLASSIFY_TYPE:
 449                 print_classify_type_expression(&expression->classify_type);
 450                 break;
 451         case EXPR_OFFSETOF:
 452                 print_offsetof_expression(&expression->offsetofe);
 453                 break;
 454         case EXPR_STATEMENT:
 455                 print_statement_expression(&expression->statement);
 456                 break;
 457
 458         default:
 459                 /* TODO */
 460                 fprintf(out, "some expression of type %d", (int) expression->kind);
 461                 break;
 462         }
 463 }
 464
 465 static void print_compound_statement(const compound_statement_t *block)
 466 {
 467         fputs("{\n", out);
 468         indent++;
 469
 470         statement_t *statement = block->statements;
 471         while(statement != NULL) {
 472                 print_indent();
 473                 print_statement(statement);
 474
 475                 statement = statement->base.next;
 476         }
 477         indent--;
 478         print_indent();
 479         fputs("}\n", out);
 480 }
 481
 482 static void print_return_statement(const return_statement_t *statement)
 483 {
 484         fprintf(out, "return ");
 485         if(statement->return_value != NULL)
 486                 print_expression(statement->return_value);
 487         fputs(";\n", out);
 488 }
 489
 490 static void print_expression_statement(const expression_statement_t *statement)
 491 {
 492         print_expression(statement->expression);
 493         fputs(";\n", out);
 494 }
 495
 496 static void print_goto_statement(const goto_statement_t *statement)
 497 {
 498         fprintf(out, "goto ");
 499         fputs(statement->label->symbol->string, out);
 500         fprintf(stderr, "(%p)", (void*) statement->label);
 501         fputs(";\n", out);
 502 }
 503
 504 static void print_label_statement(const label_statement_t *statement)
 505 {
 506         fprintf(stderr, "(%p)", (void*) statement->label);
 507         fprintf(out, "%s:\n", statement->label->symbol->string);
 508         if(statement->label_statement != NULL) {
 509                 print_statement(statement->label_statement);
 510         }
 511 }
 512
 513 static void print_if_statement(const if_statement_t *statement)
 514 {
 515         fputs("if(", out);
 516         print_expression(statement->condition);
 517         fputs(") ", out);
 518         if(statement->true_statement != NULL) {
 519                 print_statement(statement->true_statement);
 520         }
 521
 522         if(statement->false_statement != NULL) {
 523                 print_indent();
 524                 fputs("else ", out);
 525                 print_statement(statement->false_statement);
 526         }
 527 }
 528
 529 static void print_switch_statement(const switch_statement_t *statement)
 530 {
 531         fputs("switch(", out);
 532         print_expression(statement->expression);
 533         fputs(") ", out);
 534         print_statement(statement->body);
 535 }
 536
 537 static void print_case_label(const case_label_statement_t *statement)
 538 {
 539         if(statement->expression == NULL) {
 540                 fputs("default:\n", out);
 541         } else {
 542                 fputs("case ", out);
 543                 print_expression(statement->expression);
 544                 fputs(":\n", out);
 545         }
 546         print_statement(statement->label_statement);
 547 }
 548
 549 static void print_declaration_statement(
 550                 const declaration_statement_t *statement)
 551 {
 552         int first = 1;
 553         declaration_t *declaration = statement->declarations_begin;
 554         for( ; declaration != statement->declarations_end->next;
 555                declaration = declaration->next) {
 556                 if(!first) {
 557                         print_indent();
 558                 } else {
 559                         first = 0;
 560                 }
 561                 print_declaration(declaration);
 562                 fputc('\n', out);
 563         }
 564 }
 565
 566 static void print_while_statement(const while_statement_t *statement)
 567 {
 568         fputs("while(", out);
 569         print_expression(statement->condition);
 570         fputs(") ", out);
 571         print_statement(statement->body);
 572 }
 573
 574 static void print_do_while_statement(const do_while_statement_t *statement)
 575 {
 576         fputs("do ", out);
 577         print_statement(statement->body);
 578         print_indent();
 579         fputs("while(", out);
 580         print_expression(statement->condition);
 581         fputs(");\n", out);
 582 }
 583
 584 static void print_for_statement(const for_statement_t *statement)
 585 {
 586         fputs("for(", out);
 587         if(statement->context.declarations != NULL) {
 588                 assert(statement->initialisation == NULL);
 589                 print_declaration(statement->context.declarations);
 590                 if(statement->context.declarations->next != NULL) {
 591                         panic("multiple declarations in for statement not supported yet");
 592                 }
 593                 fputc(' ', out);
 594         } else {
 595                 if(statement->initialisation) {
 596                         print_expression(statement->initialisation);
 597                 }
 598                 fputs("; ", out);
 599         }
 600         if(statement->condition != NULL) {
 601                 print_expression(statement->condition);
 602         }
 603         fputs("; ", out);
 604         if(statement->step != NULL) {
 605                 print_expression(statement->step);
 606         }
 607         fputs(")", out);
 608         print_statement(statement->body);
 609 }
 610
 611 static void print_asm_constraints(asm_constraint_t *constraints)
 612 {
 613         asm_constraint_t *constraint = constraints;
 614         for( ; constraint != NULL; constraint = constraint->next) {
 615                 if(constraint != constraints)
 616                         fputs(", ", out);
 617
 618                 if(constraint->symbol) {
 619                         fprintf(out, "[%s] ", constraint->symbol->string);
 620                 }
 621                 print_quoted_string(constraint->constraints);
 622                 fputs(" (", out);
 623                 print_expression(constraint->expression);
 624                 fputs(")", out);
 625         }
 626 }
 627
 628 static void print_asm_clobbers(asm_clobber_t *clobbers)
 629 {
 630         asm_clobber_t *clobber = clobbers;
 631         for( ; clobber != NULL; clobber = clobber->next) {
 632                 if(clobber != clobbers)
 633                         fputs(", ", out);
 634
 635                 print_quoted_string(clobber->clobber);
 636         }
 637 }
 638
 639 static void print_asm_statement(const asm_statement_t *statement)
 640 {
 641         fputs("asm ", out);
 642         if(statement->is_volatile) {
 643                 fputs("volatile ", out);
 644         }
 645         fputs("(", out);
 646         print_quoted_string(statement->asm_text);
 647         if(statement->inputs == NULL && statement->outputs == NULL
 648                         && statement->clobbers == NULL)
 649                 goto end_of_print_asm_statement;
 650
 651         fputs(" : ", out);
 652         print_asm_constraints(statement->inputs);
 653         if(statement->outputs == NULL && statement->clobbers == NULL)
 654                 goto end_of_print_asm_statement;
 655
 656         fputs(" : ", out);
 657         print_asm_constraints(statement->outputs);
 658         if(statement->clobbers == NULL)
 659                 goto end_of_print_asm_statement;
 660
 661         fputs(" : ", out);
 662         print_asm_clobbers(statement->clobbers);
 663
 664 end_of_print_asm_statement:
 665         fputs(");\n", out);
 666 }
 667
 668 void print_statement(const statement_t *statement)
 669 {
 670         switch(statement->kind) {
 671         case STATEMENT_COMPOUND:
 672                 print_compound_statement(&statement->compound);
 673                 break;
 674         case STATEMENT_RETURN:
 675                 print_return_statement(&statement->returns);
 676                 break;
 677         case STATEMENT_EXPRESSION:
 678                 print_expression_statement(&statement->expression);
 679                 break;
 680         case STATEMENT_LABEL:
 681                 print_label_statement(&statement->label);
 682                 break;
 683         case STATEMENT_GOTO:
 684                 print_goto_statement(&statement->gotos);
 685                 break;
 686         case STATEMENT_CONTINUE:
 687                 fputs("continue;\n", out);
 688                 break;
 689         case STATEMENT_BREAK:
 690                 fputs("break;\n", out);
 691                 break;
 692         case STATEMENT_IF:
 693                 print_if_statement(&statement->ifs);
 694                 break;
 695         case STATEMENT_SWITCH:
 696                 print_switch_statement(&statement->switchs);
 697                 break;
 698         case STATEMENT_CASE_LABEL:
 699                 print_case_label(&statement->case_label);
 700                 break;
 701         case STATEMENT_DECLARATION:
 702                 print_declaration_statement(&statement->declaration);
 703                 break;
 704         case STATEMENT_WHILE:
 705                 print_while_statement(&statement->whiles);
 706                 break;
 707         case STATEMENT_DO_WHILE:
 708                 print_do_while_statement(&statement->do_while);
 709                 break;
 710         case STATEMENT_FOR:
 711                 print_for_statement(&statement->fors);
 712                 break;
 713         case STATEMENT_ASM:
 714                 print_asm_statement(&statement->asms);
 715                 break;
 716         case STATEMENT_INVALID:
 717                 fprintf(out, "*invalid statement*");
 718                 break;
 719         }
 720 }
 721
 722 static void print_storage_class(unsigned storage_class)
 723 {
 724         switch((storage_class_tag_t) storage_class) {
 725         case STORAGE_CLASS_ENUM_ENTRY:
 726         case STORAGE_CLASS_NONE:
 727                 break;
 728         case STORAGE_CLASS_TYPEDEF:       fputs("typedef ",        out); break;
 729         case STORAGE_CLASS_EXTERN:        fputs("extern ",         out); break;
 730         case STORAGE_CLASS_STATIC:        fputs("static ",         out); break;
 731         case STORAGE_CLASS_AUTO:          fputs("auto ",           out); break;
 732         case STORAGE_CLASS_REGISTER:      fputs("register ",       out); break;
 733         case STORAGE_CLASS_THREAD:        fputs("__thread",        out); break;
 734         case STORAGE_CLASS_THREAD_EXTERN: fputs("extern __thread", out); break;
 735         case STORAGE_CLASS_THREAD_STATIC: fputs("static __thread", out); break;
 736         }
 737 }
 738
 739 void print_initializer(const initializer_t *initializer)
 740 {
 741         if(initializer->kind == INITIALIZER_VALUE) {
 742                 const initializer_value_t *value = &initializer->value;
 743                 print_expression(value->value);
 744                 return;
 745         }
 746
 747         assert(initializer->kind == INITIALIZER_LIST);
 748         fputs("{ ", out);
 749         const initializer_list_t *list = &initializer->list;
 750
 751         for(size_t i = 0 ; i < list->len; ++i) {
 752                 if(i > 0) {
 753                         fputs(", ", out);
 754                 }
 755                 print_initializer(list->initializers[i]);
 756         }
 757         fputs("}", out);
 758 }
 759
 760 static void print_normal_declaration(const declaration_t *declaration)
 761 {
 762         print_storage_class(declaration->storage_class);
 763         if(declaration->is_inline) {
 764                 if (declaration->modifiers & DM_FORCEINLINE)
 765                         fputs("__forceinline ", out);
 766                 else
 767                         fputs("inline ", out);
 768         }
 769         print_type_ext(declaration->type, declaration->symbol,
 770                        &declaration->context);
 771
 772         if(declaration->type->kind == TYPE_FUNCTION) {
 773                 if(declaration->init.statement != NULL) {
 774                         fputs("\n", out);
 775                         print_statement(declaration->init.statement);
 776                         return;
 777                 }
 778         } else if(declaration->init.initializer != NULL) {
 779                 fputs(" = ", out);
 780                 print_initializer(declaration->init.initializer);
 781         }
 782         fputc(';', out);
 783 }
 784
 785 void print_declaration(const declaration_t *declaration)
 786 {
 787         if(declaration->namespc != NAMESPACE_NORMAL &&
 788                         declaration->symbol == NULL)
 789                 return;
 790
 791         switch(declaration->namespc) {
 792         case NAMESPACE_NORMAL:
 793                 print_normal_declaration(declaration);
 794                 break;
 795         case NAMESPACE_STRUCT:
 796                 fputs("struct ", out);
 797                 fputs(declaration->symbol->string, out);
 798                 fputc(' ', out);
 799                 print_compound_definition(declaration);
 800                 fputc(';', out);
 801                 break;
 802         case NAMESPACE_UNION:
 803                 fputs("union ", out);
 804                 fputs(declaration->symbol->string, out);
 805                 fputc(' ', out);
 806                 print_compound_definition(declaration);
 807                 fputc(';', out);
 808                 break;
 809         case NAMESPACE_ENUM:
 810                 fputs("enum ", out);
 811                 fputs(declaration->symbol->string, out);
 812                 fputc(' ', out);
 813                 print_enum_definition(declaration);
 814                 fputc(';', out);
 815                 break;
 816         }
 817 }
 818
 819 void print_ast(const translation_unit_t *unit)
 820 {
 821         inc_type_visited();
 822
 823         declaration_t *declaration = unit->context.declarations;
 824         for( ; declaration != NULL; declaration = declaration->next) {
 825                 if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
 826                         continue;
 827                 if(declaration->namespc != NAMESPACE_NORMAL &&
 828                                 declaration->symbol == NULL)
 829                         continue;
 830
 831                 print_indent();
 832                 print_declaration(declaration);
 833                 fputc('\n', out);
 834         }
 835 }
 836
 837 bool is_constant_expression(const expression_t *expression)
 838 {
 839         switch(expression->kind) {
 840
 841         case EXPR_CONST:
 842         case EXPR_STRING_LITERAL:
 843         case EXPR_WIDE_STRING_LITERAL:
 844         case EXPR_SIZEOF:
 845         case EXPR_CLASSIFY_TYPE:
 846         case EXPR_FUNCTION:
 847         case EXPR_PRETTY_FUNCTION:
 848         case EXPR_OFFSETOF:
 849         case EXPR_ALIGNOF:
 850         case EXPR_BUILTIN_CONSTANT_P:
 851                 return true;
 852
 853         case EXPR_BUILTIN_SYMBOL:
 854         case EXPR_BUILTIN_PREFETCH:
 855         case EXPR_CALL:
 856         case EXPR_SELECT:
 857         case EXPR_VA_START:
 858         case EXPR_VA_ARG:
 859         case EXPR_STATEMENT:
 860         case EXPR_UNARY_POSTFIX_INCREMENT:
 861         case EXPR_UNARY_POSTFIX_DECREMENT:
 862         case EXPR_UNARY_PREFIX_INCREMENT:
 863         case EXPR_UNARY_PREFIX_DECREMENT:
 864         case EXPR_UNARY_ASSUME: /* has VOID type */
 865         case EXPR_BINARY_ASSIGN:
 866         case EXPR_BINARY_MUL_ASSIGN:
 867         case EXPR_BINARY_DIV_ASSIGN:
 868         case EXPR_BINARY_MOD_ASSIGN:
 869         case EXPR_BINARY_ADD_ASSIGN:
 870         case EXPR_BINARY_SUB_ASSIGN:
 871         case EXPR_BINARY_SHIFTLEFT_ASSIGN:
 872         case EXPR_BINARY_SHIFTRIGHT_ASSIGN:
 873         case EXPR_BINARY_BITWISE_AND_ASSIGN:
 874         case EXPR_BINARY_BITWISE_XOR_ASSIGN:
 875         case EXPR_BINARY_BITWISE_OR_ASSIGN:
 876         case EXPR_BINARY_COMMA:
 877                 return false;
 878
 879         case EXPR_UNARY_NEGATE:
 880         case EXPR_UNARY_PLUS:
 881         case EXPR_UNARY_BITWISE_NEGATE:
 882         case EXPR_UNARY_NOT:
 883         case EXPR_UNARY_DEREFERENCE:
 884         case EXPR_UNARY_TAKE_ADDRESS:
 885         case EXPR_UNARY_CAST:
 886         case EXPR_UNARY_CAST_IMPLICIT:
 887                 return is_constant_expression(expression->unary.value);
 888
 889         case EXPR_BINARY_ADD:
 890         case EXPR_BINARY_SUB:
 891         case EXPR_BINARY_MUL:
 892         case EXPR_BINARY_DIV:
 893         case EXPR_BINARY_MOD:
 894         case EXPR_BINARY_EQUAL:
 895         case EXPR_BINARY_NOTEQUAL:
 896         case EXPR_BINARY_LESS:
 897         case EXPR_BINARY_LESSEQUAL:
 898         case EXPR_BINARY_GREATER:
 899         case EXPR_BINARY_GREATEREQUAL:
 900         case EXPR_BINARY_BITWISE_AND:
 901         case EXPR_BINARY_BITWISE_OR:
 902         case EXPR_BINARY_BITWISE_XOR:
 903         case EXPR_BINARY_LOGICAL_AND:
 904         case EXPR_BINARY_LOGICAL_OR:
 905         case EXPR_BINARY_SHIFTLEFT:
 906         case EXPR_BINARY_SHIFTRIGHT:
 907         case EXPR_BINARY_BUILTIN_EXPECT:
 908         case EXPR_BINARY_ISGREATER:
 909         case EXPR_BINARY_ISGREATEREQUAL:
 910         case EXPR_BINARY_ISLESS:
 911         case EXPR_BINARY_ISLESSEQUAL:
 912         case EXPR_BINARY_ISLESSGREATER:
 913         case EXPR_BINARY_ISUNORDERED:
 914                 return is_constant_expression(expression->binary.left)
 915                         && is_constant_expression(expression->binary.right);
 916
 917         case EXPR_CONDITIONAL:
 918                 /* TODO: not correct, we only have to test expressions which are
 919                  * evaluated, which means either the true or false part might be not
 920                  * constant */
 921                 return is_constant_expression(expression->conditional.condition)
 922                         && is_constant_expression(expression->conditional.true_expression)
 923                         && is_constant_expression(expression->conditional.false_expression);
 924
 925         case EXPR_ARRAY_ACCESS:
 926                 return is_constant_expression(expression->array_access.array_ref)
 927                         && is_constant_expression(expression->array_access.index);
 928
 929         case EXPR_REFERENCE: {
 930                 declaration_t *declaration = expression->reference.declaration;
 931                 if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
 932                         return true;
 933
 934                 return false;
 935         }
 936
 937         case EXPR_UNKNOWN:
 938         case EXPR_INVALID:
 939                 break;
 940         }
 941         panic("invalid expression found (is constant expression)");
 942 }
 943
 944
 945 void init_ast(void)
 946 {
 947         obstack_init(&ast_obstack);
 948 }
 949
 950 void exit_ast(void)
 951 {
 952         obstack_free(&ast_obstack, NULL);
 953 }
 954
 955 void ast_set_output(FILE *stream)
 956 {
 957         out = stream;
 958         type_set_output(stream);
 959 }
 960
 961 void* (allocate_ast) (size_t size)
 962 {
 963         return _allocate_ast(size);
 964 }