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