replaced the different initializer types by one union type saving a lot of casts

[r18528]

diff --git a/ast.c b/ast.c
index 463bf13..c26b8a9 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -513,20 +513,18 @@ static void print_storage_class(storage_class_t storage_class)
 void print_initializer(const initializer_t *initializer)
 {
        if(initializer->type == INITIALIZER_VALUE) {
-               initializer_value_t *value = (initializer_value_t*) initializer;
-               print_expression(value->value);
+               print_expression(initializer->v.value);
                return;
        }
 
        assert(initializer->type == INITIALIZER_LIST);
        fputs("{ ", out);
-       initializer_list_t *list = (initializer_list_t*) initializer;
 
-       for(size_t i = 0 ; i < list->len; ++i) {
+       for(size_t i = 0 ; i < initializer->v.list.len; ++i) {
                if(i > 0) {
                        fputs(", ", out);
                }
-               print_initializer(list->initializers[i]);
+               print_initializer(initializer->v.list.initializers[i]);
        }
        fputs("}", out);
 }

diff --git a/ast.h b/ast.h
index bc93e16..1b1f8d6 100644 (file)
--- a/ast.h
+++ b/ast.h
@@ -29,9 +29,6 @@ typedef struct builtin_symbol_expression_t  builtin_symbol_expression_t;
 typedef struct classify_type_expression_t   classify_type_expression_t;
 
 typedef struct initializer_t                initializer_t;
-typedef struct initializer_list_t           initializer_list_t;
-typedef struct initializer_value_t          initializer_value_t;
-typedef struct initializer_string_t         initializer_string_t;
 typedef struct declaration_t                declaration_t;
 
 typedef struct statement_t                  statement_t;

diff --git a/ast2firm.c b/ast2firm.c
index 11f3bd7..1e0f72b 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -2041,18 +2041,18 @@ static compound_graph_path *create_compound_path(ir_type *type,
        return path;
 }
 
-static void create_initializer_value(initializer_value_t *initializer,
+static void create_initializer_value(initializer_t *initializer,
                                      ir_entity *entity,
                                      compound_graph_path_entry_t *entry,
                                      int len)
 {
-       ir_node             *node = expression_to_firm(initializer->value);
+       ir_node             *node = expression_to_firm(initializer->v.value);
        ir_type             *type = get_entity_type(entity);
        compound_graph_path *path = create_compound_path(type, entry, len);
        add_compound_ent_value_w_path(entity, node, path);
 }
 
-static void create_initializer_compound(initializer_list_t *initializer,
+static void create_initializer_compound(initializer_t *initializer,
                                         compound_type_t *type,
                                         ir_entity *entity,
                                         compound_graph_path_entry_t *last_entry,
@@ -2074,20 +2074,19 @@ static void create_initializer_compound(initializer_list_t *initializer,
                if(compound_entry->namespc != NAMESPACE_NORMAL)
                        continue;
 
-               if(i >= initializer->len)
+               if(i >= initializer->v.list.len)
                        break;
 
                entry.v.entity = compound_entry->v.entity;
 
-               initializer_t *sub_initializer = initializer->initializers[i];
+               initializer_t *sub_initializer = initializer->v.list.initializers[i];
 
                assert(compound_entry != NULL);
                assert(compound_entry->declaration_type
                                == DECLARATION_TYPE_COMPOUND_MEMBER);
 
                if(sub_initializer->type == INITIALIZER_VALUE) {
-                       create_initializer_value((initializer_value_t*) sub_initializer,
-                                                entity, &entry, len);
+                       create_initializer_value(sub_initializer, entity, &entry, len);
                } else {
                        type_t *type = skip_typeref(compound_entry->type);
                        create_initializer_object(sub_initializer, type, entity, &entry,
@@ -2098,7 +2097,7 @@ static void create_initializer_compound(initializer_list_t *initializer,
        }
 }
 
-static void create_initializer_array(initializer_list_t *initializer,
+static void create_initializer_array(initializer_t *initializer,
                                      array_type_t *type, ir_entity *entity,
                                      compound_graph_path_entry_t *last_entry,
                                      int len)
@@ -2111,14 +2110,13 @@ static void create_initializer_array(initializer_list_t *initializer,
        entry.prev = last_entry;
        ++len;
 
-       for(size_t i = 0; i < initializer->len; ++i) {
+       for(size_t i = 0; i < initializer->v.list.len; ++i) {
                entry.v.array_index = i;
 
-               initializer_t *sub_initializer = initializer->initializers[i];
+               initializer_t *sub_initializer = initializer->v.list.initializers[i];
 
                if(sub_initializer->type == INITIALIZER_VALUE) {
-                       create_initializer_value((initializer_value_t*) sub_initializer,
-                                                entity, &entry, len);
+                       create_initializer_value(sub_initializer, entity, &entry, len);
                } else {
                        assert(sub_initializer->type == INITIALIZER_LIST);
                        create_initializer_object(sub_initializer, element_type, entity,
@@ -2127,7 +2125,7 @@ static void create_initializer_array(initializer_list_t *initializer,
        }
 }
 
-static void create_initializer_string(initializer_string_t *initializer,
+static void create_initializer_string(initializer_t *initializer,
                                       array_type_t *type, ir_entity *entity,
                                       compound_graph_path_entry_t *last_entry,
                                       int len)
@@ -2142,7 +2140,7 @@ static void create_initializer_string(initializer_string_t *initializer,
 
        ir_type    *irtype  = get_entity_type(entity);
        size_t      arr_len = get_array_type_size(type);
-       const char *p       = initializer->string;
+       const char *p       = initializer->v.string;
        size_t      i       = 0;
        for(i = 0; i < arr_len; ++i, ++p) {
                entry.v.array_index = i;
@@ -2163,21 +2161,18 @@ static void create_initializer_object(initializer_t *initializer, type_t *type,
                array_type_t *array_type = (array_type_t*) type;
 
                if(initializer->type == INITIALIZER_STRING) {
-                       initializer_string_t *string = (initializer_string_t*) initializer;
-                       create_initializer_string(string, array_type, entity, entry, len);
+                       create_initializer_string(initializer, array_type, entity, entry, len);
                } else {
                        assert(initializer->type == INITIALIZER_LIST);
-                       initializer_list_t *list = (initializer_list_t*) initializer;
-                       create_initializer_array(list, array_type, entity, entry, len);
+                       create_initializer_array(initializer, array_type, entity, entry, len);
                }
        } else {
                assert(initializer->type == INITIALIZER_LIST);
-               initializer_list_t *list = (initializer_list_t*) initializer;
 
                assert(type->type == TYPE_COMPOUND_STRUCT
                                || type->type == TYPE_COMPOUND_UNION);
                compound_type_t *compound_type = (compound_type_t*) type;
-               create_initializer_compound(list, compound_type, entity, entry, len);
+               create_initializer_compound(initializer, compound_type, entity, entry, len);
        }
 }
 
@@ -2193,10 +2188,8 @@ static void create_initializer_local_variable_entity(declaration_t *declaration)
 
        if(is_atomic_entity(entity)) {
                assert(initializer->type == INITIALIZER_VALUE);
-               initializer_value_t *initializer_value
-                       = (initializer_value_t*) initializer;
 
-               ir_node *value     = expression_to_firm(initializer_value->value);
+               ir_node *value     = expression_to_firm(initializer->v.value);
                ir_node *store     = new_d_Store(dbgi, memory, addr, value);
                ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M);
                set_store(store_mem);
@@ -2242,9 +2235,7 @@ static void create_initializer(declaration_t *declaration)
        }
 
        if(initializer->type == INITIALIZER_VALUE) {
-               initializer_value_t *initializer_value
-                       = (initializer_value_t*) initializer;
-               ir_node *value = expression_to_firm(initializer_value->value);
+               ir_node *value = expression_to_firm(initializer->v.value);
 
                if(declaration_type == DECLARATION_TYPE_LOCAL_VARIABLE) {
                        set_value(declaration->v.value_number, value);

diff --git a/ast_t.h b/ast_t.h
index e342788..75c0f03 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -222,22 +222,17 @@ typedef enum {
 
 struct initializer_t {
        initializer_type_t  type;
-};
-
-struct initializer_value_t {
-       initializer_t initializer;
-       expression_t *value;
-};
-
-struct initializer_list_t {
-       initializer_t  initializer;
-       size_t         len;
-       initializer_t *initializers[];
-};
-
-struct initializer_string_t {
-       initializer_t  initializer;
-       const char    *string;
+       union {
+               /* if type == INITIALIZER_VALUE */
+               expression_t *value;
+               /* if type == INITIALIZER_LIST */
+               struct {
+                       size_t         len;
+                       initializer_t *initializers[];
+               } list;
+               /* if type == INITIALIZER_STRING */
+               const char    *string;
+       } v;
 };
 
 struct declaration_t {

diff --git a/parser.c b/parser.c
index fa8ad94..0274220 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -437,8 +437,8 @@ static declaration_t *stack_push(stack_entry_t **stack_ptr,
                        print_type_quoted(previous_declaration->type);
                        fputc('\n', stderr);
                } else {
-                       const storage_class_t old_storage = previous_declaration->storage_class;
-                       const storage_class_t new_storage = declaration->storage_class;
+                       const storage_class_t old_storage = (storage_class_t)previous_declaration->storage_class;
+                       const storage_class_t new_storage = (storage_class_t)declaration->storage_class;
                        if (current_function == NULL) {
                                if (old_storage != STORAGE_CLASS_STATIC &&
                                    new_storage == STORAGE_CLASS_STATIC) {
@@ -841,8 +841,7 @@ static void parse_attributes(void)
                        next_token();
 
                        expect_void('(');
-                       int depth = 1;
-                       while(depth > 0) {
+                       for (int depth = 1; depth > 0;) {
                                switch(token.type) {
                                case T_EOF:
                                        parse_error("EOF while parsing attribute");
@@ -933,13 +932,13 @@ static initializer_t *initializer_from_string(array_type_t *type,
        /* TODO: check len vs. size of array type */
        (void) type;
 
-       initializer_string_t *initializer
+       initializer_t *initializer
                = allocate_ast_zero(sizeof(initializer[0]));
 
-       initializer->initializer.type = INITIALIZER_STRING;
-       initializer->string           = string;
+       initializer->type     = INITIALIZER_STRING;
+       initializer->v.string = string;
 
-       return (initializer_t*) initializer;
+       return initializer;
 }
 
 static initializer_t *initializer_from_expression(type_t *type,
@@ -970,11 +969,11 @@ static initializer_t *initializer_from_expression(type_t *type,
 
        semantic_assign(type, &expression, "initializer");
 
-       initializer_value_t *result = allocate_ast_zero(sizeof(result[0]));
-       result->initializer.type = INITIALIZER_VALUE;
-       result->value            = expression;
+       initializer_t *result = allocate_ast_zero(sizeof(result[0]));
+       result->type    = INITIALIZER_VALUE;
+       result->v.value = expression;
 
-       return (initializer_t*) result;
+       return result;
 }
 
 static initializer_t *parse_sub_initializer(type_t *type,
@@ -1025,15 +1024,15 @@ static initializer_t *parse_sub_initializer(type_t *type,
        /* TODO: ignore qualifiers, comparing pointers is probably
         * not correct */
        if(expression != NULL && expression_type == type) {
-               initializer_value_t *result = allocate_ast_zero(sizeof(result[0]));
-               result->initializer.type    = INITIALIZER_VALUE;
+               initializer_t *result = allocate_ast_zero(sizeof(result[0]));
+               result->type          = INITIALIZER_VALUE;
 
                if(type != NULL) {
                        semantic_assign(type, &expression, "initializer");
                }
-               result->value = expression;
+               result->v.value = expression;
 
-               return (initializer_t*) result;
+               return result;
        }
 
        bool read_paren = false;
@@ -1142,14 +1141,14 @@ static initializer_t *parse_sub_initializer(type_t *type,
        int    len        = ARR_LEN(elems);
        size_t elems_size = sizeof(initializer_t*) * len;
 
-       initializer_list_t *init = allocate_ast_zero(sizeof(init[0]) + elems_size);
+       initializer_t *init = allocate_ast_zero(sizeof(init[0]) + elems_size);
 
-       init->initializer.type = INITIALIZER_LIST;
-       init->len              = len;
-       memcpy(init->initializers, elems, elems_size);
+       init->type       = INITIALIZER_LIST;
+       init->v.list.len = len;
+       memcpy(init->v.list.initializers, elems, elems_size);
        DEL_ARR_F(elems);
 
-       result = (initializer_t*) init;
+       result = init;
 
        if(read_paren) {
                if(token.type == ',')
@@ -2221,14 +2220,10 @@ static void parse_init_declarators(const declaration_specifiers_t *specifiers)
                                        cnst->expression.datatype = type_size_t;
 
                                        if(initializer->type == INITIALIZER_LIST) {
-                                               initializer_list_t *list
-                                                       = (initializer_list_t*) initializer;
-                                               cnst->v.int_value = list->len;
+                                               cnst->v.int_value = initializer->v.list.len;
                                        } else {
                                                assert(initializer->type == INITIALIZER_STRING);
-                                               initializer_string_t *string
-                                                       = (initializer_string_t*) initializer;
-                                               cnst->v.int_value = strlen(string->string) + 1;
+                                               cnst->v.int_value = strlen(initializer->v.string) + 1;
                                        }
 
                                        array_type->size = (expression_t*) cnst;