Merge EXPR_LITERAL_WIDE_CHARACTER into EXPR_LITERAL_CHARACTER.

diff --git a/ast.c b/ast.c
index 6ddf111..ac9ede0 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -107,7 +107,6 @@ static unsigned get_expression_precedence(expression_kind_t kind)
                [EXPR_LITERAL_INTEGER]            = PREC_PRIMARY,
                [EXPR_LITERAL_FLOATINGPOINT]      = PREC_PRIMARY,
                [EXPR_LITERAL_CHARACTER]          = PREC_PRIMARY,
-               [EXPR_LITERAL_WIDE_CHARACTER]     = PREC_PRIMARY,
                [EXPR_LITERAL_MS_NOOP]            = PREC_PRIMARY,
                [EXPR_STRING_LITERAL]             = PREC_PRIMARY,
                [EXPR_COMPOUND_LITERAL]           = PREC_UNARY,
@@ -232,17 +231,10 @@ static void print_quoted_string(const string_t *const string, char border)
        print_char(border);
 }
 
-static void print_char_literal(string_literal_expression_t const *const literal)
-{
-       if (literal->base.kind == EXPR_LITERAL_WIDE_CHARACTER)
-               print_char('L');
-       print_quoted_string(&literal->value, '\'');
-}
-
-static void print_string_literal(const string_literal_expression_t *literal)
+static void print_string_literal(string_literal_expression_t const *const literal, char const delimiter)
 {
        print_string(get_string_encoding_prefix(literal->encoding));
-       print_quoted_string(&literal->value, '"');
+       print_quoted_string(&literal->value, delimiter);
 }
 
 static void print_literal(const literal_expression_t *literal)
