implement array intiailizers

[cparser] / ast.c

diff --git a/ast.c b/ast.c
index 91b8cc8..77821bc 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -161,7 +161,7 @@ static void print_unary_expression(const unary_expression_t *unexpr)
                fputs(")", out);
                break;
        case UNEXPR_INVALID:
-               fprintf(out, "unop%d", unexpr->type);
+               fprintf(out, "unop%d", (int) unexpr->type);
                break;
        }
        fputs("(", out);
@@ -234,9 +234,18 @@ static void print_select(const select_expression_t *expression)
        fputs(expression->symbol->string, out);
 }
 
+static void print_classify_type_expression(
+       const classify_type_expression_t *const expr)
+{
+       fputs("__builtin_classify_type(", out);
+       print_expression(expr->type_expression);
+       fputc(')', out);
+}
+
 void print_expression(const expression_t *expression)
 {
        switch(expression->type) {
+       case EXPR_UNKNOWN:
        case EXPR_INVALID:
                fprintf(out, "*invalid expression*");
                break;
@@ -278,11 +287,14 @@ void print_expression(const expression_t *expression)
        case EXPR_SELECT:
                print_select((const select_expression_t*) expression);
                break;
+       case EXPR_CLASSIFY_TYPE:
+               print_classify_type_expression((const classify_type_expression_t*)expression);
+               break;
 
        case EXPR_OFFSETOF:
        case EXPR_STATEMENT:
                /* TODO */
-               fprintf(out, "some expression of type %d", expression->type);
+               fprintf(out, "some expression of type %d", (int) expression->type);
                break;
        }
 }
@@ -320,17 +332,19 @@ static void print_expression_statement(const expression_statement_t *statement)
 
 static void print_goto_statement(const goto_statement_t *statement)
 {
-       (void) statement;
        fprintf(out, "goto ");
-       panic("TODO: print goto");
+       fputs(statement->label->symbol->string, out);
+       fprintf(stderr, "(%p)", (void*) statement->label);
        fputs(";\n", out);
 }
 
 static void print_label_statement(const label_statement_t *statement)
 {
-       (void) statement;
-       panic("TODO: print label");
-       //fprintf(out, "%s:\n", statement->symbol->string);
+       fprintf(stderr, "(%p)", (void*) statement->label);
+       fprintf(out, "%s:\n", statement->label->symbol->string);
+       if(statement->label_statement != NULL) {
+               print_statement(statement->label_statement);
+       }
 }
 
 static void print_if_statement(const if_statement_t *statement)
@@ -498,10 +512,11 @@ static void print_storage_class(storage_class_t storage_class)
 void print_initializer(const initializer_t *initializer)
 {
        if(initializer->type == INITIALIZER_VALUE) {
-               print_expression(initializer->v.value);
+               //print_expression(initializer->v.value);
                return;
        }
 
+#if 0
        assert(initializer->type == INITIALIZER_LIST);
        fputs("{ ", out);
        initializer_t *iter = initializer->v.list;
@@ -512,13 +527,18 @@ void print_initializer(const initializer_t *initializer)
                }
        }
        fputs("}", out);
+#endif
 }
 
 static void print_normal_declaration(const declaration_t *declaration)
 {
-       print_storage_class(declaration->storage_class);
+       print_storage_class((storage_class_t)declaration->storage_class);
        print_type_ext(declaration->type, declaration->symbol,
                       &declaration->context);
+       if(declaration->is_inline) {
+               fputs("inline ", out);
+       }
+
        if(declaration->type->type == TYPE_FUNCTION) {
                if(declaration->init.statement != NULL) {
                        fputs("\n", out);
@@ -534,11 +554,11 @@ static void print_normal_declaration(const declaration_t *declaration)
 
 void print_declaration(const declaration_t *declaration)
 {
-       if(declaration->namespace != NAMESPACE_NORMAL &&
+       if(declaration->namespc != NAMESPACE_NORMAL &&
                        declaration->symbol == NULL)
                return;
 
-       switch(declaration->namespace) {
+       switch(declaration->namespc) {
        case NAMESPACE_NORMAL:
                print_normal_declaration(declaration);
                break;
@@ -575,7 +595,7 @@ void print_ast(const translation_unit_t *unit)
        for( ; declaration != NULL; declaration = declaration->next) {
                if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
                        continue;
-               if(declaration->namespace != NAMESPACE_NORMAL &&
+               if(declaration->namespc != NAMESPACE_NORMAL &&
                                declaration->symbol == NULL)
                        continue;