main: rework preprocessor invocation
[cparser] / parser.c
index 0a0cdf6..76343b5 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -20,6 +20,7 @@
 #include <config.h>
 
 #include <assert.h>
+#include <ctype.h>
 #include <stdarg.h>
 #include <stdbool.h>
 
@@ -27,7 +28,7 @@
 #include "parser.h"
 #include "diagnostic.h"
 #include "format_check.h"
-#include "lexer.h"
+#include "preprocessor.h"
 #include "symbol_t.h"
 #include "token_t.h"
 #include "types.h"
@@ -40,6 +41,7 @@
 #include "walk.h"
 #include "warning.h"
 #include "printer.h"
+#include "ast2firm.h"
 #include "adt/bitfiddle.h"
 #include "adt/error.h"
 #include "adt/array.h"
@@ -59,7 +61,7 @@ struct declaration_specifiers_t {
        storage_class_t    storage_class;
        unsigned char      alignment;         /**< Alignment, 0 if not set. */
        bool               is_inline    : 1;
-       bool               thread_local : 1;  /**< GCC __thread */
+       bool               thread_local : 1;
        attribute_t       *attributes;        /**< list of attributes */
        type_t            *type;
 };
@@ -131,16 +133,13 @@ static elf_visibility_tag_t default_visibility = ELF_VISIBILITY_DEFAULT;
 #define PUSH_EXTENSION() \
        (void)0; \
        bool const old_gcc_extension = in_gcc_extension; \
-       while (next_if(T___extension__)) { \
+       while (accept(T___extension__)) { \
                in_gcc_extension = true; \
        } \
        do {} while (0)
 #define POP_EXTENSION() \
        ((void)(in_gcc_extension = old_gcc_extension))
 
-/** special symbol used for anonymous entities. */
-static symbol_t *sym_anonymous = NULL;
-
 /** The token anchor set */
 static unsigned short token_anchor_set[T_LAST_TOKEN];
 
@@ -185,7 +184,7 @@ static void semantic_comparison(binary_expression_t *expression);
        case T_static:          \
        case T_auto:            \
        case T_register:        \
-       case T___thread:
+       case T__Thread_local:
 
 #define TYPE_QUALIFIERS     \
        case T_const:           \
@@ -247,18 +246,14 @@ static void semantic_comparison(binary_expression_t *expression);
        case '~':                         \
        case T_ANDAND:                    \
        case T_CHARACTER_CONSTANT:        \
-       case T_FLOATINGPOINT:             \
-       case T_INTEGER:                   \
+       case T_NUMBER:                    \
        case T_MINUSMINUS:                \
        case T_PLUSPLUS:                  \
        case T_STRING_LITERAL:            \
-       case T_WIDE_CHARACTER_CONSTANT:   \
-       case T_WIDE_STRING_LITERAL:       \
+       case T__Alignof:                  \
        case T___FUNCDNAME__:             \
        case T___FUNCSIG__:               \
-       case T___FUNCTION__:              \
        case T___PRETTY_FUNCTION__:       \
-       case T___alignof__:               \
        case T___builtin_classify_type:   \
        case T___builtin_constant_p:      \
        case T___builtin_isgreater:       \
@@ -302,7 +297,6 @@ static size_t get_statement_struct_size(statement_kind_t kind)
                [STATEMENT_GOTO]          = sizeof(goto_statement_t),
                [STATEMENT_LABEL]         = sizeof(label_statement_t),
                [STATEMENT_CASE_LABEL]    = sizeof(case_label_statement_t),
-               [STATEMENT_WHILE]         = sizeof(while_statement_t),
                [STATEMENT_DO_WHILE]      = sizeof(do_while_statement_t),
                [STATEMENT_FOR]           = sizeof(for_statement_t),
                [STATEMENT_ASM]           = sizeof(asm_statement_t),
@@ -328,10 +322,9 @@ static size_t get_expression_struct_size(expression_kind_t kind)
                [EXPR_LITERAL_BOOLEAN]            = sizeof(literal_expression_t),
                [EXPR_LITERAL_INTEGER]            = sizeof(literal_expression_t),
                [EXPR_LITERAL_FLOATINGPOINT]      = sizeof(literal_expression_t),
-               [EXPR_LITERAL_CHARACTER]          = sizeof(literal_expression_t),
-               [EXPR_LITERAL_WIDE_CHARACTER]     = sizeof(literal_expression_t),
+               [EXPR_LITERAL_CHARACTER]          = sizeof(string_literal_expression_t),
+               [EXPR_LITERAL_MS_NOOP]            = sizeof(literal_expression_t),
                [EXPR_STRING_LITERAL]             = sizeof(string_literal_expression_t),
-               [EXPR_WIDE_STRING_LITERAL]        = sizeof(string_literal_expression_t),
                [EXPR_COMPOUND_LITERAL]           = sizeof(compound_literal_expression_t),
                [EXPR_CALL]                       = sizeof(call_expression_t),
                [EXPR_UNARY_FIRST]                = sizeof(unary_expression_t),
@@ -432,8 +425,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_WIDE_STRING] = sizeof(initializer_wide_string_t),
+               [INITIALIZER_STRING]      = sizeof(initializer_value_t),
                [INITIALIZER_LIST]        = sizeof(initializer_list_t),
                [INITIALIZER_DESIGNATOR]  = sizeof(initializer_designator_t)
        };
@@ -476,8 +468,8 @@ static size_t label_top(void)
 static inline void next_token(void)
 {
        token                              = lookahead_buffer[lookahead_bufpos];
-       lookahead_buffer[lookahead_bufpos] = lexer_token;
-       lexer_next_token();
+       lookahead_buffer[lookahead_bufpos] = pp_token;
+       next_preprocessing_token();
 
        lookahead_bufpos = (lookahead_bufpos + 1) % MAX_LOOKAHEAD;
 
@@ -487,12 +479,23 @@ static inline void next_token(void)
 #endif
 }
 
-#define eat(token_kind) (assert(token.kind == (token_kind)), next_token())
+static inline void eat(token_kind_t const kind)
+{
+       assert(token.kind == kind);
+       (void)kind;
+       next_token();
+}
 
-static inline bool next_if(token_kind_t const type)
+/**
+ * Consume the current token, if it is of the expected kind.
+ *
+ * @param  kind  The kind of token to consume.
+ * @return Whether the token was consumed.
+ */
+static inline bool accept(token_kind_t const kind)
 {
-       if (token.kind == type) {
-               eat(type);
+       if (token.kind == kind) {
+               eat(kind);
                return true;
        } else {
                return false;
@@ -600,7 +603,7 @@ static void eat_until_anchor(void)
 static void eat_block(void)
 {
        eat_until_matching_token('{');
-       next_if('}');
+       accept('}');
 }
 
 /**
@@ -631,33 +634,33 @@ static void type_error_incompatible(const char *msg,
               msg, type1, type2);
 }
 
-/**
- * Expect the current token is the expected token.
- * If not, generate an error and skip until the next anchor.
- */
-static void expect(token_kind_t const expected)
+static bool skip_till(token_kind_t const expected, char const *const context)
 {
        if (UNLIKELY(token.kind != expected)) {
-               parse_error_expected(NULL, expected, NULL);
+               parse_error_expected(context, expected, NULL);
                add_anchor_token(expected);
                eat_until_anchor();
                rem_anchor_token(expected);
                if (token.kind != expected)
-                       return;
+                       return false;
        }
-       eat(expected);
+       return true;
+}
+
+/**
+ * Expect the current token is the expected token.
+ * If not, generate an error and skip until the next anchor.
+ */
+static void expect(token_kind_t const expected)
+{
+       if (skip_till(expected, NULL))
+               eat(expected);
 }
 
 static symbol_t *expect_identifier(char const *const context, source_position_t *const pos)
 {
-       if (token.kind != T_IDENTIFIER) {
-               parse_error_expected(context, T_IDENTIFIER, NULL);
-               add_anchor_token(T_IDENTIFIER);
-               eat_until_anchor();
-               rem_anchor_token(T_IDENTIFIER);
-               if (token.kind != T_IDENTIFIER)
-                       return NULL;
-       }
+       if (!skip_till(T_IDENTIFIER, context))
+               return NULL;
        symbol_t *const sym = token.base.symbol;
        if (pos)
                *pos = *HERE;
@@ -1037,27 +1040,67 @@ static expression_t *parse_assignment_expression(void)
        return parse_subexpression(PREC_ASSIGNMENT);
 }
 
-static void warn_string_concat(const source_position_t *pos)
+static void append_string(string_t const *const s)
 {
-       warningf(WARN_TRADITIONAL, pos, "traditional C rejects string constant concatenation");
+       /* FIXME Using the ast_obstack is a hack.  Using the symbol_obstack is not
+        * possible, because other tokens are grown there alongside. */
+       obstack_grow(&ast_obstack, s->begin, s->size);
 }
 
-static string_t parse_string_literals(void)
+static string_t finish_string(string_encoding_t const enc)
 {
-       assert(token.kind == T_STRING_LITERAL);
-       string_t result = token.string.string;
+       obstack_1grow(&ast_obstack, '\0');
+       size_t      const size   = obstack_object_size(&ast_obstack) - 1;
+       char const *const string = obstack_finish(&ast_obstack);
+       return (string_t){ string, size, enc };
+}
 
-       eat(T_STRING_LITERAL);
+static string_t concat_string_literals(void)
+{
+       assert(token.kind == T_STRING_LITERAL);
 
-       while (token.kind == T_STRING_LITERAL) {
-               warn_string_concat(HERE);
-               result = concat_strings(&result, &token.string.string);
+       string_t result;
+       if (look_ahead(1)->kind == T_STRING_LITERAL) {
+               append_string(&token.literal.string);
+               eat(T_STRING_LITERAL);
+               warningf(WARN_TRADITIONAL, HERE, "traditional C rejects string constant concatenation");
+               string_encoding_t enc = token.literal.string.encoding;
+               do {
+                       string_encoding_t const new_enc = token.literal.string.encoding;
+                       if (new_enc != enc && new_enc != STRING_ENCODING_CHAR) {
+                               if (enc == STRING_ENCODING_CHAR) {
+                                       enc = new_enc;
+                               } else {
+                                       errorf(HERE, "concatenating string literals with encodings %s and %s", get_string_encoding_prefix(enc), get_string_encoding_prefix(new_enc));
+                               }
+                       }
+                       append_string(&token.literal.string);
+                       eat(T_STRING_LITERAL);
+               } while (token.kind == T_STRING_LITERAL);
+               result = finish_string(enc);
+       } else {
+               result = token.literal.string;
                eat(T_STRING_LITERAL);
        }
 
        return result;
 }
 
+static string_t parse_string_literals(char const *const context)
+{
+       if (!skip_till(T_STRING_LITERAL, context))
+               return (string_t){ "", 0, STRING_ENCODING_CHAR };
+
+       source_position_t const pos = *HERE;
+       string_t          const res = concat_string_literals();
+
+       if (res.encoding != STRING_ENCODING_CHAR) {
+               errorf(&pos, "expected plain string literal, got %s string literal", get_string_encoding_prefix(res.encoding));
+       }
+
+       return res;
+}
+
 static attribute_t *allocate_attribute_zero(attribute_kind_t kind)
 {
        attribute_t *attribute = allocate_ast_zero(sizeof(*attribute));
@@ -1118,7 +1161,7 @@ static attribute_argument_t *parse_attribute_arguments(void)
                /* append argument */
                *anchor = argument;
                anchor  = &argument->next;
-       } while (next_if(','));
+       } while (accept(','));
        expect(')');
        return first;
 }
@@ -1145,6 +1188,12 @@ static attribute_t *parse_attribute_gnu_single(void)
        char const *const name = symbol->string;
        for (kind = ATTRIBUTE_GNU_FIRST;; ++kind) {
                if (kind > ATTRIBUTE_GNU_LAST) {
+                       /* special case for "__const" */
+                       if (token.kind == T_const) {
+                               kind = ATTRIBUTE_GNU_CONST;
+                               break;
+                       }
+
                        warningf(WARN_ATTRIBUTE, HERE, "unknown attribute '%s' ignored", name);
                        /* TODO: we should still save the attribute in the list... */
                        kind = ATTRIBUTE_UNKNOWN;
@@ -1160,7 +1209,7 @@ static attribute_t *parse_attribute_gnu_single(void)
        next_token();
 
        /* parse arguments */
-       if (next_if('('))
+       if (accept('('))
                attribute->a.arguments = parse_attribute_arguments();
 
        return attribute;
@@ -1183,7 +1232,7 @@ static attribute_t *parse_attribute_gnu(void)
                        *anchor = attribute;
                        anchor  = &attribute->next;
                }
-       } while (next_if(','));
+       } while (accept(','));
        rem_anchor_token(',');
        rem_anchor_token(')');
 
@@ -1456,9 +1505,9 @@ unary:
                        return;
 
                case EXPR_LITERAL_CASES:
+               case EXPR_LITERAL_CHARACTER:
                case EXPR_ERROR:
                case EXPR_STRING_LITERAL:
-               case EXPR_WIDE_STRING_LITERAL:
                case EXPR_COMPOUND_LITERAL: // TODO init?
                case EXPR_SIZEOF:
                case EXPR_CLASSIFY_TYPE:
@@ -1512,31 +1561,6 @@ static designator_t *parse_designation(void)
        }
 }
 
