11 #include "adt/error.h"
13 struct obstack ast_obstack;
18 static void print_statement(const statement_t *statement);
19 static void print_declaration(const declaration_t *declaration);
21 static void print_indent(void)
23 for(int i = 0; i < indent; ++i)
27 static void print_const(const const_t *cnst)
29 if(cnst->expression.datatype == NULL)
32 if(is_type_integer(cnst->expression.datatype)) {
33 fprintf(out, "%d", cnst->v.int_value);
34 } else if(is_type_floating(cnst->expression.datatype)) {
35 fprintf(out, "%Lf", cnst->v.float_value);
39 static void print_string_literal(const string_literal_t *string_literal)
42 for(const char *c = string_literal->value; *c != '\0'; ++c) {
44 case '\"': fputs("\\\"", out); break;
45 case '\\': fputs("\\\\", out); break;
46 case '\a': fputs("\\a", out); break;
47 case '\b': fputs("\\b", out); break;
48 case '\f': fputs("\\f", out); break;
49 case '\n': fputs("\\n", out); break;
50 case '\r': fputs("\\r", out); break;
51 case '\t': fputs("\\t", out); break;
52 case '\v': fputs("\\v", out); break;
53 case '\?': fputs("\\?", out); break;
56 fprintf(out, "\\x%x", *c);
66 static void print_call_expression(const call_expression_t *call)
68 print_expression(call->method);
70 call_argument_t *argument = call->arguments;
72 while(argument != NULL) {
78 print_expression(argument->expression);
80 argument = argument->next;
85 static void print_binary_expression(const binary_expression_t *binexpr)
88 print_expression(binexpr->left);
90 switch(binexpr->type) {
91 case BINEXPR_INVALID: fputs("INVOP", out); break;
92 case BINEXPR_COMMA: fputs(",", out); break;
93 case BINEXPR_ASSIGN: fputs("=", out); break;
94 case BINEXPR_ADD: fputs("+", out); break;
95 case BINEXPR_SUB: fputs("-", out); break;
96 case BINEXPR_MUL: fputs("*", out); break;
97 case BINEXPR_MOD: fputs("%", out); break;
98 case BINEXPR_DIV: fputs("/", out); break;
99 case BINEXPR_BITWISE_OR: fputs("|", out); break;
100 case BINEXPR_BITWISE_AND: fputs("&", out); break;
101 case BINEXPR_BITWISE_XOR: fputs("^", out); break;
102 case BINEXPR_LOGICAL_OR: fputs("||", out); break;
103 case BINEXPR_LOGICAL_AND: fputs("&&", out); break;
104 case BINEXPR_NOTEQUAL: fputs("!=", out); break;
105 case BINEXPR_EQUAL: fputs("==", out); break;
106 case BINEXPR_LESS: fputs("<", out); break;
107 case BINEXPR_LESSEQUAL: fputs("<=", out); break;
108 case BINEXPR_GREATER: fputs(">", out); break;
109 case BINEXPR_GREATEREQUAL: fputs(">=", out); break;
110 case BINEXPR_SHIFTLEFT: fputs("<<", out); break;
111 case BINEXPR_SHIFTRIGHT: fputs(">>", out); break;
113 case BINEXPR_ADD_ASSIGN: fputs("+=", out); break;
114 case BINEXPR_SUB_ASSIGN: fputs("-=", out); break;
115 case BINEXPR_MUL_ASSIGN: fputs("*=", out); break;
116 case BINEXPR_MOD_ASSIGN: fputs("%=", out); break;
117 case BINEXPR_DIV_ASSIGN: fputs("/=", out); break;
118 case BINEXPR_BITWISE_OR_ASSIGN: fputs("|=", out); break;
119 case BINEXPR_BITWISE_AND_ASSIGN: fputs("&=", out); break;
120 case BINEXPR_BITWISE_XOR_ASSIGN: fputs("^=", out); break;
121 case BINEXPR_SHIFTLEFT_ASSIGN: fputs("<<=", out); break;
122 case BINEXPR_SHIFTRIGHT_ASSIGN: fputs(">>=", out); break;
125 print_expression(binexpr->right);
129 static void print_unary_expression(const unary_expression_t *unexpr)
131 switch(unexpr->type) {
132 case UNEXPR_NEGATE: fputs("-", out); break;
133 case UNEXPR_PLUS: fputs("+", out); break;
134 case UNEXPR_NOT: fputs("!", out); break;
135 case UNEXPR_BITWISE_NEGATE: fputs("~", out); break;
136 case UNEXPR_PREFIX_INCREMENT: fputs("++", out); break;
137 case UNEXPR_PREFIX_DECREMENT: fputs("--", out); break;
138 case UNEXPR_DEREFERENCE: fputs("*", out); break;
139 case UNEXPR_TAKE_ADDRESS: fputs("&", out); break;
141 case UNEXPR_POSTFIX_INCREMENT:
143 print_expression(unexpr->value);
147 case UNEXPR_POSTFIX_DECREMENT:
149 print_expression(unexpr->value);
155 print_type(unexpr->expression.datatype);
159 fprintf(out, "unop%d", unexpr->type);
163 print_expression(unexpr->value);
167 static void print_reference_expression(const reference_expression_t *ref)
169 fprintf(out, "%s", ref->declaration->symbol->string);
172 static void print_array_expression(const array_access_expression_t *expression)
175 print_expression(expression->array_ref);
177 print_expression(expression->index);
181 static void print_sizeof_expression(const sizeof_expression_t *expression)
183 fputs("sizeof", out);
184 if(expression->size_expression != NULL) {
186 print_expression(expression->size_expression);
190 print_type(expression->type);
195 static void print_builtin_symbol(const builtin_symbol_expression_t *expression)
197 fputs(expression->symbol->string, out);
200 static void print_conditional(const conditional_expression_t *expression)
203 print_expression(expression->condition);
205 print_expression(expression->true_expression);
207 print_expression(expression->false_expression);
211 void print_expression(const expression_t *expression)
213 switch(expression->type) {
215 fprintf(out, "*invalid expression*");
218 print_const((const const_t*) expression);
221 case EXPR_PRETTY_FUNCTION:
222 case EXPR_STRING_LITERAL:
223 print_string_literal((const string_literal_t*) expression);
226 print_call_expression((const call_expression_t*) expression);
229 print_binary_expression((const binary_expression_t*) expression);
232 print_reference_expression((const reference_expression_t*) expression);
234 case EXPR_ARRAY_ACCESS:
235 print_array_expression((const array_access_expression_t*) expression);
238 print_unary_expression((const unary_expression_t*) expression);
241 print_sizeof_expression((const sizeof_expression_t*) expression);
243 case EXPR_BUILTIN_SYMBOL:
244 print_builtin_symbol((const builtin_symbol_expression_t*) expression);
246 case EXPR_CONDITIONAL:
247 print_conditional((const conditional_expression_t*) expression);
254 fprintf(out, "some expression of type %d", expression->type);
259 static void print_compound_statement(const compound_statement_t *block)
264 statement_t *statement = block->statements;
265 while(statement != NULL) {
267 print_statement(statement);
269 statement = statement->next;
276 static void print_return_statement(const return_statement_t *statement)
278 fprintf(out, "return ");
279 if(statement->return_value != NULL)
280 print_expression(statement->return_value);
284 static void print_expression_statement(const expression_statement_t *statement)
286 print_expression(statement->expression);
290 static void print_goto_statement(const goto_statement_t *statement)
292 fprintf(out, "goto ");
293 if(statement->label != NULL) {
294 fprintf(out, "%s", statement->label->symbol->string);
296 fprintf(out, "?%s", statement->label_symbol->string);
301 static void print_label_statement(const label_statement_t *statement)
303 fprintf(out, "%s:\n", statement->symbol->string);
306 static void print_if_statement(const if_statement_t *statement)
309 print_expression(statement->condition);
311 if(statement->true_statement != NULL) {
312 print_statement(statement->true_statement);
315 if(statement->false_statement != NULL) {
318 print_statement(statement->false_statement);
322 static void print_switch_statement(const switch_statement_t *statement)
324 fputs("switch(", out);
325 print_expression(statement->expression);
327 print_statement(statement->body);
330 static void print_case_label(const case_label_statement_t *statement)
332 if(statement->expression == NULL) {
333 fputs("default:\n", out);
336 print_expression(statement->expression);
341 static void print_declaration_statement(
342 const declaration_statement_t *statement)
344 declaration_t *declaration = statement->declarations_begin;
345 for( ; declaration != statement->declarations_end->next;
346 declaration = declaration->next) {
347 print_declaration(declaration);
351 static void print_while_statement(const while_statement_t *statement)
353 fputs("while(", out);
354 print_expression(statement->condition);
356 print_statement(statement->body);
359 static void print_do_while_statement(const do_while_statement_t *statement)
362 print_statement(statement->body);
364 fputs("while(", out);
365 print_expression(statement->condition);
369 static void print_for_statement(const for_statement_t *statement)
372 if(statement->context.declarations != NULL) {
373 assert(statement->initialisation == NULL);
374 print_declaration(statement->context.declarations);
375 if(statement->context.declarations->next != NULL) {
376 panic("multiple declarations in for statement not supported yet");
378 } else if(statement->initialisation) {
379 print_expression(statement->initialisation);
382 if(statement->condition != NULL) {
383 print_expression(statement->condition);
386 if(statement->step != NULL) {
387 print_expression(statement->step);
390 print_statement(statement->body);
393 void print_statement(const statement_t *statement)
395 switch(statement->type) {
396 case STATEMENT_COMPOUND:
397 print_compound_statement((const compound_statement_t*) statement);
399 case STATEMENT_RETURN:
400 print_return_statement((const return_statement_t*) statement);
402 case STATEMENT_EXPRESSION:
403 print_expression_statement((const expression_statement_t*) statement);
405 case STATEMENT_LABEL:
406 print_label_statement((const label_statement_t*) statement);
409 print_goto_statement((const goto_statement_t*) statement);
411 case STATEMENT_CONTINUE:
412 fputs("continue;\n", out);
414 case STATEMENT_BREAK:
415 fputs("break;\n", out);
418 print_if_statement((const if_statement_t*) statement);
420 case STATEMENT_SWITCH:
421 print_switch_statement((const switch_statement_t*) statement);
423 case STATEMENT_CASE_LABEL:
424 print_case_label((const case_label_statement_t*) statement);
426 case STATEMENT_DECLARATION:
427 print_declaration_statement((const declaration_statement_t*) statement);
429 case STATEMENT_WHILE:
430 print_while_statement((const while_statement_t*) statement);
432 case STATEMENT_DO_WHILE:
433 print_do_while_statement((const do_while_statement_t*) statement);
436 print_for_statement((const for_statement_t*) statement);
438 case STATEMENT_INVALID:
439 fprintf(out, "*invalid statement*");
444 static void print_storage_class(storage_class_t storage_class)
446 switch(storage_class) {
447 case STORAGE_CLASS_ENUM_ENTRY:
448 case STORAGE_CLASS_NONE:
450 case STORAGE_CLASS_TYPEDEF: fputs("typedef ", out); break;
451 case STORAGE_CLASS_EXTERN: fputs("extern ", out); break;
452 case STORAGE_CLASS_STATIC: fputs("static ", out); break;
453 case STORAGE_CLASS_AUTO: fputs("auto ", out); break;
454 case STORAGE_CLASS_REGISTER: fputs("register ", out); break;
458 static void print_declaration(const declaration_t *declaration)
460 print_storage_class(declaration->storage_class);
461 print_type_ext(declaration->type, declaration->symbol,
462 &declaration->context);
463 if(declaration->statement != NULL) {
465 print_statement(declaration->statement);
466 } else if(declaration->initializer != NULL) {
468 print_expression(declaration->initializer);
475 void print_ast(const translation_unit_t *unit)
477 declaration_t *declaration = unit->context.declarations;
478 while(declaration != NULL) {
479 print_declaration(declaration);
481 declaration = declaration->next;
487 obstack_init(&ast_obstack);
492 obstack_free(&ast_obstack, NULL);
495 void ast_set_output(FILE *stream)
498 type_set_output(stream);
501 void* (allocate_ast) (size_t size)
503 return _allocate_ast(size);