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