cast enum expressions to enum type if needed
[cparser] / parser.c
index c1c3054..b85ac28 100644 (file)
--- a/parser.c
+++ b/parser.c
 #include "type_hash.h"
 #include "ast_t.h"
 #include "lang_features.h"
+#include "warning.h"
 #include "adt/bitfiddle.h"
 #include "adt/error.h"
 #include "adt/array.h"
 
 //#define PRINT_TOKENS
-//#define ABORT_ON_ERROR
 #define MAX_LOOKAHEAD 2
 
 typedef struct {
@@ -44,15 +44,17 @@ static token_t             lookahead_buffer[MAX_LOOKAHEAD];
 static int                 lookahead_bufpos;
 static stack_entry_t      *environment_stack = NULL;
 static stack_entry_t      *label_stack       = NULL;
-static context_t          *global_context    = NULL;
-static context_t          *context           = NULL;
+static scope_t            *global_scope      = NULL;
+static scope_t            *scope             = NULL;
 static declaration_t      *last_declaration  = NULL;
 static declaration_t      *current_function  = NULL;
 static switch_statement_t *current_switch    = NULL;
 static statement_t        *current_loop      = NULL;
 static goto_statement_t   *goto_first        = NULL;
 static goto_statement_t   *goto_last         = NULL;
-static struct obstack  temp_obst;
+static label_statement_t  *label_first       = NULL;
+static label_statement_t  *label_last        = NULL;
+static struct obstack      temp_obst;
 
 /** The current source position. */
 #define HERE token.source_position
@@ -66,7 +68,7 @@ static expression_t *parse_sub_expression(unsigned precedence);
 static expression_t *parse_expression(void);
 static type_t       *parse_typename(void);
 
-static void parse_compound_type_entries(void);
+static void parse_compound_type_entries(declaration_t *compound_declaration);
 static declaration_t *parse_declarator(
                const declaration_specifiers_t *specifiers, bool may_be_abstract);
 static declaration_t *record_declaration(declaration_t *declaration);
@@ -136,6 +138,13 @@ static void *allocate_ast_zero(size_t size)
        return res;
 }
 
+static declaration_t *allocate_declaration_zero(void)
+{
+       declaration_t *declaration = allocate_ast_zero(sizeof(declaration_t));
+       declaration->type = type_error_type;
+       return declaration;
+}
+
 /**
  * Returns the size of a statement node.
  *
@@ -189,15 +198,18 @@ static size_t get_expression_struct_size(expression_kind_t kind)
                [EXPR_INVALID]             = sizeof(expression_base_t),
                [EXPR_REFERENCE]           = sizeof(reference_expression_t),
                [EXPR_CONST]               = sizeof(const_expression_t),
+               [EXPR_CHAR_CONST]          = sizeof(const_expression_t),
                [EXPR_STRING_LITERAL]      = sizeof(string_literal_expression_t),
                [EXPR_WIDE_STRING_LITERAL] = sizeof(wide_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),
                [EXPR_BINARY_FIRST]        = sizeof(binary_expression_t),
                [EXPR_CONDITIONAL]         = sizeof(conditional_expression_t),
                [EXPR_SELECT]              = sizeof(select_expression_t),
                [EXPR_ARRAY_ACCESS]        = sizeof(array_access_expression_t),
-               [EXPR_SIZEOF]              = sizeof(sizeof_expression_t),
+               [EXPR_SIZEOF]              = sizeof(typeprop_expression_t),
+               [EXPR_ALIGNOF]             = sizeof(typeprop_expression_t),
                [EXPR_CLASSIFY_TYPE]       = sizeof(classify_type_expression_t),
                [EXPR_FUNCTION]            = sizeof(string_literal_expression_t),
                [EXPR_PRETTY_FUNCTION]     = sizeof(string_literal_expression_t),
@@ -230,6 +242,7 @@ static expression_t *allocate_expression_zero(expression_kind_t kind)
        expression_t *res  = allocate_ast_zero(size);
 
        res->base.kind = kind;
+       res->base.type = type_error_type;
        return res;
 }
 
@@ -263,13 +276,14 @@ static size_t get_type_struct_size(type_kind_t kind)
  * Allocate a type node of given kind and initialize all
  * fields with zero.
  */
-static type_t *allocate_type_zero(type_kind_t kind)
+static type_t *allocate_type_zero(type_kind_t kind, source_position_t source_position)
 {
        size_t  size = get_type_struct_size(kind);
        type_t *res  = obstack_alloc(type_obst, size);
        memset(res, 0, size);
 
-       res->base.kind = kind;
+       res->base.kind            = kind;
+       res->base.source_position = source_position;
        return res;
 }
 
@@ -284,7 +298,8 @@ static size_t get_initializer_size(initializer_kind_t kind)
                [INITIALIZER_VALUE]       = sizeof(initializer_value_t),
                [INITIALIZER_STRING]      = sizeof(initializer_string_t),
                [INITIALIZER_WIDE_STRING] = sizeof(initializer_wide_string_t),
-               [INITIALIZER_LIST]        = sizeof(initializer_list_t)
+               [INITIALIZER_LIST]        = sizeof(initializer_list_t),
+               [INITIALIZER_DESIGNATOR]  = sizeof(initializer_designator_t)
        };
        assert(kind < sizeof(sizes) / sizeof(*sizes));
        assert(sizes[kind] != 0);
@@ -367,7 +382,7 @@ static void parse_error_expected(const char *message, ...)
        }
        va_list ap;
        va_start(ap, message);
-       errorf(HERE, "got '%K', expected %#k", &token, &ap, ", ");
+       errorf(HERE, "got %K, expected %#k", &token, &ap, ", ");
        va_end(ap);
 }
 
@@ -456,39 +471,43 @@ static void eat_paren(void)
 }
 
 #define expect(expected)                           \
+       do {                                           \
     if(UNLIKELY(token.type != (expected))) {       \
         parse_error_expected(NULL, (expected), 0); \
         eat_statement();                           \
         return NULL;                               \
     }                                              \
-    next_token();
+    next_token();                                  \
+       } while(0)
 
 #define expect_block(expected)                     \
+       do {                                           \
     if(UNLIKELY(token.type != (expected))) {       \
         parse_error_expected(NULL, (expected), 0); \
         eat_block();                               \
         return NULL;                               \
     }                                              \
-    next_token();
+    next_token();                                  \
+       } while(0)
 
 #define expect_void(expected)                      \
+       do {                                           \
     if(UNLIKELY(token.type != (expected))) {       \
         parse_error_expected(NULL, (expected), 0); \
         eat_statement();                           \
         return;                                    \
     }                                              \
-    next_token();
+    next_token();                                  \
+    } while(0)
 
