From cc6b178146de60a12ea0bb8dc80fc3b457c35bc5 Mon Sep 17 00:00:00 2001 From: Michael Beck Date: Sun, 25 Nov 2007 18:32:08 +0000 Subject: [PATCH] replaced the different initializer types by one union type saving a lot of casts [r18528] --- ast.c | 8 +++----- ast.h | 3 --- ast2firm.c | 43 +++++++++++++++++-------------------------- ast_t.h | 27 +++++++++++---------------- parser.c | 49 ++++++++++++++++++++++--------------------------- 5 files changed, 53 insertions(+), 77 deletions(-) diff --git a/ast.c b/ast.c index 463bf13..c26b8a9 100644 --- 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 --- 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 --- 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 --- 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 --- 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; -- 2.20.1