-static initializer_t *initializer_from_string(array_type_t *const type,
-                                              const string_t *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;
-
-       return initializer;
-}
-
 /**
  * Build an initializer from a given expression.
  */
@@ -1545,39 +1569,36 @@ static initializer_t *initializer_from_expression(type_t *orig_type,
 {
        /* TODO check that expression is a constant expression */
 
-       /* §6.7.8.14/15 char array may be initialized by string literals */
-       type_t *type           = skip_typeref(orig_type);
-       type_t *expr_type_orig = expression->base.type;
-       type_t *expr_type      = skip_typeref(expr_type_orig);
+       type_t *const type = skip_typeref(orig_type);
 
-       if (is_type_array(type) && expr_type->kind == TYPE_POINTER) {
+       /* §6.7.8.14/15 char array may be initialized by string literals */
+       if (expression->kind == EXPR_STRING_LITERAL && is_type_array(type)) {
                array_type_t *const array_type   = &type->array;
                type_t       *const element_type = skip_typeref(array_type->element_type);
-
-               if (element_type->kind == TYPE_ATOMIC) {
-                       atomic_type_kind_t akind = element_type->atomic.akind;
-                       switch (expression->kind) {
-                       case EXPR_STRING_LITERAL:
-                               if (akind == ATOMIC_TYPE_CHAR
-                                               || akind == ATOMIC_TYPE_SCHAR
-                                               || akind == ATOMIC_TYPE_UCHAR) {
-                                       return initializer_from_string(array_type,
-                                                       &expression->string_literal.value);
-                               }
-                               break;
-
-                       case EXPR_WIDE_STRING_LITERAL: {
-                               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);
-                               }
-                               break;
+               switch (expression->string_literal.value.encoding) {
+               case STRING_ENCODING_CHAR:
+               case STRING_ENCODING_UTF8: {
+                       if (is_type_atomic(element_type, ATOMIC_TYPE_CHAR)  ||
+                           is_type_atomic(element_type, ATOMIC_TYPE_SCHAR) ||
+                           is_type_atomic(element_type, ATOMIC_TYPE_UCHAR)) {
+                               goto make_string_init;
                        }
+                       break;
+               }
 
-                       default:
-                               break;
+               case STRING_ENCODING_CHAR16:
+               case STRING_ENCODING_CHAR32:
+               case STRING_ENCODING_WIDE: {
+                       assert(is_type_pointer(expression->base.type));
+                       type_t *const init_type = get_unqualified_type(expression->base.type->pointer.points_to);
+                       if (types_compatible(get_unqualified_type(element_type), init_type)) {
+make_string_init:;
+                               initializer_t *const init = allocate_initializer_zero(INITIALIZER_STRING);
+                               init->value.value = expression;
+                               return init;
                        }
+                       break;
+               }
                }
        }
 
@@ -1631,7 +1652,7 @@ static initializer_t *parse_scalar_initializer(type_t *type,
 
        bool additional_warning_displayed = false;
        while (braces > 0) {
-               next_if(',');
+               accept(',');
                if (token.kind != '}') {
                        if (!additional_warning_displayed) {
                                warningf(WARN_OTHER, HERE, "additional elements in scalar initializer");
@@ -1829,7 +1850,8 @@ static bool walk_designator(type_path_t *path, const designator_t *designator,
                        }
                } else {
                        expression_t *array_index = designator->array_index;
-                       assert(designator->array_index != NULL);
+                       if (is_constant_expression(array_index) != EXPR_CLASS_CONSTANT)
+                               return true;
 
                        if (!is_type_array(type)) {
                                if (is_type_valid(type)) {
@@ -1922,7 +1944,7 @@ static void advance_current_object(type_path_t *path, size_t top_path_level)
  */
 static void skip_initializers(void)
 {
-       next_if('{');
+       accept('{');
 
        while (token.kind != '}') {
                if (token.kind == T_EOF)
@@ -1954,6 +1976,8 @@ static initializer_t *parse_sub_initializer(type_path_t *path,
                return create_empty_initializer();
        }
 
+       initializer_t *result = NULL;
+
        type_t *orig_type = path->top_type;
        type_t *type      = NULL;
 
@@ -2056,17 +2080,15 @@ finish_designator:
                        }
 
                        /* handle { "string" } special case */
-                       if ((expression->kind == EXPR_STRING_LITERAL
-                                       || expression->kind == EXPR_WIDE_STRING_LITERAL)
-                                       && outer_type != NULL) {
-                               sub = initializer_from_expression(outer_type, expression);
-                               if (sub != NULL) {
-                                       next_if(',');
+                       if (expression->kind == EXPR_STRING_LITERAL && outer_type != NULL) {
+                               result = initializer_from_expression(outer_type, expression);
+                               if (result != NULL) {
+                                       accept(',');
                                        if (token.kind != '}') {
-                                               warningf(WARN_OTHER, HERE, "excessive elements in initializer for type '%T'", orig_type);
+                                               warningf(WARN_OTHER, HERE, "excessive elements in initializer for type '%T'", outer_type);
                                        }
                                        /* TODO: eat , ... */
-                                       return sub;
+                                       goto out;
                                }
                        }
 
@@ -2107,12 +2129,8 @@ finish_designator:
                ARR_APP1(initializer_t*, initializers, sub);
 
 error_parse_next:
-               if (token.kind == '}') {
+               if (!accept(','))
                        break;
-               }
-               add_anchor_token('}');
-               expect(',');
-               rem_anchor_token('}');
                if (token.kind == '}') {
                        break;
                }
@@ -2130,22 +2148,19 @@ error_parse_next:
 
        size_t len  = ARR_LEN(initializers);
        size_t size = sizeof(initializer_list_t) + len * sizeof(initializers[0]);
-       initializer_t *result = allocate_ast_zero(size);
-       result->kind          = INITIALIZER_LIST;
-       result->list.len      = len;
+       result = allocate_ast_zero(size);
+       result->kind     = INITIALIZER_LIST;
+       result->list.len = len;
        memcpy(&result->list.initializers, initializers,
               len * sizeof(initializers[0]));
-
-       DEL_ARR_F(initializers);
-       ascend_to(path, top_path_level+1);
-
-       return result;
+       goto out;
 
 end_error:
        skip_initializers();
+out:
        DEL_ARR_F(initializers);
        ascend_to(path, top_path_level+1);
-       return NULL;
+       return result;
 }
 
 static expression_t *make_size_literal(size_t value)
@@ -2207,13 +2222,10 @@ static initializer_t *parse_initializer(parse_initializer_env_t *env)
                        size = max_index + 1;
                        break;
 
-               case INITIALIZER_STRING:
-                       size = result->string.string.size;
-                       break;
-
-               case INITIALIZER_WIDE_STRING:
-                       size = result->wide_string.string.size;
+               case INITIALIZER_STRING: {
+                       size = get_string_len(&get_init_string(result)->value) + 1;
                        break;
+               }
 
                case INITIALIZER_DESIGNATOR:
                case INITIALIZER_VALUE:
@@ -2312,6 +2324,7 @@ static compound_t *parse_compound_type_specifier(bool is_struct)
        }
 
        if (attributes != NULL) {
+               entity->compound.attributes = attributes;
                handle_entity_attributes(attributes, entity);
        }
 
@@ -2338,7 +2351,7 @@ static void parse_enum_entries(type_t *const enum_type)
                entity->enum_value.enum_type = enum_type;
                rem_anchor_token('=');
 
-               if (next_if('=')) {
+               if (accept('=')) {
                        expression_t *value = parse_constant_expression();
 
                        value = create_implicit_cast(value, enum_type);
@@ -2348,7 +2361,7 @@ static void parse_enum_entries(type_t *const enum_type)
                }
 
                record_entity(entity, false);
-       } while (next_if(',') && token.kind != '}');
+       } while (accept(',') && token.kind != '}');
        rem_anchor_token(',');
        rem_anchor_token('}');
 
@@ -2467,6 +2480,7 @@ static type_t *parse_typeof(void)
 }
 
 typedef enum specifiers_t {
+       SPECIFIER_NONE      = 0,
        SPECIFIER_SIGNED    = 1 << 0,
        SPECIFIER_UNSIGNED  = 1 << 1,
        SPECIFIER_LONG      = 1 << 2,
@@ -2532,7 +2546,7 @@ static attribute_t *parse_attribute_ms_property(attribute_t *attribute)
                symbol_t *const sym = expect_identifier("while parsing property declspec", NULL);
                if (prop != NULL)
                        *prop = sym ? sym : sym_anonymous;
-       } while (next_if(','));
+       } while (accept(','));
        rem_anchor_token(',');
        rem_anchor_token(')');
 
@@ -2545,7 +2559,7 @@ static attribute_t *parse_attribute_ms_property(attribute_t *attribute)
 static attribute_t *parse_microsoft_extended_decl_modifier_single(void)
 {
        attribute_kind_t kind = ATTRIBUTE_UNKNOWN;
-       if (next_if(T_restrict)) {
+       if (accept(T_restrict)) {
                kind = ATTRIBUTE_MS_RESTRICT;
        } else if (token.kind == T_IDENTIFIER) {
                char const *const name = token.base.symbol->string;
@@ -2574,7 +2588,7 @@ static attribute_t *parse_microsoft_extended_decl_modifier_single(void)
        }
 
        /* parse arguments */
-       if (next_if('('))
+       if (accept('('))
                attribute->a.arguments = parse_attribute_arguments();
 
        return attribute;
@@ -2599,7 +2613,7 @@ static attribute_t *parse_microsoft_extended_decl_modifier(attribute_t *first)
 
                        *anchor = attribute;
                        anchor  = &attribute->next;
-               } while (next_if(','));
+               } while (accept(','));
        }
        rem_anchor_token(')');
        expect(')');
@@ -2659,9 +2673,9 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
                                = parse_microsoft_extended_decl_modifier(specifiers->attributes);
                        break;
 
-               case T___thread:
+               case T__Thread_local:
                        if (specifiers->thread_local) {
-                               errorf(HERE, "duplicate '__thread'");
+                               errorf(HERE, "duplicate %K", &token);
                        } else {
                                specifiers->thread_local = true;
 check_thread_storage_class:
@@ -2676,7 +2690,7 @@ check_thread_storage_class:
                                        case STORAGE_CLASS_REGISTER: wrong = "register"; goto wrong_thread_storage_class;
                                        case STORAGE_CLASS_TYPEDEF:  wrong = "typedef";  goto wrong_thread_storage_class;
 wrong_thread_storage_class:
-                                               errorf(HERE, "'__thread' used with '%s'", wrong);
+                                               errorf(HERE, "%K used with '%s'", &token, wrong);
                                                break;
                                }
                        }
@@ -3005,7 +3019,8 @@ warn_about_long_long:
                        } else {
                                errorf(pos, "multiple datatypes in declaration");
                        }
-                       goto end_error;
+                       specifiers->type = type_error_type;
+                       return;
                }
                }
 
@@ -3034,10 +3049,6 @@ warn_about_long_long:
        if (specifiers->attributes != NULL)
                type = handle_type_attributes(specifiers->attributes, type);
        specifiers->type = type;
-       return;
-
-end_error:
-       specifiers->type = type_error_type;
 }
 
 static type_qualifiers_t parse_type_qualifiers(void)
@@ -3076,7 +3087,7 @@ static void parse_identifier_list(scope_t *scope)
 
                if (scope != NULL)
                        append_entity(scope, entity);
-       } while (next_if(',') && token.kind == T_IDENTIFIER);
+       } while (accept(',') && token.kind == T_IDENTIFIER);
 }
 
 static entity_t *parse_parameter(void)
