Use initializer_value_t for INITIALIZER_STRING, too.

This way we do not lose the location information of the string.

diff --git a/ast.c b/ast.c
index fa20c3f..e3e4bea 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -1203,8 +1203,7 @@ void print_initializer(const initializer_t *initializer)
        }
 
        case INITIALIZER_STRING:
-               print_string(get_string_encoding_prefix(initializer->string.encoding));
-               print_quoted_string(&initializer->string.string, '"');
+               print_string_literal(get_init_string(initializer), '"');
                return;
 
        case INITIALIZER_DESIGNATOR:

diff --git a/ast.h b/ast.h
index 2898882..5603584 100644 (file)
--- a/ast.h
+++ b/ast.h
@@ -56,7 +56,6 @@ typedef union  expression_t                          expression_t;
 typedef struct initializer_base_t                    initializer_base_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 initializer_designator_t              initializer_designator_t;
 typedef union  initializer_t                         initializer_t;
 

diff --git a/ast2firm.c b/ast2firm.c
index 9b88760..05ed110 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -3851,18 +3851,19 @@ static ir_initializer_t *create_ir_initializer_list(
        return result;
 }
 
-static ir_initializer_t *create_ir_initializer_string(initializer_string_t const *const initializer, type_t *type)
+static ir_initializer_t *create_ir_initializer_string(initializer_t const *const init, type_t *type)
 {
        type = skip_typeref(type);
 
        assert(type->kind == TYPE_ARRAY);
        assert(type->array.size_constant);
-       size_t            const str_len = initializer->string.size;
+       string_literal_expression_t const *const str = get_init_string(init);
+       size_t            const str_len = str->value.size;
        size_t            const arr_len = type->array.size;
        ir_initializer_t *const irinit  = create_initializer_compound(arr_len);
        ir_mode          *const mode    = get_ir_mode_storage(type->array.element_type);
-       char const       *      p       = initializer->string.begin;
-       switch (initializer->encoding) {
+       char const       *      p       = str->value.begin;
+       switch (str->encoding) {
        case STRING_ENCODING_CHAR:
                for (size_t i = 0; i != arr_len; ++i) {
                        char              const c      = i < str_len ? *p++ : 0;
@@ -3890,7 +3891,7 @@ static ir_initializer_t *create_ir_initializer(
 {
        switch(initializer->kind) {
                case INITIALIZER_STRING:
-                       return create_ir_initializer_string(&initializer->string, type);
+                       return create_ir_initializer_string(initializer, type);
 
                case INITIALIZER_LIST:
                        return create_ir_initializer_list(&initializer->list, type);

diff --git a/ast_t.h b/ast_t.h
index 9fa8dfa..6f68d8f 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -442,12 +442,6 @@ struct initializer_list_t {
        initializer_t      *initializers[];
 };
 
-struct initializer_string_t {
-       initializer_base_t base;
-       string_encoding_t  encoding;
-       string_t           string;
-};
-
 struct initializer_designator_t {
        initializer_base_t  base;
        designator_t       *designator;
@@ -458,10 +452,16 @@ union initializer_t {
        initializer_base_t        base;
        initializer_value_t       value;
        initializer_list_t        list;
-       initializer_string_t      string;
        initializer_designator_t  designator;
 };
 
+static inline string_literal_expression_t const *get_init_string(initializer_t const *const init)
+{
+       assert(init->kind == INITIALIZER_STRING);
+       assert(init->value.value->kind == EXPR_STRING_LITERAL);
+       return &init->value.value->string_literal;
+}
+
 /**
  * The statement kinds.
  */

diff --git a/parser.c b/parser.c
index abd38c9..3fb68d8 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -427,7 +427,7 @@ static size_t get_initializer_size(initializer_kind_t kind)
 {
        static const size_t sizes[] = {
                [INITIALIZER_VALUE]       = sizeof(initializer_value_t),
-               [INITIALIZER_STRING]      = sizeof(initializer_string_t),
+               [INITIALIZER_STRING]      = sizeof(initializer_value_t),
                [INITIALIZER_LIST]        = sizeof(initializer_list_t),
                [INITIALIZER_DESIGNATOR]  = sizeof(initializer_designator_t)
        };
@@ -1543,18 +1543,6 @@ static designator_t *parse_designation(void)
        }
 }
 
-static initializer_t *initializer_from_string(array_type_t *const type, string_encoding_t const enc, string_t const *const string)
-{
-       /* TODO: check len vs. size of array type */
-       (void) type;
-
-       initializer_t *initializer = allocate_initializer_zero(INITIALIZER_STRING);
-       initializer->string.encoding = enc;
-       initializer->string.string   = *string;
-
-       return initializer;
-}
-
 /**
  * Build an initializer from a given expression.
  */
@@ -1582,8 +1570,10 @@ static initializer_t *initializer_from_expression(type_t *orig_type,
                case STRING_ENCODING_WIDE: {
                        type_t *bare_wchar_type = skip_typeref(type_wchar_t);
                        if (get_unqualified_type(element_type) == bare_wchar_type) {
-make_string_init:
-                               return initializer_from_string(array_type, expression->string_literal.encoding, &expression->string_literal.value);
+make_string_init:;
+                               initializer_t *const init = allocate_initializer_zero(INITIALIZER_STRING);
+                               init->value.value = expression;
+                               return init;
                        }
                        break;
                }
@@ -2215,9 +2205,11 @@ static initializer_t *parse_initializer(parse_initializer_env_t *env)
                        size = max_index + 1;
                        break;
 
-               case INITIALIZER_STRING:
-                       size = get_string_len(result->string.encoding, &result->string.string) + 1;
+               case INITIALIZER_STRING: {
+                       string_literal_expression_t const *const str = get_init_string(result);
+                       size = get_string_len(str->encoding, &str->value) + 1;
                        break;
+               }
 
                case INITIALIZER_DESIGNATOR:
                case INITIALIZER_VALUE: