Merge INITIALIZER_WIDE_STRING into INITIALIZER_STRING.

diff --git a/ast.c b/ast.c
index a3f4be9..fa20c3f 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -1201,12 +1201,12 @@ void print_initializer(const initializer_t *initializer)
                print_string(" }");
                return;
        }
+
        case INITIALIZER_STRING:
+               print_string(get_string_encoding_prefix(initializer->string.encoding));
                print_quoted_string(&initializer->string.string, '"');
                return;
-       case INITIALIZER_WIDE_STRING:
-               print_quoted_string(&initializer->string.string, '"');
-               return;
+
        case INITIALIZER_DESIGNATOR:
                print_designator(initializer->designator.designator);
                print_string(" = ");
@@ -1495,7 +1495,6 @@ expression_classification_t is_constant_initializer(const initializer_t *initial
 {
        switch (initializer->kind) {
        case INITIALIZER_STRING:
-       case INITIALIZER_WIDE_STRING:
        case INITIALIZER_DESIGNATOR:
                return EXPR_CLASS_CONSTANT;
 

diff --git a/ast.h b/ast.h
index 2d361fd..2898882 100644 (file)
--- a/ast.h
+++ b/ast.h
@@ -57,7 +57,6 @@ 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_wide_string_t             initializer_wide_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 b425c62..9c150b9 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -3827,8 +3827,7 @@ static ir_initializer_t *create_ir_initializer_list(
                                        break;
                                descend_into_subtype(&path);
                        }
-               } else if (sub_initializer->kind == INITIALIZER_STRING
-                               || sub_initializer->kind == INITIALIZER_WIDE_STRING) {
+               } else if (sub_initializer->kind == INITIALIZER_STRING) {
                        /* we might have to descend into types until we're at a scalar
                         * type */
                        while (true) {
@@ -3861,58 +3860,38 @@ static ir_initializer_t *create_ir_initializer_list(
        return result;
 }
 
-static ir_initializer_t *create_ir_initializer_string(
-               const initializer_string_t *initializer, type_t *type)
+static ir_initializer_t *create_ir_initializer_string(initializer_string_t const *const initializer, type_t *type)
 {
        type = skip_typeref(type);
 
-       size_t            string_len    = initializer->string.size;
        assert(type->kind == TYPE_ARRAY);
        assert(type->array.size_constant);
-       size_t            len           = type->array.size;
-       ir_initializer_t *irinitializer = create_initializer_compound(len);
-
-       const char *string = initializer->string.begin;
-       ir_mode    *mode   = get_ir_mode_storage(type->array.element_type);
-
-       for (size_t i = 0; i < len; ++i) {
-               char c = 0;
-               if (i < string_len)
-                       c = string[i];
-
-               ir_tarval        *tv = new_tarval_from_long(c, mode);
-               ir_initializer_t *char_initializer = create_initializer_tarval(tv);
-
-               set_initializer_compound_value(irinitializer, i, char_initializer);
-       }
-
-       return irinitializer;
-}
-
-static ir_initializer_t *create_ir_initializer_wide_string(
-               const initializer_wide_string_t *initializer, type_t *type)
-{
-       assert(type->kind == TYPE_ARRAY);
-       assert(type->array.size_constant);
-       size_t            len           = type->array.size;
-       size_t            string_len    = wstrlen(&initializer->string);
-       ir_initializer_t *irinitializer = create_initializer_compound(len);
-
-       const char *p    = initializer->string.begin;
-       ir_mode    *mode = get_type_mode(ir_type_wchar_t);
-
-       for (size_t i = 0; i < len; ++i) {
-               utf32 c = 0;
-               if (i < string_len) {
-                       c = read_utf8_char(&p);
+       size_t            const str_len = initializer->string.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) {
+       case STRING_ENCODING_CHAR:
+               for (size_t i = 0; i != arr_len; ++i) {
+                       char              const c      = i < str_len ? *p++ : 0;
+                       ir_tarval        *const tv     = new_tarval_from_long(c, mode);
+                       ir_initializer_t *const tvinit = create_initializer_tarval(tv);
+                       set_initializer_compound_value(irinit, i, tvinit);
                }
-               ir_tarval *tv = new_tarval_from_long(c, mode);
-               ir_initializer_t *char_initializer = create_initializer_tarval(tv);
+               break;
 
-               set_initializer_compound_value(irinitializer, i, char_initializer);
+       case STRING_ENCODING_WIDE:
+               for (size_t i = 0; i != arr_len; ++i) {
+                       utf32             const c      = i < str_len ? read_utf8_char(&p) : 0;
+                       ir_tarval        *const tv     = new_tarval_from_long(c, mode);
+                       ir_initializer_t *const tvinit = create_initializer_tarval(tv);
+                       set_initializer_compound_value(irinit, i, tvinit);
+               }
+               break;
        }
 
-       return irinitializer;
+       return irinit;
 }
 
 static ir_initializer_t *create_ir_initializer(
@@ -3922,10 +3901,6 @@ static ir_initializer_t *create_ir_initializer(
                case INITIALIZER_STRING:
                        return create_ir_initializer_string(&initializer->string, type);
 
-               case INITIALIZER_WIDE_STRING:
-                       return create_ir_initializer_wide_string(&initializer->wide_string,
-                                                                type);
-
                case INITIALIZER_LIST:
                        return create_ir_initializer_list(&initializer->list, type);
 

diff --git a/ast_t.h b/ast_t.h
index a23e03a..9fa8dfa 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -424,7 +424,6 @@ typedef enum initializer_kind_t {
        INITIALIZER_VALUE,
        INITIALIZER_LIST,
        INITIALIZER_STRING,
-       INITIALIZER_WIDE_STRING,
        INITIALIZER_DESIGNATOR
 } initializer_kind_t;
 
@@ -445,14 +444,10 @@ struct initializer_list_t {
 
 struct initializer_string_t {
        initializer_base_t base;
+       string_encoding_t  encoding;
        string_t           string;
 };
 
-struct initializer_wide_string_t {
-       initializer_base_t  base;
-       string_t            string;
-};
-
 struct initializer_designator_t {
        initializer_base_t  base;
        designator_t       *designator;
@@ -464,7 +459,6 @@ union initializer_t {
        initializer_value_t       value;
        initializer_list_t        list;
        initializer_string_t      string;
-       initializer_wide_string_t wide_string;
        initializer_designator_t  designator;
 };
 

diff --git a/parser.c b/parser.c
index 2671b10..1dc9abb 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -428,7 +428,6 @@ 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_WIDE_STRING] = sizeof(initializer_wide_string_t),
                [INITIALIZER_LIST]        = sizeof(initializer_list_t),
                [INITIALIZER_DESIGNATOR]  = sizeof(initializer_designator_t)
        };
@@ -1544,27 +1543,14 @@ static designator_t *parse_designation(void)
        }
 }
 
-static initializer_t *initializer_from_string(array_type_t *const type,
-                                              const string_t *const string)
+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.string = *string;
-
-       return initializer;
-}
-
-static initializer_t *initializer_from_wide_string(array_type_t *const type,
-                                                   const string_t *const string)
-{
-       /* TODO: check len vs. size of array type */
-       (void) type;
-
-       initializer_t *const initializer =
-               allocate_initializer_zero(INITIALIZER_WIDE_STRING);
-       initializer->wide_string.string = *string;
+       initializer->string.encoding = enc;
+       initializer->string.string   = *string;
 
        return initializer;
 }
@@ -1593,8 +1579,7 @@ static initializer_t *initializer_from_expression(type_t *orig_type,
                                if (akind == ATOMIC_TYPE_CHAR
                                                || akind == ATOMIC_TYPE_SCHAR
                                                || akind == ATOMIC_TYPE_UCHAR) {
-                                       return initializer_from_string(array_type,
-                                                       &expression->string_literal.value);
+                                       goto make_string_init;
                                }
                                break;
                        }
@@ -1602,8 +1587,8 @@ 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) {
-                                       return initializer_from_wide_string(array_type,
-                                                       &expression->string_literal.value);
+make_string_init:
+                                       return initializer_from_string(array_type, expression->string_literal.encoding, &expression->string_literal.value);
                                }
                                break;
                        }
@@ -2240,10 +2225,6 @@ static initializer_t *parse_initializer(parse_initializer_env_t *env)
                        size = result->string.string.size + 1;
                        break;
 
-               case INITIALIZER_WIDE_STRING:
-                       size = result->wide_string.string.size;
-                       break;
-
                case INITIALIZER_DESIGNATOR:
                case INITIALIZER_VALUE:
                        /* can happen for parse errors */
@@ -4736,7 +4717,6 @@ static bool initializer_returns(initializer_t const *const init)
                }
 
                case INITIALIZER_STRING:
-               case INITIALIZER_WIDE_STRING:
                case INITIALIZER_DESIGNATOR: // designators have no payload
                        return true;
        }

diff --git a/walk.c b/walk.c
index bdbab01..46ff307 100644 (file)
--- a/walk.c
+++ b/walk.c
@@ -214,8 +214,8 @@ static void walk_initializer(const initializer_t  *initializer,
        case INITIALIZER_DESIGNATOR:
                walk_designator(initializer->designator.designator, env);
                return;
+
        case INITIALIZER_STRING:
-       case INITIALIZER_WIDE_STRING:
                return;
        }
 }