-static void set_context(context_t *new_context)
+static void set_scope(scope_t *new_scope)
 {
-       context = new_context;
-
-       last_declaration = new_context->declarations;
-       if(last_declaration != NULL) {
-               while(last_declaration->next != NULL) {
-                       last_declaration = last_declaration->next;
-               }
+       if(scope != NULL) {
+               scope->last_declaration = last_declaration;
        }
+       scope = new_scope;
+
+       last_declaration = new_scope->last_declaration;
 }
 
 /**
@@ -512,22 +531,15 @@ static declaration_t *get_declaration(const symbol_t *const symbol, const namesp
  */
 static void stack_push(stack_entry_t **stack_ptr, declaration_t *declaration)
 {
-       symbol_t    *symbol    = declaration->symbol;
-       namespace_t  namespc = (namespace_t)declaration->namespc;
-
-       /* remember old declaration */
-       stack_entry_t entry;
-       entry.symbol          = symbol;
-       entry.old_declaration = symbol->declaration;
-       entry.namespc         = (unsigned short) namespc;
-       ARR_APP1(stack_entry_t, *stack_ptr, entry);
+       symbol_t    *symbol  = declaration->symbol;
+       namespace_t  namespc = (namespace_t) declaration->namespc;
 
        /* replace/add declaration into declaration list of the symbol */
-       if(symbol->declaration == NULL) {
+       declaration_t *iter = symbol->declaration;
+       if (iter == NULL) {
                symbol->declaration = declaration;
        } else {
                declaration_t *iter_last = NULL;
-               declaration_t *iter      = symbol->declaration;
                for( ; iter != NULL; iter_last = iter, iter = iter->symbol_next) {
                        /* replace an entry? */
                        if(iter->namespc == namespc) {
@@ -545,18 +557,25 @@ static void stack_push(stack_entry_t **stack_ptr, declaration_t *declaration)
                        iter_last->symbol_next = declaration;
                }
        }
+
+       /* remember old declaration */
+       stack_entry_t entry;
+       entry.symbol          = symbol;
+       entry.old_declaration = iter;
+       entry.namespc         = (unsigned short) namespc;
+       ARR_APP1(stack_entry_t, *stack_ptr, entry);
 }
 
 static void environment_push(declaration_t *declaration)
 {
        assert(declaration->source_position.input_name != NULL);
-       assert(declaration->parent_context != NULL);
+       assert(declaration->parent_scope != NULL);
        stack_push(&environment_stack, declaration);
 }
 
 static void label_push(declaration_t *declaration)
 {
-       declaration->parent_context = &current_function->context;
+       declaration->parent_scope = &current_function->scope;
        stack_push(&label_stack, declaration);
 }
 
@@ -597,7 +616,9 @@ static void stack_pop_to(stack_entry_t **stack_ptr, size_t new_top)
                                if(iter->namespc == namespc) {
                                        assert(iter_last != NULL);
                                        iter_last->symbol_next = old_declaration;
-                                       old_declaration->symbol_next = iter->symbol_next;
+                                       if(old_declaration != NULL) {
+                                               old_declaration->symbol_next = iter->symbol_next;
+                                       }
                                        break;
                                }
                        }
@@ -631,15 +652,13 @@ static int get_rank(const type_t *type)
                return ATOMIC_TYPE_INT;
 
        assert(type->kind == TYPE_ATOMIC);
-       const atomic_type_t *atomic_type = &type->atomic;
-       atomic_type_kind_t   atype       = atomic_type->akind;
-       return atype;
+       return type->atomic.akind;
 }
 
 static type_t *promote_integer(type_t *type)
 {
        if(type->kind == TYPE_BITFIELD)
-               return promote_integer(type->bitfield.base);
+               type = type->bitfield.base;
 
        if(get_rank(type) < ATOMIC_TYPE_INT)
                type = type_int;
@@ -658,8 +677,8 @@ static expression_t *create_cast_expression(expression_t *expression,
 {
        expression_t *cast = allocate_expression_zero(EXPR_UNARY_CAST_IMPLICIT);
 
-       cast->unary.value   = expression;
-       cast->base.datatype = dest_type;
+       cast->unary.value = expression;
+       cast->base.type   = dest_type;
 
        return cast;
 }
@@ -680,7 +699,7 @@ static bool is_null_pointer_constant(const expression_t *expression)
        if (expression->kind != EXPR_CONST)
                return false;
 
-       type_t *const type = skip_typeref(expression->base.datatype);
+       type_t *const type = skip_typeref(expression->base.type);
        if (!is_type_integer(type))
                return false;
 
@@ -696,134 +715,75 @@ static bool is_null_pointer_constant(const expression_t *expression)
 static expression_t *create_implicit_cast(expression_t *expression,
                                           type_t *dest_type)
 {
-       type_t *source_type = expression->base.datatype;
-
-       if(source_type == NULL)
-               return expression;
-
-       source_type = skip_typeref(source_type);
-       dest_type   = skip_typeref(dest_type);
+       type_t *const source_type = expression->base.type;
 
-       if(source_type == dest_type)
+       if (source_type == dest_type)
                return expression;
 
-       switch (dest_type->kind) {
-               case TYPE_ENUM:
-                       /* TODO warning for implicitly converting to enum */
-               case TYPE_BITFIELD:
-               case TYPE_ATOMIC:
-                       if (source_type->kind != TYPE_ATOMIC &&
-                                       source_type->kind != TYPE_ENUM &&
-                                       source_type->kind != TYPE_BITFIELD) {
-                               panic("casting of non-atomic types not implemented yet");
-                       }
-
-                       if(is_type_floating(dest_type) && !is_type_scalar(source_type)) {
-                               type_error_incompatible("can't cast types",
-                                               expression->base.source_position, source_type,
-                                               dest_type);
-                               return expression;
-                       }
-
-                       return create_cast_expression(expression, dest_type);
-
-               case TYPE_POINTER:
-                       switch (source_type->kind) {
-                               case TYPE_ATOMIC:
-                                       if (is_null_pointer_constant(expression)) {
-                                               return create_cast_expression(expression, dest_type);
-                                       }
-                                       break;
-
-                               case TYPE_POINTER:
-                                       if (pointers_compatible(source_type, dest_type)) {
-                                               return create_cast_expression(expression, dest_type);
-                                       }
-                                       break;
-
-                               case TYPE_ARRAY: {
-                                       array_type_t   *array_type   = &source_type->array;
-                                       pointer_type_t *pointer_type = &dest_type->pointer;
-                                       if (types_compatible(array_type->element_type,
-                                                                                pointer_type->points_to)) {
-                                               return create_cast_expression(expression, dest_type);
-                                       }
-                                       break;
-                               }
-
-                               default:
-                                       panic("casting of non-atomic types not implemented yet");
-                       }
-
-                       type_error_incompatible("can't implicitly cast types",
-                                       expression->base.source_position, source_type, dest_type);
-                       return expression;
-
-               default:
-                       panic("casting of non-atomic types not implemented yet");
-       }
+       return create_cast_expression(expression, dest_type);
 }
 
 /** Implements the rules from ยง 6.5.16.1 */
-static void semantic_assign(type_t *orig_type_left, expression_t **right,
+static type_t *semantic_assign(type_t *orig_type_left,
+                            const expression_t *const right,
                             const char *context)
 {
-       type_t *orig_type_right = (*right)->base.datatype;
-
-       if(orig_type_right == NULL)
-               return;
-
-       type_t *const type_left  = skip_typeref(orig_type_left);
-       type_t *const type_right = skip_typeref(orig_type_right);
+       type_t *const orig_type_right = right->base.type;
+       type_t *const type_left       = skip_typeref(orig_type_left);
+       type_t *const type_right      = skip_typeref(orig_type_right);
 
        if ((is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) ||
-           (is_type_pointer(type_left) && is_null_pointer_constant(*right)) ||
+           (is_type_pointer(type_left) && is_null_pointer_constant(right)) ||
            (is_type_atomic(type_left, ATOMIC_TYPE_BOOL)
                && is_type_pointer(type_right))) {
-               *right = create_implicit_cast(*right, type_left);
-               return;
+               return orig_type_left;
        }
 
        if (is_type_pointer(type_left) && is_type_pointer(type_right)) {
-               pointer_type_t *pointer_type_left  = &type_left->pointer;
-               pointer_type_t *pointer_type_right = &type_right->pointer;
-               type_t         *points_to_left     = pointer_type_left->points_to;
-               type_t         *points_to_right    = pointer_type_right->points_to;
-
-               points_to_left  = skip_typeref(points_to_left);
-               points_to_right = skip_typeref(points_to_right);
+               type_t *points_to_left  = skip_typeref(type_left->pointer.points_to);
+               type_t *points_to_right = skip_typeref(type_right->pointer.points_to);
 
                /* the left type has all qualifiers from the right type */
                unsigned missing_qualifiers
                        = points_to_right->base.qualifiers & ~points_to_left->base.qualifiers;
                if(missing_qualifiers != 0) {
                        errorf(HERE, "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointed-to type", type_left, context, type_right, missing_qualifiers);
-                       return;
+                       return orig_type_left;
                }
 
                points_to_left  = get_unqualified_type(points_to_left);
                points_to_right = get_unqualified_type(points_to_right);
 
-               if(!is_type_atomic(points_to_left, ATOMIC_TYPE_VOID)
-                               && !is_type_atomic(points_to_right, ATOMIC_TYPE_VOID)
-                               && !types_compatible(points_to_left, points_to_right)) {
-                       goto incompatible_assign_types;
+               if (is_type_atomic(points_to_left, ATOMIC_TYPE_VOID) ||
+                               is_type_atomic(points_to_right, ATOMIC_TYPE_VOID)) {
+                       return orig_type_left;
                }
 
-               *right = create_implicit_cast(*right, type_left);
-               return;
+               if (!types_compatible(points_to_left, points_to_right)) {
+                       warningf(right->base.source_position,
+                               "destination type '%T' in %s is incompatible with '%E' of type '%T'",
+                               orig_type_left, context, right, orig_type_right);
+               }
+
+               return orig_type_left;
        }
 
-       if (is_type_compound(type_left)
-                       && types_compatible(type_left, type_right)) {
-               *right = create_implicit_cast(*right, type_left);
-               return;
+       if ((is_type_compound(type_left)  && is_type_compound(type_right))
+                       || (is_type_builtin(type_left) && is_type_builtin(type_right))) {
+               type_t *const unqual_type_left  = get_unqualified_type(type_left);
+               type_t *const unqual_type_right = get_unqualified_type(type_right);
+               if (types_compatible(unqual_type_left, unqual_type_right)) {
+                       return orig_type_left;
+               }
        }
 
-incompatible_assign_types:
-       /* TODO: improve error message */
-       errorf(HERE, "incompatible types in %s", context);
-       errorf(HERE, "'%T' <- '%T'", orig_type_left, orig_type_right);
+       if (!is_type_valid(type_left))
+               return type_left;
+
+       if (!is_type_valid(type_right))
+               return orig_type_right;
+
+       return NULL;
 }
 
 static expression_t *parse_constant_expression(void)
@@ -848,7 +808,7 @@ static type_t *make_global_typedef(const char *name, type_t *type)
 {
        symbol_t *const symbol       = symbol_table_insert(name);
 
-       declaration_t *declaration   = allocate_ast_zero(sizeof(declaration[0]));
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->namespc         = NAMESPACE_NORMAL;
        declaration->storage_class   = STORAGE_CLASS_TYPEDEF;
        declaration->type            = type;
@@ -857,21 +817,21 @@ static type_t *make_global_typedef(const char *name, type_t *type)
 
        record_declaration(declaration);
 
-       type_t *typedef_type               = allocate_type_zero(TYPE_TYPEDEF);
+       type_t *typedef_type               = allocate_type_zero(TYPE_TYPEDEF, builtin_source_position);
        typedef_type->typedeft.declaration = declaration;
 
        return typedef_type;
 }
 
-static const char *parse_string_literals(void)
+static string_t parse_string_literals(void)
 {
        assert(token.type == T_STRING_LITERAL);
-       const char *result = token.v.string;
+       string_t result = token.v.string;
 
        next_token();
 
-       while(token.type == T_STRING_LITERAL) {
-               result = concat_strings(result, token.v.string);
+       while (token.type == T_STRING_LITERAL) {
+               result = concat_strings(&result, &token.v.string);
                next_token();
        }
 
@@ -928,26 +888,24 @@ attributes_finished:
        ;
 }
 
-#if 0
 static designator_t *parse_designation(void)
 {
-       if(token.type != '[' && token.type != '.')
-               return NULL;
-
        designator_t *result = NULL;
        designator_t *last   = NULL;
 
-       while(1) {
+       while(true) {
                designator_t *designator;
                switch(token.type) {
                case '[':
                        designator = allocate_ast_zero(sizeof(designator[0]));
+                       designator->source_position = token.source_position;
                        next_token();
-                       designator->array_access = parse_constant_expression();
+                       designator->array_index = parse_constant_expression();
                        expect(']');
                        break;
                case '.':
                        designator = allocate_ast_zero(sizeof(designator[0]));
+                       designator->source_position = token.source_position;
                        next_token();
                        if(token.type != T_IDENTIFIER) {
                                parse_error_expected("while parsing designator",
@@ -971,16 +929,15 @@ static designator_t *parse_designation(void)
                last = designator;
        }
 }
-#endif
 
 static initializer_t *initializer_from_string(array_type_t *type,
-                                              const char *string)
+                                              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;
+       initializer->string.string = *string;
 
        return initializer;
 }
@@ -998,23 +955,28 @@ static initializer_t *initializer_from_wide_string(array_type_t *const type,
        return initializer;
 }
 
-static initializer_t *initializer_from_expression(type_t *type,
+static initializer_t *initializer_from_expression(type_t *orig_type,
                                                   expression_t *expression)
 {
        /* TODO check that expression is a constant expression */
 
        /* ยง 6.7.8.14/15 char array may be initialized by string literals */
-       type_t *const expr_type = expression->base.datatype;
+       type_t *type           = skip_typeref(orig_type);
+       type_t *expr_type_orig = expression->base.type;
+       type_t *expr_type      = skip_typeref(expr_type_orig);
        if (is_type_array(type) && expr_type->kind == TYPE_POINTER) {
                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 (element_type->atomic.akind == ATOMIC_TYPE_CHAR) {
+                                       if (akind == ATOMIC_TYPE_CHAR
+                                                       || akind == ATOMIC_TYPE_SCHAR
+                                                       || akind == ATOMIC_TYPE_UCHAR) {
                                                return initializer_from_string(array_type,
-                                                       expression->string.value);
+                                                       &expression->string.value);
                                        }
 
                                case EXPR_WIDE_STRING_LITERAL: {
@@ -1031,255 +993,484 @@ static initializer_t *initializer_from_expression(type_t *type,
                }
        }
 
-       type_t *expression_type = skip_typeref(expression->base.datatype);
-       if(is_type_scalar(type) || types_compatible(type, expression_type)) {
-               semantic_assign(type, &expression, "initializer");
+       type_t *const res_type = semantic_assign(type, expression, "initializer");
+       if (res_type == NULL)
+               return NULL;
 
-               initializer_t *result = allocate_initializer_zero(INITIALIZER_VALUE);
-               result->value.value   = expression;
+       initializer_t *const result = allocate_initializer_zero(INITIALIZER_VALUE);
+       result->value.value = create_implicit_cast(expression, res_type);
 
-               return result;
+       return result;
+}
+
+static initializer_t *parse_scalar_initializer(type_t *type)
+{
+       /* there might be extra {} hierarchies */
+       int braces = 0;
+       while(token.type == '{') {
+               next_token();
+               if(braces == 0) {
+                       warningf(HERE, "extra curly braces around scalar initializer");
+               }
+               braces++;
        }
 
-       return NULL;
+       expression_t  *expression  = parse_assignment_expression();
+       initializer_t *initializer = initializer_from_expression(type, expression);
+
+       if(initializer == NULL) {
+               errorf(expression->base.source_position,
+                      "expression '%E' doesn't match expected type '%T'",
+                      expression, type);
+               /* TODO */
+               return NULL;
+       }
+
+       bool additional_warning_displayed = false;
+       while(braces > 0) {
+               if(token.type == ',') {
+                       next_token();
+               }
+               if(token.type != '}') {
+                       if(!additional_warning_displayed) {
+                               warningf(HERE, "additional elements in scalar initializer");
+                               additional_warning_displayed = true;
+                       }
+               }
+               eat_block();
+               braces--;
+       }
+
+       return initializer;
 }
 
-static initializer_t *parse_sub_initializer(type_t *type,
-                                            expression_t *expression,
-                                            type_t *expression_type);
+typedef struct type_path_entry_t type_path_entry_t;
+struct type_path_entry_t {
+       type_t *type;
+       union {
+               size_t         index;
+               declaration_t *compound_entry;
+       } v;
+};
+
+typedef struct type_path_t type_path_t;
+struct type_path_t {
+       type_path_entry_t *path;
+       type_t            *top_type;
+       bool               invalid;
+};
 
-static initializer_t *parse_sub_initializer_elem(type_t *type)
+static __attribute__((unused)) void debug_print_type_path(const type_path_t *path)
 {
-       if(token.type == '{') {
-               return parse_sub_initializer(type, NULL, NULL);
+       size_t len = ARR_LEN(path->path);
+
+       if(path->invalid) {
+               fprintf(stderr, "invalid path");
+               return;
        }
 
-       expression_t *expression      = parse_assignment_expression();
-       type_t       *expression_type = skip_typeref(expression->base.datatype);
+       for(size_t i = 0; i < len; ++i) {
+               const type_path_entry_t *entry = & path->path[i];
 
-       return parse_sub_initializer(type, expression, expression_type);
+               type_t *type = skip_typeref(entry->type);
+               if(is_type_compound(type)) {
+                       fprintf(stderr, ".%s", entry->v.compound_entry->symbol->string);
+               } else if(is_type_array(type)) {
+                       fprintf(stderr, "[%u]", entry->v.index);
+               } else {
+                       fprintf(stderr, "-INVALID-");
+               }
+       }
+       fprintf(stderr, "  (");
+       print_type(path->top_type);
+       fprintf(stderr, ")");
 }
 
-static bool had_initializer_brace_warning;
+static type_path_entry_t *get_type_path_top(const type_path_t *path)
+{
+       size_t len = ARR_LEN(path->path);
+       assert(len > 0);
+       return & path->path[len-1];
+}
 
-static void skip_designator(void)
+static type_path_entry_t *append_to_type_path(type_path_t *path)
 {
-       while(1) {
-               if(token.type == '.') {
-                       next_token();
-                       if(token.type == T_IDENTIFIER)
-                               next_token();
-               } else if(token.type == '[') {
-                       next_token();
-                       parse_constant_expression();
-                       if(token.type == ']')
-                               next_token();
-               } else {
-                       break;
-               }
+       size_t len = ARR_LEN(path->path);
+       ARR_RESIZE(type_path_entry_t, path->path, len+1);
+
+       type_path_entry_t *result = & path->path[len];
+       memset(result, 0, sizeof(result[0]));
+       return result;
+}
+
+static void descend_into_subtype(type_path_t *path)
+{
+       type_t *orig_top_type = path->top_type;
+       type_t *top_type      = skip_typeref(orig_top_type);
+
+       assert(is_type_compound(top_type) || is_type_array(top_type));
+
+       type_path_entry_t *top = append_to_type_path(path);
+       top->type              = top_type;
+
+       if(is_type_compound(top_type)) {
+               declaration_t *declaration = top_type->compound.declaration;
+               declaration_t *entry       = declaration->scope.declarations;
+
+               top->v.compound_entry = entry;
+               path->top_type        = entry->type;
+       } else {
+               assert(is_type_array(top_type));
+
+               top->v.index   = 0;
+               path->top_type = top_type->array.element_type;
        }
 }
 
-static initializer_t *parse_sub_initializer(type_t *type,
-                                            expression_t *expression,
-                                            type_t *expression_type)
+static void ascend_from_subtype(type_path_t *path)
 {
-       if(is_type_scalar(type)) {
-               /* there might be extra {} hierarchies */
-               if(token.type == '{') {
-                       next_token();
-                       if(!had_initializer_brace_warning) {
-                               warningf(HERE, "braces around scalar initializer");
-                               had_initializer_brace_warning = true;
+       type_path_entry_t *top = get_type_path_top(path);
+
+       path->top_type = top->type;
+
+       size_t len = ARR_LEN(path->path);
+       ARR_RESIZE(type_path_entry_t, path->path, len-1);
+}
+
+static void ascend_to(type_path_t *path, size_t top_path_level)
+{
+       size_t len = ARR_LEN(path->path);
+       assert(len >= top_path_level);
+
+       while(len > top_path_level) {
+               ascend_from_subtype(path);
+               len = ARR_LEN(path->path);
+       }
+}
+
+static bool walk_designator(type_path_t *path, const designator_t *designator,
+                            bool used_in_offsetof)
+{
+       for( ; designator != NULL; designator = designator->next) {
+               type_path_entry_t *top       = get_type_path_top(path);
+               type_t            *orig_type = top->type;
+
+               type_t *type = skip_typeref(orig_type);
+
+               if(designator->symbol != NULL) {
+                       symbol_t *symbol = designator->symbol;
+                       if(!is_type_compound(type)) {
+                               if(is_type_valid(type)) {
+                                       errorf(designator->source_position,
+                                              "'.%Y' designator used for non-compound type '%T'",
+                                              symbol, orig_type);
+                               }
+                               goto failed;
                        }
-                       initializer_t *result = parse_sub_initializer(type, NULL, NULL);
-                       if(token.type == ',') {
-                               next_token();
-                               /* TODO: warn about excessive elements */
+
+                       declaration_t *declaration = type->compound.declaration;
+                       declaration_t *iter        = declaration->scope.declarations;
+                       for( ; iter != NULL; iter = iter->next) {
+                               if(iter->symbol == symbol) {
+                                       break;
+                               }
                        }
-                       expect_block('}');
-                       return result;
+                       if(iter == NULL) {
+                               errorf(designator->source_position,
+                                      "'%T' has no member named '%Y'", orig_type, symbol);
+                               goto failed;
+                       }
+                       if(used_in_offsetof) {
+                               type_t *real_type = skip_typeref(iter->type);
+                               if(real_type->kind == TYPE_BITFIELD) {
+                                       errorf(designator->source_position,
+                                              "offsetof designator '%Y' may not specify bitfield",
+                                              symbol);
+                                       goto failed;
+                               }
+                       }
+
+                       top->type             = orig_type;
+                       top->v.compound_entry = iter;
+                       orig_type             = iter->type;
+               } else {
+                       expression_t *array_index = designator->array_index;
+                       assert(designator->array_index != NULL);
+
+                       if(!is_type_array(type)) {
+                               if(is_type_valid(type)) {
+                                       errorf(designator->source_position,
+                                              "[%E] designator used for non-array type '%T'",
+                                              array_index, orig_type);
+                               }
+                               goto failed;
+                       }
+                       if(!is_type_valid(array_index->base.type)) {
+                               goto failed;
+                       }
+
+                       long index = fold_constant(array_index);
+                       if(!used_in_offsetof) {
+                               if(index < 0) {
+                                       errorf(designator->source_position,
+                                              "array index [%E] must be positive", array_index);
+                                       goto failed;
+                               }
+                               if(type->array.size_constant == true) {
+                                       long array_size = type->array.size;
+                                       if(index >= array_size) {
+                                               errorf(designator->source_position,
+                                                               "designator [%E] (%d) exceeds array size %d",
+                                                               array_index, index, array_size);
+                                               goto failed;
+                                       }
+                               }
+                       }
+
+                       top->type    = orig_type;
+                       top->v.index = (size_t) index;
+                       orig_type    = type->array.element_type;
                }
+               path->top_type = orig_type;
 
-               if(expression == NULL) {
-                       expression = parse_assignment_expression();
+               if(designator->next != NULL) {
+                       descend_into_subtype(path);
                }
-               return initializer_from_expression(type, expression);
        }
 
-       /* does the expression match the currently looked at object to initialize */
-       if(expression != NULL) {
-               initializer_t *result = initializer_from_expression(type, expression);
-               if(result != NULL)
-                       return result;
-       }
+       path->invalid  = false;
+       return true;
 
-       bool read_paren = false;
-       if(token.type == '{') {
-               next_token();
-               read_paren = true;
-       }
+failed:
+       return false;
+}
 
-       /* descend into subtype */
-       initializer_t  *result = NULL;
-       initializer_t **elems;
-       if(is_type_array(type)) {
-               array_type_t *array_type   = &type->array;
-               type_t       *element_type = array_type->element_type;
-               element_type               = skip_typeref(element_type);
+static void advance_current_object(type_path_t *path, size_t top_path_level)
+{
+       if(path->invalid)
+               return;
 
-               if(token.type == '.') {
-                       errorf(HERE,
-                              "compound designator in initializer for array type '%T'",
-                              type);
-                       skip_designator();
+       type_path_entry_t *top = get_type_path_top(path);
+
+       type_t *type = skip_typeref(top->type);
+       if(is_type_union(type)) {
+               /* in unions only the first element is initialized */
+               top->v.compound_entry = NULL;
+       } else if(is_type_struct(type)) {
+               declaration_t *entry = top->v.compound_entry;
+
+               entry                 = entry->next;
+               top->v.compound_entry = entry;
+               if(entry != NULL) {
+                       path->top_type = entry->type;
+                       return;
                }
+       } else {
+               assert(is_type_array(type));
 
-               initializer_t *sub;
-               had_initializer_brace_warning = false;
-               if(expression == NULL) {
-                       sub = parse_sub_initializer_elem(element_type);
-               } else {
-                       sub = parse_sub_initializer(element_type, expression,
-                                                   expression_type);
+               top->v.index++;
+
+               if(!type->array.size_constant || top->v.index < type->array.size) {
+                       return;
                }
+       }
+
+       /* we're past the last member of the current sub-aggregate, try if we
+        * can ascend in the type hierarchy and continue with another subobject */
+       size_t len = ARR_LEN(path->path);
+
+       if(len > top_path_level) {
+               ascend_from_subtype(path);
+               advance_current_object(path, top_path_level);
+       } else {
+               path->invalid = true;
+       }
+}
 
-               /* didn't match the subtypes -> try the parent type */
-               if(sub == NULL) {
-                       assert(!read_paren);
-                       return NULL;
+static void skip_initializers(void)
+{
+       if(token.type == '{')
+               next_token();
+
+       while(token.type != '}') {
+               if(token.type == T_EOF)
+                       return;
+               if(token.type == '{') {
+                       eat_block();
+                       continue;
                }
+               next_token();
+       }
+}
 
-               elems = NEW_ARR_F(initializer_t*, 0);
-               ARR_APP1(initializer_t*, elems, sub);
+static initializer_t *parse_sub_initializer(type_path_t *path,
+               type_t *outer_type, size_t top_path_level)
+{
+       type_t *orig_type = path->top_type;
+       type_t *type      = skip_typeref(orig_type);
 
-               while(true) {
-                       if(token.type == '}')
-                               break;
-                       expect_block(',');
-                       if(token.type == '}')
-                               break;
+       /* we can't do usefull stuff if we didn't even parse the type. Skip the
+        * initializers in this case. */
+       if(!is_type_valid(type)) {
+               skip_initializers();
+               return NULL;
+       }
 
-                       sub = parse_sub_initializer_elem(element_type);
-                       if(sub == NULL) {
-                               /* TODO error, do nicer cleanup */
-                               errorf(HERE, "member initializer didn't match");
-                               DEL_ARR_F(elems);
-                               return NULL;
+       initializer_t **initializers = NEW_ARR_F(initializer_t*, 0);
+
+       while(true) {
+               designator_t *designator = NULL;
+               if(token.type == '.' || token.type == '[') {
+                       designator = parse_designation();
+
+                       /* reset path to toplevel, evaluate designator from there */
+                       ascend_to(path, top_path_level);
+                       if(!walk_designator(path, designator, false)) {
+                               /* can't continue after designation error */
+                               goto end_error;
                        }
-                       ARR_APP1(initializer_t*, elems, sub);
-               }
-       } else {
-               assert(is_type_compound(type));
-               compound_type_t *compound_type = &type->compound;
-               context_t       *context       = &compound_type->declaration->context;
 
-               if(token.type == '[') {
-                       errorf(HERE,
-                              "array designator in initializer for compound type '%T'",
-                              type);
-                       skip_designator();
+                       initializer_t *designator_initializer
+                               = allocate_initializer_zero(INITIALIZER_DESIGNATOR);
+                       designator_initializer->designator.designator = designator;
+                       ARR_APP1(initializer_t*, initializers, designator_initializer);
                }
 
-               declaration_t *first = context->declarations;
-               if(first == NULL)
-                       return NULL;
-               type_t *first_type = first->type;
-               first_type         = skip_typeref(first_type);
-
                initializer_t *sub;
-               had_initializer_brace_warning = false;
-               if(expression == NULL) {
-                       sub = parse_sub_initializer_elem(first_type);
-               } else {
-                       sub = parse_sub_initializer(first_type, expression,expression_type);
-               }
 
-               /* didn't match the subtypes -> try our parent type */
-               if(sub == NULL) {
-                       assert(!read_paren);
-                       return NULL;
-               }
+               if(token.type == '{') {
+                       if(is_type_scalar(type)) {
+                               sub = parse_scalar_initializer(type);
+                       } else {
+                               eat('{');
+                               descend_into_subtype(path);
 
-               elems = NEW_ARR_F(initializer_t*, 0);
-               ARR_APP1(initializer_t*, elems, sub);
+                               sub = parse_sub_initializer(path, orig_type, top_path_level+1);
 
-               declaration_t *iter  = first->next;
-               for( ; iter != NULL; iter = iter->next) {
-                       if(iter->symbol == NULL)
-                               continue;
-                       if(iter->namespc != NAMESPACE_NORMAL)
-                               continue;
+                               ascend_from_subtype(path);
 
-                       if(token.type == '}')
-                               break;
-                       expect_block(',');
-                       if(token.type == '}')
-                               break;
+                               expect_block('}');
+                       }
+               } else {
+                       /* must be an expression */
+                       expression_t *expression = parse_assignment_expression();
+
+                       /* 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) {
+                                       if(token.type == ',') {
+                                               next_token();
+                                       }
+                                       if(token.type != '}') {
+                                               warningf(HERE, "excessive elements in initializer for type '%T'",
+                                                                orig_type);
+                                       }
+                                       /* TODO: eat , ... */
+                                       return sub;
+                               }
+                       }
 
-                       type_t *iter_type = iter->type;
-                       iter_type         = skip_typeref(iter_type);
+                       /* descend into subtypes until expression matches type */
+                       while(true) {
+                               orig_type = path->top_type;
+                               type      = skip_typeref(orig_type);
 
-                       sub = parse_sub_initializer_elem(iter_type);
-                       if(sub == NULL) {
-                               /* TODO error, do nicer cleanup */
-                               errorf(HERE, "member initializer didn't match");
-                               DEL_ARR_F(elems);
-                               return NULL;
+                               sub = initializer_from_expression(orig_type, expression);
+                               if(sub != NULL) {
+                                       break;
+                               }
+                               if(!is_type_valid(type)) {
+                                       goto end_error;
+                               }
+                               if(is_type_scalar(type)) {
+                                       errorf(expression->base.source_position,
+                                                       "expression '%E' doesn't match expected type '%T'",
+                                                       expression, orig_type);
+                                       goto end_error;
+                               }
+
+                               descend_into_subtype(path);
                        }
-                       ARR_APP1(initializer_t*, elems, sub);
                }
-       }
+               ARR_APP1(initializer_t*, initializers, sub);
 
-       int    len        = ARR_LEN(elems);
-       size_t elems_size = sizeof(initializer_t*) * len;
+               if(token.type == '}') {
+                       break;
+               }
+               expect(',');
+               if(token.type == '}') {
+                       break;
+               }
+               advance_current_object(path, top_path_level);
+       }
 
-       initializer_list_t *init = allocate_ast_zero(sizeof(init[0]) + elems_size);
+       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;
+       memcpy(&result->list.initializers, initializers,
+              len * sizeof(initializers[0]));
 
-       init->initializer.kind = INITIALIZER_LIST;
-       init->len              = len;
-       memcpy(init->initializers, elems, elems_size);
-       DEL_ARR_F(elems);
+       ascend_to(path, top_path_level);
 
-       result = (initializer_t*) init;
+       /* TODO: if(is_global && !is_constant(...)) { error } */
 
-       if(read_paren) {
-               if(token.type == ',')
-                       next_token();
-               expect('}');
-       }
        return result;
+
+end_error:
+       skip_initializers();
+       DEL_ARR_F(initializers);
+       ascend_to(path, top_path_level);
+       return NULL;
 }
 
-static initializer_t *parse_initializer(type_t *type)
+static initializer_t *parse_initializer(type_t *const orig_type)
 {
        initializer_t *result;
 
-       type = skip_typeref(type);
+       type_t *const type = skip_typeref(orig_type);
 
        if(token.type != '{') {
                expression_t  *expression  = parse_assignment_expression();
                initializer_t *initializer = initializer_from_expression(type, expression);
                if(initializer == NULL) {
-                       errorf(HERE, "initializer expression '%E', type '%T' is incompatible with type '%T'", expression, expression->base.datatype, type);
+                       errorf(HERE,
+                               "initializer expression '%E' of type '%T' is incompatible with type '%T'",
+                               expression, expression->base.type, orig_type);
                }
                return initializer;
        }
 
        if(is_type_scalar(type)) {
-               /* ยง 6.7.8.11 */
-               eat('{');
+               /* TODO: ยง 6.7.8.11; eat {} without warning */
 
-               expression_t *expression = parse_assignment_expression();
-               result = initializer_from_expression(type, expression);
+               result = parse_scalar_initializer(type);
 
                if(token.type == ',')
                        next_token();
 
-               expect('}');
                return result;
+       } else if(token.type == '{') {
+               next_token();
+
+               type_path_t path;
+               memset(&path, 0, sizeof(path));
+               path.top_type = orig_type;
+               path.path     = NEW_ARR_F(type_path_entry_t, 0);
+
+               descend_into_subtype(&path);
+
+               result = parse_sub_initializer(&path, orig_type, 1);
+
+               DEL_ARR_F(path.path);
+
+               expect('}');
        } else {
-               result = parse_sub_initializer(type, NULL, NULL);
+               /* TODO ... */
        }
 
        return result;
@@ -1325,16 +1516,12 @@ static declaration_t *parse_compound_type_specifier(bool is_struct)
        }
 
        if(declaration == NULL) {
-               declaration = allocate_ast_zero(sizeof(declaration[0]));
-
-               if(is_struct) {
-                       declaration->namespc = NAMESPACE_STRUCT;
-               } else {
-                       declaration->namespc = NAMESPACE_UNION;
-               }
+               declaration = allocate_declaration_zero();
+               declaration->namespc         =
+                       (is_struct ? NAMESPACE_STRUCT : NAMESPACE_UNION);
                declaration->source_position = token.source_position;
                declaration->symbol          = symbol;
-               declaration->parent_context  = context;
+               declaration->parent_scope  = scope;
                if (symbol != NULL) {
                        environment_push(declaration);
                }
@@ -1344,28 +1531,20 @@ static declaration_t *parse_compound_type_specifier(bool is_struct)
        if(token.type == '{') {
                if(declaration->init.is_defined) {
                        assert(symbol != NULL);
-                       errorf(HERE, "multiple definition of '%s %Y'",
+                       errorf(HERE, "multiple definitions of '%s %Y'",
                               is_struct ? "struct" : "union", symbol);
-                       declaration->context.declarations = NULL;
+                       declaration->scope.declarations = NULL;
                }
                declaration->init.is_defined = true;
 
-               int         top          = environment_top();
-               context_t  *last_context = context;
-               set_context(&declaration->context);
-
-               parse_compound_type_entries();
+               parse_compound_type_entries(declaration);
                parse_attributes();
-
-               assert(context == &declaration->context);
-               set_context(last_context);
-               environment_pop_to(top);
        }
 
        return declaration;
 }
 
-static void parse_enum_entries(enum_type_t *const enum_type)
+static void parse_enum_entries(type_t *const enum_type)
 {
        eat('{');
 
@@ -1376,22 +1555,25 @@ static void parse_enum_entries(enum_type_t *const enum_type)
        }
 
        do {
-               declaration_t *entry = allocate_ast_zero(sizeof(entry[0]));
-
                if(token.type != T_IDENTIFIER) {
                        parse_error_expected("while parsing enum entry", T_IDENTIFIER, 0);
                        eat_block();
                        return;
                }
+
+               declaration_t *const entry = allocate_declaration_zero();
                entry->storage_class   = STORAGE_CLASS_ENUM_ENTRY;
-               entry->type            = (type_t*) enum_type;
+               entry->type            = enum_type;
                entry->symbol          = token.v.symbol;
                entry->source_position = token.source_position;
                next_token();
 
                if(token.type == '=') {
                        next_token();
-                       entry->init.enum_value = parse_constant_expression();
+                       expression_t *value = parse_constant_expression();
+
+                       value = create_implicit_cast(value, enum_type);
+                       entry->init.enum_value = value;
 
                        /* TODO semantic */
                }
@@ -1428,15 +1610,14 @@ static type_t *parse_enum_specifier(void)
        }
 
        if(declaration == NULL) {
-               declaration = allocate_ast_zero(sizeof(declaration[0]));
-
-               declaration->namespc       = NAMESPACE_ENUM;
+               declaration = allocate_declaration_zero();
+               declaration->namespc         = NAMESPACE_ENUM;
                declaration->source_position = token.source_position;
                declaration->symbol          = symbol;
-               declaration->parent_context  = context;
+               declaration->parent_scope  = scope;
        }
 
-       type_t *const type      = allocate_type_zero(TYPE_ENUM);
+       type_t *const type      = allocate_type_zero(TYPE_ENUM, declaration->source_position);
        type->enumt.declaration = declaration;
 
        if(token.type == '{') {
@@ -1449,7 +1630,7 @@ static type_t *parse_enum_specifier(void)
                append_declaration(declaration);
                declaration->init.is_defined = 1;
 
-               parse_enum_entries(&type->enumt);
+               parse_enum_entries(type);
                parse_attributes();
        }
 
@@ -1493,7 +1674,7 @@ restart:
                        type = parse_typename();
                } else {
                        expression = parse_expression();
-                       type       = expression->base.datatype;
+                       type       = expression->base.type;
                }
                break;
 
@@ -1503,13 +1684,13 @@ restart:
 
        default:
                expression = parse_expression();
-               type       = expression->base.datatype;
+               type       = expression->base.type;
                break;
        }
 
        expect(')');
 
-       type_t *typeof_type              = allocate_type_zero(TYPE_TYPEOF);
+       type_t *typeof_type              = allocate_type_zero(TYPE_TYPEOF, expression->base.source_position);
        typeof_type->typeoft.expression  = expression;
        typeof_type->typeoft.typeof_type = type;
 
@@ -1537,7 +1718,7 @@ typedef enum {
 static type_t *create_builtin_type(symbol_t *const symbol,
                                    type_t *const real_type)
 {
-       type_t *type            = allocate_type_zero(TYPE_BUILTIN);
+       type_t *type            = allocate_type_zero(TYPE_BUILTIN, builtin_source_position);
        type->builtin.symbol    = symbol;
        type->builtin.real_type = real_type;
 
@@ -1556,7 +1737,7 @@ static type_t *get_typedef_type(symbol_t *symbol)
                        || declaration->storage_class != STORAGE_CLASS_TYPEDEF)
                return NULL;
 
-       type_t *type               = allocate_type_zero(TYPE_TYPEDEF);
+       type_t *type               = allocate_type_zero(TYPE_TYPEDEF, declaration->source_position);
        type->typedeft.declaration = declaration;
 
        return type;
@@ -1671,16 +1852,14 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
                        }
                        break;
 
-               /* TODO: if type != NULL for the following rules should issue
-                * an error */
                case T_struct: {
-                       type = allocate_type_zero(TYPE_COMPOUND_STRUCT);
+                       type = allocate_type_zero(TYPE_COMPOUND_STRUCT, HERE);
 
                        type->compound.declaration = parse_compound_type_specifier(true);
                        break;
                }
                case T_union: {
-                       type = allocate_type_zero(TYPE_COMPOUND_STRUCT);
+                       type = allocate_type_zero(TYPE_COMPOUND_UNION, HERE);
 
                        type->compound.declaration = parse_compound_type_specifier(false);
                        break;
@@ -1697,11 +1876,14 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
                        break;
 
                case T___attribute__:
-                       /* TODO */
                        parse_attributes();
                        break;
 
                case T_IDENTIFIER: {
+                       /* only parse identifier if we haven't found a type yet */
+                       if(type != NULL || type_specifiers != 0)
+                               goto finish_specifiers;
+
                        type_t *typedef_type = get_typedef_type(token.v.symbol);
 
                        if(typedef_type == NULL)
@@ -1814,7 +1996,9 @@ finish_specifiers:
                        /* invalid specifier combination, give an error message */
                        if(type_specifiers == 0) {
                                if (! strict_mode) {
-                                       warningf(HERE, "no type specifiers in declaration, using int");
+                                       if (warning.implicit_int) {
+                                               warningf(HERE, "no type specifiers in declaration, using 'int'");
+                                       }
                                        atomic_type = ATOMIC_TYPE_INT;
                                        break;
                                } else {
@@ -1831,7 +2015,7 @@ finish_specifiers:
                        atomic_type = ATOMIC_TYPE_INVALID;
                }
 
-               type               = allocate_type_zero(TYPE_ATOMIC);
+               type               = allocate_type_zero(TYPE_ATOMIC, builtin_source_position);
                type->atomic.akind = atomic_type;
                newtype            = 1;
        } else {
@@ -1872,8 +2056,8 @@ static declaration_t *parse_identifier_list(void)
        declaration_t *declarations     = NULL;
        declaration_t *last_declaration = NULL;
        do {
-               declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
-
+               declaration_t *const declaration = allocate_declaration_zero();
+               declaration->type            = NULL; /* a K&R parameter list has no types, yet */
                declaration->source_position = token.source_position;
                declaration->symbol          = token.v.symbol;
                next_token();
@@ -1904,16 +2088,13 @@ static void semantic_parameter(declaration_t *declaration)
                errorf(HERE, "parameter may only have none or register storage class");
        }
 
-       type_t *orig_type = declaration->type;
-       if(orig_type == NULL)
-               return;
-       type_t *type = skip_typeref(orig_type);
+       type_t *const orig_type = declaration->type;
+       type_t *      type      = skip_typeref(orig_type);
 
        /* Array as last part of a parameter type is just syntactic sugar.  Turn it
         * into a pointer. ยง 6.7.5.3 (7) */
        if (is_type_array(type)) {
-               const array_type_t *arr_type     = &type->array;
-               type_t             *element_type = arr_type->element_type;
+               type_t *const element_type = type->array.element_type;
 
                type = make_pointer_type(element_type, type->base.qualifiers);
 
@@ -1921,7 +2102,7 @@ static void semantic_parameter(declaration_t *declaration)
        }
 
        if(is_type_incomplete(type)) {
-               errorf(HERE, "incomplete type ('%T') not allowed for parameter '%Y'",
+               errorf(HERE, "incomplete type '%T' not allowed for parameter '%Y'",
                       orig_type, declaration->symbol);
        }
 }
@@ -2006,11 +2187,11 @@ typedef enum {
        CONSTRUCT_POINTER,
        CONSTRUCT_FUNCTION,
        CONSTRUCT_ARRAY
-} construct_type_type_t;
+} construct_type_kind_t;
 
 typedef struct construct_type_t construct_type_t;
 struct construct_type_t {
-       construct_type_type_t  type;
+       construct_type_kind_t  kind;
        construct_type_t      *next;
 };
 
@@ -2047,7 +2228,7 @@ static construct_type_t *parse_pointer_declarator(void)
 
        parsed_pointer_t *pointer = obstack_alloc(&temp_obst, sizeof(pointer[0]));
        memset(pointer, 0, sizeof(pointer[0]));
-       pointer->construct_type.type = CONSTRUCT_POINTER;
+       pointer->construct_type.kind = CONSTRUCT_POINTER;
        pointer->type_qualifiers     = parse_type_qualifiers();
 
        return (construct_type_t*) pointer;
@@ -2059,7 +2240,7 @@ static construct_type_t *parse_array_declarator(void)
 
        parsed_array_t *array = obstack_alloc(&temp_obst, sizeof(array[0]));
        memset(array, 0, sizeof(array[0]));
-       array->construct_type.type = CONSTRUCT_ARRAY;
+       array->construct_type.kind = CONSTRUCT_ARRAY;
 
        if(token.type == T_static) {
                array->is_static = true;
@@ -2091,17 +2272,22 @@ static construct_type_t *parse_function_declarator(declaration_t *declaration)
 {
        eat('(');
 
-       type_t *type = allocate_type_zero(TYPE_FUNCTION);
+       type_t *type;
+       if(declaration != NULL) {
+               type = allocate_type_zero(TYPE_FUNCTION, declaration->source_position);
+       } else {
+               type = allocate_type_zero(TYPE_FUNCTION, token.source_position);
+       }
 
        declaration_t *parameters = parse_parameters(&type->function);
        if(declaration != NULL) {
-               declaration->context.declarations = parameters;
+               declaration->scope.declarations = parameters;
        }
 
        construct_function_type_t *construct_function_type =
                obstack_alloc(&temp_obst, sizeof(construct_function_type[0]));
        memset(construct_function_type, 0, sizeof(construct_function_type[0]));
-       construct_function_type->construct_type.type = CONSTRUCT_FUNCTION;
+       construct_function_type->construct_type.kind = CONSTRUCT_FUNCTION;
        construct_function_type->function_type       = type;
 
        expect(')');
@@ -2212,7 +2398,7 @@ static type_t *construct_declarator_type(construct_type_t *construct_list,
 {
        construct_type_t *iter = construct_list;
        for( ; iter != NULL; iter = iter->next) {
-               switch(iter->type) {
+               switch(iter->kind) {
                case CONSTRUCT_INVALID:
                        panic("invalid type construction found");
                case CONSTRUCT_FUNCTION: {
@@ -2223,13 +2409,22 @@ static type_t *construct_declarator_type(construct_type_t *construct_list,
 
                        function_type->function.return_type = type;
 
-                       type = function_type;
+                       type_t *skipped_return_type = skip_typeref(type);
+                       if (is_type_function(skipped_return_type)) {
+                               errorf(HERE, "function returning function is not allowed");
+                               type = type_error_type;
+                       } else if (is_type_array(skipped_return_type)) {
+                               errorf(HERE, "function returning array is not allowed");
+                               type = type_error_type;
+                       } else {
+                               type = function_type;
+                       }
                        break;
                }
 
                case CONSTRUCT_POINTER: {
                        parsed_pointer_t *parsed_pointer = (parsed_pointer_t*) iter;
-                       type_t           *pointer_type   = allocate_type_zero(TYPE_POINTER);
+                       type_t           *pointer_type   = allocate_type_zero(TYPE_POINTER, (source_position_t){NULL, 0});
                        pointer_type->pointer.points_to  = type;
                        pointer_type->base.qualifiers    = parsed_pointer->type_qualifiers;
 
@@ -2239,15 +2434,30 @@ static type_t *construct_declarator_type(construct_type_t *construct_list,
 
                case CONSTRUCT_ARRAY: {
                        parsed_array_t *parsed_array  = (parsed_array_t*) iter;
-                       type_t         *array_type    = allocate_type_zero(TYPE_ARRAY);
+                       type_t         *array_type    = allocate_type_zero(TYPE_ARRAY, (source_position_t){NULL, 0});
+
+                       expression_t *size_expression = parsed_array->size;
+
+                       array_type->base.qualifiers       = parsed_array->type_qualifiers;
+                       array_type->array.element_type    = type;
+                       array_type->array.is_static       = parsed_array->is_static;
+                       array_type->array.is_variable     = parsed_array->is_variable;
+                       array_type->array.size_expression = size_expression;
 
-                       array_type->base.qualifiers    = parsed_array->type_qualifiers;
-                       array_type->array.element_type = type;
-                       array_type->array.is_static    = parsed_array->is_static;
-                       array_type->array.is_variable  = parsed_array->is_variable;
-                       array_type->array.size         = parsed_array->size;
+                       if(size_expression != NULL &&
+                                       is_constant_expression(size_expression)) {
+                               array_type->array.size_constant = true;
+                               array_type->array.size
+                                       = fold_constant(size_expression);
+                       }
 
-                       type = array_type;
+                       type_t *skipped_type = skip_typeref(type);
+                       if (is_type_atomic(skipped_type, ATOMIC_TYPE_VOID)) {
+                               errorf(HERE, "array of void is not allowed");
+                               type = type_error_type;
+                       } else {
+                               type = array_type;
+                       }
                        break;
                }
                }
@@ -2256,7 +2466,7 @@ static type_t *construct_declarator_type(construct_type_t *construct_list,
                if(hashed_type != type) {
                        /* the function type was constructed earlier freeing it here will
                         * destroy other types... */
-                       if(iter->type != CONSTRUCT_FUNCTION) {
+                       if(iter->kind != CONSTRUCT_FUNCTION) {
                                free_type(type);
                        }
                        type = hashed_type;
@@ -2269,14 +2479,14 @@ static type_t *construct_declarator_type(construct_type_t *construct_list,
 static declaration_t *parse_declarator(
                const declaration_specifiers_t *specifiers, bool may_be_abstract)
 {
-       type_t        *type         = specifiers->type;
-       declaration_t *declaration  = allocate_ast_zero(sizeof(declaration[0]));
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->storage_class  = specifiers->storage_class;
        declaration->modifiers      = specifiers->decl_modifiers;
        declaration->is_inline      = specifiers->is_inline;
 
        construct_type_t *construct_type
                = parse_inner_declarator(declaration, may_be_abstract);
+       type_t *const type = specifiers->type;
        declaration->type = construct_declarator_type(construct_type, type);
 
        if(construct_type != NULL) {
@@ -2303,12 +2513,67 @@ static declaration_t *append_declaration(declaration_t* const declaration)
        if (last_declaration != NULL) {
                last_declaration->next = declaration;
        } else {
-               context->declarations = declaration;
+               scope->declarations = declaration;
        }
        last_declaration = declaration;
        return declaration;
 }
 
+/**
+ * Check if the declaration of main is suspicious.  main should be a
+ * function with external linkage, returning int, taking either zero
+ * arguments, two, or three arguments of appropriate types, ie.
+ *
+ * int main([ int argc, char **argv [, char **env ] ]).
+ *
+ * @param decl    the declaration to check
+ * @param type    the function type of the declaration
+ */
+static void check_type_of_main(const declaration_t *const decl, const function_type_t *const func_type)
+{
+       if (decl->storage_class == STORAGE_CLASS_STATIC) {
+               warningf(decl->source_position, "'main' is normally a non-static function");
+       }
+       if (skip_typeref(func_type->return_type) != type_int) {
+               warningf(decl->source_position, "return type of 'main' should be 'int', but is '%T'", func_type->return_type);
+       }
+       const function_parameter_t *parm = func_type->parameters;
+       if (parm != NULL) {
+               type_t *const first_type = parm->type;
+               if (!types_compatible(skip_typeref(first_type), type_int)) {
+                       warningf(decl->source_position, "first argument of 'main' should be 'int', but is '%T'", first_type);
+               }
+               parm = parm->next;
+               if (parm != NULL) {
+                       type_t *const second_type = parm->type;
+                       if (!types_compatible(skip_typeref(second_type), type_char_ptr_ptr)) {
+                               warningf(decl->source_position, "second argument of 'main' should be 'char**', but is '%T'", second_type);
+                       }
+                       parm = parm->next;
+                       if (parm != NULL) {
+                               type_t *const third_type = parm->type;
+                               if (!types_compatible(skip_typeref(third_type), type_char_ptr_ptr)) {
+                                       warningf(decl->source_position, "third argument of 'main' should be 'char**', but is '%T'", third_type);
+                               }
+                               parm = parm->next;
+                               if (parm != NULL) {
+                                       warningf(decl->source_position, "'main' takes only zero, two or three arguments");
+                               }
+                       }
+               } else {
+                       warningf(decl->source_position, "'main' takes only zero, two or three arguments");
+               }
+       }
+}
+
+/**
+ * Check if a symbol is the equal to "main".
+ */
+static bool is_sym_main(const symbol_t *const sym)
+{
+       return strcmp(sym->string, "main") == 0;
+}
+
 static declaration_t *internal_record_declaration(
        declaration_t *const declaration,
        const bool is_function_definition)
@@ -2316,84 +2581,141 @@ static declaration_t *internal_record_declaration(
        const symbol_t *const symbol  = declaration->symbol;
        const namespace_t     namespc = (namespace_t)declaration->namespc;
 
-       const type_t *const type = skip_typeref(declaration->type);
-       if (is_type_function(type) && type->function.unspecified_parameters) {
+       type_t *const orig_type = declaration->type;
+       type_t *const type      = skip_typeref(orig_type);
+       if (is_type_function(type) &&
+                       type->function.unspecified_parameters &&
+                       warning.strict_prototypes) {
                warningf(declaration->source_position,
                         "function declaration '%#T' is not a prototype",
-                        type, declaration->symbol);
+                        orig_type, declaration->symbol);
+       }
+
+       if (is_function_definition && warning.main && is_sym_main(symbol)) {
+               check_type_of_main(declaration, &type->function);
        }
 
-       declaration_t *const previous_declaration = get_declaration(symbol, namespc);
+       assert(declaration->symbol != NULL);
+       declaration_t *previous_declaration = get_declaration(symbol, namespc);
+
        assert(declaration != previous_declaration);
-       if (previous_declaration != NULL
-                       && previous_declaration->parent_context == context) {
-               /* can happen for K&R style declarations */
-               if(previous_declaration->type == NULL) {
-                       previous_declaration->type = declaration->type;
-               }
-
-               const type_t *const prev_type = skip_typeref(previous_declaration->type);
-               if (!types_compatible(type, prev_type)) {
-                       errorf(declaration->source_position,
-                               "declaration '%#T' is incompatible with previous declaration '%#T'",
-                               type, symbol, previous_declaration->type, symbol);
-                       errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
-               } else {
-                       unsigned old_storage_class = previous_declaration->storage_class;
-                       unsigned new_storage_class = declaration->storage_class;
-
-                       /* pretend no storage class means extern for function declarations
-                        * (except if the previous declaration is neither none nor extern) */
-                       if (is_type_function(type)) {
-                               switch (old_storage_class) {
-                                       case STORAGE_CLASS_NONE:
-                                               old_storage_class = STORAGE_CLASS_EXTERN;
-
-                                       case STORAGE_CLASS_EXTERN:
-                                               if (new_storage_class == STORAGE_CLASS_NONE && !is_function_definition) {
-                                                       new_storage_class = STORAGE_CLASS_EXTERN;
-                                               }
-                                               break;
+       if (previous_declaration != NULL) {
+               if (previous_declaration->parent_scope == scope) {
+                       /* can happen for K&R style declarations */
+                       if(previous_declaration->type == NULL) {
+                               previous_declaration->type = declaration->type;
+                       }
+
+                       const type_t *prev_type = skip_typeref(previous_declaration->type);
+                       if (!types_compatible(type, prev_type)) {
+                               errorf(declaration->source_position,
+                                      "declaration '%#T' is incompatible with "
+                                      "previous declaration '%#T'",
+                                      orig_type, symbol, previous_declaration->type, symbol);
+                               errorf(previous_declaration->source_position,
+                                      "previous declaration of '%Y' was here", symbol);
+                       } else {
+                               unsigned old_storage_class
+                                       = previous_declaration->storage_class;
+                               unsigned new_storage_class = declaration->storage_class;
 
-                                       default: break;
+                               if(is_type_incomplete(prev_type)) {
+                                       previous_declaration->type = type;
+                                       prev_type                  = type;
                                }
-                       }
 
-                       if (old_storage_class == STORAGE_CLASS_EXTERN &&
-                           new_storage_class == STORAGE_CLASS_EXTERN) {
+                               /* pretend no storage class means extern for function
+                                * declarations (except if the previous declaration is neither
+                                * none nor extern) */
+                               if (is_type_function(type)) {
+                                       switch (old_storage_class) {
+                                               case STORAGE_CLASS_NONE:
+                                                       old_storage_class = STORAGE_CLASS_EXTERN;
+
+                                               case STORAGE_CLASS_EXTERN:
+                                                       if (is_function_definition) {
+                                                               if (warning.missing_prototypes &&
+                                                                   prev_type->function.unspecified_parameters &&
+                                                                   !is_sym_main(symbol)) {
+                                                                       warningf(declaration->source_position,
+                                                                                "no previous prototype for '%#T'",
+                                                                                orig_type, symbol);
+                                                               }
+                                                       } else if (new_storage_class == STORAGE_CLASS_NONE) {
+                                                               new_storage_class = STORAGE_CLASS_EXTERN;
+                                                       }
+                                                       break;
+
+                                               default: break;
+                                       }
+                               }
+
+                               if (old_storage_class == STORAGE_CLASS_EXTERN &&
+                                               new_storage_class == STORAGE_CLASS_EXTERN) {
 warn_redundant_declaration:
-                                       warningf(declaration->source_position, "redundant declaration for '%Y'", symbol);
-                                       warningf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
-                       } else if (current_function == NULL) {
-                               if (old_storage_class != STORAGE_CLASS_STATIC &&
-                                   new_storage_class == STORAGE_CLASS_STATIC) {
-                                       errorf(declaration->source_position, "static declaration of '%Y' follows non-static declaration", symbol);
-                                       errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
-                               } else {
-                                       if (old_storage_class != STORAGE_CLASS_EXTERN) {
-                                               goto warn_redundant_declaration;
+                                       if (warning.redundant_decls) {
+                                               warningf(declaration->source_position,
+                                                        "redundant declaration for '%Y'", symbol);
+                                               warningf(previous_declaration->source_position,
+                                                        "previous declaration of '%Y' was here",
+                                                        symbol);
                                        }
-                                       if (new_storage_class == STORAGE_CLASS_NONE) {
-                                               previous_declaration->storage_class = STORAGE_CLASS_NONE;
+                               } else if (current_function == NULL) {
+                                       if (old_storage_class != STORAGE_CLASS_STATIC &&
+                                                       new_storage_class == STORAGE_CLASS_STATIC) {
+                                               errorf(declaration->source_position,
+                                                      "static declaration of '%Y' follows non-static declaration",
+                                                      symbol);
+                                               errorf(previous_declaration->source_position,
+                                                      "previous declaration of '%Y' was here", symbol);
+                                       } else {
+                                               if (old_storage_class != STORAGE_CLASS_EXTERN && !is_function_definition) {
+                                                       goto warn_redundant_declaration;
+                                               }
+                                               if (new_storage_class == STORAGE_CLASS_NONE) {
+                                                       previous_declaration->storage_class = STORAGE_CLASS_NONE;
+                                               }
                                        }
-                               }
-                       } else {
-                               if (old_storage_class == new_storage_class) {
-                                       errorf(declaration->source_position, "redeclaration of '%Y'", symbol);
                                } else {
-                                       errorf(declaration->source_position, "redeclaration of '%Y' with different linkage", symbol);
+                                       if (old_storage_class == new_storage_class) {
+                                               errorf(declaration->source_position,
+                                                      "redeclaration of '%Y'", symbol);
+                                       } else {
+                                               errorf(declaration->source_position,
+                                                      "redeclaration of '%Y' with different linkage",
+                                                      symbol);
+                                       }
+                                       errorf(previous_declaration->source_position,
+                                              "previous declaration of '%Y' was here", symbol);
                                }
-                               errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
                        }
+                       return previous_declaration;
                }
-               return previous_declaration;
+       } else if (is_function_definition) {
+               if (declaration->storage_class != STORAGE_CLASS_STATIC) {
+                       if (warning.missing_prototypes && !is_sym_main(symbol)) {
+                               warningf(declaration->source_position,
+                                        "no previous prototype for '%#T'", orig_type, symbol);
+                       } else if (warning.missing_declarations && !is_sym_main(symbol)) {
+                               warningf(declaration->source_position,
+                                        "no previous declaration for '%#T'", orig_type,
+                                        symbol);
+                       }
+               }
+       } else if (warning.missing_declarations &&
+           scope == global_scope &&
+           !is_type_function(type) && (
+             declaration->storage_class == STORAGE_CLASS_NONE ||
+             declaration->storage_class == STORAGE_CLASS_THREAD
+           )) {
+               warningf(declaration->source_position,
+                        "no previous declaration for '%#T'", orig_type, symbol);
        }
 
-       assert(declaration->parent_context == NULL);
-       assert(declaration->symbol != NULL);
-       assert(context != NULL);
+       assert(declaration->parent_scope == NULL);
+       assert(scope != NULL);
 
-       declaration->parent_context = context;
+       declaration->parent_scope = scope;
 
        environment_push(declaration);
        return append_declaration(declaration);
@@ -2404,7 +2726,7 @@ static declaration_t *record_declaration(declaration_t *declaration)
        return internal_record_declaration(declaration, false);
 }
 
-static declaration_t *record_function_definition(declaration_t *const declaration)
+static declaration_t *record_function_definition(declaration_t *declaration)
 {
        return internal_record_declaration(declaration, true);
 }
@@ -2442,9 +2764,7 @@ static void parse_init_declarator_rest(declaration_t *declaration)
        eat('=');
 
        type_t *orig_type = declaration->type;
-       type_t *type      = NULL;
-       if(orig_type != NULL)
-               type = skip_typeref(orig_type);
+       type_t *type      = type = skip_typeref(orig_type);
 
        if(declaration->init.initializer != NULL) {
                parser_error_multiple_definition(declaration, token.source_position);
@@ -2454,42 +2774,45 @@ static void parse_init_declarator_rest(declaration_t *declaration)
 
        /* ยง 6.7.5 (22)  array initializers for arrays with unknown size determine
         * the array type size */
-       if(type != NULL && is_type_array(type) && initializer != NULL) {
+       if(is_type_array(type) && initializer != NULL) {
                array_type_t *array_type = &type->array;
 
-               if(array_type->size == NULL) {
-                       expression_t *cnst = allocate_expression_zero(EXPR_CONST);
-
-                       cnst->base.datatype = type_size_t;
-
+               if(array_type->size_expression == NULL) {
+                       size_t size;
                        switch (initializer->kind) {
                                case INITIALIZER_LIST: {
-                                       initializer_list_t *const list = &initializer->list;
-                                       cnst->conste.v.int_value = list->len;
+                                       /* TODO */
+                                       size = initializer->list.len;
                                        break;
                                }
 
                                case INITIALIZER_STRING: {
-                                       initializer_string_t *const string = &initializer->string;
-                                       cnst->conste.v.int_value = strlen(string->string) + 1;
+                                       size = initializer->string.string.size;
                                        break;
                                }
 
                                case INITIALIZER_WIDE_STRING: {
-                                       initializer_wide_string_t *const string = &initializer->wide_string;
-                                       cnst->conste.v.int_value = string->string.size;
+                                       size = initializer->wide_string.string.size;
                                        break;
                                }
 
-                               default:
+                               default: {
                                        panic("invalid initializer type");
+                                       break;
+                               }
                        }
 
-                       array_type->size = cnst;
+                       expression_t *cnst       = allocate_expression_zero(EXPR_CONST);
+                       cnst->base.type          = type_size_t;
+                       cnst->conste.v.int_value = size;
+
+                       array_type->size_expression = cnst;
+                       array_type->size_constant   = true;
+                       array_type->size            = size;
                }
        }
 
-       if(type != NULL && is_type_function(type)) {
+       if(is_type_function(type)) {
                errorf(declaration->source_position,
                       "initializers not allowed for function types at declator '%Y' (type '%T')",
                       declaration->symbol, orig_type);
@@ -2505,8 +2828,7 @@ static void parse_anonymous_declaration_rest(
 {
        eat(';');
 
-       declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
-
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->type            = specifiers->type;
        declaration->storage_class   = specifiers->storage_class;
        declaration->source_position = specifiers->source_position;
@@ -2519,8 +2841,7 @@ static void parse_anonymous_declaration_rest(
        switch (type->kind) {
                case TYPE_COMPOUND_STRUCT:
                case TYPE_COMPOUND_UNION: {
-                       const compound_type_t *compound_type = &type->compound;
-                       if (compound_type->declaration->symbol == NULL) {
+                       if (type->compound.declaration->symbol == NULL) {
                                warningf(declaration->source_position, "unnamed struct/union that defines no instances");
                        }
                        break;
@@ -2547,7 +2868,9 @@ static void parse_declaration_rest(declaration_t *ndeclaration,
                type_t *orig_type = declaration->type;
                type_t *type      = skip_typeref(orig_type);
 
-               if(type->kind != TYPE_FUNCTION && declaration->is_inline) {
+               if (type->kind != TYPE_FUNCTION &&
+                   declaration->is_inline &&
+                   is_type_valid(type)) {
                        warningf(declaration->source_position,
                                 "variable '%Y' declared 'inline'\n", declaration->symbol);
                }
@@ -2579,16 +2902,16 @@ static declaration_t *finished_kr_declaration(declaration_t *declaration)
 
        declaration_t *previous_declaration = get_declaration(symbol, namespc);
        if(previous_declaration == NULL ||
-                       previous_declaration->parent_context != context) {
+                       previous_declaration->parent_scope != scope) {
                errorf(HERE, "expected declaration of a function parameter, found '%Y'",
                       symbol);
                return declaration;
        }
 
        if(previous_declaration->type == NULL) {
-               previous_declaration->type           = declaration->type;
-               previous_declaration->storage_class  = declaration->storage_class;
-               previous_declaration->parent_context = context;
+               previous_declaration->type          = declaration->type;
+               previous_declaration->storage_class = declaration->storage_class;
+               previous_declaration->parent_scope  = scope;
                return previous_declaration;
        } else {
                return record_declaration(declaration);
@@ -2602,7 +2925,7 @@ static void parse_declaration(parsed_declaration_func finished_declaration)
        parse_declaration_specifiers(&specifiers);
 
        if(token.type == ';') {
-               parse_anonymous_declaration_rest(&specifiers, finished_declaration);
+               parse_anonymous_declaration_rest(&specifiers, append_declaration);
        } else {
                declaration_t *declaration = parse_declarator(&specifiers, /*may_be_abstract=*/false);
                parse_declaration_rest(declaration, &specifiers, finished_declaration);
@@ -2619,14 +2942,14 @@ static void parse_kr_declaration_list(declaration_t *declaration)
                return;
 
        /* push function parameters */
-       int         top          = environment_top();
-       context_t  *last_context = context;
-       set_context(&declaration->context);
+       int       top        = environment_top();
+       scope_t  *last_scope = scope;
+       set_scope(&declaration->scope);
 
-       declaration_t *parameter = declaration->context.declarations;
+       declaration_t *parameter = declaration->scope.declarations;
        for( ; parameter != NULL; parameter = parameter->next) {
-               assert(parameter->parent_context == NULL);
-               parameter->parent_context = context;
+               assert(parameter->parent_scope == NULL);
+               parameter->parent_scope = scope;
                environment_push(parameter);
        }
 
@@ -2636,8 +2959,8 @@ static void parse_kr_declaration_list(declaration_t *declaration)
        }
 
        /* pop function parameters */
-       assert(context == &declaration->context);
-       set_context(last_context);
+       assert(scope == &declaration->scope);
+       set_scope(last_scope);
        environment_pop_to(top);
 
        /* update function type */
@@ -2647,7 +2970,7 @@ static void parse_kr_declaration_list(declaration_t *declaration)
        function_parameter_t *parameters     = NULL;
        function_parameter_t *last_parameter = NULL;
 
-       declaration_t *parameter_declaration = declaration->context.declarations;
+       declaration_t *parameter_declaration = declaration->scope.declarations;
        for( ; parameter_declaration != NULL;
                        parameter_declaration = parameter_declaration->next) {
                type_t *parameter_type = parameter_declaration->type;
@@ -2656,8 +2979,10 @@ static void parse_kr_declaration_list(declaration_t *declaration)
                                errorf(HERE, "no type specified for function parameter '%Y'",
                                       parameter_declaration->symbol);
                        } else {
-                               warningf(HERE, "no type specified for function parameter '%Y', using int",
-                                        parameter_declaration->symbol);
+                               if (warning.implicit_int) {
+                                       warningf(HERE, "no type specified for function parameter '%Y', using 'int'",
+                                               parameter_declaration->symbol);
+                               }
                                parameter_type              = type_int;
                                parameter_declaration->type = parameter_type;
                        }
@@ -2688,29 +3013,76 @@ static void parse_kr_declaration_list(declaration_t *declaration)
        declaration->type = type;
 }
 
+static bool first_err = true;
+
+/**
+ * When called with first_err set, prints the name of the current function,
+ * else does noting.
+ */
+static void print_in_function(void) {
+       if (first_err) {
+               first_err = false;
+               diagnosticf("%s: In function '%Y':\n",
+                       current_function->source_position.input_name,
+                       current_function->symbol);
+       }
+}
+
 /**
  * Check if all labels are defined in the current function.
+ * Check if all labels are used in the current function.
  */
-static void check_for_missing_labels(void)
+static void check_labels(void)
 {
-       bool first_err = true;
        for (const goto_statement_t *goto_statement = goto_first;
-            goto_statement != NULL;
-            goto_statement = goto_statement->next) {
-                const declaration_t *label = goto_statement->label;
-
-                if (label->source_position.input_name == NULL) {
-                        if (first_err) {
-                                first_err = false;
-                                diagnosticf("%s: In function '%Y':\n",
-                                        current_function->source_position.input_name,
-                                        current_function->symbol);
-                        }
-                        errorf(goto_statement->statement.source_position,
-                                "label '%Y' used but not defined", label->symbol);
+           goto_statement != NULL;
+           goto_statement = goto_statement->next) {
+               declaration_t *label = goto_statement->label;
+
+               label->used = true;
+               if (label->source_position.input_name == NULL) {
+                       print_in_function();
+                       errorf(goto_statement->base.source_position,
+                              "label '%Y' used but not defined", label->symbol);
                 }
        }
        goto_first = goto_last = NULL;
+
+       if (warning.unused_label) {
+               for (const label_statement_t *label_statement = label_first;
+                        label_statement != NULL;
+                        label_statement = label_statement->next) {
+                       const declaration_t *label = label_statement->label;
+
+                       if (! label->used) {
+                               print_in_function();
+                               warningf(label_statement->base.source_position,
+                                       "label '%Y' defined but not used", label->symbol);
+                       }
+               }
+       }
+       label_first = label_last = NULL;
+}
+
+/**
+ * Check declarations of current_function for unused entities.
+ */
+static void check_declarations(void)
+{
+       if (warning.unused_parameter) {
+               const scope_t *scope = &current_function->scope;
+
+               const declaration_t *parameter = scope->declarations;
+               for (; parameter != NULL; parameter = parameter->next) {
+                       if (! parameter->used) {
+                               print_in_function();
+                               warningf(parameter->source_position,
+                                       "unused parameter '%Y'", parameter->symbol);
+                       }
+               }
+       }
+       if (warning.unused_variable) {
+       }
 }
 
 static void parse_external_declaration(void)
@@ -2746,16 +3118,14 @@ static void parse_external_declaration(void)
        }
 
        type_t *type = ndeclaration->type;
-       if(type == NULL) {
-               eat_block();
-               return;
-       }
 
        /* note that we don't skip typerefs: the standard doesn't allow them here
         * (so we can't use is_type_function here) */
        if(type->kind != TYPE_FUNCTION) {
-               errorf(HERE, "declarator '%#T' has a body but is not a function type",
-                      type, ndeclaration->symbol);
+               if (is_type_valid(type)) {
+                       errorf(HERE, "declarator '%#T' has a body but is not a function type",
+                              type, ndeclaration->symbol);
+               }
                eat_block();
                return;
        }
@@ -2775,23 +3145,23 @@ static void parse_external_declaration(void)
 
        declaration_t *const declaration = record_function_definition(ndeclaration);
        if(ndeclaration != declaration) {
-               declaration->context = ndeclaration->context;
+               declaration->scope = ndeclaration->scope;
        }
        type = skip_typeref(declaration->type);
 
-       /* push function parameters and switch context */
-       int         top          = environment_top();
-       context_t  *last_context = context;
-       set_context(&declaration->context);
+       /* push function parameters and switch scope */
+       int       top        = environment_top();
+       scope_t  *last_scope = scope;
+       set_scope(&declaration->scope);
 
-       declaration_t *parameter = declaration->context.declarations;
+       declaration_t *parameter = declaration->scope.declarations;
        for( ; parameter != NULL; parameter = parameter->next) {
-               if(parameter->parent_context == &ndeclaration->context) {
-                       parameter->parent_context = context;
+               if(parameter->parent_scope == &ndeclaration->scope) {
+                       parameter->parent_scope = scope;
                }
-               assert(parameter->parent_context == NULL
-                               || parameter->parent_context == context);
-               parameter->parent_context = context;
+               assert(parameter->parent_scope == NULL
+                               || parameter->parent_scope == scope);
+               parameter->parent_scope = scope;
                environment_push(parameter);
        }
 
@@ -2806,7 +3176,9 @@ static void parse_external_declaration(void)
                current_function                    = declaration;
 
                declaration->init.statement = parse_compound_statement();
-               check_for_missing_labels();
+               first_err = true;
+               check_labels();
+               check_declarations();
 
                assert(current_function == declaration);
                current_function = old_current_function;
@@ -2814,55 +3186,135 @@ static void parse_external_declaration(void)
        }
 
 end_of_parse_external_declaration:
-       assert(context == &declaration->context);
-       set_context(last_context);
+       assert(scope == &declaration->scope);
+       set_scope(last_scope);
        environment_pop_to(top);
 }
 
-static type_t *make_bitfield_type(type_t *base, expression_t *size)
+static type_t *make_bitfield_type(type_t *base, expression_t *size,
+                                  source_position_t source_position)
 {
-       type_t *type        = allocate_type_zero(TYPE_BITFIELD);
+       type_t *type        = allocate_type_zero(TYPE_BITFIELD, source_position);
        type->bitfield.base = base;
        type->bitfield.size = size;
 
        return type;
 }
 
-static void parse_struct_declarators(const declaration_specifiers_t *specifiers)
+static declaration_t *find_compound_entry(declaration_t *compound_declaration,
+                                          symbol_t *symbol)
+{
+       declaration_t *iter = compound_declaration->scope.declarations;
+       for( ; iter != NULL; iter = iter->next) {
+               if(iter->namespc != NAMESPACE_NORMAL)
+                       continue;
+
+               if(iter->symbol == NULL) {
+                       type_t *type = skip_typeref(iter->type);
+                       if(is_type_compound(type)) {
+                               declaration_t *result
+                                       = find_compound_entry(type->compound.declaration, symbol);
+                               if(result != NULL)
+                                       return result;
+                       }
+                       continue;
+               }
+
+               if(iter->symbol == symbol) {
+                       return iter;
+               }
+       }
+
+       return NULL;
+}
+
+static void parse_compound_declarators(declaration_t *struct_declaration,
+               const declaration_specifiers_t *specifiers)
 {
-       /* TODO: check constraints for struct declarations (in specifiers) */
+       declaration_t *last_declaration = struct_declaration->scope.declarations;
+       if(last_declaration != NULL) {
+               while(last_declaration->next != NULL) {
+                       last_declaration = last_declaration->next;
+               }
+       }
+
        while(1) {
                declaration_t *declaration;
 
                if(token.type == ':') {
+                       source_position_t source_position = HERE;
                        next_token();
 
                        type_t *base_type = specifiers->type;
                        expression_t *size = parse_constant_expression();
 
-                       type_t *type = make_bitfield_type(base_type, size);
+                       if(!is_type_integer(skip_typeref(base_type))) {
+                               errorf(HERE, "bitfield base type '%T' is not an integer type",
+                                      base_type);
+                       }
 
-                       declaration = allocate_ast_zero(sizeof(declaration[0]));
+                       type_t *type = make_bitfield_type(base_type, size, source_position);
 
+                       declaration                  = allocate_declaration_zero();
                        declaration->namespc         = NAMESPACE_NORMAL;
                        declaration->storage_class   = STORAGE_CLASS_NONE;
-                       declaration->source_position = token.source_position;
+                       declaration->source_position = source_position;
                        declaration->modifiers       = specifiers->decl_modifiers;
                        declaration->type            = type;
-
-                       record_declaration(declaration);
                } else {
                        declaration = parse_declarator(specifiers,/*may_be_abstract=*/true);
 
+                       type_t *orig_type = declaration->type;
+                       type_t *type      = skip_typeref(orig_type);
+
                        if(token.type == ':') {
+                               source_position_t source_position = HERE;
                                next_token();
                                expression_t *size = parse_constant_expression();
 
-                               type_t *type = make_bitfield_type(declaration->type, size);
-                               declaration->type = type;
+                               if(!is_type_integer(type)) {
+                                       errorf(HERE, "bitfield base type '%T' is not an "
+                                              "integer type", orig_type);
+                               }
+
+                               type_t *bitfield_type = make_bitfield_type(orig_type, size, source_position);
+                               declaration->type = bitfield_type;
+                       } else {
+                               /* TODO we ignore arrays for now... what is missing is a check
+                                * that they're at the end of the struct */
+                               if(is_type_incomplete(type) && !is_type_array(type)) {
+                                       errorf(HERE,
+                                              "compound member '%Y' has incomplete type '%T'",
+                                              declaration->symbol, orig_type);
+                               } else if(is_type_function(type)) {
+                                       errorf(HERE, "compound member '%Y' must not have function "
+                                              "type '%T'", declaration->symbol, orig_type);
+                               }
+                       }
+               }
+
+               /* make sure we don't define a symbol multiple times */
+               symbol_t *symbol = declaration->symbol;
+               if(symbol != NULL) {
+                       declaration_t *prev_decl
+                               = find_compound_entry(struct_declaration, symbol);
+
+                       if(prev_decl != NULL) {
+                               assert(prev_decl->symbol == symbol);
+                               errorf(declaration->source_position,
+                                      "multiple declarations of symbol '%Y'", symbol);
+                               errorf(prev_decl->source_position,
+                                      "previous declaration of '%Y' was here", symbol);
                        }
                }
-               record_declaration(declaration);
+
+               /* append declaration */
+               if(last_declaration != NULL) {
+                       last_declaration->next = declaration;
+               } else {
+                       struct_declaration->scope.declarations = declaration;
+               }
+               last_declaration = declaration;
 
                if(token.type != ',')
                        break;
@@ -2871,7 +3323,7 @@ static void parse_struct_declarators(const declaration_specifiers_t *specifiers)
        expect_void(';');
 }
 
-static void parse_compound_type_entries(void)
+static void parse_compound_type_entries(declaration_t *compound_declaration)
 {
        eat('{');
 
@@ -2880,7 +3332,7 @@ static void parse_compound_type_entries(void)
                memset(&specifiers, 0, sizeof(specifiers));
                parse_declaration_specifiers(&specifiers);
 
-               parse_struct_declarators(&specifiers);
+               parse_compound_declarators(compound_declaration, &specifiers);
        }
        if(token.type == T_EOF) {
                errorf(HERE, "EOF while parsing struct");
@@ -2932,10 +3384,15 @@ static expression_t *create_invalid_expression(void)
        return expression;
 }
 
+/**
+ * Prints an error message if an expression was expected but not read
+ */
 static expression_t *expected_expression_error(void)
 {
-       errorf(HERE, "expected expression, got token '%K'", &token);
-
+       /* skip the error message if the error token was read */
+       if (token.type != T_ERROR) {
+               errorf(HERE, "expected expression, got token '%K'", &token);
+       }
        next_token();
 
        return create_invalid_expression();
@@ -2946,34 +3403,82 @@ static expression_t *expected_expression_error(void)
  */
 static expression_t *parse_string_const(void)
 {
-       expression_t *cnst  = allocate_expression_zero(EXPR_STRING_LITERAL);
-       cnst->base.datatype = type_string;
-       cnst->string.value  = parse_string_literals();
+       wide_string_t wres;
+       if (token.type == T_STRING_LITERAL) {
+               string_t res = token.v.string;
+               next_token();
+               while (token.type == T_STRING_LITERAL) {
+                       res = concat_strings(&res, &token.v.string);
+                       next_token();
+               }
+               if (token.type != T_WIDE_STRING_LITERAL) {
+                       expression_t *const cnst = allocate_expression_zero(EXPR_STRING_LITERAL);
+                       cnst->base.type    = type_char_ptr;
+                       cnst->string.value = res;
+                       return cnst;
+               }
 
-       return cnst;
+               wres = concat_string_wide_string(&res, &token.v.wide_string);
+       } else {
+               wres = token.v.wide_string;
+       }
+       next_token();
+
+       for (;;) {
+               switch (token.type) {
+                       case T_WIDE_STRING_LITERAL:
+                               wres = concat_wide_strings(&wres, &token.v.wide_string);
+                               break;
+
+                       case T_STRING_LITERAL:
+                               wres = concat_wide_string_string(&wres, &token.v.string);
+                               break;
+
+                       default: {
+                               expression_t *const cnst = allocate_expression_zero(EXPR_WIDE_STRING_LITERAL);
+                               cnst->base.type         = type_wchar_t_ptr;
+                               cnst->wide_string.value = wres;
+                               return cnst;
+                       }
+               }
+               next_token();
+       }
 }
 
 /**
- * Parse a wide string constant.
+ * Parse an integer constant.
  */
-static expression_t *parse_wide_string_const(void)
+static expression_t *parse_int_const(void)
 {
-       expression_t *const cnst = allocate_expression_zero(EXPR_WIDE_STRING_LITERAL);
-       cnst->base.datatype      = type_wchar_t_ptr;
-       cnst->wide_string.value  = token.v.wide_string; /* TODO concatenate */
+       expression_t *cnst         = allocate_expression_zero(EXPR_CONST);
+       cnst->base.source_position = HERE;
+       cnst->base.type            = token.datatype;
+       cnst->conste.v.int_value   = token.v.intvalue;
+
        next_token();
+
        return cnst;
 }
 
 /**
- * Parse an integer constant.
+ * Parse a character constant.
  */
-static expression_t *parse_int_const(void)
+static expression_t *parse_char_const(void)
 {
-       expression_t *cnst       = allocate_expression_zero(EXPR_CONST);
-       cnst->base.datatype      = token.datatype;
-       cnst->conste.v.int_value = token.v.intvalue;
+       expression_t *cnst         = allocate_expression_zero(EXPR_CHAR_CONST);
+       cnst->base.source_position = HERE;
+       cnst->base.type            = token.datatype;
+       cnst->conste.v.chars.begin = token.v.string.begin;
+       cnst->conste.v.chars.size  = token.v.string.size;
 
+       if (cnst->conste.v.chars.size != 1) {
+               if (warning.multichar && (c_mode & _GNUC)) {
+                       /* TODO */
+                       warningf(HERE, "multi-character character constant");
+               } else {
+                       errorf(HERE, "more than 1 characters in character constant");
+               }
+       }
        next_token();
 
        return cnst;
@@ -2985,7 +3490,7 @@ static expression_t *parse_int_const(void)
 static expression_t *parse_float_const(void)
 {
        expression_t *cnst         = allocate_expression_zero(EXPR_CONST);
-       cnst->base.datatype        = token.datatype;
+       cnst->base.type            = token.datatype;
        cnst->conste.v.float_value = token.v.floatvalue;
 
        next_token();
@@ -2996,7 +3501,7 @@ static expression_t *parse_float_const(void)
 static declaration_t *create_implicit_function(symbol_t *symbol,
                const source_position_t source_position)
 {
-       type_t *ntype                          = allocate_type_zero(TYPE_FUNCTION);
+       type_t *ntype                          = allocate_type_zero(TYPE_FUNCTION, source_position);
        ntype->function.return_type            = type_int;
        ntype->function.unspecified_parameters = true;
 
@@ -3005,24 +3510,23 @@ static declaration_t *create_implicit_function(symbol_t *symbol,
                free_type(ntype);
        }
 
-       declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
-
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->storage_class   = STORAGE_CLASS_EXTERN;
        declaration->type            = type;
        declaration->symbol          = symbol;
        declaration->source_position = source_position;
-       declaration->parent_context  = global_context;
+       declaration->parent_scope  = global_scope;
 
-       context_t *old_context = context;
-       set_context(global_context);
+       scope_t *old_scope = scope;
+       set_scope(global_scope);
 
        environment_push(declaration);
-       /* prepend the declaration to the global declarations list */
-       declaration->next     = context->declarations;
-       context->declarations = declaration;
+       /* prepends the declaration to the global declarations list */
+       declaration->next   = scope->declarations;
+       scope->declarations = declaration;
 
-       assert(context == global_context);
-       set_context(old_context);
+       assert(scope == global_scope);
+       set_scope(old_scope);
 
        return declaration;
 }
@@ -3041,7 +3545,7 @@ static type_t *make_function_1_type(type_t *return_type, type_t *argument_type)
        memset(parameter, 0, sizeof(parameter[0]));
        parameter->type = argument_type;
 
-       type_t *type               = allocate_type_zero(TYPE_FUNCTION);
+       type_t *type               = allocate_type_zero(TYPE_FUNCTION, builtin_source_position);
        type->function.return_type = return_type;
        type->function.parameters  = parameter;
 
@@ -3064,11 +3568,11 @@ static type_t *get_builtin_symbol_type(symbol_t *symbol)
        case T___builtin_alloca:
                return make_function_1_type(type_void_ptr, type_size_t);
        case T___builtin_nan:
-               return make_function_1_type(type_double, type_string);
+               return make_function_1_type(type_double, type_char_ptr);
        case T___builtin_nanf:
-               return make_function_1_type(type_float, type_string);
+               return make_function_1_type(type_float, type_char_ptr);
        case T___builtin_nand:
-               return make_function_1_type(type_long_double, type_string);
+               return make_function_1_type(type_long_double, type_char_ptr);
        case T___builtin_va_end:
                return make_function_1_type(type_void, type_valist);
        default:
@@ -3083,9 +3587,6 @@ static type_t *get_builtin_symbol_type(symbol_t *symbol)
  */
 static type_t *automatic_type_conversion(type_t *orig_type)
 {
-       if(orig_type == NULL)
-               return NULL;
-
        type_t *type = skip_typeref(orig_type);
        if(is_type_array(type)) {
                array_type_t *array_type   = &type->array;
@@ -3108,45 +3609,33 @@ static type_t *automatic_type_conversion(type_t *orig_type)
  */
 type_t *revert_automatic_type_conversion(const expression_t *expression)
 {
-       if(expression->base.datatype == NULL)
-               return NULL;
+       switch (expression->kind) {
+               case EXPR_REFERENCE: return expression->reference.declaration->type;
+               case EXPR_SELECT:    return expression->select.compound_entry->type;
 
-       switch(expression->kind) {
-       case EXPR_REFERENCE: {
-               const reference_expression_t *ref = &expression->reference;
-               return ref->declaration->type;
-       }
-       case EXPR_SELECT: {
-               const select_expression_t *select = &expression->select;
-               return select->compound_entry->type;
-       }
-       case EXPR_UNARY_DEREFERENCE: {
-               expression_t   *value        = expression->unary.value;
-               type_t         *type         = skip_typeref(value->base.datatype);
-               pointer_type_t *pointer_type = &type->pointer;
+               case EXPR_UNARY_DEREFERENCE: {
+                       const expression_t *const value = expression->unary.value;
+                       type_t             *const type  = skip_typeref(value->base.type);
+                       assert(is_type_pointer(type));
+                       return type->pointer.points_to;
+               }
 
-               return pointer_type->points_to;
-       }
-       case EXPR_BUILTIN_SYMBOL: {
-               const builtin_symbol_expression_t *builtin
-                       = &expression->builtin_symbol;
-               return get_builtin_symbol_type(builtin->symbol);
-       }
-       case EXPR_ARRAY_ACCESS: {
-               const array_access_expression_t *array_access
-                       = &expression->array_access;
-               const expression_t *array_ref = array_access->array_ref;
-               type_t *type_left  = skip_typeref(array_ref->base.datatype);
-               assert(is_type_pointer(type_left));
-               pointer_type_t *pointer_type = &type_left->pointer;
-               return pointer_type->points_to;
-       }
+               case EXPR_BUILTIN_SYMBOL:
+                       return get_builtin_symbol_type(expression->builtin_symbol.symbol);
 
-       default:
-               break;
+               case EXPR_ARRAY_ACCESS: {
+                       const expression_t *array_ref = expression->array_access.array_ref;
+                       type_t             *type_left = skip_typeref(array_ref->base.type);
+                       if (!is_type_valid(type_left))
+                               return type_left;
+                       assert(is_type_pointer(type_left));
+                       return type_left->pointer.points_to;
+               }
+
+               default: break;
        }
 
-       return expression->base.datatype;
+       return expression->base.type;
 }
 
 static expression_t *parse_reference(void)
@@ -3164,14 +3653,16 @@ static expression_t *parse_reference(void)
        if(declaration == NULL) {
                if (! strict_mode && token.type == '(') {
                        /* an implicitly defined function */
-                       warningf(HERE, "implicit declaration of function '%Y'",
-                                ref->symbol);
+                       if (warning.implicit_function_declaration) {
+                               warningf(HERE, "implicit declaration of function '%Y'",
+                                       ref->symbol);
+                       }
 
                        declaration = create_implicit_function(ref->symbol,
                                                               source_position);
                } else {
                        errorf(HERE, "unknown symbol '%Y' found.", ref->symbol);
-                       return expression;
+                       return create_invalid_expression();
                }
        }
 
@@ -3181,8 +3672,11 @@ static expression_t *parse_reference(void)
         * code to revert this! */
        type = automatic_type_conversion(type);
 
-       ref->declaration         = declaration;
-       ref->expression.datatype = type;
+       ref->declaration = declaration;
+       ref->base.type   = type;
+
+       /* this declaration is used */
+       declaration->used = true;
 
        return expression;
 }
@@ -3194,21 +3688,38 @@ static void check_cast_allowed(expression_t *expression, type_t *dest_type)
        /* TODO check if explicit cast is allowed and issue warnings/errors */
 }
 
-static expression_t *parse_cast(void)
+static expression_t *parse_compound_literal(type_t *type)
 {
-       expression_t *cast = allocate_expression_zero(EXPR_UNARY_CAST);
+       expression_t *expression = allocate_expression_zero(EXPR_COMPOUND_LITERAL);
 
-       cast->base.source_position = token.source_position;
+       expression->compound_literal.type        = type;
+       expression->compound_literal.initializer = parse_initializer(type);
+       expression->base.type                    = automatic_type_conversion(type);
+
+       return expression;
+}
+
+static expression_t *parse_cast(void)
+{
+       source_position_t source_position = token.source_position;
 
        type_t *type  = parse_typename();
 
        expect(')');
+
+       if(token.type == '{') {
+               return parse_compound_literal(type);
+       }
+
+       expression_t *cast = allocate_expression_zero(EXPR_UNARY_CAST);
+       cast->base.source_position = source_position;
+
        expression_t *value = parse_sub_expression(20);
 
        check_cast_allowed(value, type);
 
-       cast->base.datatype = type;
-       cast->unary.value   = value;
+       cast->base.type   = type;
+       cast->unary.value = value;
 
        return cast;
 }
@@ -3217,31 +3728,24 @@ static expression_t *parse_statement_expression(void)
 {
        expression_t *expression = allocate_expression_zero(EXPR_STATEMENT);
 
-       statement_t *statement          = parse_compound_statement();
-       expression->statement.statement = statement;
-       if(statement == NULL) {
-               expect(')');
-               return NULL;
-       }
-
-       assert(statement->kind == STATEMENT_COMPOUND);
-       compound_statement_t *compound_statement = &statement->compound;
+       statement_t *statement           = parse_compound_statement();
+       expression->statement.statement  = statement;
+       expression->base.source_position = statement->base.source_position;
 
-       /* find last statement and use it's type */
-       const statement_t *last_statement = NULL;
-       const statement_t *iter           = compound_statement->statements;
-       for( ; iter != NULL; iter = iter->base.next) {
-               last_statement = iter;
-       }
+       /* find last statement and use its type */
+       type_t *type = type_void;
+       const statement_t *stmt = statement->compound.statements;
+       if (stmt != NULL) {
+               while (stmt->base.next != NULL)
+                       stmt = stmt->base.next;
 
-       if(last_statement->kind == STATEMENT_EXPRESSION) {
-               const expression_statement_t *expression_statement
-                       = &last_statement->expression;
-               expression->base.datatype
-                       = expression_statement->expression->base.datatype;
+               if (stmt->kind == STATEMENT_EXPRESSION) {
+                       type = stmt->expression.expression->base.type;
+               }
        } else {
-               expression->base.datatype = type_void;
+               warningf(expression->base.source_position, "empty statement expression ({})");
        }
+       expression->base.type = type;
 
        expect(')');
 
@@ -3281,14 +3785,10 @@ static expression_t *parse_function_keyword(void)
                errorf(HERE, "'__func__' used outside of a function");
        }
 
-       string_literal_expression_t *expression
-               = allocate_ast_zero(sizeof(expression[0]));
-
-       expression->expression.kind     = EXPR_FUNCTION;
-       expression->expression.datatype = type_string;
-       expression->value               = current_function->symbol->string;
+       expression_t *expression = allocate_expression_zero(EXPR_FUNCTION);
+       expression->base.type    = type_char_ptr;
 
-       return (expression_t*) expression;
+       return expression;
 }
 
 static expression_t *parse_pretty_function_keyword(void)
@@ -3300,19 +3800,16 @@ static expression_t *parse_pretty_function_keyword(void)
                errorf(HERE, "'__PRETTY_FUNCTION__' used outside of a function");
        }
 
-       string_literal_expression_t *expression
-               = allocate_ast_zero(sizeof(expression[0]));
-
-       expression->expression.kind     = EXPR_PRETTY_FUNCTION;
-       expression->expression.datatype = type_string;
-       expression->value               = current_function->symbol->string;
+       expression_t *expression = allocate_expression_zero(EXPR_PRETTY_FUNCTION);
+       expression->base.type    = type_char_ptr;
 
-       return (expression_t*) expression;
+       return expression;
 }
 
 static designator_t *parse_designator(void)
 {
-       designator_t *result = allocate_ast_zero(sizeof(result[0]));
+       designator_t *result    = allocate_ast_zero(sizeof(result[0]));
+       result->source_position = HERE;
 
        if(token.type != T_IDENTIFIER) {
                parse_error_expected("while parsing member designator",
@@ -3333,8 +3830,9 @@ static designator_t *parse_designator(void)
                                eat_paren();
                                return NULL;
                        }
-                       designator_t *designator = allocate_ast_zero(sizeof(result[0]));
-                       designator->symbol       = token.v.symbol;
+                       designator_t *designator    = allocate_ast_zero(sizeof(result[0]));
+                       designator->source_position = HERE;
+                       designator->symbol          = token.v.symbol;
                        next_token();
 
                        last_designator->next = designator;
@@ -3343,9 +3841,10 @@ static designator_t *parse_designator(void)
                }
                if(token.type == '[') {
                        next_token();
-                       designator_t *designator = allocate_ast_zero(sizeof(result[0]));
-                       designator->array_access = parse_expression();
-                       if(designator->array_access == NULL) {
+                       designator_t *designator    = allocate_ast_zero(sizeof(result[0]));
+                       designator->source_position = HERE;
+                       designator->array_index     = parse_expression();
+                       if(designator->array_index == NULL) {
                                eat_paren();
                                return NULL;
                        }
@@ -3365,15 +3864,31 @@ static expression_t *parse_offsetof(void)
 {
        eat(T___builtin_offsetof);
 
-       expression_t *expression  = allocate_expression_zero(EXPR_OFFSETOF);
-       expression->base.datatype = type_size_t;
+       expression_t *expression = allocate_expression_zero(EXPR_OFFSETOF);
+       expression->base.type    = type_size_t;
 
        expect('(');
-       expression->offsetofe.type = parse_typename();
+       type_t *type = parse_typename();
        expect(',');
-       expression->offsetofe.designator = parse_designator();
+       designator_t *designator = parse_designator();
        expect(')');
 
+       expression->offsetofe.type       = type;
+       expression->offsetofe.designator = designator;
+
+       type_path_t path;
+       memset(&path, 0, sizeof(path));
+       path.top_type = type;
+       path.path     = NEW_ARR_F(type_path_entry_t, 0);
+
+       descend_into_subtype(&path);
+
+       if(!walk_designator(&path, designator, true)) {
+               return create_invalid_expression();
+       }
+
+       DEL_ARR_F(path.path);
+
        return expression;
 }
 
@@ -3389,7 +3904,9 @@ static expression_t *parse_va_start(void)
        expression_t *const expr = parse_assignment_expression();
        if (expr->kind == EXPR_REFERENCE) {
                declaration_t *const decl = expr->reference.declaration;
-               if (decl->parent_context == &current_function->context &&
+               if (decl == NULL)
+                       return create_invalid_expression();
+               if (decl->parent_scope == &current_function->scope &&
                    decl->next == NULL) {
                        expression->va_starte.parameter = decl;
                        expect(')');
@@ -3410,7 +3927,7 @@ static expression_t *parse_va_arg(void)
        expect('(');
        expression->va_arge.ap = parse_assignment_expression();
        expect(',');
-       expression->base.datatype = parse_typename();
+       expression->base.type = parse_typename();
        expect(')');
 
        return expression;
@@ -3428,7 +3945,7 @@ static expression_t *parse_builtin_symbol(void)
        type_t *type = get_builtin_symbol_type(symbol);
        type = automatic_type_conversion(type);
 
-       expression->base.datatype = type;
+       expression->base.type = type;
        return expression;
 }
 
@@ -3441,7 +3958,7 @@ static expression_t *parse_builtin_constant(void)
        expect('(');
        expression->builtin_constant.value = parse_assignment_expression();
        expect(')');
-       expression->base.datatype = type_int;
+       expression->base.type = type_int;
 
        return expression;
 }
@@ -3463,7 +3980,7 @@ static expression_t *parse_builtin_prefetch(void)
                expression->builtin_prefetch.locality = parse_assignment_expression();
        }
        expect(')');
-       expression->base.datatype = type_void;
+       expression->base.type = type_void;
 
        return expression;
 }
@@ -3495,6 +4012,7 @@ static expression_t *parse_compare_builtin(void)
                panic("invalid compare builtin found");
                break;
        }
+       expression->base.source_position = HERE;
        next_token();
 
        expect('(');
@@ -3503,16 +4021,16 @@ static expression_t *parse_compare_builtin(void)
        expression->binary.right = parse_assignment_expression();
        expect(')');
 
-       type_t *orig_type_left  = expression->binary.left->base.datatype;
-       type_t *orig_type_right = expression->binary.right->base.datatype;
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return expression;
+       type_t *const orig_type_left  = expression->binary.left->base.type;
+       type_t *const orig_type_right = expression->binary.right->base.type;
 
-       type_t *type_left  = skip_typeref(orig_type_left);
-       type_t *type_right = skip_typeref(orig_type_right);
-       if(!is_type_floating(type_left) && !is_type_floating(type_right)) {
-               type_error_incompatible("invalid operands in comparison",
-                                       token.source_position, type_left, type_right);
+       type_t *const type_left  = skip_typeref(orig_type_left);
+       type_t *const type_right = skip_typeref(orig_type_right);
+       if(!is_type_float(type_left) && !is_type_float(type_right)) {
+               if (is_type_valid(type_left) && is_type_valid(type_right)) {
+                       type_error_incompatible("invalid operands in comparison",
+                               expression->base.source_position, orig_type_left, orig_type_right);
+               }
        } else {
                semantic_comparison(&expression->binary);
        }
@@ -3533,7 +4051,7 @@ static expression_t *parse_builtin_expect(void)
        expression->binary.right = parse_constant_expression();
        expect(')');
 
-       expression->base.datatype = expression->binary.left->base.datatype;
+       expression->base.type = expression->binary.left->base.type;
 
        return expression;
 }
@@ -3548,75 +4066,45 @@ static expression_t *parse_assume(void) {
        expression->unary.value = parse_assignment_expression();
        expect(')');
 
-       expression->base.datatype = type_void;
-       return expression;
-}
-
-static expression_t *parse_alignof(void) {
-       eat(T___alignof__);
-
-       expression_t *expression
-               = allocate_expression_zero(EXPR_ALIGNOF);
-
-       expect('(');
-       expression->alignofe.type = parse_typename();
-       expect(')');
-
-       expression->base.datatype = type_size_t;
+       expression->base.type = type_void;
        return expression;
 }
 
 static expression_t *parse_primary_expression(void)
 {
-       switch(token.type) {
-       case T_INTEGER:
-               return parse_int_const();
-       case T_FLOATINGPOINT:
-               return parse_float_const();
-       case T_STRING_LITERAL:
-               return parse_string_const();
-       case T_WIDE_STRING_LITERAL:
-               return parse_wide_string_const();
-       case T_IDENTIFIER:
-               return parse_reference();
-       case T___FUNCTION__:
-       case T___func__:
-               return parse_function_keyword();
-       case T___PRETTY_FUNCTION__:
-               return parse_pretty_function_keyword();
-       case T___builtin_offsetof:
-               return parse_offsetof();
-       case T___builtin_va_start:
-               return parse_va_start();
-       case T___builtin_va_arg:
-               return parse_va_arg();
-       case T___builtin_expect:
-               return parse_builtin_expect();
-       case T___builtin_nanf:
-       case T___builtin_alloca:
-       case T___builtin_va_end:
-               return parse_builtin_symbol();
-       case T___builtin_isgreater:
-       case T___builtin_isgreaterequal:
-       case T___builtin_isless:
-       case T___builtin_islessequal:
-       case T___builtin_islessgreater:
-       case T___builtin_isunordered:
-               return parse_compare_builtin();
-       case T___builtin_constant_p:
-               return parse_builtin_constant();
-       case T___builtin_prefetch:
-               return parse_builtin_prefetch();
-       case T___alignof__:
-               return parse_alignof();
-       case T_assume:
-               return parse_assume();
-
-       case '(':
-               return parse_brace_expression();
-       }
-
-       errorf(HERE, "unexpected token '%K'", &token);
+       switch (token.type) {
+               case T_INTEGER:                  return parse_int_const();
+               case T_CHARS:                    return parse_char_const();
+               case T_FLOATINGPOINT:            return parse_float_const();
+               case T_STRING_LITERAL:
+               case T_WIDE_STRING_LITERAL:      return parse_string_const();
+               case T_IDENTIFIER:               return parse_reference();
+               case T___FUNCTION__:
+               case T___func__:                 return parse_function_keyword();
+               case T___PRETTY_FUNCTION__:      return parse_pretty_function_keyword();
+               case T___builtin_offsetof:       return parse_offsetof();
+               case T___builtin_va_start:       return parse_va_start();
+               case T___builtin_va_arg:         return parse_va_arg();
+               case T___builtin_expect:         return parse_builtin_expect();
+               case T___builtin_alloca:
+               case T___builtin_nan:
+               case T___builtin_nand:
+               case T___builtin_nanf:
+               case T___builtin_va_end:         return parse_builtin_symbol();
+               case T___builtin_isgreater:
+               case T___builtin_isgreaterequal:
+               case T___builtin_isless:
+               case T___builtin_islessequal:
+               case T___builtin_islessgreater:
+               case T___builtin_isunordered:    return parse_compare_builtin();
+               case T___builtin_constant_p:     return parse_builtin_constant();
+               case T___builtin_prefetch:       return parse_builtin_prefetch();
+               case T_assume:                   return parse_assume();
+
+               case '(':                        return parse_brace_expression();
+       }
+
+       errorf(HERE, "unexpected token %K, expected an expression", &token);
        eat_statement();
 
        return create_invalid_expression();
@@ -3626,14 +4114,13 @@ static expression_t *parse_primary_expression(void)
  * Check if the expression has the character type and issue a warning then.
  */
 static void check_for_char_index_type(const expression_t *expression) {
-       type_t *type      = expression->base.datatype;
-       type_t *base_type = skip_typeref(type);
+       type_t       *const type      = expression->base.type;
+       const type_t *const base_type = skip_typeref(type);
 
-       if (base_type->base.kind == TYPE_ATOMIC) {
-               if (base_type->atomic.akind == ATOMIC_TYPE_CHAR) {
-                       warningf(expression->base.source_position,
-                               "array subscript has type '%T'", type);
-               }
+       if (is_type_atomic(base_type, ATOMIC_TYPE_CHAR) &&
+                       warning.char_subscripts) {
+               warningf(expression->base.source_position,
+                       "array subscript has type '%T'", type);
        }
 }
 
@@ -3646,74 +4133,80 @@ static expression_t *parse_array_expression(unsigned precedence,
 
        expression_t *inside = parse_expression();
 
-       array_access_expression_t *array_access
-               = allocate_ast_zero(sizeof(array_access[0]));
-
-       array_access->expression.kind = EXPR_ARRAY_ACCESS;
-
-       type_t *type_left   = left->base.datatype;
-       type_t *type_inside = inside->base.datatype;
-       type_t *return_type = NULL;
-
-       if(type_left != NULL && type_inside != NULL) {
-               type_left   = skip_typeref(type_left);
-               type_inside = skip_typeref(type_inside);
-
-               if(is_type_pointer(type_left)) {
-                       pointer_type_t *pointer = &type_left->pointer;
-                       return_type             = pointer->points_to;
-                       array_access->array_ref = left;
-                       array_access->index     = inside;
-                       check_for_char_index_type(inside);
-               } else if(is_type_pointer(type_inside)) {
-                       pointer_type_t *pointer = &type_inside->pointer;
-                       return_type             = pointer->points_to;
-                       array_access->array_ref = inside;
-                       array_access->index     = left;
-                       array_access->flipped   = true;
-                       check_for_char_index_type(left);
-               } else {
-                       errorf(HERE, "array access on object with non-pointer types '%T', '%T'", type_left, type_inside);
-               }
-       } else {
+       expression_t *expression = allocate_expression_zero(EXPR_ARRAY_ACCESS);
+
+       array_access_expression_t *array_access = &expression->array_access;
+
+       type_t *const orig_type_left   = left->base.type;
+       type_t *const orig_type_inside = inside->base.type;
+
+       type_t *const type_left   = skip_typeref(orig_type_left);
+       type_t *const type_inside = skip_typeref(orig_type_inside);
+
+       type_t *return_type;
+       if (is_type_pointer(type_left)) {
+               return_type             = type_left->pointer.points_to;
                array_access->array_ref = left;
                array_access->index     = inside;
+               check_for_char_index_type(inside);
+       } else if (is_type_pointer(type_inside)) {
+               return_type             = type_inside->pointer.points_to;
+               array_access->array_ref = inside;
+               array_access->index     = left;
+               array_access->flipped   = true;
+               check_for_char_index_type(left);
+       } else {
+               if (is_type_valid(type_left) && is_type_valid(type_inside)) {
+                       errorf(HERE,
+                               "array access on object with non-pointer types '%T', '%T'",
+                               orig_type_left, orig_type_inside);
+               }
+               return_type             = type_error_type;
+               array_access->array_ref = create_invalid_expression();
        }
 
        if(token.type != ']') {
                parse_error_expected("Problem while parsing array access", ']', 0);
-               return (expression_t*) array_access;
+               return expression;
        }
        next_token();
 
-       return_type = automatic_type_conversion(return_type);
-       array_access->expression.datatype = return_type;
+       return_type           = automatic_type_conversion(return_type);
+       expression->base.type = return_type;
 
-       return (expression_t*) array_access;
+       return expression;
 }
 
-static expression_t *parse_sizeof(unsigned precedence)
+static expression_t *parse_typeprop(expression_kind_t kind, unsigned precedence)
 {
-       eat(T_sizeof);
-
-       sizeof_expression_t *sizeof_expression
-               = allocate_ast_zero(sizeof(sizeof_expression[0]));
-       sizeof_expression->expression.kind     = EXPR_SIZEOF;
-       sizeof_expression->expression.datatype = type_size_t;
+       expression_t *tp_expression = allocate_expression_zero(kind);
+       tp_expression->base.type    = type_size_t;
 
        if(token.type == '(' && is_declaration_specifier(look_ahead(1), true)) {
                next_token();
-               sizeof_expression->type = parse_typename();
+               tp_expression->typeprop.type = parse_typename();
                expect(')');
        } else {
-               expression_t *expression  = parse_sub_expression(precedence);
-               expression->base.datatype = revert_automatic_type_conversion(expression);
+               expression_t *expression = parse_sub_expression(precedence);
+               expression->base.type    = revert_automatic_type_conversion(expression);
 
-               sizeof_expression->type            = expression->base.datatype;
-               sizeof_expression->size_expression = expression;
+               tp_expression->typeprop.type          = expression->base.type;
+               tp_expression->typeprop.tp_expression = expression;
        }
 
-       return (expression_t*) sizeof_expression;
+       return tp_expression;
+}
+
+static expression_t *parse_sizeof(unsigned precedence)
+{
+       eat(T_sizeof);
+       return parse_typeprop(EXPR_SIZEOF, precedence);
+}
+
+static expression_t *parse_alignof(unsigned precedence)
+{
+       eat(T___alignof__);
+       return parse_typeprop(EXPR_SIZEOF, precedence);
 }
 
 static expression_t *parse_select_expression(unsigned precedence,
@@ -3736,32 +4229,31 @@ static expression_t *parse_select_expression(unsigned precedence,
        select->select.symbol = symbol;
        next_token();
 
-       type_t *orig_type = compound->base.datatype;
-       if(orig_type == NULL)
-               return create_invalid_expression();
-
-       type_t *type = skip_typeref(orig_type);
+       type_t *const orig_type = compound->base.type;
+       type_t *const type      = skip_typeref(orig_type);
 
        type_t *type_left = type;
        if(is_pointer) {
-               if(type->kind != TYPE_POINTER) {
-                       errorf(HERE, "left hand side of '->' is not a pointer, but '%T'", orig_type);
+               if (!is_type_pointer(type)) {
+                       if (is_type_valid(type)) {
+                               errorf(HERE, "left hand side of '->' is not a pointer, but '%T'", orig_type);
+                       }
                        return create_invalid_expression();
                }
-               pointer_type_t *pointer_type = &type->pointer;
-               type_left                    = pointer_type->points_to;
+               type_left = type->pointer.points_to;
        }
        type_left = skip_typeref(type_left);
 
-       if(type_left->kind != TYPE_COMPOUND_STRUCT
-                       && type_left->kind != TYPE_COMPOUND_UNION) {
-               errorf(HERE, "request for member '%Y' in something not a struct or "
-                      "union, but '%T'", symbol, type_left);
+       if (type_left->kind != TYPE_COMPOUND_STRUCT &&
+           type_left->kind != TYPE_COMPOUND_UNION) {
+               if (is_type_valid(type_left)) {
+                       errorf(HERE, "request for member '%Y' in something not a struct or "
+                              "union, but '%T'", symbol, type_left);
+               }
                return create_invalid_expression();
        }
 
-       compound_type_t *compound_type = &type_left->compound;
-       declaration_t   *declaration   = compound_type->declaration;
+       declaration_t *const declaration = type_left->compound.declaration;
 
        if(!declaration->init.is_defined) {
                errorf(HERE, "request for member '%Y' of incomplete type '%T'",
@@ -3769,12 +4261,7 @@ static expression_t *parse_select_expression(unsigned precedence,
                return create_invalid_expression();
        }
 
-       declaration_t *iter = declaration->context.declarations;
-       for( ; iter != NULL; iter = iter->next) {
-               if(iter->symbol == symbol) {
-                       break;
-               }
-       }
+       declaration_t *iter = find_compound_entry(declaration, symbol);
        if(iter == NULL) {
                errorf(HERE, "'%T' has no member named '%Y'", orig_type, symbol);
                return create_invalid_expression();
@@ -3785,13 +4272,13 @@ static expression_t *parse_select_expression(unsigned precedence,
        type_t *expression_type = automatic_type_conversion(iter->type);
 
        select->select.compound_entry = iter;
-       select->base.datatype         = expression_type;
+       select->base.type             = expression_type;
 
        if(expression_type->kind == TYPE_BITFIELD) {
                expression_t *extract
                        = allocate_expression_zero(EXPR_UNARY_BITFIELD_EXTRACT);
-               extract->unary.value   = select;
-               extract->base.datatype = expression_type->bitfield.base;
+               extract->unary.value = select;
+               extract->base.type   = expression_type->bitfield.base;
 
                return extract;
        }
@@ -3813,27 +4300,21 @@ static expression_t *parse_call_expression(unsigned precedence,
        call_expression_t *call = &result->call;
        call->function          = expression;
 
-       function_type_t *function_type = NULL;
-       type_t          *orig_type     = expression->base.datatype;
-       if(orig_type != NULL) {
-               type_t *type  = skip_typeref(orig_type);
-
-               if(is_type_pointer(type)) {
-                       pointer_type_t *pointer_type = &type->pointer;
+       type_t *const orig_type = expression->base.type;
+       type_t *const type      = skip_typeref(orig_type);
 
-                       type = skip_typeref(pointer_type->points_to);
+       function_type_t *function_type = NULL;
+       if (is_type_pointer(type)) {
+               type_t *const to_type = skip_typeref(type->pointer.points_to);
 
-                       if (is_type_function(type)) {
-                               function_type             = &type->function;
-                               call->expression.datatype = function_type->return_type;
-                       }
+               if (is_type_function(to_type)) {
+                       function_type   = &to_type->function;
+                       call->base.type = function_type->return_type;
                }
-               if(function_type == NULL) {
-                       errorf(HERE, "called object '%E' (type '%T') is not a pointer to a function", expression, orig_type);
+       }
 
-                       function_type             = NULL;
-                       call->expression.datatype = NULL;
-               }
+       if (function_type == NULL && is_type_valid(type)) {
+               errorf(HERE, "called object '%E' (type '%T') is not a pointer to a function", expression, orig_type);
        }
 
        /* parse arguments */
@@ -3866,9 +4347,17 @@ static expression_t *parse_call_expression(unsigned precedence,
                for( ; parameter != NULL && argument != NULL;
                                parameter = parameter->next, argument = argument->next) {
                        type_t *expected_type = parameter->type;
-                       /* TODO report context in error messages */
-                       argument->expression = create_implicit_cast(argument->expression,
-                                                                   expected_type);
+                       /* TODO report scope in error messages */
+                       expression_t *const arg_expr = argument->expression;
+                       type_t       *const res_type = semantic_assign(expected_type, arg_expr, "function call");
+                       if (res_type == NULL) {
+                               /* TODO improve error message */
+                               errorf(arg_expr->base.source_position,
+                                       "Cannot call function with argument '%E' of type '%T' where type '%T' is expected",
+                                       arg_expr, arg_expr->base.type, expected_type);
+                       } else {
+                               argument->expression = create_implicit_cast(argument->expression, expected_type);
+                       }
                }
                /* too few parameters */
                if(parameter != NULL) {
@@ -3881,10 +4370,7 @@ static expression_t *parse_call_expression(unsigned precedence,
                        } else {
                                /* do default promotion */
                                for( ; argument != NULL; argument = argument->next) {
-                                       type_t *type = argument->expression->base.datatype;
-
-                                       if(type == NULL)
-                                               continue;
+                                       type_t *type = argument->expression->base.type;
 
                                        type = skip_typeref(type);
                                        if(is_type_integer(type)) {
@@ -3911,15 +4397,10 @@ static type_t *semantic_arithmetic(type_t *type_left, type_t *type_right);
 
 static bool same_compound_type(const type_t *type1, const type_t *type2)
 {
-       if(!is_type_compound(type1))
-               return false;
-       if(type1->kind != type2->kind)
-               return false;
-
-       const compound_type_t *compound1 = &type1->compound;
-       const compound_type_t *compound2 = &type2->compound;
-
-       return compound1->declaration == compound2->declaration;
+       return
+               is_type_compound(type1) &&
+               type1->kind == type2->kind &&
+               type1->compound.declaration == type2->compound.declaration;
 }
 
 /**
@@ -3938,58 +4419,65 @@ static expression_t *parse_conditional_expression(unsigned precedence,
        conditional->condition = expression;
 
        /* 6.5.15.2 */
-       type_t *condition_type_orig = expression->base.datatype;
-       if(condition_type_orig != NULL) {
-               type_t *condition_type = skip_typeref(condition_type_orig);
-               if(condition_type != NULL && !is_type_scalar(condition_type)) {
-                       type_error("expected a scalar type in conditional condition",
-                                  expression->base.source_position, condition_type_orig);
-               }
+       type_t *const condition_type_orig = expression->base.type;
+       type_t *const condition_type      = skip_typeref(condition_type_orig);
+       if (!is_type_scalar(condition_type) && is_type_valid(condition_type)) {
+               type_error("expected a scalar type in conditional condition",
+                          expression->base.source_position, condition_type_orig);
        }
 
        expression_t *true_expression = parse_expression();
        expect(':');
        expression_t *false_expression = parse_sub_expression(precedence);
 
-       conditional->true_expression  = true_expression;
-       conditional->false_expression = false_expression;
-
-       type_t *orig_true_type  = true_expression->base.datatype;
-       type_t *orig_false_type = false_expression->base.datatype;
-       if(orig_true_type == NULL || orig_false_type == NULL)
-               return result;
-
-       type_t *true_type  = skip_typeref(orig_true_type);
-       type_t *false_type = skip_typeref(orig_false_type);
+       type_t *const orig_true_type  = true_expression->base.type;
+       type_t *const orig_false_type = false_expression->base.type;
+       type_t *const true_type       = skip_typeref(orig_true_type);
+       type_t *const false_type      = skip_typeref(orig_false_type);
 
        /* 6.5.15.3 */
-       type_t *result_type = NULL;
+       type_t *result_type;
        if (is_type_arithmetic(true_type) && is_type_arithmetic(false_type)) {
                result_type = semantic_arithmetic(true_type, false_type);
 
                true_expression  = create_implicit_cast(true_expression, result_type);
                false_expression = create_implicit_cast(false_expression, result_type);
 
-               conditional->true_expression     = true_expression;
-               conditional->false_expression    = false_expression;
-               conditional->expression.datatype = result_type;
-       } else if (same_compound_type(true_type, false_type)
-                       || (is_type_atomic(true_type, ATOMIC_TYPE_VOID) &&
-                               is_type_atomic(false_type, ATOMIC_TYPE_VOID))) {
+               conditional->true_expression  = true_expression;
+               conditional->false_expression = false_expression;
+               conditional->base.type        = result_type;
+       } else if (same_compound_type(true_type, false_type) || (
+           is_type_atomic(true_type, ATOMIC_TYPE_VOID) &&
+           is_type_atomic(false_type, ATOMIC_TYPE_VOID)
+               )) {
                /* just take 1 of the 2 types */
                result_type = true_type;
        } else if (is_type_pointer(true_type) && is_type_pointer(false_type)
                        && pointers_compatible(true_type, false_type)) {
                /* ok */
                result_type = true_type;
+       } else if (is_type_pointer(true_type)
+                       && is_null_pointer_constant(false_expression)) {
+               result_type = true_type;
+       } else if (is_type_pointer(false_type)
+                       && is_null_pointer_constant(true_expression)) {
+               result_type = false_type;
        } else {
-               /* TODO */
-               type_error_incompatible("while parsing conditional",
-                                       expression->base.source_position, true_type,
-                                       false_type);
+               /* TODO: one pointer to void*, other some pointer */
+
+               if (is_type_valid(true_type) && is_type_valid(false_type)) {
+                       type_error_incompatible("while parsing conditional",
+                                               expression->base.source_position, true_type,
+                                               false_type);
+               }
+               result_type = type_error_type;
        }
 
-       conditional->expression.datatype = result_type;
+       conditional->true_expression
+               = create_implicit_cast(true_expression, result_type);
+       conditional->false_expression
+               = create_implicit_cast(false_expression, result_type);
+       conditional->base.type = result_type;
        return result;
 }
 
@@ -4010,8 +4498,8 @@ static expression_t *parse_builtin_classify_type(const unsigned precedence)
 {
        eat(T___builtin_classify_type);
 
-       expression_t *result  = allocate_expression_zero(EXPR_CLASSIFY_TYPE);
-       result->base.datatype = type_int;
+       expression_t *result = allocate_expression_zero(EXPR_CLASSIFY_TYPE);
+       result->base.type    = type_int;
 
        expect('(');
        expression_t *expression = parse_sub_expression(precedence);
@@ -4023,83 +4511,77 @@ static expression_t *parse_builtin_classify_type(const unsigned precedence)
 
 static void semantic_incdec(unary_expression_t *expression)
 {
-       type_t *orig_type = expression->value->base.datatype;
-       if(orig_type == NULL)
-               return;
-
-       type_t *type = skip_typeref(orig_type);
+       type_t *const orig_type = expression->value->base.type;
+       type_t *const type      = skip_typeref(orig_type);
+       /* TODO !is_type_real && !is_type_pointer */
        if(!is_type_arithmetic(type) && type->kind != TYPE_POINTER) {
-               /* TODO: improve error message */
-               errorf(HERE, "operation needs an arithmetic or pointer type");
+               if (is_type_valid(type)) {
+                       /* TODO: improve error message */
+                       errorf(HERE, "operation needs an arithmetic or pointer type");
+               }
                return;
        }
 
-       expression->expression.datatype = orig_type;
+       expression->base.type = orig_type;
 }
 
 static void semantic_unexpr_arithmetic(unary_expression_t *expression)
 {
-       type_t *orig_type = expression->value->base.datatype;
-       if(orig_type == NULL)
-               return;
-
-       type_t *type = skip_typeref(orig_type);
+       type_t *const orig_type = expression->value->base.type;
+       type_t *const type      = skip_typeref(orig_type);
        if(!is_type_arithmetic(type)) {
-               /* TODO: improve error message */
-               errorf(HERE, "operation needs an arithmetic type");
+               if (is_type_valid(type)) {
+                       /* TODO: improve error message */
+                       errorf(HERE, "operation needs an arithmetic type");
+               }
                return;
        }
 
-       expression->expression.datatype = orig_type;
+       expression->base.type = orig_type;
 }
 
 static void semantic_unexpr_scalar(unary_expression_t *expression)
 {
-       type_t *orig_type = expression->value->base.datatype;
-       if(orig_type == NULL)
-               return;
-
-       type_t *type = skip_typeref(orig_type);
+       type_t *const orig_type = expression->value->base.type;
+       type_t *const type      = skip_typeref(orig_type);
        if (!is_type_scalar(type)) {
-               errorf(HERE, "operand of ! must be of scalar type");
+               if (is_type_valid(type)) {
+                       errorf(HERE, "operand of ! must be of scalar type");
+               }
                return;
        }
 
-       expression->expression.datatype = orig_type;
+       expression->base.type = orig_type;
 }
 
 static void semantic_unexpr_integer(unary_expression_t *expression)
 {
-       type_t *orig_type = expression->value->base.datatype;
-       if(orig_type == NULL)
-               return;
-
-       type_t *type = skip_typeref(orig_type);
+       type_t *const orig_type = expression->value->base.type;
+       type_t *const type      = skip_typeref(orig_type);
        if (!is_type_integer(type)) {
-               errorf(HERE, "operand of ~ must be of integer type");
+               if (is_type_valid(type)) {
+                       errorf(HERE, "operand of ~ must be of integer type");
+               }
                return;
        }
 
-       expression->expression.datatype = orig_type;
+       expression->base.type = orig_type;
 }
 
 static void semantic_dereference(unary_expression_t *expression)
 {
-       type_t *orig_type = expression->value->base.datatype;
-       if(orig_type == NULL)
-               return;
-
-       type_t *type = skip_typeref(orig_type);
+       type_t *const orig_type = expression->value->base.type;
+       type_t *const type      = skip_typeref(orig_type);
        if(!is_type_pointer(type)) {
-               errorf(HERE, "Unary '*' needs pointer or arrray type, but type '%T' given", orig_type);
+               if (is_type_valid(type)) {
+                       errorf(HERE, "Unary '*' needs pointer or arrray type, but type '%T' given", orig_type);
+               }
                return;
        }
 
-       pointer_type_t *pointer_type = &type->pointer;
-       type_t         *result_type  = pointer_type->points_to;
-
-       result_type = automatic_type_conversion(result_type);
-       expression->expression.datatype = result_type;
+       type_t *result_type   = type->pointer.points_to;
+       result_type           = automatic_type_conversion(result_type);
+       expression->base.type = result_type;
 }
 
 /**
@@ -4107,19 +4589,18 @@ static void semantic_dereference(unary_expression_t *expression)
  */
 static void semantic_take_addr(unary_expression_t *expression)
 {
-       expression_t *value  = expression->value;
-       value->base.datatype = revert_automatic_type_conversion(value);
+       expression_t *value = expression->value;
+       value->base.type    = revert_automatic_type_conversion(value);
 
-       type_t *orig_type = value->base.datatype;
-       if(orig_type == NULL)
+       type_t *orig_type = value->base.type;
+       if(!is_type_valid(orig_type))
                return;
 
        if(value->kind == EXPR_REFERENCE) {
-               reference_expression_t *reference   = (reference_expression_t*) value;
-               declaration_t          *declaration = reference->declaration;
+               declaration_t *const declaration = value->reference.declaration;
                if(declaration != NULL) {
                        if (declaration->storage_class == STORAGE_CLASS_REGISTER) {
-                               errorf(expression->expression.source_position,
+                               errorf(expression->base.source_position,
                                        "address of register variable '%Y' requested",
                                        declaration->symbol);
                        }
@@ -4127,7 +4608,7 @@ static void semantic_take_addr(unary_expression_t *expression)
                }
        }
 
-       expression->expression.datatype = make_pointer_type(orig_type, TYPE_QUALIFIER_NONE);
+       expression->base.type = make_pointer_type(orig_type, TYPE_QUALIFIER_NONE);
 }
 
 #define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type, sfunc)   \
@@ -4229,166 +4710,173 @@ static type_t *semantic_arithmetic(type_t *type_left, type_t *type_right)
  */
 static void semantic_binexpr_arithmetic(binary_expression_t *expression)
 {
-       expression_t *left       = expression->left;
-       expression_t *right      = expression->right;
-       type_t       *orig_type_left  = left->base.datatype;
-       type_t       *orig_type_right = right->base.datatype;
-
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return;
-
-       type_t *type_left  = skip_typeref(orig_type_left);
-       type_t *type_right = skip_typeref(orig_type_right);
+       expression_t *const left            = expression->left;
+       expression_t *const right           = expression->right;
+       type_t       *const orig_type_left  = left->base.type;
+       type_t       *const orig_type_right = right->base.type;
+       type_t       *const type_left       = skip_typeref(orig_type_left);
+       type_t       *const type_right      = skip_typeref(orig_type_right);
 
        if(!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
                /* TODO: improve error message */
-               errorf(HERE, "operation needs arithmetic types");
+               if (is_type_valid(type_left) && is_type_valid(type_right)) {
+                       errorf(HERE, "operation needs arithmetic types");
+               }
                return;
        }
 
        type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
-       expression->left  = create_implicit_cast(left, arithmetic_type);
-       expression->right = create_implicit_cast(right, arithmetic_type);
-       expression->expression.datatype = arithmetic_type;
+       expression->left      = create_implicit_cast(left, arithmetic_type);
+       expression->right     = create_implicit_cast(right, arithmetic_type);
+       expression->base.type = arithmetic_type;
 }
 
 static void semantic_shift_op(binary_expression_t *expression)
 {
-       expression_t *left       = expression->left;
-       expression_t *right      = expression->right;
-       type_t       *orig_type_left  = left->base.datatype;
-       type_t       *orig_type_right = right->base.datatype;
-
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return;
-
-       type_t *type_left  = skip_typeref(orig_type_left);
-       type_t *type_right = skip_typeref(orig_type_right);
+       expression_t *const left            = expression->left;
+       expression_t *const right           = expression->right;
+       type_t       *const orig_type_left  = left->base.type;
+       type_t       *const orig_type_right = right->base.type;
+       type_t       *      type_left       = skip_typeref(orig_type_left);
+       type_t       *      type_right      = skip_typeref(orig_type_right);
 
        if(!is_type_integer(type_left) || !is_type_integer(type_right)) {
                /* TODO: improve error message */
-               errorf(HERE, "operation needs integer types");
+               if (is_type_valid(type_left) && is_type_valid(type_right)) {
+                       errorf(HERE, "operation needs integer types");
+               }
                return;
        }
 
        type_left  = promote_integer(type_left);
        type_right = promote_integer(type_right);
 
-       expression->left  = create_implicit_cast(left, type_left);
-       expression->right = create_implicit_cast(right, type_right);
-       expression->expression.datatype = type_left;
+       expression->left      = create_implicit_cast(left, type_left);
+       expression->right     = create_implicit_cast(right, type_right);
+       expression->base.type = type_left;
 }
 
 static void semantic_add(binary_expression_t *expression)
 {
-       expression_t *left            = expression->left;
-       expression_t *right           = expression->right;
-       type_t       *orig_type_left  = left->base.datatype;
-       type_t       *orig_type_right = right->base.datatype;
-
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return;
-
-       type_t *type_left  = skip_typeref(orig_type_left);
-       type_t *type_right = skip_typeref(orig_type_right);
+       expression_t *const left            = expression->left;
+       expression_t *const right           = expression->right;
+       type_t       *const orig_type_left  = left->base.type;
+       type_t       *const orig_type_right = right->base.type;
+       type_t       *const type_left       = skip_typeref(orig_type_left);
+       type_t       *const type_right      = skip_typeref(orig_type_right);
 
        /* ยง 5.6.5 */
        if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
                type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
                expression->left  = create_implicit_cast(left, arithmetic_type);
                expression->right = create_implicit_cast(right, arithmetic_type);
-               expression->expression.datatype = arithmetic_type;
+               expression->base.type = arithmetic_type;
                return;
        } else if(is_type_pointer(type_left) && is_type_integer(type_right)) {
-               expression->expression.datatype = type_left;
+               expression->base.type = type_left;
        } else if(is_type_pointer(type_right) && is_type_integer(type_left)) {
-               expression->expression.datatype = type_right;
-       } else {
+               expression->base.type = type_right;
+       } else if (is_type_valid(type_left) && is_type_valid(type_right)) {
                errorf(HERE, "invalid operands to binary + ('%T', '%T')", orig_type_left, orig_type_right);
        }
 }
 
 static void semantic_sub(binary_expression_t *expression)
 {
-       expression_t *left            = expression->left;
-       expression_t *right           = expression->right;
-       type_t       *orig_type_left  = left->base.datatype;
-       type_t       *orig_type_right = right->base.datatype;
-
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return;
-
-       type_t       *type_left       = skip_typeref(orig_type_left);
-       type_t       *type_right      = skip_typeref(orig_type_right);
+       expression_t *const left            = expression->left;
+       expression_t *const right           = expression->right;
+       type_t       *const orig_type_left  = left->base.type;
+       type_t       *const orig_type_right = right->base.type;
+       type_t       *const type_left       = skip_typeref(orig_type_left);
+       type_t       *const type_right      = skip_typeref(orig_type_right);
 
        /* ยง 5.6.5 */
        if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
                type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
-               expression->left  = create_implicit_cast(left, arithmetic_type);
-               expression->right = create_implicit_cast(right, arithmetic_type);
-               expression->expression.datatype = arithmetic_type;
+               expression->left        = create_implicit_cast(left, arithmetic_type);
+               expression->right       = create_implicit_cast(right, arithmetic_type);
+               expression->base.type =  arithmetic_type;
                return;
        } else if(is_type_pointer(type_left) && is_type_integer(type_right)) {
-               expression->expression.datatype = type_left;
+               expression->base.type = type_left;
        } else if(is_type_pointer(type_left) && is_type_pointer(type_right)) {
                if(!pointers_compatible(type_left, type_right)) {
-                       errorf(HERE, "pointers to incompatible objects to binary - ('%T', '%T')", orig_type_left, orig_type_right);
+                       errorf(HERE,
+                              "pointers to incompatible objects to binary '-' ('%T', '%T')",
+                              orig_type_left, orig_type_right);
                } else {
-                       expression->expression.datatype = type_ptrdiff_t;
+                       expression->base.type = type_ptrdiff_t;
                }
-       } else {
-               errorf(HERE, "invalid operands to binary - ('%T', '%T')", orig_type_left, orig_type_right);
+       } else if (is_type_valid(type_left) && is_type_valid(type_right)) {
+               errorf(HERE, "invalid operands to binary '-' ('%T', '%T')",
+                      orig_type_left, orig_type_right);
        }
 }
 
+/**
+ * Check the semantics of comparison expressions.
+ *
+ * @param expression   The expression to check.
+ */
 static void semantic_comparison(binary_expression_t *expression)
 {
        expression_t *left            = expression->left;
        expression_t *right           = expression->right;
-       type_t       *orig_type_left  = left->base.datatype;
-       type_t       *orig_type_right = right->base.datatype;
-
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return;
+       type_t       *orig_type_left  = left->base.type;
+       type_t       *orig_type_right = right->base.type;
 
        type_t *type_left  = skip_typeref(orig_type_left);
        type_t *type_right = skip_typeref(orig_type_right);
 
        /* TODO non-arithmetic types */
        if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
+               if (warning.sign_compare &&
+                   (expression->base.kind != EXPR_BINARY_EQUAL &&
+                    expression->base.kind != EXPR_BINARY_NOTEQUAL) &&
+                   (is_type_signed(type_left) != is_type_signed(type_right))) {
+                       warningf(expression->base.source_position,
+                                "comparison between signed and unsigned");
+               }
                type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
-               expression->left  = create_implicit_cast(left, arithmetic_type);
-               expression->right = create_implicit_cast(right, arithmetic_type);
-               expression->expression.datatype = arithmetic_type;
+               expression->left        = create_implicit_cast(left, arithmetic_type);
+               expression->right       = create_implicit_cast(right, arithmetic_type);
+               expression->base.type   = arithmetic_type;
+               if (warning.float_equal &&
+                   (expression->base.kind == EXPR_BINARY_EQUAL ||
+                    expression->base.kind == EXPR_BINARY_NOTEQUAL) &&
+                   is_type_float(arithmetic_type)) {
+                       warningf(expression->base.source_position,
+                                "comparing floating point with == or != is unsafe");
+               }
        } else if (is_type_pointer(type_left) && is_type_pointer(type_right)) {
                /* TODO check compatibility */
        } else if (is_type_pointer(type_left)) {
                expression->right = create_implicit_cast(right, type_left);
        } else if (is_type_pointer(type_right)) {
                expression->left = create_implicit_cast(left, type_right);
-       } else {
+       } else if (is_type_valid(type_left) && is_type_valid(type_right)) {
                type_error_incompatible("invalid operands in comparison",
-                                       token.source_position, type_left, type_right);
+                                       expression->base.source_position,
+                                       type_left, type_right);
        }
-       expression->expression.datatype = type_int;
+       expression->base.type = type_int;
 }
 
 static void semantic_arithmetic_assign(binary_expression_t *expression)
 {
        expression_t *left            = expression->left;
        expression_t *right           = expression->right;
-       type_t       *orig_type_left  = left->base.datatype;
-       type_t       *orig_type_right = right->base.datatype;
-
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return;
+       type_t       *orig_type_left  = left->base.type;
+       type_t       *orig_type_right = right->base.type;
 
        type_t *type_left  = skip_typeref(orig_type_left);
        type_t *type_right = skip_typeref(orig_type_right);
 
        if(!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
                /* TODO: improve error message */
-               errorf(HERE, "operation needs arithmetic types");
+               if (is_type_valid(type_left) && is_type_valid(type_right)) {
+                       errorf(HERE, "operation needs arithmetic types");
+               }
                return;
        }
 
@@ -4398,21 +4886,17 @@ static void semantic_arithmetic_assign(binary_expression_t *expression)
         * for the arithmetic operation and create a cast by itself */
        type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
        expression->right       = create_implicit_cast(right, arithmetic_type);
-       expression->expression.datatype = type_left;
+       expression->base.type   = type_left;
 }
 
 static void semantic_arithmetic_addsubb_assign(binary_expression_t *expression)
 {
-       expression_t *left            = expression->left;
-       expression_t *right           = expression->right;
-       type_t       *orig_type_left  = left->base.datatype;
-       type_t       *orig_type_right = right->base.datatype;
-
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return;
-
-       type_t *type_left  = skip_typeref(orig_type_left);
-       type_t *type_right = skip_typeref(orig_type_right);
+       expression_t *const left            = expression->left;
+       expression_t *const right           = expression->right;
+       type_t       *const orig_type_left  = left->base.type;
+       type_t       *const orig_type_right = right->base.type;
+       type_t       *const type_left       = skip_typeref(orig_type_left);
+       type_t       *const type_right      = skip_typeref(orig_type_right);
 
        if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
                /* combined instructions are tricky. We can't create an implicit cast on
@@ -4420,13 +4904,12 @@ static void semantic_arithmetic_addsubb_assign(binary_expression_t *expression)
                 * The ast2firm pass has to know that left_type must be right_type
                 * for the arithmetic operation and create a cast by itself */
                type_t *const arithmetic_type = semantic_arithmetic(type_left, type_right);
-               expression->right = create_implicit_cast(right, arithmetic_type);
-               expression->expression.datatype = type_left;
+               expression->right     = create_implicit_cast(right, arithmetic_type);
+               expression->base.type = type_left;
        } else if (is_type_pointer(type_left) && is_type_integer(type_right)) {
-               expression->expression.datatype = type_left;
-       } else {
+               expression->base.type = type_left;
+       } else if (is_type_valid(type_left) && is_type_valid(type_right)) {
                errorf(HERE, "incompatible types '%T' and '%T' in assignment", orig_type_left, orig_type_right);
-               return;
        }
 }
 
@@ -4435,24 +4918,22 @@ static void semantic_arithmetic_addsubb_assign(binary_expression_t *expression)
  */
 static void semantic_logical_op(binary_expression_t *expression)
 {
-       expression_t *left            = expression->left;
-       expression_t *right           = expression->right;
-       type_t       *orig_type_left  = left->base.datatype;
-       type_t       *orig_type_right = right->base.datatype;
-
-       if(orig_type_left == NULL || orig_type_right == NULL)
-               return;
-
-       type_t *type_left  = skip_typeref(orig_type_left);
-       type_t *type_right = skip_typeref(orig_type_right);
+       expression_t *const left            = expression->left;
+       expression_t *const right           = expression->right;
+       type_t       *const orig_type_left  = left->base.type;
+       type_t       *const orig_type_right = right->base.type;
+       type_t       *const type_left       = skip_typeref(orig_type_left);
+       type_t       *const type_right      = skip_typeref(orig_type_right);
 
        if (!is_type_scalar(type_left) || !is_type_scalar(type_right)) {
                /* TODO: improve error message */
-               errorf(HERE, "operation needs scalar types");
+               if (is_type_valid(type_left) && is_type_valid(type_right)) {
+                       errorf(HERE, "operation needs scalar types");
+               }
                return;
        }
 
-       expression->expression.datatype = type_int;
+       expression->base.type = type_int;
 }
 
 /**
@@ -4460,8 +4941,8 @@ static void semantic_logical_op(binary_expression_t *expression)
  */
 static bool has_const_fields(const compound_type_t *type)
 {
-       const context_t     *context = &type->declaration->context;
-       const declaration_t *declaration = context->declarations;
+       const scope_t       *scope       = &type->declaration->scope;
+       const declaration_t *declaration = scope->declarations;
 
        for (; declaration != NULL; declaration = declaration->next) {
                if (declaration->namespc != NAMESPACE_NORMAL)
@@ -4481,10 +4962,7 @@ static bool has_const_fields(const compound_type_t *type)
 static void semantic_binexpr_assign(binary_expression_t *expression)
 {
        expression_t *left           = expression->left;
-       type_t       *orig_type_left = left->base.datatype;
-
-       if(orig_type_left == NULL)
-               return;
+       type_t       *orig_type_left = left->base.type;
 
        type_t *type_left = revert_automatic_type_conversion(left);
        type_left         = skip_typeref(orig_type_left);
@@ -4511,14 +4989,133 @@ static void semantic_binexpr_assign(binary_expression_t *expression)
                return;
        }
 
-       semantic_assign(orig_type_left, &expression->right, "assignment");
+       type_t *const res_type = semantic_assign(orig_type_left, expression->right,
+                                                "assignment");
+       if (res_type == NULL) {
+               errorf(expression->base.source_position,
+                       "cannot assign to '%T' from '%T'",
+                       orig_type_left, expression->right->base.type);
+       } else {
+               expression->right = create_implicit_cast(expression->right, res_type);
+       }
+
+       expression->base.type = orig_type_left;
+}
 
-       expression->expression.datatype = orig_type_left;
+static bool expression_has_effect(const expression_t *const expr)
+{
+       switch (expr->kind) {
+               case EXPR_UNKNOWN:                   break;
+               case EXPR_INVALID:                   break;
+               case EXPR_REFERENCE:                 return false;
+               case EXPR_CONST:                     return false;
+               case EXPR_CHAR_CONST:                return false;
+               case EXPR_STRING_LITERAL:            return false;
+               case EXPR_WIDE_STRING_LITERAL:       return false;
+               case EXPR_CALL: {
+                       const call_expression_t *const call = &expr->call;
+                       if (call->function->kind != EXPR_BUILTIN_SYMBOL)
+                               return true;
+
+                       switch (call->function->builtin_symbol.symbol->ID) {
+                               case T___builtin_va_end: return true;
+                               default:                 return false;
+                       }
+               }
+               case EXPR_CONDITIONAL: {
+                       const conditional_expression_t *const cond = &expr->conditional;
+                       return
+                               expression_has_effect(cond->true_expression) &&
+                               expression_has_effect(cond->false_expression);
+               }
+               case EXPR_SELECT:                    return false;
+               case EXPR_ARRAY_ACCESS:              return false;
+               case EXPR_SIZEOF:                    return false;
+               case EXPR_CLASSIFY_TYPE:             return false;
+               case EXPR_ALIGNOF:                   return false;
+
+               case EXPR_FUNCTION:                  return false;
+               case EXPR_PRETTY_FUNCTION:           return false;
+               case EXPR_BUILTIN_SYMBOL:            break; /* handled in EXPR_CALL */
+               case EXPR_BUILTIN_CONSTANT_P:        return false;
+               case EXPR_BUILTIN_PREFETCH:          return true;
+               case EXPR_OFFSETOF:                  return false;
+               case EXPR_VA_START:                  return true;
+               case EXPR_VA_ARG:                    return true;
+               case EXPR_STATEMENT:                 return true; // TODO
+               case EXPR_COMPOUND_LITERAL:          return false;
+
+               case EXPR_UNARY_NEGATE:              return false;
+               case EXPR_UNARY_PLUS:                return false;
+               case EXPR_UNARY_BITWISE_NEGATE:      return false;
+               case EXPR_UNARY_NOT:                 return false;
+               case EXPR_UNARY_DEREFERENCE:         return false;
+               case EXPR_UNARY_TAKE_ADDRESS:        return false;
+               case EXPR_UNARY_POSTFIX_INCREMENT:   return true;
+               case EXPR_UNARY_POSTFIX_DECREMENT:   return true;
+               case EXPR_UNARY_PREFIX_INCREMENT:    return true;
+               case EXPR_UNARY_PREFIX_DECREMENT:    return true;
+               case EXPR_UNARY_CAST: {
+                       type_t *type = skip_typeref(expr->base.type);
+                       return is_type_atomic(type, ATOMIC_TYPE_VOID);
+               }
+               case EXPR_UNARY_CAST_IMPLICIT:       return true;
+               case EXPR_UNARY_ASSUME:              return true;
+               case EXPR_UNARY_BITFIELD_EXTRACT:    return false;
+
+               case EXPR_BINARY_ADD:                return false;
+               case EXPR_BINARY_SUB:                return false;
+               case EXPR_BINARY_MUL:                return false;
+               case EXPR_BINARY_DIV:                return false;
+               case EXPR_BINARY_MOD:                return false;
+               case EXPR_BINARY_EQUAL:              return false;
+               case EXPR_BINARY_NOTEQUAL:           return false;
+               case EXPR_BINARY_LESS:               return false;
+               case EXPR_BINARY_LESSEQUAL:          return false;
+               case EXPR_BINARY_GREATER:            return false;
+               case EXPR_BINARY_GREATEREQUAL:       return false;
+               case EXPR_BINARY_BITWISE_AND:        return false;
+               case EXPR_BINARY_BITWISE_OR:         return false;
+               case EXPR_BINARY_BITWISE_XOR:        return false;
+               case EXPR_BINARY_SHIFTLEFT:          return false;
+               case EXPR_BINARY_SHIFTRIGHT:         return false;
+               case EXPR_BINARY_ASSIGN:             return true;
+               case EXPR_BINARY_MUL_ASSIGN:         return true;
+               case EXPR_BINARY_DIV_ASSIGN:         return true;
+               case EXPR_BINARY_MOD_ASSIGN:         return true;
+               case EXPR_BINARY_ADD_ASSIGN:         return true;
+               case EXPR_BINARY_SUB_ASSIGN:         return true;
+               case EXPR_BINARY_SHIFTLEFT_ASSIGN:   return true;
+               case EXPR_BINARY_SHIFTRIGHT_ASSIGN:  return true;
+               case EXPR_BINARY_BITWISE_AND_ASSIGN: return true;
+               case EXPR_BINARY_BITWISE_XOR_ASSIGN: return true;
+               case EXPR_BINARY_BITWISE_OR_ASSIGN:  return true;
+               case EXPR_BINARY_LOGICAL_AND:
+               case EXPR_BINARY_LOGICAL_OR:
+               case EXPR_BINARY_COMMA:
+                       return expression_has_effect(expr->binary.right);
+
+               case EXPR_BINARY_BUILTIN_EXPECT:     return true;
+               case EXPR_BINARY_ISGREATER:          return false;
+               case EXPR_BINARY_ISGREATEREQUAL:     return false;
+               case EXPR_BINARY_ISLESS:             return false;
+               case EXPR_BINARY_ISLESSEQUAL:        return false;
+               case EXPR_BINARY_ISLESSGREATER:      return false;
+               case EXPR_BINARY_ISUNORDERED:        return false;
+       }
+
+       panic("unexpected statement");
 }
 
 static void semantic_comma(binary_expression_t *expression)
 {
-       expression->expression.datatype = expression->right->base.datatype;
+       if (warning.unused_value) {
+               const expression_t *const left = expression->left;
+               if (!expression_has_effect(left)) {
+                       warningf(left->base.source_position, "left-hand operand of comma expression has no effect");
+               }
+       }
+       expression->base.type = expression->right->base.type;
 }
 
 #define CREATE_BINEXPR_PARSER(token_type, binexpression_type, sfunc, lr)  \
@@ -4526,10 +5123,12 @@ static expression_t *parse_##binexpression_type(unsigned precedence,      \
                                                 expression_t *left)       \
 {                                                                         \
        eat(token_type);                                                      \
+       source_position_t pos = HERE;                                         \
                                                                           \
        expression_t *right = parse_sub_expression(precedence + lr);          \
                                                                           \
        expression_t *binexpr = allocate_expression_zero(binexpression_type); \
+       binexpr->base.source_position = pos;                                  \
        binexpr->binary.left  = left;                                         \
        binexpr->binary.right = right;                                        \
        sfunc(&binexpr->binary);                                              \
@@ -4745,7 +5344,8 @@ static void init_expression_parsers(void)
                                                                  T_PLUSPLUS,   25);
        register_expression_parser(parse_EXPR_UNARY_PREFIX_DECREMENT,
                                                                  T_MINUSMINUS, 25);
-       register_expression_parser(parse_sizeof,                  T_sizeof,     25);
+       register_expression_parser(parse_sizeof,                      T_sizeof, 25);
+       register_expression_parser(parse_alignof,                T___alignof__, 25);
        register_expression_parser(parse_extension,            T___extension__, 25);
        register_expression_parser(parse_builtin_classify_type,
                                                     T___builtin_classify_type, 25);
@@ -4876,6 +5476,13 @@ static statement_t *parse_case_statement(void)
        statement->base.source_position  = token.source_position;
        statement->case_label.expression = parse_expression();
 
+       if (c_mode & _GNUC) {
+               if (token.type == T_DOTDOTDOT) {
+                       next_token();
+                       statement->case_label.end_range = parse_expression();
+               }
+       }
+
        expect(':');
 
        if (! is_constant_expression(statement->case_label.expression)) {
@@ -4896,7 +5503,7 @@ static statement_t *parse_case_statement(void)
                                "case label not within a switch statement");
                }
        }
-       statement->case_label.label_statement = parse_statement();
+       statement->case_label.statement = parse_statement();
 
        return statement;
 }
@@ -4907,9 +5514,8 @@ static statement_t *parse_case_statement(void)
 static case_label_statement_t *
 find_default_label(const switch_statement_t *statement)
 {
-       for (case_label_statement_t *label = statement->first_case;
-            label != NULL;
-                label = label->next) {
+       case_label_statement_t *label = statement->first_case;
+       for ( ; label != NULL; label = label->next) {
                if (label->expression == NULL)
                        return label;
        }
@@ -4932,7 +5538,7 @@ static statement_t *parse_default_statement(void)
                const case_label_statement_t *def_label = find_default_label(current_switch);
                if (def_label != NULL) {
                        errorf(HERE, "multiple default labels in one switch");
-                       errorf(def_label->statement.source_position,
+                       errorf(def_label->base.source_position,
                                "this is the first default label");
                } else {
                        /* link all cases into the switch statement */
@@ -4947,7 +5553,7 @@ static statement_t *parse_default_statement(void)
                errorf(statement->base.source_position,
                        "'default' label not within a switch statement");
        }
-       statement->label.label_statement = parse_statement();
+       statement->case_label.statement = parse_statement();
 
        return statement;
 }
@@ -4962,12 +5568,12 @@ static declaration_t *get_label(symbol_t *symbol)
        /* if we found a label in the same function, then we already created the
         * declaration */
        if(candidate != NULL
-                       && candidate->parent_context == &current_function->context) {
+                       && candidate->parent_scope == &current_function->scope) {
                return candidate;
        }
 
        /* otherwise we need to create a new one */
-       declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->namespc       = NAMESPACE_LABEL;
        declaration->symbol        = symbol;
 
@@ -4997,23 +5603,37 @@ static statement_t *parse_label_statement(void)
                label->source_position = token.source_position;
        }
 
-       label_statement_t *label_statement = allocate_ast_zero(sizeof(label[0]));
+       statement_t *statement = allocate_statement_zero(STATEMENT_LABEL);
 
-       label_statement->statement.kind            = STATEMENT_LABEL;
-       label_statement->statement.source_position = token.source_position;
-       label_statement->label                     = label;
+       statement->base.source_position = token.source_position;
+       statement->label.label          = label;
 
        eat(':');
 
        if(token.type == '}') {
                /* TODO only warn? */
                errorf(HERE, "label at end of compound statement");
-               return (statement_t*) label_statement;
+               return statement;
+       } else {
+               if (token.type == ';') {
+                       /* eat an empty statement here, to avoid the warning about an empty
+                        * after a label.  label:; is commonly used to have a label before
+                        * a }. */
+                       next_token();
+               } else {
+                       statement->label.statement = parse_statement();
+               }
+       }
+
+       /* remember the labels's in a list for later checking */
+       if (label_last == NULL) {
+               label_first = &statement->label;
        } else {
-               label_statement->label_statement = parse_statement();
+               label_last->next = &statement->label;
        }
+       label_last = &statement->label;
 
-       return (statement_t*) label_statement;
+       return statement;
 }
 
 /**
@@ -5023,21 +5643,20 @@ static statement_t *parse_if(void)
 {
        eat(T_if);
 
-       if_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_IF;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_IF);
+       statement->base.source_position = token.source_position;
 
        expect('(');
-       statement->condition = parse_expression();
+       statement->ifs.condition = parse_expression();
        expect(')');
 
-       statement->true_statement = parse_statement();
+       statement->ifs.true_statement = parse_statement();
        if(token.type == T_else) {
                next_token();
-               statement->false_statement = parse_statement();
+               statement->ifs.false_statement = parse_statement();
        }
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5047,29 +5666,42 @@ static statement_t *parse_switch(void)
 {
        eat(T_switch);
 
-       switch_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_SWITCH;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_SWITCH);
+       statement->base.source_position = token.source_position;
 
        expect('(');
        expression_t *const expr = parse_expression();
-       type_t       *const type = promote_integer(skip_typeref(expr->base.datatype));
-       statement->expression = create_implicit_cast(expr, type);
+       type_t       *      type = skip_typeref(expr->base.type);
+       if (is_type_integer(type)) {
+               type = promote_integer(type);
+       } else if (is_type_valid(type)) {
+               errorf(expr->base.source_position,
+                      "switch quantity is not an integer, but '%T'", type);
+               type = type_error_type;
+       }
+       statement->switchs.expression = create_implicit_cast(expr, type);
        expect(')');
 
        switch_statement_t *rem = current_switch;
-       current_switch  = statement;
-       statement->body = parse_statement();
-       current_switch  = rem;
+       current_switch          = &statement->switchs;
+       statement->switchs.body = parse_statement();
+       current_switch          = rem;
 
-       return (statement_t*) statement;
+       if (warning.switch_default
+                       && find_default_label(&statement->switchs) == NULL) {
+               warningf(statement->base.source_position, "switch has no default case");
+       }
+
+       return statement;
 }
 
 static statement_t *parse_loop_body(statement_t *const loop)
 {
        statement_t *const rem = current_loop;
        current_loop = loop;
+
        statement_t *const body = parse_statement();
+
        current_loop = rem;
        return body;
 }
@@ -5081,17 +5713,16 @@ static statement_t *parse_while(void)
 {
        eat(T_while);
 
-       while_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_WHILE;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_WHILE);
+       statement->base.source_position = token.source_position;
 
        expect('(');
-       statement->condition = parse_expression();
+       statement->whiles.condition = parse_expression();
        expect(')');
 
-       statement->body = parse_loop_body((statement_t*)statement);
+       statement->whiles.body = parse_loop_body(statement);
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5101,18 +5732,19 @@ static statement_t *parse_do(void)
 {
        eat(T_do);
 
-       do_while_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_DO_WHILE;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement = allocate_statement_zero(STATEMENT_DO_WHILE);
+
+       statement->base.source_position = token.source_position;
+
+       statement->do_while.body = parse_loop_body(statement);
 
-       statement->body = parse_loop_body((statement_t*)statement);
        expect(T_while);
        expect('(');
-       statement->condition = parse_expression();
+       statement->do_while.condition = parse_expression();
        expect(')');
        expect(';');
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5122,21 +5754,24 @@ static statement_t *parse_for(void)
 {
        eat(T_for);
 
-       for_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_FOR;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_FOR);
+       statement->base.source_position = token.source_position;
 
        expect('(');
 
-       int         top          = environment_top();
-       context_t  *last_context = context;
-       set_context(&statement->context);
+       int      top        = environment_top();
+       scope_t *last_scope = scope;
+       set_scope(&statement->fors.scope);
 
        if(token.type != ';') {
                if(is_declaration_specifier(&token, false)) {
                        parse_declaration(record_declaration);
                } else {
-                       statement->initialisation = parse_expression();
+                       expression_t *const init = parse_expression();
+                       statement->fors.initialisation = init;
+                       if (warning.unused_value  && !expression_has_effect(init)) {
+                               warningf(init->base.source_position, "initialisation of 'for'-statement has no effect");
+                       }
                        expect(';');
                }
        } else {
@@ -5144,20 +5779,24 @@ static statement_t *parse_for(void)
        }
 
        if(token.type != ';') {
-               statement->condition = parse_expression();
+               statement->fors.condition = parse_expression();
        }
        expect(';');
        if(token.type != ')') {
-               statement->step = parse_expression();
+               expression_t *const step = parse_expression();
+               statement->fors.step = step;
+               if (warning.unused_value  && !expression_has_effect(step)) {
+                       warningf(step->base.source_position, "step of 'for'-statement has no effect");
+               }
        }
        expect(')');
-       statement->body = parse_loop_body((statement_t*)statement);
+       statement->fors.body = parse_loop_body(statement);
 
-       assert(context == &statement->context);
-       set_context(last_context);
+       assert(scope == &statement->fors.scope);
+       set_scope(last_scope);
        environment_pop_to(top);
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5177,23 +5816,22 @@ static statement_t *parse_goto(void)
 
        declaration_t *label = get_label(symbol);
 
-       goto_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-
-       statement->statement.kind            = STATEMENT_GOTO;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_GOTO);
+       statement->base.source_position = token.source_position;
 
-       statement->label = label;
+       statement->gotos.label = label;
 
        /* remember the goto's in a list for later checking */
        if (goto_last == NULL) {
-               goto_first = goto_last = statement;
+               goto_first = &statement->gotos;
        } else {
-               goto_last->next = statement;
+               goto_last->next = &statement->gotos;
        }
+       goto_last = &statement->gotos;
 
        expect(';');
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5201,18 +5839,19 @@ static statement_t *parse_goto(void)
  */
 static statement_t *parse_continue(void)
 {
-       eat(T_continue);
-       expect(';');
-
-       statement_t *statement          = allocate_ast_zero(sizeof(statement[0]));
-       statement->kind                 = STATEMENT_CONTINUE;
-       statement->base.source_position = token.source_position;
-
+       statement_t *statement;
        if (current_loop == NULL) {
                errorf(HERE, "continue statement not within loop");
-               return NULL;
+               statement = NULL;
+       } else {
+               statement = allocate_statement_zero(STATEMENT_CONTINUE);
+
+               statement->base.source_position = token.source_position;
        }
 
+       eat(T_continue);
+       expect(';');
+
        return statement;
 }
 
@@ -5221,17 +5860,19 @@ static statement_t *parse_continue(void)
  */
 static statement_t *parse_break(void)
 {
-       eat(T_break);
-       expect(';');
-
-       statement_t *statement          = allocate_ast_zero(sizeof(statement[0]));
-       statement->kind                 = STATEMENT_BREAK;
-       statement->base.source_position = token.source_position;
-
+       statement_t *statement;
        if (current_switch == NULL && current_loop == NULL) {
                errorf(HERE, "break statement not within loop or switch");
-               return NULL;
+               statement = NULL;
+       } else {
+               statement = allocate_statement_zero(STATEMENT_BREAK);
+
+               statement->base.source_position = token.source_position;
        }
+
+       eat(T_break);
+       expect(';');
+
        return statement;
 }
 
@@ -5255,6 +5896,31 @@ static bool is_local_var_declaration(const declaration_t *declaration) {
        }
 }
 
+/**
+ * Check if a given declaration represents a variable.
+ */
+static bool is_var_declaration(const declaration_t *declaration) {
+       switch ((storage_class_tag_t) declaration->storage_class) {
+       case STORAGE_CLASS_NONE:
+       case STORAGE_CLASS_EXTERN:
+       case STORAGE_CLASS_STATIC:
+       case STORAGE_CLASS_AUTO:
+       case STORAGE_CLASS_REGISTER:
+       case STORAGE_CLASS_THREAD:
+       case STORAGE_CLASS_THREAD_EXTERN:
+       case STORAGE_CLASS_THREAD_STATIC: {
+               const type_t *type = skip_typeref(declaration->type);
+               if(is_type_function(type)) {
+                       return false;
+               } else {
+                       return true;
+               }
+       }
+       default:
+               return false;
+       }
+}
+
 /**
  * Check if a given expression represents a local variable.
  */
@@ -5267,6 +5933,21 @@ static bool is_local_variable(const expression_t *expression)
        return is_local_var_declaration(declaration);
 }
 
+/**
+ * Check if a given expression represents a local variable and
+ * return its declaration then, else return NULL.
+ */
+declaration_t *expr_is_variable(const expression_t *expression)
+{
+       if (expression->base.kind != EXPR_REFERENCE) {
+               return NULL;
+       }
+       declaration_t *declaration = expression->reference.declaration;
+       if (is_var_declaration(declaration))
+               return declaration;
+       return NULL;
+}
+
 /**
  * Parse a return statement.
  */
@@ -5274,14 +5955,8 @@ static statement_t *parse_return(void)
 {
        eat(T_return);
 
-       return_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-
-       statement->statement.kind            = STATEMENT_RETURN;
-       statement->statement.source_position = token.source_position;
-
-       assert(is_type_function(current_function->type));
-       function_type_t *function_type = &current_function->type->function;
-       type_t          *return_type   = function_type->return_type;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_RETURN);
+       statement->base.source_position = token.source_position;
 
        expression_t *return_value = NULL;
        if(token.type != ';') {
@@ -5289,43 +5964,46 @@ static statement_t *parse_return(void)
        }
        expect(';');
 
-       if(return_type == NULL)
-               return (statement_t*) statement;
-       if(return_value != NULL && return_value->base.datatype == NULL)
-               return (statement_t*) statement;
-
-       return_type = skip_typeref(return_type);
+       const type_t *const func_type = current_function->type;
+       assert(is_type_function(func_type));
+       type_t *const return_type = skip_typeref(func_type->function.return_type);
 
        if(return_value != NULL) {
-               type_t *return_value_type = skip_typeref(return_value->base.datatype);
+               type_t *return_value_type = skip_typeref(return_value->base.type);
 
                if(is_type_atomic(return_type, ATOMIC_TYPE_VOID)
                                && !is_type_atomic(return_value_type, ATOMIC_TYPE_VOID)) {
-                       warningf(statement->statement.source_position,
-                               "'return' with a value, in function returning void");
+                       warningf(statement->base.source_position,
+                                "'return' with a value, in function returning void");
                        return_value = NULL;
                } else {
-                       if(return_type != NULL) {
-                               semantic_assign(return_type, &return_value, "'return'");
+                       type_t *const res_type = semantic_assign(return_type,
+                               return_value, "'return'");
+                       if (res_type == NULL) {
+                               errorf(statement->base.source_position,
+                                      "cannot return something of type '%T' in function returning '%T'",
+                                      return_value->base.type, return_type);
+                       } else {
+                               return_value = create_implicit_cast(return_value, res_type);
                        }
                }
                /* check for returning address of a local var */
                if (return_value->base.kind == EXPR_UNARY_TAKE_ADDRESS) {
                        const expression_t *expression = return_value->unary.value;
                        if (is_local_variable(expression)) {
-                               warningf(statement->statement.source_position,
-                                       "function returns address of local variable");
+                               warningf(statement->base.source_position,
+                                        "function returns address of local variable");
                        }
                }
        } else {
                if(!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
-                       warningf(statement->statement.source_position,
-                               "'return' without value, in function returning non-void");
+                       warningf(statement->base.source_position,
+                                "'return' without value, in function returning non-void");
                }
        }
-       statement->return_value = return_value;
+       statement->returns.value = return_value;
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5341,7 +6019,7 @@ static statement_t *parse_declaration_statement(void)
        parse_declaration(record_declaration);
 
        if(before == NULL) {
-               statement->declaration.declarations_begin = context->declarations;
+               statement->declaration.declarations_begin = scope->declarations;
        } else {
                statement->declaration.declarations_begin = before->next;
        }
@@ -5358,7 +6036,12 @@ static statement_t *parse_expression_statement(void)
        statement_t *statement = allocate_statement_zero(STATEMENT_EXPRESSION);
 
        statement->base.source_position  = token.source_position;
-       statement->expression.expression = parse_expression();
+       expression_t *const expr         = parse_expression();
+       statement->expression.expression = expr;
+
+       if (warning.unused_value  && !expression_has_effect(expr)) {
+               warningf(expr->base.source_position, "statement has no effect");
+       }
 
        expect(';');
 
@@ -5427,6 +6110,9 @@ static statement_t *parse_statement(void)
                break;
 
        case ';':
+               if (warning.empty_statement) {
+                       warningf(HERE, "statement is empty");
+               }
                next_token();
                statement = NULL;
                break;
@@ -5474,47 +6160,47 @@ static statement_t *parse_statement(void)
  */
 static statement_t *parse_compound_statement(void)
 {
-       compound_statement_t *compound_statement
-               = allocate_ast_zero(sizeof(compound_statement[0]));
-       compound_statement->statement.kind            = STATEMENT_COMPOUND;
-       compound_statement->statement.source_position = token.source_position;
+       statement_t *statement = allocate_statement_zero(STATEMENT_COMPOUND);
+
+       statement->base.source_position = token.source_position;
 
        eat('{');
 
-       int        top          = environment_top();
-       context_t *last_context = context;
-       set_context(&compound_statement->context);
+       int      top        = environment_top();
+       scope_t *last_scope = scope;
+       set_scope(&statement->compound.scope);
 
        statement_t *last_statement = NULL;
 
        while(token.type != '}' && token.type != T_EOF) {
-               statement_t *statement = parse_statement();
-               if(statement == NULL)
+               statement_t *sub_statement = parse_statement();
+               if(sub_statement == NULL)
                        continue;
 
                if(last_statement != NULL) {
-                       last_statement->base.next = statement;
+                       last_statement->base.next = sub_statement;
                } else {
-                       compound_statement->statements = statement;
+                       statement->compound.statements = sub_statement;
                }
 
-               while(statement->base.next != NULL)
-                       statement = statement->base.next;
+               while(sub_statement->base.next != NULL)
+                       sub_statement = sub_statement->base.next;
 
-               last_statement = statement;
+               last_statement = sub_statement;
        }
 
        if(token.type == '}') {
                next_token();
        } else {
-               errorf(compound_statement->statement.source_position, "end of file while looking for closing '}'");
+               errorf(statement->base.source_position,
+                      "end of file while looking for closing '}'");
        }
 
-       assert(context == &compound_statement->context);
-       set_context(last_context);
+       assert(scope == &statement->compound.scope);
+       set_scope(last_scope);
        environment_pop_to(top);
 
-       return (statement_t*) compound_statement;
+       return statement;
 }
 
 /**
@@ -5537,6 +6223,37 @@ static void initialize_builtin_types(void)
        type_wchar_t_ptr   = make_pointer_type(type_wchar_t,   TYPE_QUALIFIER_NONE);
 }
 
+/**
+ * Check for unused global static functions and variables
+ */
+static void check_unused_globals(void)
+{
+       if (!warning.unused_function && !warning.unused_variable)
+               return;
+
+       for (const declaration_t *decl = global_scope->declarations; decl != NULL; decl = decl->next) {
+               if (decl->used || decl->storage_class != STORAGE_CLASS_STATIC)
+                       continue;
+
+               type_t *const type = decl->type;
+               const char *s;
+               if (is_type_function(skip_typeref(type))) {
+                       if (!warning.unused_function || decl->is_inline)
+                               continue;
+
+                       s = (decl->init.statement != NULL ? "defined" : "declared");
+               } else {
+                       if (!warning.unused_variable)
+                               continue;
+
+                       s = "defined";
+               }
+
+               warningf(decl->source_position, "'%#T' %s but not used",
+                       type, decl->symbol, s);
+       }
+}
+
 /**
  * Parse a translation unit.
  */
@@ -5544,11 +6261,11 @@ static translation_unit_t *parse_translation_unit(void)
 {
        translation_unit_t *unit = allocate_ast_zero(sizeof(unit[0]));
 
-       assert(global_context == NULL);
-       global_context = &unit->context;
+       assert(global_scope == NULL);
+       global_scope = &unit->scope;
 
-       assert(context == NULL);
-       set_context(&unit->context);
+       assert(scope == NULL);
+       set_scope(&unit->scope);
 
        initialize_builtin_types();
 
@@ -5562,12 +6279,13 @@ static translation_unit_t *parse_translation_unit(void)
                }
        }
 
-       assert(context == &unit->context);
-       context          = NULL;
+       assert(scope == &unit->scope);
+       scope          = NULL;
        last_declaration = NULL;
 
-       assert(global_context == &unit->context);
-       global_context = NULL;
+       assert(global_scope == &unit->scope);
+       check_unused_globals();
+       global_scope = NULL;
 
        return unit;
 }