struct obstack ast_obstack;
+static FILE *out;
+static int indent;
+
+static void print_statement(const statement_t *statement);
+
static
-void print_const(FILE *out, const const_t *cnst)
+void print_const(const const_t *cnst)
{
fprintf(out, "%d", cnst->value);
}
static
-void print_string_literal(FILE *out, const string_literal_t *string_literal)
+void print_string_literal(const string_literal_t *string_literal)
{
/* TODO escape " and non-printable chars */
fprintf(out, "\"%s\"", string_literal->value);
}
static
-void print_call_expression(FILE *out, const call_expression_t *call)
+void print_call_expression(const call_expression_t *call)
{
- print_expression(out, call->method);
+ print_expression(call->method);
fprintf(out, "(");
call_argument_t *argument = call->arguments;
int first = 1;
} else {
first = 0;
}
- print_expression(out, argument->expression);
+ print_expression(argument->expression);
argument = argument->next;
}
}
static
-void print_binary_expression(FILE *out, const binary_expression_t *binexpr)
+void print_binary_expression(const binary_expression_t *binexpr)
{
fprintf(out, "(");
- print_expression(out, binexpr->left);
+ print_expression(binexpr->left);
fprintf(out, " ");
switch(binexpr->type) {
case BINEXPR_INVALID:
break;
}
fprintf(out, " ");
- print_expression(out, binexpr->right);
+ print_expression(binexpr->right);
fprintf(out, ")");
}
-void print_expression(FILE *out, const expression_t *expression)
+void print_expression(const expression_t *expression)
{
switch(expression->type) {
case EXPR_INVALID:
fprintf(out, "*invalid expression*");
break;
case EXPR_CONST:
- print_const(out, (const const_t*) expression);
+ print_const((const const_t*) expression);
break;
case EXPR_STRING_LITERAL:
- print_string_literal(out, (const string_literal_t*) expression);
+ print_string_literal((const string_literal_t*) expression);
break;
case EXPR_CALL:
- print_call_expression(out, (const call_expression_t*) expression);
+ print_call_expression((const call_expression_t*) expression);
break;
case EXPR_BINARY:
- print_binary_expression(out, (const binary_expression_t*) expression);
+ print_binary_expression((const binary_expression_t*) expression);
break;
case EXPR_REFERENCE:
case EXPR_UNARY:
}
static
-void print_block_statement(FILE *out, int indent,
- const block_statement_t *block)
+void print_compound_statement(const compound_statement_t *block)
{
- statement_t *statement = block->first_statement;
+ fputs("{\n", out);
+ indent++;
+
+ statement_t *statement = block->statements;
while(statement != NULL) {
- print_statement(out, indent + 1, statement);
+ print_statement(statement);
statement = statement->next;
}
+ indent--;
+ fputs("}\n", out);
}
static
-void print_return_statement(FILE *out, const return_statement_t *statement)
+void print_return_statement(const return_statement_t *statement)
{
fprintf(out, "return ");
if(statement->return_value != NULL)
- print_expression(out, statement->return_value);
+ print_expression(statement->return_value);
}
static
-void print_expression_statement(FILE *out,
- const expression_statement_t *statement)
+void print_expression_statement(const expression_statement_t *statement)
{
- print_expression(out, statement->expression);
+ print_expression(statement->expression);
}
static
-void print_goto_statement(FILE *out, const goto_statement_t *statement)
+void print_goto_statement(const goto_statement_t *statement)
{
fprintf(out, "goto ");
if(statement->label != NULL) {
}
static
-void print_label_statement(FILE *out, const label_statement_t *statement)
+void print_label_statement(const label_statement_t *statement)
{
fprintf(out, ":%s", statement->symbol->string);
}
static
-void print_if_statement(FILE *out, int indent, const if_statement_t *statement)
+void print_if_statement(const if_statement_t *statement)
{
fprintf(out, "if ");
- print_expression(out, statement->condition);
+ print_expression(statement->condition);
fprintf(out, ":\n");
if(statement->true_statement != NULL) {
- print_statement(out, indent, statement->true_statement);
+ print_statement(statement->true_statement);
}
if(statement->false_statement != NULL) {
fprintf(out, "else:\n");
- print_statement(out, indent, statement->false_statement);
+ print_statement(statement->false_statement);
}
}
static
-void print_variable_declaration_statement(FILE *out,
- const variable_declaration_statement_t *statement)
+void print_declaration_statement(const declaration_statement_t *statement)
{
- fprintf(out, "var");
- if(statement->type != NULL) {
- fprintf(out, "<");
- print_type(out, statement->type);
- fprintf(out, ">");
- }
- fprintf(out, " %s", statement->symbol->string);
+ (void) statement;
+ fprintf(out, "*declaration statement*");
}
-void print_statement(FILE *out, int indent, const statement_t *statement)
+void print_statement(const statement_t *statement)
{
for(int i = 0; i < indent; ++i)
fprintf(out, "\t");
switch(statement->type) {
- case STATEMENT_BLOCK:
- print_block_statement(out, indent,
- (const block_statement_t*) statement);
+ case STATEMENT_COMPOUND:
+ print_compound_statement((const compound_statement_t*) statement);
break;
case STATEMENT_RETURN:
- print_return_statement(out, (const return_statement_t*) statement);
+ print_return_statement((const return_statement_t*) statement);
break;
case STATEMENT_EXPRESSION:
- print_expression_statement(out,
- (const expression_statement_t*) statement);
+ print_expression_statement((const expression_statement_t*) statement);
break;
case STATEMENT_LABEL:
- print_label_statement(out, (const label_statement_t*) statement);
+ print_label_statement((const label_statement_t*) statement);
break;
case STATEMENT_GOTO:
- print_goto_statement(out, (const goto_statement_t*) statement);
+ print_goto_statement((const goto_statement_t*) statement);
break;
case STATEMENT_IF:
- print_if_statement(out, indent, (const if_statement_t*) statement);
+ print_if_statement((const if_statement_t*) statement);
break;
- case STATEMENT_VARIABLE_DECLARATION:
- print_variable_declaration_statement(out,
- (const variable_declaration_statement_t*) statement);
+ case STATEMENT_DECLARATION:
+ print_declaration_statement((const declaration_statement_t*) statement);
break;
case STATEMENT_INVALID:
default:
fprintf(out, "\n");
}
+#if 0
static
-void print_method_parameters(FILE *out, const method_parameter_t *parameters,
+void print_method_parameters(const method_parameter_t *parameters,
const method_type_t *method_type)
{
fprintf(out, "(");
first = 0;
}
- print_type(out, parameter_type->type);
+ print_type(parameter_type->type);
fprintf(out, " %s", parameter->symbol->string);
parameter = parameter->next;
fprintf(out, ")");
}
+#endif
static
-void print_method(FILE *out, const method_t *method)
+void print_storage_class(storage_class_t storage_class)
{
- method_type_t *type = method->type;
-
- fprintf(out, "func ");
- print_type(out, type->result_type);
- fprintf(out, " %s", method->symbol->string);
-
- print_method_parameters(out, method->parameters, type);
-
- if(method->statement != NULL) {
- fprintf(out, ":\n");
- print_statement(out, 0, method->statement);
- } else {
- fprintf(out, "\n");
+ switch(storage_class) {
+ case STORAGE_CLASS_NONE:
+ break;
+ case STORAGE_CLASS_TYPEDEF: fputs("typedef ", out); break;
+ case STORAGE_CLASS_EXTERN: fputs("extern ", out); break;
+ case STORAGE_CLASS_STATIC: fputs("static ", out); break;
+ case STORAGE_CLASS_AUTO: fputs("auto ", out); break;
+ case STORAGE_CLASS_REGISTER: fputs("register ", out); break;
}
}
static
-void print_namespace_entry(FILE *out, const unit_entry_t *entry)
+void print_declaration(const declaration_t *declaration)
{
- switch(entry->type) {
- case UNIT_ENTRY_METHOD:
- print_method(out, (const method_t*) entry);
- break;
- case UNIT_ENTRY_VARIABLE:
- /* TODO */
- fprintf(out, "some namespace entry of type %d\n\n", entry->type);
- break;
- case UNIT_ENTRY_INVALID:
- default:
- fprintf(out, "invalid namespace entry (%d)\n", entry->type);
- break;
+ print_storage_class(declaration->storage_class);
+ print_type(declaration->type, declaration->symbol);
+ if(declaration->statement != NULL) {
+ fprintf(out, "\n");
+ print_statement(declaration->statement);
+ } else {
+ fprintf(out, ";\n");
}
}
-void print_ast(FILE *out, const translation_unit_t *unit)
+void print_ast(const translation_unit_t *unit)
{
- unit_entry_t *entry = unit->entries;
-
- while(entry != NULL) {
- print_namespace_entry(out, entry);
+ declaration_t *declaration = unit->context.declarations;
+ while(declaration != NULL) {
+ print_declaration(declaration);
- entry = entry->next;
+ declaration = declaration->next;
}
}
obstack_free(&ast_obstack, NULL);
}
+void ast_set_output(FILE *stream)
+{
+ out = stream;
+ type_set_output(stream);
+}
+
void* (allocate_ast) (size_t size)
{
return _allocate_ast(size);
projects / cparser / blobdiff