X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=parser.c;h=702cdcf7afa74c28d3d72cbfec26465bd54e8d39;hb=cbfb5f3fbdbc786f6893a12dd636916278a2fd4e;hp=ccb7789bd1c0a868559c29ca187d5c8e7470dc3c;hpb=e9b50bf5bd1addc58c2f8cb12abcff139529fef4;p=cparser

diff --git a/parser.c b/parser.c
index ccb7789..702cdcf 100644
--- a/parser.c
+++ b/parser.c
@@ -22,7 +22,7 @@
 typedef struct {
 	declaration_t *old_declaration;
 	symbol_t      *symbol;
-	unsigned short namespace;
+	unsigned short namespc;
 } stack_entry_t;
 
 static token_t         token;
@@ -341,6 +341,14 @@ static void eat_brace(void)
     }                                              \
     next_token();
 
+#define expect_block(expected)                     \
+    if(UNLIKELY(token.type != (expected))) {       \
+        parse_error_expected(NULL, (expected), 0); \
+        eat_block();                               \
+        return NULL;                               \
+    }                                              \
+    next_token();
+
 #define expect_void(expected)                      \
     if(UNLIKELY(token.type != (expected))) {       \
         parse_error_expected(NULL, (expected), 0); \
@@ -372,20 +380,20 @@ static bool is_compatible_declaration (declaration_t *declaration,
 	return declaration->type == previous->type;
 }
 
-static declaration_t *get_declaration(symbol_t *symbol, namespace_t namespace)
+static declaration_t *get_declaration(symbol_t *symbol, namespace_t namespc)
 {
 	declaration_t *declaration = symbol->declaration;
 	for( ; declaration != NULL; declaration = declaration->symbol_next) {
-		if(declaration->namespace == namespace)
+		if(declaration->namespc == namespc)
 			return declaration;
 	}
 
 	return NULL;
 }
 
-static const char *get_namespace_prefix(namespace_t namespace)
+static const char *get_namespace_prefix(namespace_t namespc)
 {
-	switch(namespace) {
+	switch(namespc) {
 	case NAMESPACE_NORMAL:
 		return "";
 	case NAMESPACE_UNION:
@@ -409,20 +417,20 @@ static declaration_t *stack_push(stack_entry_t **stack_ptr,
                                  context_t *parent_context)
 {
 	symbol_t    *symbol    = declaration->symbol;
-	namespace_t  namespace = (namespace_t)declaration->namespace;
+	namespace_t  namespc = (namespace_t)declaration->namespc;
 
 	/* a declaration should be only pushed once */
 	assert(declaration->parent_context == NULL);
 	declaration->parent_context = parent_context;
 
-	declaration_t *previous_declaration = get_declaration(symbol, namespace);
+	declaration_t *previous_declaration = get_declaration(symbol, namespc);
 	assert(declaration != previous_declaration);
 	if(previous_declaration != NULL
 			&& previous_declaration->parent_context == context) {
 		if(!is_compatible_declaration(declaration, previous_declaration)) {
 			parser_print_error_prefix_pos(declaration->source_position);
 			fprintf(stderr, "definition of symbol %s%s with type ",
-					get_namespace_prefix(namespace), symbol->string);
+					get_namespace_prefix(namespc), symbol->string);
 			print_type_quoted(declaration->type);
 			fputc('\n', stderr);
 			parser_print_error_prefix_pos(
@@ -487,7 +495,7 @@ static declaration_t *stack_push(stack_entry_t **stack_ptr,
 	stack_entry_t entry;
 	entry.symbol          = symbol;
 	entry.old_declaration = symbol->declaration;
-	entry.namespace       = namespace;
+	entry.namespc       = namespc;
 	ARR_APP1(stack_entry_t, *stack_ptr, entry);
 
 	/* replace/add declaration into declaration list of the symbol */
@@ -498,7 +506,7 @@ static declaration_t *stack_push(stack_entry_t **stack_ptr,
 		declaration_t *iter      = symbol->declaration;
 		for( ; iter != NULL; iter_last = iter, iter = iter->symbol_next) {
 			/* replace an entry? */
-			if(iter->namespace == namespace) {
+			if(iter->namespc == namespc) {
 				if(iter_last == NULL) {
 					symbol->declaration = declaration;
 				} else {
@@ -546,12 +554,12 @@ static void stack_pop_to(stack_entry_t **stack_ptr, size_t new_top)
 
 		declaration_t *old_declaration = entry->old_declaration;
 		symbol_t      *symbol          = entry->symbol;
-		namespace_t    namespace       = (namespace_t)entry->namespace;
+		namespace_t    namespc         = (namespace_t)entry->namespc;
 
 		/* replace/remove declaration */
 		declaration_t *declaration = symbol->declaration;
 		assert(declaration != NULL);
-		if(declaration->namespace == namespace) {
+		if(declaration->namespc == namespc) {
 			if(old_declaration == NULL) {
 				symbol->declaration = declaration->symbol_next;
 			} else {
@@ -562,7 +570,7 @@ static void stack_pop_to(stack_entry_t **stack_ptr, size_t new_top)
 			declaration_t *iter      = declaration->symbol_next;
 			for( ; iter != NULL; iter_last = iter, iter = iter->symbol_next) {
 				/* replace an entry? */
-				if(iter->namespace == namespace) {
+				if(iter->namespc == namespc) {
 					assert(iter_last != NULL);
 					iter_last->symbol_next = old_declaration;
 					old_declaration->symbol_next = iter->symbol_next;
@@ -691,7 +699,7 @@ static expression_t *create_implicit_cast(expression_t *expression,
 				panic("casting of non-atomic types not implemented yet");
 		}
 
-		type_error_incompatible("can't implicitely cast types",
+		type_error_incompatible("can't implicitly cast types",
 														expression->source_position,
 														source_type, dest_type);
 		return expression;
@@ -711,23 +719,48 @@ static void semantic_assign(type_t *orig_type_left, expression_t **right,
 	type_t *const type_left  = skip_typeref(orig_type_left);
 	type_t *const type_right = skip_typeref(orig_type_right);
 
-	if(type_left == type_right) {
-		/* fine */
-	} else if ((is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) ||
-	           (type_left->type == TYPE_POINTER && is_null_expression(*right)) ||
-	           (type_left->type == TYPE_POINTER && type_right->type == TYPE_POINTER)) {
+	if (type_left == type_right) {
+		return;
+	}
+
+	if ((is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) ||
+	    (type_left->type == TYPE_POINTER && is_null_expression(*right)) ||
+	    (type_left->type == TYPE_POINTER && type_right->type == TYPE_POINTER)) {
 		*right = create_implicit_cast(*right, type_left);
-	} else {
-		/* TODO: improve error message */
-		parser_print_error_prefix();
-		fprintf(stderr, "incompatible types in %s\n", context);
-		parser_print_error_prefix();
-		print_type_quoted(type_left);
-		fputs(" <- ", stderr);
-		print_type_quoted(type_right);
-		fputs("\n", stderr);
+		return;
+	}
+
+	if (type_left->type == TYPE_POINTER) {
+		switch (type_right->type) {
+			case TYPE_FUNCTION: {
+				pointer_type_t *const ptr_type = (pointer_type_t*)type_left;
+				if (ptr_type->points_to == type_right) {
+					return;
+				}
+				break;
+			}
+
+			case TYPE_ARRAY: {
+				pointer_type_t *const ptr_type = (pointer_type_t*)type_left;
+				array_type_t   *const arr_type = (array_type_t*)type_right;
+				if (ptr_type->points_to == arr_type->element_type) {
+					return;
+				}
+				break;
+			}
+
+			default: break;
+		}
 	}
 
+	/* TODO: improve error message */
+	parser_print_error_prefix();
+	fprintf(stderr, "incompatible types in %s\n", context);
+	parser_print_error_prefix();
+	print_type_quoted(type_left);
+	fputs(" <- ", stderr);
+	print_type_quoted(type_right);
+	fputs("\n", stderr);
 }
 
 static expression_t *parse_constant_expression(void)
@@ -819,6 +852,7 @@ attributes_finished:
 	;
 }
 
+#if 0
 static designator_t *parse_designation(void)
 {
 	if(token.type != '[' && token.type != '.')
@@ -861,69 +895,225 @@ static designator_t *parse_designation(void)
 		last = designator;
 	}
 }
+#endif
 
-static initializer_t *parse_initializer_list(type_t *type);
-
-static initializer_t *parse_initializer(type_t *type)
+static initializer_t *initializer_from_expression(type_t *type,
+                                                  expression_t *expression)
 {
-	designator_t *designator = parse_designation();
+	initializer_value_t *result = allocate_ast_zero(sizeof(result[0]));
 
-	initializer_t *result;
-	if(token.type == '{') {
-		result = parse_initializer_list(type);
-	} else {
-		result          = allocate_ast_zero(sizeof(result[0]));
-		result->type    = INITIALIZER_VALUE;
-		result->v.value = parse_assignment_expression();
+	/* TODO check that expression is a constant expression */
 
-		if(type != NULL) {
-			semantic_assign(type, &result->v.value, "initializer");
+	/* § 6.7.8.14/15 char array may be initialized by string literals */
+	if(type->type == TYPE_ARRAY && expression->type == EXPR_STRING_LITERAL) {
+		array_type_t *array_type   = (array_type_t*) type;
+		type_t       *element_type = array_type->element_type;
+
+		if(element_type->type == TYPE_ATOMIC) {
+			atomic_type_t      *atomic_type = (atomic_type_t*) element_type;
+			atomic_type_type_t  atype       = atomic_type->atype;
+
+			/* TODO handle wide strings */
+			if(atype == ATOMIC_TYPE_CHAR
+					|| atype == ATOMIC_TYPE_SCHAR
+					|| atype == ATOMIC_TYPE_UCHAR) {
+				/* it's fine TODO: check for length of string array... */
+				goto initializer_from_expression_finished;
+			}
 		}
 	}
-	result->designator = designator;
 
-	return result;
+	semantic_assign(type, &expression, "initializer");
+
+initializer_from_expression_finished:
+	result->initializer.type = INITIALIZER_VALUE;
+	result->value            = expression;
+
+	return (initializer_t*) result;
 }
 
-static initializer_t *parse_initializer_list(type_t *type)
+static initializer_t *parse_sub_initializer(type_t *type,
+                                            expression_t *expression,
+                                            type_t *expression_type);
+
+static initializer_t *parse_sub_initializer_elem(type_t *type)
 {
-	eat('{');
+	if(token.type == '{') {
+		return parse_sub_initializer(type, NULL, NULL);
+	}
 
-	/* TODO: semantic */
-	(void) type;
+	expression_t *expression      = parse_assignment_expression();
+	type_t       *expression_type = skip_typeref(expression->datatype);
 
-	initializer_t *result = allocate_ast_zero(sizeof(result[0]));
-	result->type = INITIALIZER_LIST;
+	return parse_sub_initializer(type, expression, expression_type);
+}
 
-	initializer_t *last = NULL;
-	while(1) {
-		initializer_t *initializer = parse_initializer(NULL);
-		if(last != NULL) {
-			last->next = initializer;
+static bool had_initializer_brace_warning;
+
+static initializer_t *parse_sub_initializer(type_t *type,
+                                            expression_t *expression,
+                                            type_t *expression_type)
+{
+	if(is_type_scalar(type)) {
+		/* there might be extra {} hierarchies */
+		if(token.type == '{') {
+			next_token();
+			if(!had_initializer_brace_warning) {
+				parse_warning("braces around scalar initializer");
+				had_initializer_brace_warning = true;
+			}
+			initializer_t *result = parse_sub_initializer(type, NULL, NULL);
+			if(token.type == ',') {
+				next_token();
+				/* TODO: warn about excessive elements */
+			}
+			expect_block('}');
+			return result;
+		}
+
+		if(expression == NULL) {
+			expression = parse_assignment_expression();
+		}
+		return initializer_from_expression(type, expression);
+	}
+
+	/* TODO: ignore qualifiers, comparing pointers is probably
+	 * not correct */
+	if(expression != NULL && expression_type == type) {
+		initializer_t *result = allocate_ast_zero(sizeof(result[0]));
+		result->type          = INITIALIZER_VALUE;
+
+		if(type != NULL) {
+			semantic_assign(type, &expression, "initializer");
+		}
+		//result->v.value = expression;
+
+		return result;
+	}
+
+	bool read_paren = false;
+	if(token.type == '{') {
+		next_token();
+		read_paren = true;
+	}
+
+	/* descend into subtype */
+	initializer_t *result = NULL;
+	if(type->type == TYPE_ARRAY) {
+		array_type_t *array_type   = (array_type_t*) type;
+		type_t       *element_type = array_type->element_type;
+		element_type               = skip_typeref(element_type);
+
+		result
+			= parse_sub_initializer(element_type, expression, expression_type);
+	} else {
+		assert(type->type == TYPE_COMPOUND_STRUCT
+				|| type->type == TYPE_COMPOUND_UNION);
+		compound_type_t *compound_type = (compound_type_t*) type;
+		context_t       *context       = & compound_type->declaration->context;
+
+		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 {
-			result->v.list = initializer;
+			sub = parse_sub_initializer(first_type, expression,expression_type);
 		}
-		last = initializer;
 
-		if(token.type == '}')
-			break;
+		/* didn't match the subtypes -> try our parent type */
+		if(sub == NULL) {
+			assert(!read_paren);
+			return NULL;
+		}
 
-		if(token.type != ',') {
-			parse_error_expected("while parsing initializer list", ',', '}', 0);
-			eat_block();
-			return result;
+		initializer_t **elems = NEW_ARR_F(initializer_t*, 0);
+		ARR_APP1(initializer_t*, elems, sub);
+
+		declaration_t *iter  = first->next;
+		for( ; iter != NULL; iter = iter->next) {
+			if(iter->symbol == NULL)
+				continue;
+			if(iter->namespc != NAMESPACE_NORMAL)
+				continue;
+
+			if(token.type == '}')
+				break;
+			expect_block(',');
+
+			type_t *iter_type = iter->type;
+			iter_type         = skip_typeref(iter_type);
+
+			/* read next token */
+			initializer_t *sub = parse_sub_initializer(iter_type, NULL, NULL);
+			if(sub == NULL) {
+				/* TODO error, do nicer cleanup*/
+				parse_error("member initializer didn't match");
+				DEL_ARR_F(elems);
+				return NULL;
+			}
+			ARR_APP1(initializer_t*, elems, sub);
 		}
-		eat(',');
 
-		if(token.type == '}')
-			break;
+		int    len        = ARR_LEN(elems);
+		size_t elems_size = sizeof(initializer_t*) * len;
+
+		initializer_list_t *init
+			= allocate_ast_zero(sizeof(init[0]) + elems_size);
+
+		init->initializer.type = INITIALIZER_LIST;
+		init->len              = len;
+		memcpy(init->initializers, elems, elems_size);
+		DEL_ARR_F(elems);
+
+		result = (initializer_t*) init;
 	}
 
-	expect('}');
+	if(read_paren) {
+		if(token.type == ',')
+			next_token();
+		expect('}');
+	}
+	return result;
+}
+
+static initializer_t *parse_initializer(type_t *type)
+{
+	initializer_t *result;
+
+	type = skip_typeref(type);
+
+	if(token.type != '{') {
+		expression_t *expression = parse_assignment_expression();
+		return initializer_from_expression(type, expression);
+	}
+
+	if(is_type_scalar(type)) {
+		/* § 6.7.8.11 */
+		eat('{');
+
+		expression_t *expression = parse_assignment_expression();
+		result = initializer_from_expression(type, expression);
+
+		if(token.type == ',')
+			next_token();
+
+		expect('}');
+		return result;
+	} else {
+		result = parse_sub_initializer(type, NULL, NULL);
+	}
 
 	return result;
 }
 
+
+
 static declaration_t *parse_compound_type_specifier(bool is_struct)
 {
 	if(is_struct) {
@@ -935,6 +1125,11 @@ static declaration_t *parse_compound_type_specifier(bool is_struct)
 	symbol_t      *symbol      = NULL;
 	declaration_t *declaration = NULL;
 
+	if (token.type == T___attribute__) {
+		/* TODO */
+		parse_attributes();
+	}
+
 	if(token.type == T_IDENTIFIER) {
 		symbol = token.v.symbol;
 		next_token();
@@ -960,9 +1155,9 @@ static declaration_t *parse_compound_type_specifier(bool is_struct)
 		declaration = allocate_type_zero(sizeof(declaration[0]));
 
 		if(is_struct) {
-			declaration->namespace = NAMESPACE_STRUCT;
+			declaration->namespc = NAMESPACE_STRUCT;
 		} else {
-			declaration->namespace = NAMESPACE_UNION;
+			declaration->namespc = NAMESPACE_UNION;
 		}
 		declaration->source_position = token.source_position;
 		declaration->symbol          = symbol;
@@ -1056,7 +1251,7 @@ static declaration_t *parse_enum_specifier(void)
 	if(declaration == NULL) {
 		declaration = allocate_type_zero(sizeof(declaration[0]));
 
-		declaration->namespace       = NAMESPACE_ENUM;
+		declaration->namespc       = NAMESPACE_ENUM;
 		declaration->source_position = token.source_position;
 		declaration->symbol          = symbol;
 	}
@@ -1082,12 +1277,11 @@ static declaration_t *parse_enum_specifier(void)
  */
 static bool is_typedef_symbol(symbol_t *symbol)
 {
-	declaration_t *declaration = get_declaration(symbol, NAMESPACE_NORMAL);
-	if(declaration == NULL
-			|| declaration->storage_class != STORAGE_CLASS_TYPEDEF)
-		return false;
-
-	return true;
+	const declaration_t *const declaration =
+		get_declaration(symbol, NAMESPACE_NORMAL);
+	return
+		declaration != NULL &&
+		declaration->storage_class == STORAGE_CLASS_TYPEDEF;
 }
 
 static type_t *parse_typeof(void)
@@ -1511,6 +1705,15 @@ static declaration_t *parse_parameter(void)
 		parse_error("typedef not allowed in parameter list");
 	}
 
+	/* Array as last part of a paramter type is just syntactic sugar.  Turn it
+	 * into a pointer */
+	if (declaration->type->type == TYPE_ARRAY) {
+		const array_type_t *const arr_type =
+			(const array_type_t*)declaration->type;
+		declaration->type =
+			make_pointer_type(arr_type->element_type, TYPE_QUALIFIER_NONE);
+	}
+
 	return declaration;
 }
 
@@ -1724,6 +1927,14 @@ static construct_type_t *parse_inner_declarator(declaration_t *declaration,
 		if(may_be_abstract)
 			break;
 		parse_error_expected("while parsing declarator", T_IDENTIFIER, '(', 0);
+		/* avoid a loop in the outermost scope, because eat_statement doesn't
+		 * eat '}' */
+		if(token.type == '}' && current_function == NULL) {
+			next_token();
+		} else {
+			eat_statement();
+		}
+		return NULL;
 	}
 
 	while(true) {
@@ -1880,8 +2091,7 @@ static void parser_error_multiple_definition(declaration_t *previous,
 	fprintf(stderr, "multiple definition of symbol '%s'\n",
 	        declaration->symbol->string);
 	parser_print_error_prefix_pos(previous->source_position);
-	fprintf(stderr, "this is the location of the previous "
-	        "definition.\n");
+	fprintf(stderr, "this is the location of the previous definition.\n");
 }
 
 static void parse_init_declarators(const declaration_specifiers_t *specifiers)
@@ -1895,7 +2105,7 @@ static void parse_init_declarators(const declaration_specifiers_t *specifiers)
 		type_t *type = declaration->type;
 		if(type->type != TYPE_FUNCTION && declaration->is_inline) {
 			parser_print_warning_prefix_pos(declaration->source_position);
-			fprintf(stderr, "variable ‘%s’ declared ‘inline’\n",
+			fprintf(stderr, "variable '%s' declared 'inline'\n",
 			        declaration->symbol->string);
 		}
 
@@ -2197,7 +2407,7 @@ static expression_t *parse_reference(void)
 
 	if(declaration == NULL) {
 #ifndef STRICT_C99
-		/* an implicitely defined function */
+		/* an implicitly defined function */
 		if(token.type == '(') {
 			parser_print_prefix_pos(token.source_position);
 			fprintf(stderr, "warning: implicit declaration of function '%s'\n",
@@ -2624,7 +2834,7 @@ static expression_t *parse_select_expression(unsigned precedence,
 	if(iter == NULL) {
 		parser_print_error_prefix();
 		print_type_quoted(type_left);
-		fprintf(stderr, " has no memeber named '%s'\n", symbol->string);
+		fprintf(stderr, " has no member named '%s'\n", symbol->string);
 		return make_invalid_expression();
 	}
 
@@ -2643,20 +2853,24 @@ static expression_t *parse_call_expression(unsigned precedence,
 
 	function_type_t *function_type;
 	type_t          *type = expression->datatype;
-	if(type->type != TYPE_FUNCTION) {
-		/* TODO calling pointers to functions is ok */
+	if (type->type == TYPE_FUNCTION) {
+		function_type             = (function_type_t*) type;
+		call->expression.datatype = function_type->result_type;
+	} else if (type->type == TYPE_POINTER &&
+	           ((pointer_type_t*)type)->points_to->type == TYPE_FUNCTION) {
+		pointer_type_t *const ptr_type = (pointer_type_t*)type;
+		function_type                  = (function_type_t*)ptr_type->points_to;
+		call->expression.datatype      = function_type->result_type;
+	} else {
 		parser_print_error_prefix();
 		fputs("called object '", stderr);
 		print_expression(expression);
 		fputs("' (type ", stderr);
 		print_type_quoted(type);
-		fputs("is not a function\n", stderr);
+		fputs(") is not a function\n", stderr);
 
 		function_type             = NULL;
 		call->expression.datatype = NULL;
-	} else {
-		function_type             = (function_type_t*) type;
-		call->expression.datatype = function_type->result_type;
 	}
 
 	/* parse arguments */
@@ -2749,12 +2963,11 @@ static expression_t *parse_conditional_expression(unsigned precedence,
 	conditional->condition = expression;
 
 	/* 6.5.15.2 */
-	type_t *condition_type = conditional->condition->datatype;
-	if(condition_type != NULL) {
-		if(!is_type_scalar(skip_typeref(condition_type))) {
-			type_error("expected a scalar type", expression->source_position,
-			           condition_type);
-		}
+	type_t *condition_type_orig = conditional->condition->datatype;
+	type_t *condition_type      = skip_typeref(condition_type_orig);
+	if(condition_type != NULL && !is_type_scalar(condition_type)) {
+		type_error("expected a scalar type", expression->source_position,
+		           condition_type_orig);
 	}
 
 	conditional->true_expression = parse_expression();
@@ -2809,6 +3022,23 @@ static expression_t *parse_extension(unsigned precedence)
 	return parse_sub_expression(precedence);
 }
 
+static expression_t *parse_builtin_classify_type(const unsigned precedence)
+{
+	eat(T___builtin_classify_type);
+
+	classify_type_expression_t *const classify_type_expr =
+		allocate_ast_zero(sizeof(classify_type_expr[0]));
+	classify_type_expr->expression.type     = EXPR_CLASSIFY_TYPE;
+	classify_type_expr->expression.datatype = type_int;
+
+	expect('(');
+	expression_t *const expression = parse_sub_expression(precedence);
+	expect(')');
+	classify_type_expr->type_expression = expression;
+
+	return (expression_t*)classify_type_expr;
+}
+
 static void semantic_incdec(unary_expression_t *expression)
 {
 	type_t *orig_type = expression->value->datatype;
@@ -2843,6 +3073,36 @@ static void semantic_unexpr_arithmetic(unary_expression_t *expression)
 	expression->expression.datatype = orig_type;
 }
 
+static void semantic_unexpr_scalar(unary_expression_t *expression)
+{
+	type_t *orig_type = expression->value->datatype;
+	if(orig_type == NULL)
+		return;
+
+	type_t *type = skip_typeref(orig_type);
+	if (!is_type_scalar(type)) {
+		parse_error("operand of ! must be of scalar type\n");
+		return;
+	}
+
+	expression->expression.datatype = orig_type;
+}
+
+static void semantic_unexpr_integer(unary_expression_t *expression)
+{
+	type_t *orig_type = expression->value->datatype;
+	if(orig_type == NULL)
+		return;
+
+	type_t *type = skip_typeref(orig_type);
+	if (!is_type_integer(type)) {
+		parse_error("operand of ~ must be of integer type\n");
+		return;
+	}
+
+	expression->expression.datatype = orig_type;
+}
+
 static void semantic_dereference(unary_expression_t *expression)
 {
 	type_t *orig_type = expression->value->datatype;
@@ -2851,7 +3111,12 @@ static void semantic_dereference(unary_expression_t *expression)
 
 	type_t *type = skip_typeref(orig_type);
 	switch (type->type) {
-		case TYPE_ARRAY:
+		case TYPE_ARRAY: {
+			array_type_t *const array_type  = (array_type_t*)type;
+			expression->expression.datatype = array_type->element_type;
+			break;
+		}
+
 		case TYPE_POINTER: {
 			pointer_type_t *pointer_type    = (pointer_type_t*)type;
 			expression->expression.datatype = pointer_type->points_to;
@@ -2903,11 +3168,11 @@ static expression_t *parse_##unexpression_type(unsigned precedence)            \
 
 CREATE_UNARY_EXPRESSION_PARSER('-', UNEXPR_NEGATE, semantic_unexpr_arithmetic)
 CREATE_UNARY_EXPRESSION_PARSER('+', UNEXPR_PLUS,   semantic_unexpr_arithmetic)
-CREATE_UNARY_EXPRESSION_PARSER('!', UNEXPR_NOT,    semantic_unexpr_arithmetic)
+CREATE_UNARY_EXPRESSION_PARSER('!', UNEXPR_NOT,    semantic_unexpr_scalar)
 CREATE_UNARY_EXPRESSION_PARSER('*', UNEXPR_DEREFERENCE, semantic_dereference)
 CREATE_UNARY_EXPRESSION_PARSER('&', UNEXPR_TAKE_ADDRESS, semantic_take_addr)
 CREATE_UNARY_EXPRESSION_PARSER('~', UNEXPR_BITWISE_NEGATE,
-                               semantic_unexpr_arithmetic)
+                               semantic_unexpr_integer)
 CREATE_UNARY_EXPRESSION_PARSER(T_PLUSPLUS,   UNEXPR_PREFIX_INCREMENT,
                                semantic_incdec)
 CREATE_UNARY_EXPRESSION_PARSER(T_MINUSMINUS, UNEXPR_PREFIX_DECREMENT,
@@ -3051,6 +3316,14 @@ static void semantic_add(binary_expression_t *expression)
 		expression->expression.datatype = type_left;
 	} else if(type_right->type == TYPE_POINTER && is_type_integer(type_left)) {
 		expression->expression.datatype = type_right;
+	} else if (type_left->type == TYPE_ARRAY && is_type_integer(type_right)) {
+		const array_type_t *const arr_type = (const array_type_t*)type_left;
+		expression->expression.datatype =
+		  make_pointer_type(arr_type->element_type, TYPE_QUALIFIER_NONE);
+	} else if (type_right->type == TYPE_ARRAY && is_type_integer(type_left)) {
+		const array_type_t *const arr_type = (const array_type_t*)type_right;
+		expression->expression.datatype =
+			make_pointer_type(arr_type->element_type, TYPE_QUALIFIER_NONE);
 	} else {
 		parser_print_error_prefix();
 		fprintf(stderr, "invalid operands to binary + (");
@@ -3168,6 +3441,40 @@ static void semantic_arithmetic_assign(binary_expression_t *expression)
 	expression->expression.datatype = 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->datatype;
+	type_t       *orig_type_right = right->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);
+
+	if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
+		/* combined instructions are tricky. We can't create an implicit cast on
+		 * the left side, because we need the uncasted form for the store.
+		 * The ast2firm pass has to know that left_type must be right_type
+		 * for the arithmeitc 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;
+	} else if (type_left->type == TYPE_POINTER && is_type_integer(type_right)) {
+		expression->expression.datatype = type_left;
+	} else {
+		parser_print_error_prefix();
+		fputs("Incompatible types ", stderr);
+		print_type_quoted(orig_type_left);
+		fputs(" and ", stderr);
+		print_type_quoted(orig_type_right);
+		fputs(" in assignment\n", stderr);
+		return;
+	}
+}
+
 static void semantic_logical_op(binary_expression_t *expression)
 {
 	expression_t *left            = expression->left;
@@ -3196,7 +3503,9 @@ static void semantic_binexpr_assign(binary_expression_t *expression)
 	expression_t *left       = expression->left;
 	type_t       *type_left  = left->datatype;
 
-	if(type_left != NULL) {
+	if (type_left->type == TYPE_ARRAY) {
+		parse_error("Cannot assign to arrays.");
+	} else if (type_left != NULL) {
 		semantic_assign(type_left, &expression->right, "assignment");
 	}
 
@@ -3253,9 +3562,9 @@ CREATE_BINEXPR_PARSER(T_LESSLESS, BINEXPR_SHIFTLEFT,
 CREATE_BINEXPR_PARSER(T_GREATERGREATER, BINEXPR_SHIFTRIGHT,
                       semantic_shift_op, 1)
 CREATE_BINEXPR_PARSER(T_PLUSEQUAL, BINEXPR_ADD_ASSIGN,
-                      semantic_arithmetic_assign, 0)
+                      semantic_arithmetic_addsubb_assign, 0)
 CREATE_BINEXPR_PARSER(T_MINUSEQUAL, BINEXPR_SUB_ASSIGN,
-                      semantic_arithmetic_assign, 0)
+                      semantic_arithmetic_addsubb_assign, 0)
 CREATE_BINEXPR_PARSER(T_ASTERISKEQUAL, BINEXPR_MUL_ASSIGN,
                       semantic_arithmetic_assign, 0)
 CREATE_BINEXPR_PARSER(T_SLASHEQUAL, BINEXPR_DIV_ASSIGN,
@@ -3419,6 +3728,8 @@ static void init_expression_parsers(void)
 	register_expression_parser(parse_UNEXPR_PREFIX_DECREMENT, T_MINUSMINUS, 25);
 	register_expression_parser(parse_sizeof,                  T_sizeof,     25);
 	register_expression_parser(parse_extension,            T___extension__, 25);
+	register_expression_parser(parse_builtin_classify_type,
+	                                             T___builtin_classify_type, 25);
 }
 
 
@@ -3464,7 +3775,7 @@ static declaration_t *get_label(symbol_t *symbol)
 
 	/* otherwise we need to create a new one */
 	declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
-	declaration->namespace     = NAMESPACE_LABEL;
+	declaration->namespc     = NAMESPACE_LABEL;
 	declaration->symbol        = symbol;
 
 	label_push(declaration);