@@ -3189,7 +3200,7 @@ static void parse_parameters(function_type_t *type, scope_t *scope)
                        default:
                                goto parameters_finished;
                        }
-               } while (next_if(','));
+               } while (accept(','));
 parameters_finished:
                rem_anchor_token(',');
        }
@@ -3286,12 +3297,12 @@ static construct_type_t *parse_array_declarator(void)
        eat('[');
        add_anchor_token(']');
 
-       bool is_static = next_if(T_static);
+       bool is_static = accept(T_static);
 
        type_qualifiers_t type_qualifiers = parse_type_qualifiers();
 
        if (!is_static)
-               is_static = next_if(T_static);
+               is_static = accept(T_static);
 
        array->type_qualifiers = type_qualifiers;
        array->is_static       = is_static;
@@ -4287,7 +4298,7 @@ static void parse_declaration_rest(entity_t *ndeclaration,
 
                check_variable_type_complete(entity);
 
-               if (!next_if(','))
+               if (!accept(','))
                        break;
 
                add_anchor_token('=');
@@ -4577,8 +4588,7 @@ static void check_declarations(void)
                warn_unused_entity(WARN_UNUSED_PARAMETER, scope->entities, NULL);
        }
        if (is_warn_on(WARN_UNUSED_VARIABLE)) {
-               walk_statements(current_function->statement, check_unused_variables,
-                               NULL);
+               walk_statements(current_function->body, check_unused_variables, NULL);
        }
 }
 
@@ -4621,8 +4631,8 @@ static bool expression_returns(expression_t const *const expr)
                case EXPR_REFERENCE:
                case EXPR_ENUM_CONSTANT:
                case EXPR_LITERAL_CASES:
+               case EXPR_LITERAL_CHARACTER:
                case EXPR_STRING_LITERAL:
-               case EXPR_WIDE_STRING_LITERAL:
                case EXPR_COMPOUND_LITERAL: // TODO descend into initialisers
                case EXPR_LABEL_ADDRESS:
                case EXPR_CLASSIFY_TYPE:
@@ -4707,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;
        }