@@ -660,7 +652,6 @@ static bool needs_parentheses(expression_t const *const expr, unsigned const top
                case EXPR_FUNCNAME:
                case EXPR_LITERAL_CASES:
                case EXPR_LITERAL_CHARACTER:
-               case EXPR_LITERAL_WIDE_CHARACTER:
                case EXPR_REFERENCE:
                case EXPR_STRING_LITERAL:
                        /* Do not print () around subexpressions consisting of a single token. */
@@ -705,14 +696,13 @@ static void print_expression_prec(expression_t const *expr, unsigned const top_p
        case EXPR_FUNCNAME:                   print_funcname(                &expr->funcname);                 break;
        case EXPR_LABEL_ADDRESS:              print_label_address_expression(&expr->label_address);            break;
        case EXPR_LITERAL_CASES:              print_literal(                 &expr->literal);                  break;
-       case EXPR_LITERAL_CHARACTER:
-       case EXPR_LITERAL_WIDE_CHARACTER:     print_char_literal(            &expr->string_literal);           break;
+       case EXPR_LITERAL_CHARACTER:          print_string_literal(          &expr->string_literal, '\'');     break;
        case EXPR_OFFSETOF:                   print_offsetof_expression(     &expr->offsetofe);                break;
        case EXPR_REFERENCE:
        case EXPR_ENUM_CONSTANT:              print_reference_expression(    &expr->reference);                break;
        case EXPR_SELECT:                     print_select(                  &expr->select);                   break;
        case EXPR_STATEMENT:                  print_statement_expression(    &expr->statement);                break;
-       case EXPR_STRING_LITERAL:             print_string_literal(          &expr->string_literal);           break;
+       case EXPR_STRING_LITERAL:             print_string_literal(          &expr->string_literal, '"');      break;
        case EXPR_UNARY_CASES:                print_unary_expression(        &expr->unary);                    break;
        case EXPR_VA_ARG:                     print_va_arg(                  &expr->va_arge);                  break;
        case EXPR_VA_COPY:                    print_va_copy(                 &expr->va_copye);                 break;
@@ -1788,7 +1778,6 @@ expression_classification_t is_constant_expression(const expression_t *expressio
        switch (expression->kind) {
        case EXPR_LITERAL_CASES:
        case EXPR_LITERAL_CHARACTER:
-       case EXPR_LITERAL_WIDE_CHARACTER:
        case EXPR_CLASSIFY_TYPE:
        case EXPR_OFFSETOF:
        case EXPR_ALIGNOF:

diff --git a/ast2firm.c b/ast2firm.c
index f41a882..50096ad 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -1294,8 +1294,8 @@ static ir_node *char_literal_to_firm(string_literal_expression_t const *literal)
        size_t      size   = literal->value.size;
        ir_tarval  *tv;
 
-       switch (literal->base.kind) {
-       case EXPR_LITERAL_WIDE_CHARACTER: {
+       switch (literal->encoding) {
+       case STRING_ENCODING_WIDE: {
                utf32  v = read_utf8_char(&string);
                char   buf[128];
                size_t len = snprintf(buf, sizeof(buf), UTF32_PRINTF_FORMAT, v);
@@ -1304,7 +1304,7 @@ static ir_node *char_literal_to_firm(string_literal_expression_t const *literal)
                break;
        }
 
-       case EXPR_LITERAL_CHARACTER: {
+       case STRING_ENCODING_CHAR: {
                long long int v;
                bool char_is_signed
                        = get_atomic_type_flags(ATOMIC_TYPE_CHAR) & ATOMIC_TYPE_FLAG_SIGNED;
@@ -3348,8 +3348,7 @@ static ir_node *_expression_to_firm(expression_t const *const expr)
        case EXPR_FUNCNAME:                   return function_name_to_firm(           &expr->funcname);
        case EXPR_LABEL_ADDRESS:              return label_address_to_firm(           &expr->label_address);
        case EXPR_LITERAL_CASES:              return literal_to_firm(                 &expr->literal);
-       case EXPR_LITERAL_CHARACTER:
-       case EXPR_LITERAL_WIDE_CHARACTER:     return char_literal_to_firm(            &expr->string_literal);
+       case EXPR_LITERAL_CHARACTER:          return char_literal_to_firm(            &expr->string_literal);
        case EXPR_OFFSETOF:                   return offsetof_to_firm(                &expr->offsetofe);
        case EXPR_REFERENCE:                  return reference_expression_to_firm(    &expr->reference);
        case EXPR_ENUM_CONSTANT:              return enum_constant_to_firm(           &expr->reference);

diff --git a/ast_t.h b/ast_t.h
index 10ed251..d78f254 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -69,7 +69,6 @@ typedef enum expression_kind_t {
        EXPR_LITERAL_INTEGER,
        EXPR_LITERAL_FLOATINGPOINT,
        EXPR_LITERAL_CHARACTER,
-       EXPR_LITERAL_WIDE_CHARACTER,
        EXPR_LITERAL_MS_NOOP, /**< MS __noop extension */
        EXPR_STRING_LITERAL,
        EXPR_COMPOUND_LITERAL,

diff --git a/parser.c b/parser.c
index 5649114..9dadbf6 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -326,7 +326,6 @@ static size_t get_expression_struct_size(expression_kind_t kind)
                [EXPR_LITERAL_INTEGER]            = sizeof(literal_expression_t),
                [EXPR_LITERAL_FLOATINGPOINT]      = sizeof(literal_expression_t),
                [EXPR_LITERAL_CHARACTER]          = sizeof(string_literal_expression_t),
-               [EXPR_LITERAL_WIDE_CHARACTER]     = sizeof(string_literal_expression_t),
                [EXPR_STRING_LITERAL]             = sizeof(string_literal_expression_t),
                [EXPR_COMPOUND_LITERAL]           = sizeof(compound_literal_expression_t),
                [EXPR_CALL]                       = sizeof(call_expression_t),
@@ -1490,7 +1489,6 @@ unary:
 
                case EXPR_LITERAL_CASES:
                case EXPR_LITERAL_CHARACTER:
-               case EXPR_LITERAL_WIDE_CHARACTER:
                case EXPR_ERROR:
                case EXPR_STRING_LITERAL:
                case EXPR_COMPOUND_LITERAL: // TODO init?
@@ -4653,7 +4651,6 @@ static bool expression_returns(expression_t const *const expr)
                case EXPR_ENUM_CONSTANT:
                case EXPR_LITERAL_CASES:
                case EXPR_LITERAL_CHARACTER:
-               case EXPR_LITERAL_WIDE_CHARACTER:
                case EXPR_STRING_LITERAL:
                case EXPR_COMPOUND_LITERAL: // TODO descend into initialisers
                case EXPR_LABEL_ADDRESS:
@@ -5858,13 +5855,13 @@ static expression_t *parse_number_literal(void)
  */
 static expression_t *parse_character_constant(void)
 {
-       expression_t *literal;
-       switch (token.string.encoding) {
-       case STRING_ENCODING_CHAR: {
-               literal = allocate_expression_zero(EXPR_LITERAL_CHARACTER);
-               literal->base.type            = c_mode & _CXX ? type_char : type_int;
-               literal->string_literal.value = token.string.string;
+       expression_t *const literal = allocate_expression_zero(EXPR_LITERAL_CHARACTER);
+       literal->string_literal.encoding = token.string.encoding;
+       literal->string_literal.value    = token.string.string;
 
+       switch (token.string.encoding) {
+       case STRING_ENCODING_CHAR:
+               literal->base.type = c_mode & _CXX ? type_char : type_int;
                if (literal->string_literal.value.size > 1) {
                        if (!GNU_MODE && !(c_mode & _C99)) {
                                errorf(HERE, "more than 1 character in character constant");
@@ -5874,19 +5871,14 @@ static expression_t *parse_character_constant(void)
                        }
                }
                break;
-       }
-
-       case STRING_ENCODING_WIDE: {
-               literal = allocate_expression_zero(EXPR_LITERAL_WIDE_CHARACTER);
-               literal->base.type            = type_int;
-               literal->string_literal.value = token.string.string;
 
+       case STRING_ENCODING_WIDE:
+               literal->base.type = type_int;
                if (wstrlen(&literal->string_literal.value) > 1) {
                        warningf(WARN_MULTICHAR, HERE, "multi-character character constant");
                }
                break;
        }
-       }
 
        eat(T_CHARACTER_CONSTANT);
        return literal;
@@ -8309,7 +8301,6 @@ static bool expression_has_effect(const expression_t *const expr)
                case EXPR_LITERAL_MS_NOOP:            return true;
                case EXPR_LITERAL_BOOLEAN:
                case EXPR_LITERAL_CHARACTER:
-               case EXPR_LITERAL_WIDE_CHARACTER:
                case EXPR_LITERAL_INTEGER:
                case EXPR_LITERAL_FLOATINGPOINT:
                case EXPR_STRING_LITERAL:             return false;

diff --git a/walk.c b/walk.c
index 1e98f4d..bdbab01 100644 (file)
--- a/walk.c
+++ b/walk.c
@@ -178,7 +178,6 @@ static void walk_expression(expression_t *const expr,
 
        case EXPR_LITERAL_CASES:
        case EXPR_LITERAL_CHARACTER:
-       case EXPR_LITERAL_WIDE_CHARACTER:
        case EXPR_REFERENCE:
        case EXPR_ENUM_CONSTANT:
        case EXPR_STRING_LITERAL: