- more test cases

[cparser] / ast.c

diff --git a/ast.c b/ast.c
index af5ae48..3184cf6 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -22,6 +22,7 @@
 #include "ast_t.h"
 #include "symbol_t.h"
 #include "type_t.h"
+#include "parser.h"
 
 #include <assert.h>
 #include <stdio.h>
@@ -705,7 +706,7 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
        switch(expression->kind) {
        case EXPR_UNKNOWN:
        case EXPR_INVALID:
-               fprintf(out, "*invalid expression*");
+               fprintf(out, "$invalid expression$");
                break;
        case EXPR_CHARACTER_CONSTANT:
                print_character_constant(&expression->conste);
@@ -856,9 +857,7 @@ static void print_label_statement(const label_statement_t *statement)
 {
        fprintf(stderr, "(%p)", (void*) statement->label);
        fprintf(out, "%s:\n", statement->label->symbol->string);
-       if(statement->statement != NULL) {
-               print_statement(statement->statement);
-       }
+       print_statement(statement->statement);
 }
 
 /**
@@ -868,12 +867,10 @@ static void print_label_statement(const label_statement_t *statement)
  */
 static void print_if_statement(const if_statement_t *statement)
 {
-       fputs("if(", out);
+       fputs("if (", out);
        print_expression(statement->condition);
        fputs(") ", out);
-       if(statement->true_statement != NULL) {
-               print_statement(statement->true_statement);
-       }
+       print_statement(statement->true_statement);
 
        if(statement->false_statement != NULL) {
                print_indent();
@@ -889,7 +886,7 @@ static void print_if_statement(const if_statement_t *statement)
  */
 static void print_switch_statement(const switch_statement_t *statement)
 {
-       fputs("switch(", out);
+       fputs("switch (", out);
        print_expression(statement->expression);
        fputs(") ", out);
        print_statement(statement->body);
@@ -935,6 +932,9 @@ static void print_declaration_statement(
        declaration_t *declaration = statement->declarations_begin;
        for( ; declaration != statement->declarations_end->next;
               declaration = declaration->next) {
+           if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
+               continue;
+
                if(!first) {
                        print_indent();
                } else {
@@ -952,7 +952,7 @@ static void print_declaration_statement(
  */
 static void print_while_statement(const while_statement_t *statement)
 {
-       fputs("while(", out);
+       fputs("while (", out);
        print_expression(statement->condition);
        fputs(") ", out);
        print_statement(statement->body);
@@ -968,7 +968,7 @@ static void print_do_while_statement(const do_while_statement_t *statement)
        fputs("do ", out);
        print_statement(statement->body);
        print_indent();
-       fputs("while(", out);
+       fputs("while (", out);
        print_expression(statement->condition);
        fputs(");\n", out);
 }
@@ -980,7 +980,7 @@ static void print_do_while_statement(const do_while_statement_t *statement)
  */
 static void print_for_statement(const for_statement_t *statement)
 {
-       fputs("for(", out);
+       fputs("for (", out);
        if(statement->scope.declarations != NULL) {
                assert(statement->initialisation == NULL);
                print_declaration(statement->scope.declarations);
@@ -1085,6 +1085,9 @@ end_of_print_asm_statement:
 void print_statement(const statement_t *statement)
 {
        switch(statement->kind) {
+       case STATEMENT_EMPTY:
+               fputs(";\n", out);
+               break;
        case STATEMENT_COMPOUND:
                print_compound_statement(&statement->compound);
                break;
@@ -1131,7 +1134,7 @@ void print_statement(const statement_t *statement)
                print_asm_statement(&statement->asms);
                break;
        case STATEMENT_INVALID:
-               fprintf(out, "*invalid statement*");
+               fprintf(out, "$invalid statement$");
                break;
        }
 }
@@ -1166,7 +1169,7 @@ static void print_storage_class(storage_class_tag_t storage_class)
 void print_initializer(const initializer_t *initializer)
 {
        if(initializer == NULL) {
-               fputs("{ NIL-INITIALIZER }", out);
+               fputs("{}", out);
                return;
        }
 
@@ -1184,8 +1187,9 @@ void print_initializer(const initializer_t *initializer)
                for(size_t i = 0 ; i < list->len; ++i) {
                        const initializer_t *sub_init = list->initializers[i];
                        print_initializer(list->initializers[i]);
-                       if(i < list->len-1 && sub_init->kind != INITIALIZER_DESIGNATOR) {
-                               fputs(", ", out);
+                       if(i < list->len-1) {
+                               if(sub_init == NULL || sub_init->kind != INITIALIZER_DESIGNATOR)
+                                       fputs(", ", out);
                        }
                }
                fputs(" }", out);
@@ -1213,36 +1217,62 @@ static void print_ms_modifiers(const declaration_t *declaration) {
        decl_modifiers_t modifiers = declaration->modifiers;
 
        /* DM_FORCEINLINE handled outside. */
-       if((modifiers & ~DM_FORCEINLINE) != 0) {
-               char next = '(';
+       if((modifiers & ~DM_FORCEINLINE) != 0 || declaration->alignment != 0 ||
+           declaration->get_property_sym != NULL || declaration->put_property_sym != NULL) {
+               char *next = "(";
 
                fputs("__declspec", out);
                if(modifiers & DM_DLLIMPORT) {
-                       fputc(next, out); next = ' '; fputs("dllimport", out);
+                       fputs(next, out); next = ", "; fputs("dllimport", out);
                }
                if(modifiers & DM_DLLEXPORT) {
-                       fputc(next, out); next = ' '; fputs("dllexport", out);
+                       fputs(next, out); next = ", "; fputs("dllexport", out);
                }
                if(modifiers & DM_THREAD) {
-                       fputc(next, out); next = ' '; fputs("thread", out);
+                       fputs(next, out); next = ", "; fputs("thread", out);
                }
                if(modifiers & DM_NAKED) {
-                       fputc(next, out); next = ' '; fputs("naked", out);
+                       fputs(next, out); next = ", "; fputs("naked", out);
                }
                if(modifiers & DM_THREAD) {
-                       fputc(next, out); next = ' '; fputs("thread", out);
+                       fputs(next, out); next = ", "; fputs("thread", out);
                }
                if(modifiers & DM_SELECTANY) {
-                       fputc(next, out); next = ' '; fputs("selectany", out);
+                       fputs(next, out); next = ", "; fputs("selectany", out);
                }
                if(modifiers & DM_NOTHROW) {
-                       fputc(next, out); next = ' '; fputs("nothrow", out);
+                       fputs(next, out); next = ", "; fputs("nothrow", out);
                }
                if(modifiers & DM_NORETURN) {
-                       fputc(next, out); next = ' '; fputs("noreturn", out);
+                       fputs(next, out); next = ", "; fputs("noreturn", out);
                }
                if(modifiers & DM_NOINLINE) {
-                       fputc(next, out); next = ' '; fputs("noinline", out);
+                       fputs(next, out); next = ", "; fputs("noinline", out);
+               }
+               if(modifiers & DM_DEPRECATED) {
+                       fputs(next, out); next = ", "; fputs("deprecated", out);
+                       if(declaration->deprecated_string != NULL)
+                               fprintf(out, "(\"%s\")", declaration->deprecated_string);
+               }
+               if(declaration->alignment != 0) {
+                       fputs(next, out); next = ", "; fprintf(out, "align(%u)", declaration->alignment);
+               }
+               if(modifiers & DM_RESTRICT) {
+                       fputs(next, out); next = ", "; fputs("restrict", out);
+               }
+               if(modifiers & DM_NOALIAS) {
+                       fputs(next, out); next = ", "; fputs("noalias", out);
+               }
+           if(declaration->get_property_sym != NULL || declaration->put_property_sym != NULL) {
+               char *comma = "";
+                       fputs(next, out); next = ", "; fprintf(out, "property(");
+               if(declaration->get_property_sym != NULL) {
+                       fprintf(out, "get=%s", declaration->get_property_sym->string);
+                       comma = ", ";
+                       }
+               if(declaration->put_property_sym != NULL)
+                       fprintf(out, "%sput=%s", comma, declaration->put_property_sym->string);
+                       fputc(')', out);
                }
                fputs(") ", out);
        }
@@ -1365,7 +1395,7 @@ bool is_constant_initializer(const initializer_t *initializer)
        case INITIALIZER_VALUE:
                return is_constant_expression(initializer->value.value);
 
-       case INITIALIZER_LIST: {
+       case INITIALIZER_LIST:
                for(size_t i = 0; i < initializer->list.len; ++i) {
                        initializer_t *sub_initializer = initializer->list.initializers[i];
                        if(!is_constant_initializer(sub_initializer))
@@ -1373,7 +1403,6 @@ bool is_constant_initializer(const initializer_t *initializer)
                }
                return true;
        }
-       }
        panic("invalid initializer kind found");
 }
 
@@ -1419,6 +1448,14 @@ bool is_address_constant(const expression_t *expression)
        case EXPR_UNARY_TAKE_ADDRESS:
                return is_object_with_constant_address(expression->unary.value);
 
+       case EXPR_UNARY_DEREFERENCE: {
+               type_t *real_type = revert_automatic_type_conversion(expression->unary.value);
+               /* dereferencing a function is a NOP */
+               if(is_type_function(real_type)) {
+                       return is_address_constant(expression->unary.value);
+               }
+       }
+
        case EXPR_UNARY_CAST:
                return is_type_pointer(skip_typeref(expression->base.type))
                        && (is_constant_expression(expression->unary.value)
@@ -1485,8 +1522,8 @@ bool is_constant_expression(const expression_t *expression)
        case EXPR_UNARY_PREFIX_DECREMENT:
        case EXPR_UNARY_BITFIELD_EXTRACT:
        case EXPR_UNARY_ASSUME: /* has VOID type */
-       case EXPR_UNARY_DEREFERENCE:
        case EXPR_UNARY_TAKE_ADDRESS:
+       case EXPR_UNARY_DEREFERENCE:
        case EXPR_BINARY_ASSIGN:
        case EXPR_BINARY_MUL_ASSIGN:
        case EXPR_BINARY_DIV_ASSIGN: