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         fprintf(out, "(");
 144         print_expression(binexpr->left);
 145         fprintf(out, " ");
 146         switch(binexpr->type) {
 147         case BINEXPR_INVALID:            fputs("INVOP", out); break;
 148         case BINEXPR_COMMA:              fputs(",", out);     break;
 149         case BINEXPR_ASSIGN:             fputs("=", out);     break;
 150         case BINEXPR_ADD:                fputs("+", out);     break;
 151         case BINEXPR_SUB:                fputs("-", out);     break;
 152         case BINEXPR_MUL:                fputs("*", out);     break;
 153         case BINEXPR_MOD:                fputs("%", out);     break;
 154         case BINEXPR_DIV:                fputs("/", out);     break;
 155         case BINEXPR_BITWISE_OR:         fputs("|", out);     break;
 156         case BINEXPR_BITWISE_AND:        fputs("&", out);     break;
 157         case BINEXPR_BITWISE_XOR:        fputs("^", out);     break;
 158         case BINEXPR_LOGICAL_OR:         fputs("||", out);    break;
 159         case BINEXPR_LOGICAL_AND:        fputs("&&", out);    break;
 160         case BINEXPR_NOTEQUAL:           fputs("!=", out);    break;
 161         case BINEXPR_EQUAL:              fputs("==", out);    break;
 162         case BINEXPR_LESS:               fputs("<", out);     break;
 163         case BINEXPR_LESSEQUAL:          fputs("<=", out);    break;
 164         case BINEXPR_GREATER:            fputs(">", out);     break;
 165         case BINEXPR_GREATEREQUAL:       fputs(">=", out);    break;
 166         case BINEXPR_SHIFTLEFT:          fputs("<<", out);    break;
 167         case BINEXPR_SHIFTRIGHT:         fputs(">>", out);    break;
 168
 169         case BINEXPR_ADD_ASSIGN:         fputs("+=", out);    break;
 170         case BINEXPR_SUB_ASSIGN:         fputs("-=", out);    break;
 171         case BINEXPR_MUL_ASSIGN:         fputs("*=", out);    break;
 172         case BINEXPR_MOD_ASSIGN:         fputs("%=", out);    break;
 173         case BINEXPR_DIV_ASSIGN:         fputs("/=", out);    break;
 174         case BINEXPR_BITWISE_OR_ASSIGN:  fputs("|=", out);    break;
 175         case BINEXPR_BITWISE_AND_ASSIGN: fputs("&=", out);    break;
 176         case BINEXPR_BITWISE_XOR_ASSIGN: fputs("^=", out);    break;
 177         case BINEXPR_SHIFTLEFT_ASSIGN:   fputs("<<=", out);   break;
 178         case BINEXPR_SHIFTRIGHT_ASSIGN:  fputs(">>=", out);   break;
 179         }
 180         fprintf(out, " ");
 181         print_expression(binexpr->right);
 182         fprintf(out, ")");
 183 }
 184
 185 static void print_unary_expression(const unary_expression_t *unexpr)
 186 {
 187         switch(unexpr->type) {
 188         case UNEXPR_NEGATE:           fputs("-", out);  break;
 189         case UNEXPR_PLUS:             fputs("+", out);  break;
 190         case UNEXPR_NOT:              fputs("!", out);  break;
 191         case UNEXPR_BITWISE_NEGATE:   fputs("~", out);  break;
 192         case UNEXPR_PREFIX_INCREMENT: fputs("++", out); break;
 193         case UNEXPR_PREFIX_DECREMENT: fputs("--", out); break;
 194         case UNEXPR_DEREFERENCE:      fputs("*", out);  break;
 195         case UNEXPR_TAKE_ADDRESS:     fputs("&", out);  break;
 196
 197         case UNEXPR_POSTFIX_INCREMENT:
 198                 fputs("(", out);
 199                 print_expression(unexpr->value);
 200                 fputs(")", out);
 201                 fputs("++", out);
 202                 return;
 203         case UNEXPR_POSTFIX_DECREMENT:
 204                 fputs("(", out);
 205                 print_expression(unexpr->value);
 206                 fputs(")", out);
 207                 fputs("--", out);
 208                 return;
 209         case UNEXPR_CAST:
 210                 fputs("(", out);
 211                 print_type(unexpr->expression.datatype);
 212                 fputs(")", out);
 213                 break;
 214         case UNEXPR_CAST_IMPLICIT:
 215                 print_expression(unexpr->value);
 216                 return;
 217         case UNEXPR_INVALID:
 218                 fprintf(out, "unop%d", (int) unexpr->type);
 219                 break;
 220         }
 221         fputs("(", out);
 222         print_expression(unexpr->value);
 223         fputs(")", out);
 224 }
 225
 226 static void print_reference_expression(const reference_expression_t *ref)
 227 {
 228         fprintf(out, "%s", ref->declaration->symbol->string);
 229 }
 230
 231 static void print_array_expression(const array_access_expression_t *expression)
 232 {
 233         if(!expression->flipped) {
 234                 fputs("(", out);
 235                 print_expression(expression->array_ref);
 236                 fputs(")[", out);
 237                 print_expression(expression->index);
 238                 fputs("]", out);
 239         } else {
 240                 fputs("(", out);
 241                 print_expression(expression->index);
 242                 fputs(")[", out);
 243                 print_expression(expression->array_ref);
 244                 fputs("]", out);
 245         }
 246 }
 247
 248 static void print_sizeof_expression(const sizeof_expression_t *expression)
 249 {
 250         fputs("sizeof", out);
 251         if(expression->size_expression != NULL) {
 252                 fputc('(', out);
 253                 print_expression(expression->size_expression);
 254                 fputc(')', out);
 255         } else {
 256                 fputc('(', out);
 257                 print_type(expression->type);
 258                 fputc(')', out);
 259         }
 260 }
 261
 262 static void print_builtin_symbol(const builtin_symbol_expression_t *expression)
 263 {
 264         fputs(expression->symbol->string, out);
 265 }
 266
 267 static void print_conditional(const conditional_expression_t *expression)
 268 {
 269         fputs("(", out);
 270         print_expression(expression->condition);
 271         fputs(" ? ", out);
 272         print_expression(expression->true_expression);
 273         fputs(" : ", out);
 274         print_expression(expression->false_expression);
 275         fputs(")", out);
 276 }
 277
 278 static void print_va_start(const va_start_expression_t *const expression)
 279 {
 280         fputs("__builtin_va_start(", out);
 281         print_expression(expression->ap);
 282         fputs(", ", out);
 283         fputs(expression->parameter->symbol->string, out);
 284         fputs(")", out);
 285 }
 286
 287 static void print_va_arg(const va_arg_expression_t *expression)
 288 {
 289         fputs("__builtin_va_arg(", out);
 290         print_expression(expression->ap);
 291         fputs(", ", out);
 292         print_type(expression->expression.datatype);
 293         fputs(")", out);
 294 }
 295
 296 static void print_select(const select_expression_t *expression)
 297 {
 298         print_expression(expression->compound);
 299         if(expression->compound->base.datatype == NULL ||
 300                         expression->compound->base.datatype->type == TYPE_POINTER) {
 301                 fputs("->", out);
 302         } else {
 303                 fputc('.', out);
 304         }
 305         fputs(expression->symbol->string, out);
 306 }
 307
 308 static void print_classify_type_expression(
 309         const classify_type_expression_t *const expr)
 310 {
 311         fputs("__builtin_classify_type(", out);
 312         print_expression(expr->type_expression);
 313         fputc(')', out);
 314 }
 315
 316 void print_expression(const expression_t *expression)
 317 {
 318         switch(expression->type) {
 319         case EXPR_UNKNOWN:
 320         case EXPR_INVALID:
 321                 fprintf(out, "*invalid expression*");
 322                 break;
 323         case EXPR_CONST:
 324                 print_const(&expression->conste);
 325                 break;
 326         case EXPR_FUNCTION:
 327         case EXPR_PRETTY_FUNCTION:
 328         case EXPR_STRING_LITERAL:
 329                 print_string_literal(&expression->string);
 330                 break;
 331         case EXPR_WIDE_STRING_LITERAL:
 332                 print_wide_string_literal(&expression->wide_string);
 333                 break;
 334         case EXPR_CALL:
 335                 print_call_expression(&expression->call);
 336                 break;
 337         case EXPR_BINARY:
 338                 print_binary_expression(&expression->binary);
 339                 break;
 340         case EXPR_REFERENCE:
 341                 print_reference_expression(&expression->reference);
 342                 break;
 343         case EXPR_ARRAY_ACCESS:
 344                 print_array_expression(&expression->array_access);
 345                 break;
 346         case EXPR_UNARY:
 347                 print_unary_expression(&expression->unary);
 348                 break;
 349         case EXPR_SIZEOF:
 350                 print_sizeof_expression(&expression->sizeofe);
 351                 break;
 352         case EXPR_BUILTIN_SYMBOL:
 353                 print_builtin_symbol(&expression->builtin_symbol);
 354                 break;
 355         case EXPR_CONDITIONAL:
 356                 print_conditional(&expression->conditional);
 357                 break;
 358         case EXPR_VA_START:
 359                 print_va_start(&expression->va_starte);
 360         case EXPR_VA_ARG:
 361                 print_va_arg(&expression->va_arge);
 362                 break;
 363         case EXPR_SELECT:
 364                 print_select(&expression->select);
 365                 break;
 366         case EXPR_CLASSIFY_TYPE:
 367                 print_classify_type_expression(&expression->classify_type);
 368                 break;
 369
 370         case EXPR_OFFSETOF:
 371         case EXPR_STATEMENT:
 372                 /* TODO */
 373                 fprintf(out, "some expression of type %d", (int) expression->type);
 374                 break;
 375         }
 376 }
 377
 378 static void print_compound_statement(const compound_statement_t *block)
 379 {
 380         fputs("{\n", out);
 381         indent++;
 382
 383         statement_t *statement = block->statements;
 384         while(statement != NULL) {
 385                 print_indent();
 386                 print_statement(statement);
 387
 388                 statement = statement->base.next;
 389         }
 390         indent--;
 391         print_indent();
 392         fputs("}\n", out);
 393 }
 394
 395 static void print_return_statement(const return_statement_t *statement)
 396 {
 397         fprintf(out, "return ");
 398         if(statement->return_value != NULL)
 399                 print_expression(statement->return_value);
 400         fputs(";\n", out);
 401 }
 402
 403 static void print_expression_statement(const expression_statement_t *statement)
 404 {
 405         print_expression(statement->expression);
 406         fputs(";\n", out);
 407 }
 408
 409 static void print_goto_statement(const goto_statement_t *statement)
 410 {
 411         fprintf(out, "goto ");
 412         fputs(statement->label->symbol->string, out);
 413         fprintf(stderr, "(%p)", (void*) statement->label);
 414         fputs(";\n", out);
 415 }
 416
 417 static void print_label_statement(const label_statement_t *statement)
 418 {
 419         fprintf(stderr, "(%p)", (void*) statement->label);
 420         fprintf(out, "%s:\n", statement->label->symbol->string);
 421         if(statement->label_statement != NULL) {
 422                 print_statement(statement->label_statement);
 423         }
 424 }
 425
 426 static void print_if_statement(const if_statement_t *statement)
 427 {
 428         fputs("if(", out);
 429         print_expression(statement->condition);
 430         fputs(") ", out);
 431         if(statement->true_statement != NULL) {
 432                 print_statement(statement->true_statement);
 433         }
 434
 435         if(statement->false_statement != NULL) {
 436                 print_indent();
 437                 fputs("else ", out);
 438                 print_statement(statement->false_statement);
 439         }
 440 }
 441
 442 static void print_switch_statement(const switch_statement_t *statement)
 443 {
 444         fputs("switch(", out);
 445         print_expression(statement->expression);
 446         fputs(") ", out);
 447         print_statement(statement->body);
 448 }
 449
 450 static void print_case_label(const case_label_statement_t *statement)
 451 {
 452         if(statement->expression == NULL) {
 453                 fputs("default:\n", out);
 454         } else {
 455                 fputs("case ", out);
 456                 print_expression(statement->expression);
 457                 fputs(":\n", out);
 458         }
 459         print_statement(statement->label_statement);
 460 }
 461
 462 static void print_declaration_statement(
 463                 const declaration_statement_t *statement)
 464 {
 465         int first = 1;
 466         declaration_t *declaration = statement->declarations_begin;
 467         for( ; declaration != statement->declarations_end->next;
 468                declaration = declaration->next) {
 469                 if(!first) {
 470                         print_indent();
 471                 } else {
 472                         first = 0;
 473                 }
 474                 print_declaration(declaration);
 475                 fputc('\n', out);
 476         }
 477 }
 478
 479 static void print_while_statement(const while_statement_t *statement)
 480 {
 481         fputs("while(", out);
 482         print_expression(statement->condition);
 483         fputs(") ", out);
 484         print_statement(statement->body);
 485 }
 486
 487 static void print_do_while_statement(const do_while_statement_t *statement)
 488 {
 489         fputs("do ", out);
 490         print_statement(statement->body);
 491         print_indent();
 492         fputs("while(", out);
 493         print_expression(statement->condition);
 494         fputs(");\n", out);
 495 }
 496
 497 static void print_for_statement(const for_statement_t *statement)
 498 {
 499         fputs("for(", out);
 500         if(statement->context.declarations != NULL) {
 501                 assert(statement->initialisation == NULL);
 502                 print_declaration(statement->context.declarations);
 503                 if(statement->context.declarations->next != NULL) {
 504                         panic("multiple declarations in for statement not supported yet");
 505                 }
 506                 fputc(' ', out);
 507         } else {
 508                 if(statement->initialisation) {
 509                         print_expression(statement->initialisation);
 510                 }
 511                 fputs("; ", out);
 512         }
 513         if(statement->condition != NULL) {
 514                 print_expression(statement->condition);
 515         }
 516         fputs("; ", out);
 517         if(statement->step != NULL) {
 518                 print_expression(statement->step);
 519         }
 520         fputs(")", out);
 521         print_statement(statement->body);
 522 }
 523
 524 static void print_asm_constraints(asm_constraint_t *constraints)
 525 {
 526         asm_constraint_t *constraint = constraints;
 527         for( ; constraint != NULL; constraint = constraint->next) {
 528                 if(constraint != constraints)
 529                         fputs(", ", out);
 530
 531                 if(constraint->symbol) {
 532                         fprintf(out, "[%s] ", constraint->symbol->string);
 533                 }
 534                 print_quoted_string(constraint->constraints);
 535                 fputs(" (", out);
 536                 print_expression(constraint->expression);
 537                 fputs(")", out);
 538         }
 539 }
 540
 541 static void print_asm_clobbers(asm_clobber_t *clobbers)
 542 {
 543         asm_clobber_t *clobber = clobbers;
 544         for( ; clobber != NULL; clobber = clobber->next) {
 545                 if(clobber != clobbers)
 546                         fputs(", ", out);
 547
 548                 print_quoted_string(clobber->clobber);
 549         }
 550 }
 551
 552 static void print_asm_statement(const asm_statement_t *statement)
 553 {
 554         fputs("asm ", out);
 555         if(statement->is_volatile) {
 556                 fputs("volatile ", out);
 557         }
 558         fputs("(", out);
 559         print_quoted_string(statement->asm_text);
 560         if(statement->inputs == NULL && statement->outputs == NULL
 561                         && statement->clobbers == NULL)
 562                 goto end_of_print_asm_statement;
 563
 564         fputs(" : ", out);
 565         print_asm_constraints(statement->inputs);
 566         if(statement->outputs == NULL && statement->clobbers == NULL)
 567                 goto end_of_print_asm_statement;
 568
 569         fputs(" : ", out);
 570         print_asm_constraints(statement->outputs);
 571         if(statement->clobbers == NULL)
 572                 goto end_of_print_asm_statement;
 573
 574         fputs(" : ", out);
 575         print_asm_clobbers(statement->clobbers);
 576
 577 end_of_print_asm_statement:
 578         fputs(");\n", out);
 579 }
 580
 581 void print_statement(const statement_t *statement)
 582 {
 583         switch(statement->type) {
 584         case STATEMENT_COMPOUND:
 585                 print_compound_statement(&statement->compound);
 586                 break;
 587         case STATEMENT_RETURN:
 588                 print_return_statement(&statement->returns);
 589                 break;
 590         case STATEMENT_EXPRESSION:
 591                 print_expression_statement(&statement->expression);
 592                 break;
 593         case STATEMENT_LABEL:
 594                 print_label_statement(&statement->label);
 595                 break;
 596         case STATEMENT_GOTO:
 597                 print_goto_statement(&statement->gotos);
 598                 break;
 599         case STATEMENT_CONTINUE:
 600                 fputs("continue;\n", out);
 601                 break;
 602         case STATEMENT_BREAK:
 603                 fputs("break;\n", out);
 604                 break;
 605         case STATEMENT_IF:
 606                 print_if_statement(&statement->ifs);
 607                 break;
 608         case STATEMENT_SWITCH:
 609                 print_switch_statement(&statement->switchs);
 610                 break;
 611         case STATEMENT_CASE_LABEL:
 612                 print_case_label(&statement->case_label);
 613                 break;
 614         case STATEMENT_DECLARATION:
 615                 print_declaration_statement(&statement->declaration);
 616                 break;
 617         case STATEMENT_WHILE:
 618                 print_while_statement(&statement->whiles);
 619                 break;
 620         case STATEMENT_DO_WHILE:
 621                 print_do_while_statement(&statement->do_while);
 622                 break;
 623         case STATEMENT_FOR:
 624                 print_for_statement(&statement->fors);
 625                 break;
 626         case STATEMENT_ASM:
 627                 print_asm_statement(&statement->asms);
 628                 break;
 629         case STATEMENT_INVALID:
 630                 fprintf(out, "*invalid statement*");
 631                 break;
 632         }
 633 }
 634
 635 static void print_storage_class(unsigned storage_class)
 636 {
 637         switch((storage_class_tag_t) storage_class) {
 638         case STORAGE_CLASS_ENUM_ENTRY:
 639         case STORAGE_CLASS_NONE:
 640                 break;
 641         case STORAGE_CLASS_TYPEDEF:       fputs("typedef ",        out); break;
 642         case STORAGE_CLASS_EXTERN:        fputs("extern ",         out); break;
 643         case STORAGE_CLASS_STATIC:        fputs("static ",         out); break;
 644         case STORAGE_CLASS_AUTO:          fputs("auto ",           out); break;
 645         case STORAGE_CLASS_REGISTER:      fputs("register ",       out); break;
 646         case STORAGE_CLASS_THREAD:        fputs("__thread",        out); break;
 647         case STORAGE_CLASS_THREAD_EXTERN: fputs("extern __thread", out); break;
 648         case STORAGE_CLASS_THREAD_STATIC: fputs("static __thread", out); break;
 649         }
 650 }
 651
 652 void print_initializer(const initializer_t *initializer)
 653 {
 654         if(initializer->type == INITIALIZER_VALUE) {
 655                 const initializer_value_t *value = &initializer->value;
 656                 print_expression(value->value);
 657                 return;
 658         }
 659
 660         assert(initializer->type == INITIALIZER_LIST);
 661         fputs("{ ", out);
 662         const initializer_list_t *list = &initializer->list;
 663
 664         for(size_t i = 0 ; i < list->len; ++i) {
 665                 if(i > 0) {
 666                         fputs(", ", out);
 667                 }
 668                 print_initializer(list->initializers[i]);
 669         }
 670         fputs("}", out);
 671 }
 672
 673 static void print_normal_declaration(const declaration_t *declaration)
 674 {
 675         print_storage_class(declaration->storage_class);
 676         if(declaration->is_inline) {
 677                 fputs("inline ", out);
 678         }
 679         print_type_ext(declaration->type, declaration->symbol,
 680                        &declaration->context);
 681
 682         if(declaration->type->type == TYPE_FUNCTION) {
 683                 if(declaration->init.statement != NULL) {
 684                         fputs("\n", out);
 685                         print_statement(declaration->init.statement);
 686                         return;
 687                 }
 688         } else if(declaration->init.initializer != NULL) {
 689                 fputs(" = ", out);
 690                 print_initializer(declaration->init.initializer);
 691         }
 692         fputc(';', out);
 693 }
 694
 695 void print_declaration(const declaration_t *declaration)
 696 {
 697         if(declaration->namespc != NAMESPACE_NORMAL &&
 698                         declaration->symbol == NULL)
 699                 return;
 700
 701         switch(declaration->namespc) {
 702         case NAMESPACE_NORMAL:
 703                 print_normal_declaration(declaration);
 704                 break;
 705         case NAMESPACE_STRUCT:
 706                 fputs("struct ", out);
 707                 fputs(declaration->symbol->string, out);
 708                 fputc(' ', out);
 709                 print_compound_definition(declaration);
 710                 fputc(';', out);
 711                 break;
 712         case NAMESPACE_UNION:
 713                 fputs("union ", out);
 714                 fputs(declaration->symbol->string, out);
 715                 fputc(' ', out);
 716                 print_compound_definition(declaration);
 717                 fputc(';', out);
 718                 break;
 719         case NAMESPACE_ENUM:
 720                 fputs("enum ", out);
 721                 fputs(declaration->symbol->string, out);
 722                 fputc(' ', out);
 723                 print_enum_definition(declaration);
 724                 fputc(';', out);
 725                 break;
 726         }
 727 }
 728
 729 void print_ast(const translation_unit_t *unit)
 730 {
 731         inc_type_visited();
 732
 733         declaration_t *declaration = unit->context.declarations;
 734         for( ; declaration != NULL; declaration = declaration->next) {
 735                 if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
 736                         continue;
 737                 if(declaration->namespc != NAMESPACE_NORMAL &&
 738                                 declaration->symbol == NULL)
 739                         continue;
 740
 741                 print_indent();
 742                 print_declaration(declaration);
 743                 fputc('\n', out);
 744         }
 745 }
 746
 747 void init_ast(void)
 748 {
 749         obstack_init(&ast_obstack);
 750 }
 751
 752 void exit_ast(void)
 753 {
 754         obstack_free(&ast_obstack, NULL);
 755 }
 756
 757 void ast_set_output(FILE *stream)
 758 {
 759         out = stream;
 760         type_set_output(stream);
 761 }
 762
 763 void* (allocate_ast) (size_t size)
 764 {
 765         return _allocate_ast(size);
 766 }