@@ -4796,7 +4805,7 @@ static void check_reachable(statement_t *const stmt)
                                return;
 
                        if (is_constant_expression(expr) == EXPR_CLASS_CONSTANT) {
-                               long                    const val      = fold_constant_to_int(expr);
+                               ir_tarval              *const val      = fold_constant_to_tarval(expr);
                                case_label_statement_t *      defaults = NULL;
                                for (case_label_statement_t *i = switchs->first_case; i != NULL; i = i->next) {
                                        if (i->expression == NULL) {
@@ -4804,7 +4813,9 @@ static void check_reachable(statement_t *const stmt)
                                                continue;
                                        }
 
-                                       if (i->first_case <= val && val <= i->last_case) {
+                                       if (i->first_case == val || i->last_case == val ||
+                                               ((tarval_cmp(i->first_case, val) & ir_relation_less_equal)
+                                           && (tarval_cmp(val, i->last_case) & ir_relation_less_equal))) {
                                                check_reachable((statement_t*)i);
                                                return;
                                        }
@@ -4849,7 +4860,6 @@ static void check_reachable(statement_t *const stmt)
 
                                next = parent;
                                switch (parent->kind) {
-                                       case STATEMENT_WHILE:    goto continue_while;
                                        case STATEMENT_DO_WHILE: goto continue_do_while;
                                        case STATEMENT_FOR:      goto continue_for;
 
@@ -4865,7 +4875,6 @@ static void check_reachable(statement_t *const stmt)
 
                                switch (parent->kind) {
                                        case STATEMENT_SWITCH:
-                                       case STATEMENT_WHILE:
                                        case STATEMENT_DO_WHILE:
                                        case STATEMENT_FOR:
                                                last = parent;
@@ -4903,25 +4912,6 @@ found_break_parent:
                        next = stmt->case_label.statement;
                        break;
 
-               case STATEMENT_WHILE: {
-                       while_statement_t const *const whiles = &stmt->whiles;
-                       expression_t      const *const cond   = whiles->condition;
-
-                       if (!expression_returns(cond))
-                               return;
-
-                       int const val = determine_truth(cond);
-
-                       if (val >= 0)
-                               check_reachable(whiles->body);
-
-                       if (val > 0)
-                               return;
-
-                       next = stmt->base.next;
-                       break;
-               }
-
                case STATEMENT_DO_WHILE:
                        next = stmt->do_while.body;
                        break;
@@ -5026,31 +5016,6 @@ found_break_parent:
                                next = next->base.next;
                                break;
 
-                       case STATEMENT_WHILE: {
-continue_while:
-                               if (next->base.reachable)
-                                       return;
-                               next->base.reachable = true;
-
-                               while_statement_t const *const whiles = &next->whiles;
-                               expression_t      const *const cond   = whiles->condition;
-
-                               if (!expression_returns(cond))
-                                       return;
-
-                               int const val = determine_truth(cond);
-
-                               if (val >= 0)
-                                       check_reachable(whiles->body);
-
-                               if (val > 0)
-                                       return;
-
-                               last = next;
-                               next = next->base.next;
-                               break;
-                       }
-
                        case STATEMENT_DO_WHILE: {
 continue_do_while:
                                if (next->base.reachable)
@@ -5320,7 +5285,7 @@ static void parse_external_declaration(void)
                environment_push(parameter);
        }
 
-       if (function->statement != NULL) {
+       if (function->body != NULL) {
                parser_error_multiple_definition(entity, HERE);
                eat_block();
        } else {
@@ -5337,7 +5302,7 @@ static void parse_external_declaration(void)
                label_anchor = &label_first;
 
                statement_t *const body = parse_compound_statement(false);
-               function->statement = body;
+               function->body = body;
                first_err = true;
                check_labels();
                check_declarations();
@@ -5472,8 +5437,7 @@ static expression_t *find_create_select(const source_position_t *pos,
                symbol_t *iter_symbol = iter->base.symbol;
                if (iter_symbol == NULL) {
                        type_t *type = iter->declaration.type;
-                       if (type->kind != TYPE_COMPOUND_STRUCT
-                                       && type->kind != TYPE_COMPOUND_UNION)
+                       if (!is_type_compound(type))
                                continue;
 
                        compound_t *sub_compound = type->compound.compound;
@@ -5612,7 +5576,7 @@ static void parse_compound_declarators(compound_t *compound,
                                append_entity(&compound->members, entity);
                        }
                }
-       } while (next_if(','));
+       } while (accept(','));
        rem_anchor_token(',');
        rem_anchor_token(';');
        expect(';');
@@ -5680,14 +5644,17 @@ struct expression_parser_function_t {
 
 static expression_parser_function_t expression_parsers[T_LAST_TOKEN];
 
-static type_t *get_string_type(void)
+static type_t *get_string_type(string_encoding_t const enc)
 {
-       return is_warn_on(WARN_WRITE_STRINGS) ? type_const_char_ptr : type_char_ptr;
-}
-
-static type_t *get_wide_string_type(void)
-{
-       return is_warn_on(WARN_WRITE_STRINGS) ? type_const_wchar_t_ptr : type_wchar_t_ptr;
+       bool const warn = is_warn_on(WARN_WRITE_STRINGS);
+       switch (enc) {
+       case STRING_ENCODING_CHAR:
+       case STRING_ENCODING_UTF8:   return warn ? type_const_char_ptr     : type_char_ptr;
+       case STRING_ENCODING_CHAR16: return warn ? type_char16_t_const_ptr : type_char16_t_ptr;
+       case STRING_ENCODING_CHAR32: return warn ? type_char32_t_const_ptr : type_char32_t_ptr;
+       case STRING_ENCODING_WIDE:   return warn ? type_const_wchar_t_ptr  : type_wchar_t_ptr;
+       }
+       panic("invalid string encoding");
 }
 
 /**
@@ -5695,31 +5662,10 @@ static type_t *get_wide_string_type(void)
  */
 static expression_t *parse_string_literal(void)
 {
-       source_position_t begin   = *HERE;
-       string_t          res     = token.string.string;
-       bool              is_wide = (token.kind == T_WIDE_STRING_LITERAL);
-
-       next_token();
-       while (token.kind == T_STRING_LITERAL
-                       || token.kind == T_WIDE_STRING_LITERAL) {
-               warn_string_concat(HERE);
-               res = concat_strings(&res, &token.string.string);
-               next_token();
-               is_wide |= token.kind == T_WIDE_STRING_LITERAL;
-       }
-
-       expression_t *literal;
-       if (is_wide) {
-               literal = allocate_expression_zero(EXPR_WIDE_STRING_LITERAL);
-               literal->base.type = get_wide_string_type();
-       } else {
-               literal = allocate_expression_zero(EXPR_STRING_LITERAL);
-               literal->base.type = get_string_type();
-       }
-       literal->base.source_position = begin;
-       literal->literal.value        = res;
-
-       return literal;
+       expression_t *const expr = allocate_expression_zero(EXPR_STRING_LITERAL);
+       expr->string_literal.value = concat_string_literals();
+       expr->base.type            = get_string_type(expr->string_literal.value.encoding);
+       return expr;
 }
 
 /**
@@ -5736,110 +5682,204 @@ static expression_t *parse_boolean_literal(bool value)
        return literal;
 }
 
-static void warn_traditional_suffix(void)
+static void warn_traditional_suffix(char const *const suffix)
 {
-       warningf(WARN_TRADITIONAL, HERE, "traditional C rejects the '%S' suffix",
-                &token.number.suffix);
+       warningf(WARN_TRADITIONAL, HERE, "traditional C rejects the '%s' suffix", suffix);
 }
 
-static void check_integer_suffix(void)
+static void check_integer_suffix(expression_t *const expr, char const *const suffix)
 {
-       const string_t *suffix = &token.number.suffix;
-       if (suffix->size == 0)
-               return;
-
-       bool not_traditional = false;
-       const char *c = suffix->begin;
-       if (*c == 'l' || *c == 'L') {
-               ++c;
-               if (*c == *(c-1)) {
-                       not_traditional = true;
-                       ++c;
-                       if (*c == 'u' || *c == 'U') {
+       unsigned     spec = SPECIFIER_NONE;
+       char const  *c    = suffix;
+       for (;;) {
+               specifiers_t add;
+               if (*c == 'L' || *c == 'l') {
+                       add = SPECIFIER_LONG;
+                       if (*c == c[1]) {
+                               add |= SPECIFIER_LONG_LONG;
                                ++c;
                        }
-               } else if (*c == 'u' || *c == 'U') {
-                       not_traditional = true;
-                       ++c;
+               } else if (*c == 'U' || *c == 'u') {
+                       add = SPECIFIER_UNSIGNED;
+               } else {
+                       break;
                }
-       } else if (*c == 'u' || *c == 'U') {
-               not_traditional = true;
                ++c;
-               if (*c == 'l' || *c == 'L') {
-                       ++c;
-                       if (*c == *(c-1)) {
-                               ++c;
-                       }
-               }
-       }
-       if (*c != '\0') {
-               errorf(HERE, "invalid suffix '%S' on integer constant", suffix);
-       } else if (not_traditional) {
-               warn_traditional_suffix();
+               if (spec & add)
+                       goto error;
+               spec |= add;
+       }
+
+       if (*c == '\0') {
+               type_t *type;
+               switch (spec) {
+               case SPECIFIER_NONE:                                            type = type_int;                break;
+               case                      SPECIFIER_LONG:                       type = type_long;               break;
+               case                      SPECIFIER_LONG | SPECIFIER_LONG_LONG: type = type_long_long;          break;
+               case SPECIFIER_UNSIGNED:                                        type = type_unsigned_int;       break;
+               case SPECIFIER_UNSIGNED | SPECIFIER_LONG:                       type = type_unsigned_long;      break;
+               case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG: type = type_unsigned_long_long; break;
+               default: panic("inconsistent suffix");
+               }
+               if (spec != SPECIFIER_NONE && spec != SPECIFIER_LONG) {
+                       warn_traditional_suffix(suffix);
+               }
+               expr->base.type = type;
+               /* Integer type depends on the size of the number and the size
+                * representable by the types. The backend/codegeneration has to
+                * determine that. */
+               determine_literal_type(&expr->literal);
+       } else {
+error:
+               errorf(HERE, "invalid suffix '%s' on integer constant", suffix);
        }
 }
 
-static type_t *check_floatingpoint_suffix(void)
+static void check_floatingpoint_suffix(expression_t *const expr, char const *const suffix)
 {
-       const string_t *suffix = &token.number.suffix;
-       type_t         *type   = type_double;
-       if (suffix->size == 0)
-               return type;
-
-       bool not_traditional = false;
-       const char *c = suffix->begin;
-       if (*c == 'f' || *c == 'F') {
-               ++c;
-               type = type_float;
-       } else if (*c == 'l' || *c == 'L') {
-               ++c;
-               type = type_long_double;
-       }
-       if (*c != '\0') {
-               errorf(HERE, "invalid suffix '%S' on floatingpoint constant", suffix);
-       } else if (not_traditional) {
-               warn_traditional_suffix();
+       type_t     *type;
+       char const *c    = suffix;
+       switch (*c) {
+       case 'F':
+       case 'f': type = type_float;       ++c; break;
+       case 'L':
+       case 'l': type = type_long_double; ++c; break;
+       default:  type = type_double;           break;
        }
 
-       return type;
+       if (*c == '\0') {
+               expr->base.type = type;
+               if (suffix[0] != '\0') {
+                       warn_traditional_suffix(suffix);
+               }
+       } else {
+               errorf(HERE, "invalid suffix '%s' on floatingpoint constant", suffix);
+       }
 }
 
-/**
- * Parse an integer constant.
- */
 static expression_t *parse_number_literal(void)
 {
-       expression_kind_t  kind;
-       type_t            *type;
+       string_t const *const str      = &token.literal.string;
+       char     const *      i        = str->begin;
+       unsigned              digits   = 0;
+       bool                  is_float = false;
 
-       switch (token.kind) {
-       case T_INTEGER:
-               kind = EXPR_LITERAL_INTEGER;
-               check_integer_suffix();
-               type = type_int;
+       /* Parse base prefix. */
+       unsigned base;
+       if (*i == '0') {
+               switch (*++i) {
+               case 'B': case 'b': base =  2; ++i;               break;
+               case 'X': case 'x': base = 16; ++i;               break;
+               default:            base =  8; digits |= 1U << 0; break;
+               }
+       } else {
+               base = 10;
+       }
+
+       /* Parse mantissa. */
+       for (;; ++i) {
+               unsigned digit;
+               switch (*i) {
+               case '.':
+                       if (is_float) {
+                               errorf(HERE, "multiple decimal points in %K", &token);
+                               i = 0;
+                               goto done;
+                       }
+                       is_float = true;
+                       if (base == 8)
+                               base = 10;
+                       continue;
+
+               case '0':           digit =  0; break;
+               case '1':           digit =  1; break;
+               case '2':           digit =  2; break;
+               case '3':           digit =  3; break;
+               case '4':           digit =  4; break;
+               case '5':           digit =  5; break;
+               case '6':           digit =  6; break;
+               case '7':           digit =  7; break;
+               case '8':           digit =  8; break;
+               case '9':           digit =  9; break;
+               case 'A': case 'a': digit = 10; break;
+               case 'B': case 'b': digit = 11; break;
+               case 'C': case 'c': digit = 12; break;
+               case 'D': case 'd': digit = 13; break;
+               case 'E': case 'e': digit = 14; break;
+               case 'F': case 'f': digit = 15; break;
+
+               default: goto done_mantissa;
+               }
+
+               if (digit >= 10 && base != 16)
+                       goto done_mantissa;
+
+               digits |= 1U << digit;
+       }
+done_mantissa:
+
+       /* Parse exponent. */
+       switch (base) {
+       case 2:
+               if (is_float)
+                       errorf(HERE, "binary floating %K not allowed", &token);
                break;
 
-       case T_FLOATINGPOINT:
-               kind = EXPR_LITERAL_FLOATINGPOINT;
-               type = check_floatingpoint_suffix();
+       case  8:
+       case 10:
+               if (*i == 'E' || *i == 'e') {
+                       base = 10;
+                       goto parse_exponent;
+               }
+               break;
+
+       case 16:
+               if (*i == 'P' || *i == 'p') {
+parse_exponent:
+                       ++i;
+                       is_float = true;
+
+                       if (*i == '-' || *i == '+')
+                               ++i;
+
+                       if (isdigit(*i)) {
+                               do {
+                                       ++i;
+                               } while (isdigit(*i));
+                       } else {
+                               errorf(HERE, "exponent of %K has no digits", &token);
+                       }
+               } else if (is_float) {
+                       errorf(HERE, "hexadecimal floating %K requires an exponent", &token);
+                       i = 0;
+               }
                break;
 
        default:
-               panic("unexpected token type in parse_number_literal");
+               panic("invalid base");
        }
 
-       expression_t *literal = allocate_expression_zero(kind);
-       literal->base.type      = type;
-       literal->literal.value  = token.number.number;
-       literal->literal.suffix = token.number.suffix;
-       next_token();
+done:;
+       expression_t *const expr = allocate_expression_zero(is_float ? EXPR_LITERAL_FLOATINGPOINT : EXPR_LITERAL_INTEGER);
+       expr->literal.value = *str;
 
-       /* integer type depends on the size of the number and the size
-        * representable by the types. The backend/codegeneration has to determine
-        * that
-        */
-       determine_literal_type(&literal->literal);
-       return literal;
+       if (i) {
+               if (digits == 0) {
+                       errorf(HERE, "%K has no digits", &token);
+               } else if (digits & ~((1U << base) - 1)) {
+                       errorf(HERE, "invalid digit in %K", &token);
+               } else {
+                       expr->literal.suffix = i;
+                       if (is_float) {
+                               check_floatingpoint_suffix(expr, i);
+                       } else {
+                               check_integer_suffix(expr, i);
+                       }
+               }
+       }
+
+       eat(T_NUMBER);
+       return expr;
 }
 
 /**
@@ -5847,42 +5887,38 @@ static expression_t *parse_number_literal(void)
  */
 static expression_t *parse_character_constant(void)
 {
-       expression_t *literal = allocate_expression_zero(EXPR_LITERAL_CHARACTER);
-       literal->base.type     = c_mode & _CXX ? type_char : type_int;
-       literal->literal.value = token.string.string;
+       expression_t *const literal = allocate_expression_zero(EXPR_LITERAL_CHARACTER);
+       literal->string_literal.value = token.literal.string;
+
+       size_t const size = get_string_len(&token.literal.string);
+       switch (token.literal.string.encoding) {
+       case STRING_ENCODING_CHAR:
+       case STRING_ENCODING_UTF8:
+               literal->base.type = c_mode & _CXX ? type_char : type_int;
+               if (size > 1) {
+                       if (!GNU_MODE && !(c_mode & _C99)) {
+                               errorf(HERE, "more than 1 character in character constant");
+                       } else {
+                               literal->base.type = type_int;
+                               warningf(WARN_MULTICHAR, HERE, "multi-character character constant");
+                       }
+               }
+               break;
 
-       size_t len = literal->literal.value.size;
-       if (len > 1) {
-               if (!GNU_MODE && !(c_mode & _C99)) {
-                       errorf(HERE, "more than 1 character in character constant");
-               } else {
-                       literal->base.type = type_int;
+       case STRING_ENCODING_CHAR16: literal->base.type = type_char16_t; goto warn_multi;
+       case STRING_ENCODING_CHAR32: literal->base.type = type_char32_t; goto warn_multi;
+       case STRING_ENCODING_WIDE:   literal->base.type = type_wchar_t;  goto warn_multi;
+warn_multi:
+               if (size > 1) {
                        warningf(WARN_MULTICHAR, HERE, "multi-character character constant");
                }
+               break;
        }
 
        eat(T_CHARACTER_CONSTANT);
        return literal;
 }
 
-/**
- * Parse a wide character constant.
- */
-static expression_t *parse_wide_character_constant(void)
-{
-       expression_t *literal = allocate_expression_zero(EXPR_LITERAL_WIDE_CHARACTER);
-       literal->base.type     = type_int;
-       literal->literal.value = token.string.string;
-
-       size_t len = wstrlen(&literal->literal.value);
-       if (len > 1) {
-               warningf(WARN_MULTICHAR, HERE, "multi-character character constant");
-       }
-
-       eat(T_WIDE_CHARACTER_CONSTANT);
-       return literal;
-}
-
 static entity_t *create_implicit_function(symbol_t *symbol, source_position_t const *const pos)
 {
        type_t *ntype                          = allocate_type_zero(TYPE_FUNCTION);
@@ -5968,13 +6004,9 @@ type_t *revert_automatic_type_conversion(const expression_t *expression)
        }
 
        case EXPR_STRING_LITERAL: {
-               size_t size = expression->string_literal.value.size;
-               return make_array_type(type_char, size, TYPE_QUALIFIER_NONE);
-       }
-
-       case EXPR_WIDE_STRING_LITERAL: {
-               size_t size = wstrlen(&expression->string_literal.value);
-               return make_array_type(type_wchar_t, size, TYPE_QUALIFIER_NONE);
+               size_t  const size = get_string_len(&expression->string_literal.value) + 1;
+               type_t *const elem = get_unqualified_type(expression->base.type->pointer.points_to);
+               return make_array_type(elem, size, TYPE_QUALIFIER_NONE);
        }
 
        case EXPR_COMPOUND_LITERAL:
@@ -6016,7 +6048,7 @@ static entity_t *parse_qualified_identifier(void)
        source_position_t  pos;
        const scope_t     *lookup_scope = NULL;
 
-       if (next_if(T_COLONCOLON))
+       if (accept(T_COLONCOLON))
                lookup_scope = &unit->scope;
 
        entity_t *entity;
@@ -6028,7 +6060,7 @@ static entity_t *parse_qualified_identifier(void)
                /* lookup entity */
                entity = lookup_entity(lookup_scope, symbol, NAMESPACE_NORMAL);
 
-               if (!next_if(T_COLONCOLON))
+               if (!accept(T_COLONCOLON))
                        break;
 
                switch (entity->kind) {
@@ -6045,7 +6077,7 @@ static entity_t *parse_qualified_identifier(void)
                               symbol, get_entity_kind_name(entity->kind));
 
                        /* skip further qualifications */
-                       while (next_if(T_IDENTIFIER) && next_if(T_COLONCOLON)) {}
+                       while (accept(T_IDENTIFIER) && accept(T_COLONCOLON)) {}
 
                        return create_error_entity(sym_anonymous, ENTITY_VARIABLE);
                }
@@ -6294,7 +6326,7 @@ static designator_t *parse_designator(void)
 
        designator_t *last_designator = result;
        while (true) {
-               if (next_if('.')) {
+               if (accept('.')) {
                        designator_t *const designator = allocate_ast_zero(sizeof(result[0]));
                        designator->symbol = expect_identifier("while parsing member designator", &designator->source_position);
                        if (!designator->symbol)
@@ -6304,7 +6336,7 @@ static designator_t *parse_designator(void)
                        last_designator       = designator;
                        continue;
                }
-               if (next_if('[')) {
+               if (accept('[')) {
                        add_anchor_token(']');
                        designator_t *designator    = allocate_ast_zero(sizeof(result[0]));
                        designator->source_position = *HERE;
@@ -6648,7 +6680,7 @@ static expression_t *parse_noop_expression(void)
 
                if (token.kind != ')') do {
                        (void)parse_assignment_expression();
-               } while (next_if(','));
+               } while (accept(','));
 
                rem_anchor_token(',');
                rem_anchor_token(')');
@@ -6666,13 +6698,9 @@ static expression_t *parse_primary_expression(void)
        switch (token.kind) {
        case T_false:                        return parse_boolean_literal(false);
        case T_true:                         return parse_boolean_literal(true);
-       case T_INTEGER:
-       case T_FLOATINGPOINT:                return parse_number_literal();
+       case T_NUMBER:                       return parse_number_literal();
        case T_CHARACTER_CONSTANT:           return parse_character_constant();
-       case T_WIDE_CHARACTER_CONSTANT:      return parse_wide_character_constant();
-       case T_STRING_LITERAL:
-       case T_WIDE_STRING_LITERAL:          return parse_string_literal();
-       case T___FUNCTION__:
+       case T_STRING_LITERAL:               return parse_string_literal();
        case T___func__:                     return parse_function_keyword(FUNCNAME_FUNCTION);
        case T___PRETTY_FUNCTION__:          return parse_function_keyword(FUNCNAME_PRETTY_FUNCTION);
        case T___FUNCSIG__:                  return parse_function_keyword(FUNCNAME_FUNCSIG);
@@ -6756,7 +6784,8 @@ static expression_t *parse_array_expression(expression_t *left)
 check_idx:
                res_type = automatic_type_conversion(res_type);
                if (!is_type_integer(idx_type)) {
-                       errorf(&idx->base.source_position, "array subscript must have integer type");
+                       if (is_type_valid(idx_type))
+                               errorf(&idx->base.source_position, "array subscript must have integer type");
                } else if (is_type_atomic(idx_type, ATOMIC_TYPE_CHAR)) {
                        source_position_t const *const pos = &idx->base.source_position;
                        warningf(WARN_CHAR_SUBSCRIPTS, pos, "array subscript has char type");
@@ -6790,7 +6819,7 @@ static expression_t *parse_typeprop(expression_kind_t const kind)
        expression_t  *tp_expression = allocate_expression_zero(kind);
        tp_expression->base.type     = type_size_t;
 
-       eat(kind == EXPR_SIZEOF ? T_sizeof : T___alignof__);
+       eat(kind == EXPR_SIZEOF ? T_sizeof : T__Alignof);
 
        type_t       *orig_type;
        expression_t *expression;
@@ -6893,9 +6922,7 @@ static expression_t *parse_select_expression(expression_t *addr)
                type_left = type;
        }
 
-       if (type_left->kind != TYPE_COMPOUND_STRUCT &&
-           type_left->kind != TYPE_COMPOUND_UNION) {
-
+       if (!is_type_compound(type_left)) {
                if (is_type_valid(type_left) && !saw_error) {
                        errorf(&pos,
                               "request for member '%Y' in something not a struct or union, but '%T'",
@@ -7020,7 +7047,6 @@ static void handle_builtin_argument_restrictions(call_expression_t *call)
                                                   "third argument of '%Y' must be a constant expression",
                                                   call->function->reference.entity->base.symbol);
                                }
-                               locality = rw->next;
                        }
                        break;
                default:
@@ -7086,7 +7112,7 @@ static expression_t *parse_call_expression(expression_t *expression)
 
                        *anchor = argument;
                        anchor  = &argument->next;
-               } while (next_if(','));
+               } while (accept(','));
        }
        rem_anchor_token(',');
        rem_anchor_token(')');
@@ -7369,7 +7395,7 @@ static expression_t *parse_delete(void)
 
        eat(T_delete);
 
-       if (next_if('[')) {
+       if (accept('[')) {
                result->kind = EXPR_UNARY_DELETE_ARRAY;
                expect(']');
        }
@@ -7969,8 +7995,7 @@ static void warn_string_literal_address(expression_t const* expr)
                expr = expr->unary.value;
        }
 
-       if (expr->kind == EXPR_STRING_LITERAL
-                       || expr->kind == EXPR_WIDE_STRING_LITERAL) {
+       if (expr->kind == EXPR_STRING_LITERAL) {
                source_position_t const *const pos = &expr->base.source_position;
                warningf(WARN_ADDRESS, pos, "comparison with string literal results in unspecified behaviour");
        }
@@ -8308,11 +8333,9 @@ 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;
-               case EXPR_WIDE_STRING_LITERAL:        return false;
 
                case EXPR_CALL: {
                        const call_expression_t *const call = &expr->call;
@@ -8530,10 +8553,7 @@ static void register_expression_parser(parse_expression_function parser,
 {
        expression_parser_function_t *entry = &expression_parsers[token_kind];
 
-       if (entry->parser != NULL) {
-               diagnosticf("for token '%k'\n", (token_kind_t)token_kind);
-               panic("trying to register multiple expression parsers for a token");
-       }
+       assert(!entry->parser);
        entry->parser = parser;
 }
 
@@ -8549,11 +8569,7 @@ static void register_infix_parser(parse_expression_infix_function parser,
 {
        expression_parser_function_t *entry = &expression_parsers[token_kind];
 
-       if (entry->infix_parser != NULL) {
-               diagnosticf("for token '%k'\n", (token_kind_t)token_kind);
-               panic("trying to register multiple infix expression parsers for a "
-                     "token");
-       }
+       assert(!entry->infix_parser);
        entry->infix_parser     = parser;
        entry->infix_precedence = precedence;
 }
@@ -8612,7 +8628,7 @@ static void init_expression_parsers(void)
        register_expression_parser(parse_EXPR_UNARY_PREFIX_INCREMENT, T_PLUSPLUS);
        register_expression_parser(parse_EXPR_UNARY_PREFIX_DECREMENT, T_MINUSMINUS);
        register_expression_parser(parse_sizeof,                      T_sizeof);
-       register_expression_parser(parse_alignof,                     T___alignof__);
+       register_expression_parser(parse_alignof,                     T__Alignof);
        register_expression_parser(parse_extension,                   T___extension__);
        register_expression_parser(parse_builtin_classify_type,       T___builtin_classify_type);
        register_expression_parser(parse_delete,                      T_delete);
@@ -8622,120 +8638,131 @@ static void init_expression_parsers(void)
 /**
  * Parse a asm statement arguments specification.
  */
-static asm_argument_t *parse_asm_arguments(bool is_out)
+static void parse_asm_arguments(asm_argument_t **anchor, bool const is_out)
 {
-       asm_argument_t  *result = NULL;
-       asm_argument_t **anchor = &result;
+       if (token.kind == T_STRING_LITERAL || token.kind == '[') {
+               add_anchor_token(',');
+               do {
+                       asm_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
 
-       while (token.kind == T_STRING_LITERAL || token.kind == '[') {
-               asm_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
+                       add_anchor_token(')');
+                       add_anchor_token('(');
+                       add_anchor_token(T_STRING_LITERAL);
 
-               if (next_if('[')) {
-                       add_anchor_token(']');
-                       argument->symbol = expect_identifier("while parsing asm argument", NULL);
-                       rem_anchor_token(']');
-                       expect(']');
-                       if (!argument->symbol)
-                               return NULL;
-               }
-
-               argument->constraints = parse_string_literals();
-               add_anchor_token(')');
-               expect('(');
-               expression_t *expression = parse_expression();
-               rem_anchor_token(')');
-               if (is_out) {
-                       /* Ugly GCC stuff: Allow lvalue casts.  Skip casts, when they do not
-                        * change size or type representation (e.g. int -> long is ok, but
-                        * int -> float is not) */
-                       if (expression->kind == EXPR_UNARY_CAST) {
-                               type_t      *const type = expression->base.type;
-                               type_kind_t  const kind = type->kind;
-                               if (kind == TYPE_ATOMIC || kind == TYPE_POINTER) {
-                                       unsigned flags;
-                                       unsigned size;
-                                       if (kind == TYPE_ATOMIC) {
-                                               atomic_type_kind_t const akind = type->atomic.akind;
-                                               flags = get_atomic_type_flags(akind) & ~ATOMIC_TYPE_FLAG_SIGNED;
-                                               size  = get_atomic_type_size(akind);
-                                       } else {
-                                               flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC;
-                                               size  = get_type_size(type_void_ptr);
-                                       }
+                       if (accept('[')) {
+                               add_anchor_token(']');
+                               argument->symbol = expect_identifier("while parsing asm argument", NULL);
+                               rem_anchor_token(']');
+                               expect(']');
+                       }
 
-                                       do {
-                                               expression_t *const value      = expression->unary.value;
-                                               type_t       *const value_type = value->base.type;
-                                               type_kind_t   const value_kind = value_type->kind;
-
-                                               unsigned value_flags;
-                                               unsigned value_size;
-                                               if (value_kind == TYPE_ATOMIC) {
-                                                       atomic_type_kind_t const value_akind = value_type->atomic.akind;
-                                                       value_flags = get_atomic_type_flags(value_akind) & ~ATOMIC_TYPE_FLAG_SIGNED;
-                                                       value_size  = get_atomic_type_size(value_akind);
-                                               } else if (value_kind == TYPE_POINTER) {
-                                                       value_flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC;
-                                                       value_size  = get_type_size(type_void_ptr);
+                       rem_anchor_token(T_STRING_LITERAL);
+                       argument->constraints = parse_string_literals("asm argument");
+                       rem_anchor_token('(');
+                       expect('(');
+                       expression_t *expression = parse_expression();
+                       if (is_out) {
+                               /* Ugly GCC stuff: Allow lvalue casts.  Skip casts, when they do not
+                                * change size or type representation (e.g. int -> long is ok, but
+                                * int -> float is not) */
+                               if (expression->kind == EXPR_UNARY_CAST) {
+                                       type_t      *const type = expression->base.type;
+                                       type_kind_t  const kind = type->kind;
+                                       if (kind == TYPE_ATOMIC || kind == TYPE_POINTER) {
+                                               unsigned flags;
+                                               unsigned size;
+                                               if (kind == TYPE_ATOMIC) {
+                                                       atomic_type_kind_t const akind = type->atomic.akind;
+                                                       flags = get_atomic_type_flags(akind) & ~ATOMIC_TYPE_FLAG_SIGNED;
+                                                       size  = get_atomic_type_size(akind);
                                                } else {
-                                                       break;
+                                                       flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC;
+                                                       size  = get_type_size(type_void_ptr);
                                                }
 
-                                               if (value_flags != flags || value_size != size)
-                                                       break;
+                                               do {
+                                                       expression_t *const value      = expression->unary.value;
+                                                       type_t       *const value_type = value->base.type;
+                                                       type_kind_t   const value_kind = value_type->kind;
+
+                                                       unsigned value_flags;
+                                                       unsigned value_size;
+                                                       if (value_kind == TYPE_ATOMIC) {
+                                                               atomic_type_kind_t const value_akind = value_type->atomic.akind;
+                                                               value_flags = get_atomic_type_flags(value_akind) & ~ATOMIC_TYPE_FLAG_SIGNED;
+                                                               value_size  = get_atomic_type_size(value_akind);
+                                                       } else if (value_kind == TYPE_POINTER) {
+                                                               value_flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC;
+                                                               value_size  = get_type_size(type_void_ptr);
+                                                       } else {
+                                                               break;
+                                                       }
 
-                                               expression = value;
-                                       } while (expression->kind == EXPR_UNARY_CAST);
+                                                       if (value_flags != flags || value_size != size)
+                                                               break;
+
+                                                       expression = value;
+                                               } while (expression->kind == EXPR_UNARY_CAST);
+                                       }
                                }
-                       }
 
-                       if (!is_lvalue(expression)) {
-                               errorf(&expression->base.source_position,
-                                      "asm output argument is not an lvalue");
-                       }
+                               if (!is_lvalue(expression))
+                                       errorf(&expression->base.source_position, "asm output argument is not an lvalue");
 
-                       if (argument->constraints.begin[0] == '=')
-                               determine_lhs_ent(expression, NULL);
-                       else
+                               if (argument->constraints.begin[0] == '=')
+                                       determine_lhs_ent(expression, NULL);
+                               else
+                                       mark_vars_read(expression, NULL);
+                       } else {
                                mark_vars_read(expression, NULL);
-               } else {
-                       mark_vars_read(expression, NULL);
-               }
-               argument->expression = expression;
-               expect(')');
+                       }
+                       argument->expression = expression;
+                       rem_anchor_token(')');
+                       expect(')');
 
-               set_address_taken(expression, true);
+                       set_address_taken(expression, true);
 
-               *anchor = argument;
-               anchor  = &argument->next;
-
-               if (!next_if(','))
-                       break;
+                       *anchor = argument;
+                       anchor  = &argument->next;
+               } while (accept(','));
+               rem_anchor_token(',');
        }
-
-       return result;
 }
 
 /**
  * Parse a asm statement clobber specification.
  */
-static asm_clobber_t *parse_asm_clobbers(void)
+static void parse_asm_clobbers(asm_clobber_t **anchor)
 {
-       asm_clobber_t *result  = NULL;
-       asm_clobber_t **anchor = &result;
+       if (token.kind == T_STRING_LITERAL) {
+               add_anchor_token(',');
+               do {
+                       asm_clobber_t *clobber = allocate_ast_zero(sizeof(clobber[0]));
+                       clobber->clobber       = parse_string_literals(NULL);
 
-       while (token.kind == T_STRING_LITERAL) {
-               asm_clobber_t *clobber = allocate_ast_zero(sizeof(clobber[0]));
-               clobber->clobber       = parse_string_literals();
+                       *anchor = clobber;
+                       anchor  = &clobber->next;
+               } while (accept(','));
+               rem_anchor_token(',');
+       }
+}
 
-               *anchor = clobber;
-               anchor  = &clobber->next;
+static void parse_asm_labels(asm_label_t **anchor)
+{
+       if (token.kind == T_IDENTIFIER) {
+               add_anchor_token(',');
+               do {
+                       label_t *const label = get_label("while parsing 'asm goto' labels");
+                       if (label) {
+                               asm_label_t *const asm_label = allocate_ast_zero(sizeof(*asm_label));
+                               asm_label->label = label;
 
-               if (!next_if(','))
-                       break;
+                               *anchor = asm_label;
+                               anchor  = &asm_label->next;
+                       }
+               } while (accept(','));
+               rem_anchor_token(',');
        }
-
-       return result;
 }
 
 /**
@@ -8747,40 +8774,35 @@ static statement_t *parse_asm_statement(void)
        asm_statement_t *asm_statement = &statement->asms;
 
        eat(T_asm);
+       add_anchor_token(')');
+       add_anchor_token(':');
+       add_anchor_token(T_STRING_LITERAL);
 
-       if (next_if(T_volatile))
+       if (accept(T_volatile))
                asm_statement->is_volatile = true;
 
-       expect('(');
-       add_anchor_token(')');
-       if (token.kind != T_STRING_LITERAL) {
-               parse_error_expected("after asm(", T_STRING_LITERAL, NULL);
-               goto end_of_asm;
-       }
-       asm_statement->asm_text = parse_string_literals();
+       bool const asm_goto = accept(T_goto);
 
-       add_anchor_token(':');
-       if (!next_if(':')) {
-               rem_anchor_token(':');
-               goto end_of_asm;
-       }
+       expect('(');
+       rem_anchor_token(T_STRING_LITERAL);
+       asm_statement->asm_text = parse_string_literals("asm statement");
 
-       asm_statement->outputs = parse_asm_arguments(true);
-       if (!next_if(':')) {
-               rem_anchor_token(':');
-               goto end_of_asm;
-       }
+       if (accept(':')) parse_asm_arguments(&asm_statement->outputs, true);
+       if (accept(':')) parse_asm_arguments(&asm_statement->inputs, false);
+       if (accept(':')) parse_asm_clobbers( &asm_statement->clobbers);
 
-       asm_statement->inputs = parse_asm_arguments(false);
-       if (!next_if(':')) {
-               rem_anchor_token(':');
-               goto end_of_asm;
-       }
        rem_anchor_token(':');
+       if (accept(':')) {
+               if (!asm_goto)
+                       warningf(WARN_OTHER, &statement->base.source_position, "assembler statement with labels should be 'asm goto'");
+               parse_asm_labels(&asm_statement->labels);
+               if (asm_statement->labels)
+                       errorf(&statement->base.source_position, "'asm goto' not supported");
+       } else {
+               if (asm_goto)
+                       warningf(WARN_OTHER, &statement->base.source_position, "'asm goto' without labels");
+       }
 
-       asm_statement->clobbers = parse_asm_clobbers();
-
-end_of_asm:
        rem_anchor_token(')');
        expect(')');
        expect(';');
@@ -8861,13 +8883,13 @@ static statement_t *parse_case_statement(void)
                }
                statement->case_label.is_bad = true;
        } else {
-               long const val = fold_constant_to_int(expression);
+               ir_tarval *val = fold_constant_to_tarval(expression);
                statement->case_label.first_case = val;
                statement->case_label.last_case  = val;
        }
 
        if (GNU_MODE) {
-               if (next_if(T_DOTDOTDOT)) {
+               if (accept(T_DOTDOTDOT)) {
                        expression_t *end_range = parse_expression();
                        expression_type = expression->base.type;
                        skipped         = skip_typeref(expression_type);
@@ -8885,10 +8907,11 @@ static statement_t *parse_case_statement(void)
                                }
                                statement->case_label.is_bad = true;
                        } else {
-                               long const val = fold_constant_to_int(end_range);
+                               ir_tarval *val = fold_constant_to_tarval(end_range);
                                statement->case_label.last_case = val;
 
-                               if (val < statement->case_label.first_case) {
+                               if (tarval_cmp(val, statement->case_label.first_case)
+                                   == ir_relation_less) {
                                        statement->case_label.is_empty_range = true;
                                        warningf(WARN_OTHER, pos, "empty range specified");
                                }
@@ -8993,6 +9016,7 @@ static statement_t *parse_label_statement(void)
        } else {
                label->base.source_position = *pos;
                label->statement            = statement;
+               label->n_users             += 1;
        }
 
        eat(':');
@@ -9065,7 +9089,7 @@ static statement_t *parse_if(void)
                        "suggest braces around empty body in an ‘if’ statement");
        }
 
-       if (next_if(T_else)) {
+       if (accept(T_else)) {
                statement->ifs.false_statement = parse_inner_statement();
 
                if (statement->ifs.false_statement->kind == STATEMENT_EMPTY) {
@@ -9092,28 +9116,32 @@ static void check_enum_cases(const switch_statement_t *statement)
 {
        if (!is_warn_on(WARN_SWITCH_ENUM))
                return;
-       const type_t *type = skip_typeref(statement->expression->base.type);
+       type_t *type = skip_typeref(statement->expression->base.type);
        if (! is_type_enum(type))
                return;
-       const enum_type_t *enumt = &type->enumt;
+       enum_type_t *enumt = &type->enumt;
 
        /* if we have a default, no warnings */
        if (statement->default_label != NULL)
                return;
 
+       determine_enum_values(enumt);
+
        /* FIXME: calculation of value should be done while parsing */
        /* TODO: quadratic algorithm here. Change to an n log n one */
-       long            last_value = -1;
-       const entity_t *entry      = enumt->enume->base.next;
+       const entity_t *entry = enumt->enume->base.next;
        for (; entry != NULL && entry->kind == ENTITY_ENUM_VALUE;
             entry = entry->base.next) {
-               const expression_t *expression = entry->enum_value.value;
-               long                value      = expression != NULL ? fold_constant_to_int(expression) : last_value + 1;
-               bool                found      = false;
-               for (const case_label_statement_t *l = statement->first_case; l != NULL; l = l->next) {
+               ir_tarval *value = entry->enum_value.tv;
+               bool       found = false;
+               for (const case_label_statement_t *l = statement->first_case; l != NULL;
+                    l = l->next) {
                        if (l->expression == NULL)
                                continue;
-                       if (l->first_case <= value && value <= l->last_case) {
+                       if (l->first_case == l->last_case && l->first_case != value)
+                               continue;
+                       if ((tarval_cmp(l->first_case, value) & ir_relation_less_equal)
+                        && (tarval_cmp(value, l->last_case) & ir_relation_less_equal)) {
                                found = true;
                                break;
                        }
@@ -9122,7 +9150,6 @@ static void check_enum_cases(const switch_statement_t *statement)
                        source_position_t const *const pos = &statement->base.source_position;
                        warningf(WARN_SWITCH_ENUM, pos, "'%N' not handled in switch", entry);
                }
-               last_value = value;
        }
 }
 
@@ -9183,20 +9210,20 @@ static statement_t *parse_loop_body(statement_t *const loop)
  */
 static statement_t *parse_while(void)
 {
-       statement_t *statement = allocate_statement_zero(STATEMENT_WHILE);
+       statement_t *statement = allocate_statement_zero(STATEMENT_FOR);
 
        eat(T_while);
 
        PUSH_PARENT(statement);
-       PUSH_SCOPE_STATEMENT(&statement->whiles.scope);
+       PUSH_SCOPE_STATEMENT(&statement->fors.scope);
 
        expression_t *const cond = parse_condition();
-       statement->whiles.condition = cond;
+       statement->fors.condition = cond;
        /* §6.8.5:2    The controlling expression of an iteration statement shall
         *             have scalar type. */
        semantic_condition(cond, "condition of 'while'-statement");
 
-       statement->whiles.body = parse_loop_body(statement);
+       statement->fors.body = parse_loop_body(statement);
 
        POP_SCOPE();
        POP_PARENT();
@@ -9249,7 +9276,7 @@ static statement_t *parse_for(void)
 
        PUSH_EXTENSION();
 
-       if (next_if(';')) {
+       if (accept(';')) {
        } else if (is_declaration_specifier(&token)) {
                parse_declaration(record_entity, DECL_FLAGS_NONE);
        } else {
@@ -9329,6 +9356,7 @@ static statement_t *parse_goto(void)
 
                label_t *const label = get_label("while parsing goto");
                if (label) {
+                       label->n_users        += 1;
                        label->used            = true;
                        statement->gotos.label = label;
 
@@ -9427,22 +9455,6 @@ static bool expression_is_local_variable(const expression_t *expression)
        return is_local_variable(entity);
 }
 
-/**
- * Check if a given expression represents a local variable and
- * return its declaration then, else return NULL.
- */
-entity_t *expression_is_variable(const expression_t *expression)
-{
-       if (expression->base.kind != EXPR_REFERENCE) {
-               return NULL;
-       }
-       entity_t *entity = expression->reference.entity;
-       if (entity->kind != ENTITY_VARIABLE)
-               return NULL;
-
-       return entity;
-}
-
 static void err_or_warn(source_position_t const *const pos, char const *const msg)
 {
        if (c_mode & _CXX || strict_mode) {
@@ -9562,7 +9574,7 @@ static statement_t *parse_ms_try_statment(void)
 
        POP_PARENT();
 
-       if (next_if(T___except)) {
+       if (accept(T___except)) {
                expression_t *const expr = parse_condition();
                type_t       *      type = skip_typeref(expr->base.type);
                if (is_type_integer(type)) {
@@ -9573,7 +9585,7 @@ static statement_t *parse_ms_try_statment(void)
                        type = type_error_type;
                }
                statement->ms_try.except_expression = create_implicit_cast(expr, type);
-       } else if (!next_if(T__finally)) {
+       } else if (!accept(T__finally)) {
                parse_error_expected("while parsing __try statement", T___except, T___finally, NULL);
        }
        statement->ms_try.final_statement = parse_compound_statement(false);
@@ -9618,7 +9630,7 @@ static statement_t *parse_local_label_declaration(void)
                                environment_push(entity);
                        }
                }
-       } while (next_if(','));
+       } while (accept(','));
        rem_anchor_token(',');
        rem_anchor_token(';');
        expect(';');
@@ -9803,20 +9815,17 @@ static statement_t *parse_compound_statement(bool inside_expression_statement)
        add_anchor_token('~');
        add_anchor_token(T_CHARACTER_CONSTANT);
        add_anchor_token(T_COLONCOLON);
-       add_anchor_token(T_FLOATINGPOINT);
        add_anchor_token(T_IDENTIFIER);
-       add_anchor_token(T_INTEGER);
        add_anchor_token(T_MINUSMINUS);
+       add_anchor_token(T_NUMBER);
        add_anchor_token(T_PLUSPLUS);
        add_anchor_token(T_STRING_LITERAL);
-       add_anchor_token(T_WIDE_CHARACTER_CONSTANT);
-       add_anchor_token(T_WIDE_STRING_LITERAL);
+       add_anchor_token(T__Alignof);
        add_anchor_token(T__Bool);
        add_anchor_token(T__Complex);
        add_anchor_token(T__Imaginary);
-       add_anchor_token(T___FUNCTION__);
+       add_anchor_token(T__Thread_local);
        add_anchor_token(T___PRETTY_FUNCTION__);
-       add_anchor_token(T___alignof__);
        add_anchor_token(T___attribute__);
        add_anchor_token(T___builtin_va_start);
        add_anchor_token(T___extension__);
@@ -9824,7 +9833,6 @@ static statement_t *parse_compound_statement(bool inside_expression_statement)
        add_anchor_token(T___imag__);
        add_anchor_token(T___label__);
        add_anchor_token(T___real__);
-       add_anchor_token(T___thread);
        add_anchor_token(T_asm);
        add_anchor_token(T_auto);
        add_anchor_token(T_bool);
@@ -9972,7 +9980,6 @@ static statement_t *parse_compound_statement(bool inside_expression_statement)
        rem_anchor_token(T_bool);
        rem_anchor_token(T_auto);
        rem_anchor_token(T_asm);
-       rem_anchor_token(T___thread);
        rem_anchor_token(T___real__);
        rem_anchor_token(T___label__);
        rem_anchor_token(T___imag__);
@@ -9980,20 +9987,17 @@ static statement_t *parse_compound_statement(bool inside_expression_statement)
        rem_anchor_token(T___extension__);
        rem_anchor_token(T___builtin_va_start);
        rem_anchor_token(T___attribute__);
-       rem_anchor_token(T___alignof__);
        rem_anchor_token(T___PRETTY_FUNCTION__);
-       rem_anchor_token(T___FUNCTION__);
+       rem_anchor_token(T__Thread_local);
        rem_anchor_token(T__Imaginary);
        rem_anchor_token(T__Complex);
        rem_anchor_token(T__Bool);
-       rem_anchor_token(T_WIDE_STRING_LITERAL);
-       rem_anchor_token(T_WIDE_CHARACTER_CONSTANT);
+       rem_anchor_token(T__Alignof);
        rem_anchor_token(T_STRING_LITERAL);
        rem_anchor_token(T_PLUSPLUS);
+       rem_anchor_token(T_NUMBER);
        rem_anchor_token(T_MINUSMINUS);
-       rem_anchor_token(T_INTEGER);
        rem_anchor_token(T_IDENTIFIER);
-       rem_anchor_token(T_FLOATINGPOINT);
        rem_anchor_token(T_COLONCOLON);
        rem_anchor_token(T_CHARACTER_CONSTANT);
        rem_anchor_token('~');
@@ -10040,7 +10044,7 @@ static void check_unused_globals(void)
                                continue;
 
                        why = WARN_UNUSED_FUNCTION;
-                       s   = entity->function.statement != NULL ? "defined" : "declared";
+                       s   = entity->function.body != NULL ? "defined" : "declared";
                } else {
                        why = WARN_UNUSED_VARIABLE;
                        s   = "defined";
@@ -10061,7 +10065,7 @@ static void parse_global_asm(void)
        expect('(');
 
        rem_anchor_token(T_STRING_LITERAL);
-       statement->asms.asm_text = parse_string_literals();
+       statement->asms.asm_text = parse_string_literals("global asm");
        statement->base.next     = unit->global_asm;
        unit->global_asm         = statement;
 
@@ -10076,7 +10080,7 @@ static void parse_linkage_specification(void)
        eat(T_extern);
 
        source_position_t const pos     = *HERE;
-       char const       *const linkage = parse_string_literals().begin;
+       char const       *const linkage = parse_string_literals(NULL).begin;
 
        linkage_kind_t old_linkage = current_linkage;
        linkage_kind_t new_linkage;
@@ -10090,7 +10094,7 @@ static void parse_linkage_specification(void)
        }
        current_linkage = new_linkage;
 
-       if (next_if('{')) {
+       if (accept('{')) {
                parse_externals();
                expect('}');
        } else {
@@ -10214,9 +10218,6 @@ void start_parsing(void)
 {
        environment_stack = NEW_ARR_F(stack_entry_t, 0);
        label_stack       = NEW_ARR_F(stack_entry_t, 0);
-       diagnostic_count  = 0;
-       error_count       = 0;
-       warning_count     = 0;
 
        print_to_file(stderr);
 
@@ -10279,7 +10280,7 @@ static void complete_incomplete_arrays(void)
 
 static void prepare_main_collect2(entity_t *const entity)
 {
-       PUSH_SCOPE(&entity->function.statement->compound.scope);
+       PUSH_SCOPE(&entity->function.body->compound.scope);
 
        // create call to __main
        symbol_t *symbol         = symbol_table_insert("__main");
@@ -10301,9 +10302,9 @@ static void prepare_main_collect2(entity_t *const entity)
        expr_statement->base.source_position  = builtin_source_position;
        expr_statement->expression.expression = call;
 
-       statement_t *statement = entity->function.statement;
-       assert(statement->kind == STATEMENT_COMPOUND);
-       compound_statement_t *compounds = &statement->compound;
+       statement_t *const body = entity->function.body;
+       assert(body->kind == STATEMENT_COMPOUND);
+       compound_statement_t *compounds = &body->compound;
 
        expr_statement->base.next = compounds->statements;
        compounds->statements     = expr_statement;
@@ -10330,8 +10331,6 @@ void parse(void)
  */
 void init_parser(void)
 {
-       sym_anonymous = symbol_table_insert("<anonymous>");
-
        memset(token_anchor_set, 0, sizeof(token_anchor_set));
 
        init_expression_parsers();