make enum entries use an expression instead of an initializer, set array type size...

[r18516]

diff --git a/TODO b/TODO
index a68ab5e..491c6cc 100644 (file)
--- a/TODO
+++ b/TODO
@@ -1,6 +1,5 @@
 Lexer:
 - proper support of preprocessor
-- parse float numbers
 - octal&hex escape sequences
 - wide string constants
 - proper handling of different file encodings
@@ -13,10 +12,12 @@ Parser:
   implementations...
 - fix semantic to ignore type qualifiers (const double is the same as double)
 - label: declaration; is no valid C99 but we parse it anyway
+- designator support for initializers
+- support string literals in intializers
 
 ast2firm:
 - output source file positions for panics...
-- correctly handle pointer ++, --
+- create strict convs where necessary
 
 
 Coole Warnungen:

diff --git a/ast_t.h b/ast_t.h
index 40a5284..7d078ec 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -246,6 +246,7 @@ struct declaration_t {
                bool            is_defined;
                statement_t    *statement;
                initializer_t  *initializer;
+               expression_t   *enum_value;
        } init;
        context_t           context;
        context_t          *parent_context;

diff --git a/parser.c b/parser.c
index f273459..1444687 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -1241,7 +1241,7 @@ static void parse_enum_entries(void)
 
                if(token.type == '=') {
                        next_token();
-                       entry->init.initializer = parse_initializer(type_int);
+                       entry->init.enum_value = parse_constant_expression();
                }
 
                record_declaration(entry);
@@ -2123,7 +2123,8 @@ static void parse_init_declarators(const declaration_specifiers_t *specifiers)
 
                declaration_t *declaration = record_declaration(ndeclaration);
 
-               type_t *type = declaration->type;
+               type_t *orig_type = declaration->type;
+               type_t *type      = skip_typeref(orig_type);
                if(type->type != TYPE_FUNCTION && declaration->is_inline) {
                        parser_print_warning_prefix_pos(declaration->source_position);
                        fprintf(stderr, "variable '%s' declared 'inline'\n",
@@ -2139,14 +2140,33 @@ static void parse_init_declarators(const declaration_specifiers_t *specifiers)
                                parser_error_multiple_definition(declaration, ndeclaration);
                        }
 
-                       ndeclaration->init.initializer
-                               = parse_initializer(declaration->type);
+                       initializer_t *initializer = parse_initializer(type);
+
+                       if(type->type == TYPE_ARRAY && initializer != NULL) {
+                               assert(initializer->type == INITIALIZER_LIST);
+
+                               initializer_list_t *list = (initializer_list_t*) initializer;
+                               array_type_t       *array_type = (array_type_t*) type;
+
+                               if(array_type->size == NULL) {
+                                       const_t *cnst = allocate_ast_zero(sizeof(cnst[0]));
+
+                                       cnst->expression.type     = EXPR_CONST;
+                                       cnst->expression.datatype = type_size_t;
+                                       cnst->v.int_value         = list->len;
+
+                                       array_type->size = (expression_t*) cnst;
+                               }
+                       }
+
+
+                       ndeclaration->init.initializer = initializer;
                } else if(token.type == '{') {
-                       if(declaration->type->type != TYPE_FUNCTION) {
+                       if(type->type != TYPE_FUNCTION) {
                                parser_print_error_prefix();
-                               fprintf(stderr, "Declarator ");
-                               print_type_ext(declaration->type, declaration->symbol, NULL);
-                               fprintf(stderr, " has a body but is not a function type.\n");
+                               fprintf(stderr, "declarator '");
+                               print_type_ext(orig_type, declaration->symbol, NULL);
+                               fprintf(stderr, "' has a body but is not a function type.\n");
                                eat_block();
                                continue;
                        }

diff --git a/type.c b/type.c
index 1276df2..78f691a 100644 (file)
--- a/type.c
+++ b/type.c
@@ -173,7 +173,7 @@ void print_enum_definition(const declaration_t *declaration)
                fprintf(out, "%s", entry->symbol->string);
                if(entry->init.initializer != NULL) {
                        fprintf(out, " = ");
-                       print_initializer(entry->init.initializer);
+                       print_expression(entry->init.enum_value);
                }
                fprintf(out, ",\n");
        }

diff --git a/write_fluffy.c b/write_fluffy.c
index 3e6ba08..4ad6fc0 100644 (file)
--- a/write_fluffy.c
+++ b/write_fluffy.c
@@ -234,15 +234,6 @@ static void write_expression(const expression_t *expression)
        }
 }
 
-static void write_initializer(const initializer_t *initializer)
-{
-       if(initializer->type != INITIALIZER_VALUE) {
-               panic("list initializers not supported yet");
-       }
-
-       //write_expression(initializer->v.value);
-}
-
 static void write_enum(const symbol_t *symbol, const enum_type_t *type)
 {
        fprintf(out, "enum %s:\n", symbol->string);
@@ -253,7 +244,7 @@ static void write_enum(const symbol_t *symbol, const enum_type_t *type)
                fprintf(out, "\t%s", entry->symbol->string);
                if(entry->init.initializer != NULL) {
                        fprintf(out, " <- ");
-                       write_initializer(entry->init.initializer);
+                       write_expression(entry->init.enum_value);
                }
                fputc('\n', out);
        }
@@ -350,6 +341,8 @@ void write_fluffy_decls(const translation_unit_t *unit)
        /* write global variables */
        declaration = unit->context.declarations;
        for( ; declaration != NULL; declaration = declaration->next) {
+               if(declaration->namespc != NAMESPACE_NORMAL)
+                       continue;
                if(declaration->storage_class == STORAGE_CLASS_TYPEDEF
                                || declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
                        continue;
@@ -364,6 +357,8 @@ void write_fluffy_decls(const translation_unit_t *unit)
        /* write functions */
        declaration = unit->context.declarations;
        for( ; declaration != NULL; declaration = declaration->next) {
+               if(declaration->namespc != NAMESPACE_NORMAL)
+                       continue;
                if(declaration->storage_class == STORAGE_CLASS_TYPEDEF
                                || declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
                        continue;