X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=parser.c;h=372c19e36454ecebb36bd44fd24c955a75f8ae3d;hb=cf80e941ca33006ab52321c2c74c6c30a7a4d10a;hp=4e37812d802af282d0217de83e92c5fa4bd77858;hpb=14e576785476dd318701c177d97fd266f730eee2;p=cparser

diff --git a/parser.c b/parser.c
index 4e37812..372c19e 100644
--- a/parser.c
+++ b/parser.c
@@ -67,7 +67,7 @@ struct declaration_specifiers_t {
 	unsigned char      alignment;         /**< Alignment, 0 if not set. */
 	unsigned int       is_inline : 1;
 	unsigned int       deprecated : 1;
-	decl_modifiers_t   decl_modifiers;    /**< MS __declspec extended modifier mask */
+	decl_modifiers_t   modifiers;         /**< declaration modifiers */
 	gnu_attribute_t   *gnu_attributes;    /**< list of GNU attributes */
 	const char        *deprecated_string; /**< can be set if declaration was marked deprecated. */
 	symbol_t          *get_property_sym;  /**< the name of the get property if set. */
@@ -1311,6 +1311,19 @@ end_error:
 	attribute->u.value = true;
 }
 
+static void check_no_argument(gnu_attribute_t *attribute, const char *name)
+{
+	if(!attribute->have_arguments)
+		return;
+
+	/* should have no arguments */
+	errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
+	eat_until_matching_token('(');
+	/* we have already consumed '(', so we stop before ')', eat it */
+	eat(')');
+	attribute->invalid = true;
+}
+
 /**
  * Parse one GNU attribute.
  *
@@ -1387,10 +1400,11 @@ end_error:
  *  interrupt( string literal )
  *  sentinel( constant expression )
  */
-static void parse_gnu_attribute(gnu_attribute_t **attributes)
+static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes)
 {
-	gnu_attribute_t *head = *attributes;
-	gnu_attribute_t *last = *attributes;
+	gnu_attribute_t *head      = *attributes;
+	gnu_attribute_t *last      = *attributes;
+	decl_modifiers_t modifiers = 0;
 	gnu_attribute_t *attribute;
 
 	eat(T___attribute__);
@@ -1457,20 +1471,11 @@ static void parse_gnu_attribute(gnu_attribute_t **attributes)
 				case GNU_AK_STDCALL:
 				case GNU_AK_FASTCALL:
 				case GNU_AK_DEPRECATED:
-				case GNU_AK_NOINLINE:
-				case GNU_AK_NORETURN:
 				case GNU_AK_NAKED:
-				case GNU_AK_PURE:
-				case GNU_AK_ALWAYS_INLINE:
 				case GNU_AK_MALLOC:
 				case GNU_AK_WEAK:
-				case GNU_AK_CONSTRUCTOR:
-				case GNU_AK_DESTRUCTOR:
-				case GNU_AK_NOTHROW:
-				case GNU_AK_TRANSPARENT_UNION:
 				case GNU_AK_COMMON:
 				case GNU_AK_NOCOMMON:
-				case GNU_AK_PACKED:
 				case GNU_AK_SHARED:
 				case GNU_AK_NOTSHARED:
 				case GNU_AK_USED:
@@ -1498,16 +1503,62 @@ static void parse_gnu_attribute(gnu_attribute_t **attributes)
 				case GNU_AK_MAY_ALIAS:
 				case GNU_AK_MS_STRUCT:
 				case GNU_AK_GCC_STRUCT:
+					check_no_argument(attribute, name);
+					break;
+
+				case GNU_AK_PURE:
+					check_no_argument(attribute, name);
+					modifiers |= DM_PURE;
+					break;
+
+				case GNU_AK_ALWAYS_INLINE:
+					check_no_argument(attribute, name);
+					modifiers |= DM_FORCEINLINE;
+					break;
+
 				case GNU_AK_DLLIMPORT:
+					check_no_argument(attribute, name);
+					modifiers |= DM_DLLIMPORT;
+					break;
+
 				case GNU_AK_DLLEXPORT:
-					if(attribute->have_arguments) {
-						/* should have no arguments */
-						errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
-						eat_until_matching_token('(');
-						/* we have already consumed '(', so we stop before ')', eat it */
-						eat(')');
-						attribute->invalid = true;
-					}
+					check_no_argument(attribute, name);
+					modifiers |= DM_DLLEXPORT;
+					break;
+
+				case GNU_AK_PACKED:
+					check_no_argument(attribute, name);
+					modifiers |= DM_PACKED;
+					break;
+
+				case GNU_AK_NOINLINE:
+					check_no_argument(attribute, name);
+					modifiers |= DM_NOINLINE;
+					break;
+
+				case GNU_AK_NORETURN:
+					check_no_argument(attribute, name);
+					modifiers |= DM_NORETURN;
+					break;
+
+				case GNU_AK_NOTHROW:
+					check_no_argument(attribute, name);
+					modifiers |= DM_NOTHROW;
+					break;
+
+				case GNU_AK_TRANSPARENT_UNION:
+					check_no_argument(attribute, name);
+					modifiers |= DM_TRANSPARENT_UNION;
+					break;
+
+				case GNU_AK_CONSTRUCTOR:
+					check_no_argument(attribute, name);
+					modifiers |= DM_CONSTRUCTOR;
+					break;
+
+				case GNU_AK_DESTRUCTOR:
+					check_no_argument(attribute, name);
+					modifiers |= DM_DESTRUCTOR;
 					break;
 
 				case GNU_AK_ALIGNED:
@@ -1611,17 +1662,21 @@ static void parse_gnu_attribute(gnu_attribute_t **attributes)
 	expect(')');
 end_error:
 	*attributes = head;
+
+	return modifiers;
 }
 
 /**
  * Parse GNU attributes.
  */
-static void parse_attributes(gnu_attribute_t **attributes)
+static decl_modifiers_t parse_attributes(gnu_attribute_t **attributes)
 {
+	decl_modifiers_t modifiers = 0;
+
 	while(true) {
 		switch(token.type) {
 		case T___attribute__: {
-			parse_gnu_attribute(attributes);
+			modifiers |= parse_gnu_attribute(attributes);
 			break;
 		}
 		case T_asm:
@@ -1644,7 +1699,7 @@ static void parse_attributes(gnu_attribute_t **attributes)
 
 attributes_finished:
 end_error:
-	return;
+	return modifiers;
 }
 
 static designator_t *parse_designation(void)
@@ -2418,7 +2473,8 @@ static declaration_t *append_declaration(declaration_t *declaration);
 
 static declaration_t *parse_compound_type_specifier(bool is_struct)
 {
-	gnu_attribute_t *attributes = NULL;
+	gnu_attribute_t  *attributes = NULL;
+	decl_modifiers_t  modifiers  = 0;
 	if(is_struct) {
 		eat(T_struct);
 	} else {
@@ -2429,7 +2485,7 @@ static declaration_t *parse_compound_type_specifier(bool is_struct)
 	declaration_t *declaration = NULL;
 
 	if (token.type == T___attribute__) {
-		parse_attributes(&attributes);
+		modifiers |= parse_attributes(&attributes);
 	}
 
 	if(token.type == T_IDENTIFIER) {
@@ -2469,16 +2525,18 @@ static declaration_t *parse_compound_type_specifier(bool is_struct)
 	if(token.type == '{') {
 		if (declaration->init.complete) {
 			assert(symbol != NULL);
-			errorf(HERE, "multiple definitions of '%s %Y'",
-			       is_struct ? "struct" : "union", symbol);
+			errorf(HERE, "multiple definitions of '%s %Y' (previous definition at %P)",
+			       is_struct ? "struct" : "union", symbol,
+			       &declaration->source_position);
 			declaration->scope.declarations = NULL;
 		}
 		declaration->init.complete = true;
 
 		parse_compound_type_entries(declaration);
-		parse_attributes(&attributes);
+		modifiers |= parse_attributes(&attributes);
 	}
 
+	declaration->modifiers |= modifiers;
 	return declaration;
 }
 
@@ -2718,7 +2776,7 @@ static bool check_elignment_value(long long intvalue) {
 
 static void parse_microsoft_extended_decl_modifier(declaration_specifiers_t *specifiers)
 {
-	decl_modifiers_t *modifiers = &specifiers->decl_modifiers;
+	decl_modifiers_t *modifiers = &specifiers->modifiers;
 
 	while(true) {
 		if(token.type == T_restrict) {
@@ -2961,7 +3019,7 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
 
 		case T__forceinline:
 			/* only in microsoft mode */
-			specifiers->decl_modifiers |= DM_FORCEINLINE;
+			specifiers->modifiers |= DM_FORCEINLINE;
 
 		case T_inline:
 			next_token();
@@ -3003,7 +3061,8 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
 			break;
 
 		case T___attribute__:
-			parse_attributes(&specifiers->gnu_attributes);
+			specifiers->modifiers
+				|= parse_attributes(&specifiers->gnu_attributes);
 			break;
 
 		case T_IDENTIFIER: {
@@ -3522,7 +3581,9 @@ static construct_type_t *parse_inner_declarator(declaration_t *declaration,
 	}
 
 	/* TODO: find out if this is correct */
-	parse_attributes(&attributes);
+	decl_modifiers_t modifiers = parse_attributes(&attributes);
+	if (declaration != NULL)
+		declaration->modifiers |= modifiers;
 
 	construct_type_t *inner_types = NULL;
 
@@ -3586,7 +3647,9 @@ static construct_type_t *parse_inner_declarator(declaration_t *declaration,
 	}
 
 declarator_finished:
-	parse_attributes(&attributes);
+	modifiers = parse_attributes(&attributes);
+	if (declaration != NULL)
+		declaration->modifiers |= modifiers;
 
 	/* append inner_types at the end of the list, we don't to set last anymore
 	 * as it's not needed anymore */
@@ -3697,7 +3760,7 @@ static declaration_t *parse_declarator(
 {
 	declaration_t *const declaration    = allocate_declaration_zero();
 	declaration->declared_storage_class = specifiers->declared_storage_class;
-	declaration->decl_modifiers         = specifiers->decl_modifiers;
+	declaration->modifiers              = specifiers->modifiers;
 	declaration->deprecated             = specifiers->deprecated;
 	declaration->deprecated_string      = specifiers->deprecated_string;
 	declaration->get_property_sym       = specifiers->get_property_sym;
@@ -4050,7 +4113,7 @@ static void parse_anonymous_declaration_rest(
 	declaration->type                   = specifiers->type;
 	declaration->declared_storage_class = specifiers->declared_storage_class;
 	declaration->source_position        = specifiers->source_position;
-	declaration->decl_modifiers         = specifiers->decl_modifiers;
+	declaration->modifiers              = specifiers->modifiers;
 
 	if (declaration->declared_storage_class != STORAGE_CLASS_NONE) {
 		warningf(&declaration->source_position,
@@ -4527,7 +4590,7 @@ static void parse_compound_declarators(declaration_t *struct_declaration,
 			declaration->declared_storage_class = STORAGE_CLASS_NONE;
 			declaration->storage_class          = STORAGE_CLASS_NONE;
 			declaration->source_position        = source_position;
-			declaration->decl_modifiers         = specifiers->decl_modifiers;
+			declaration->modifiers              = specifiers->modifiers;
 			declaration->type                   = type;
 		} else {
 			declaration = parse_declarator(specifiers,/*may_be_abstract=*/true);
@@ -6065,19 +6128,37 @@ end_error:
 	return create_invalid_expression();
 }
 
+static void check_pointer_arithmetic(const source_position_t *source_position,
+                                     type_t *pointer_type,
+                                     type_t *orig_pointer_type)
+{
+	type_t *points_to = pointer_type->pointer.points_to;
+	points_to = skip_typeref(points_to);
+
+	if (is_type_incomplete(points_to) &&
+			(! (c_mode & _GNUC)
+			 || !is_type_atomic(points_to, ATOMIC_TYPE_VOID))) {
+		errorf(source_position,
+			   "arithmetic with pointer to incomplete type '%T' not allowed",
+			   orig_pointer_type);
+	} else if (is_type_function(points_to)) {
+		errorf(source_position,
+			   "arithmetic with pointer to function type '%T' not allowed",
+			   orig_pointer_type);
+	}
+}
+
 static void semantic_incdec(unary_expression_t *expression)
 {
 	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) {
-		if (is_type_valid(type)) {
-			/* TODO: improve error message */
-			errorf(HERE, "operation needs an arithmetic or pointer type");
-		}
-		return;
+	if (is_type_pointer(type)) {
+		check_pointer_arithmetic(&expression->base.source_position,
+		                         type, orig_type);
+	} else if (!is_type_real(type) && is_type_valid(type)) {
+		/* TODO: improve error message */
+		errorf(HERE, "operation needs an arithmetic or pointer type");
 	}
-
 	expression->base.type = orig_type;
 }
 
@@ -6321,19 +6402,25 @@ static void semantic_add(binary_expression_t *expression)
 	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)) {
+	/* § 6.5.6 */
+	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->base.type = arithmetic_type;
 		return;
-	} else if(is_type_pointer(type_left) && is_type_integer(type_right)) {
+	} else if (is_type_pointer(type_left) && is_type_integer(type_right)) {
+		check_pointer_arithmetic(&expression->base.source_position,
+		                         type_left, orig_type_left);
 		expression->base.type = type_left;
-	} else if(is_type_pointer(type_right) && is_type_integer(type_left)) {
+	} else if (is_type_pointer(type_right) && is_type_integer(type_left)) {
+		check_pointer_arithmetic(&expression->base.source_position,
+		                         type_right, orig_type_right);
 		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);
+		errorf(&expression->base.source_position,
+		       "invalid operands to binary + ('%T', '%T')",
+		       orig_type_left, orig_type_right);
 	}
 }
 
@@ -6354,6 +6441,8 @@ static void semantic_sub(binary_expression_t *expression)
 		expression->base.type =  arithmetic_type;
 		return;
 	} else if(is_type_pointer(type_left) && is_type_integer(type_right)) {
+		check_pointer_arithmetic(&expression->base.source_position,
+		                         type_left, orig_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)) {
@@ -6461,21 +6550,29 @@ static bool has_const_fields(const compound_type_t *type)
 	return false;
 }
 
+static bool is_lvalue(const expression_t *expression)
+{
+	switch (expression->kind) {
+	case EXPR_REFERENCE:
+	case EXPR_ARRAY_ACCESS:
+	case EXPR_SELECT:
+	case EXPR_UNARY_DEREFERENCE:
+		return true;
+
+	default:
+		return false;
+	}
+}
+
 static bool is_valid_assignment_lhs(expression_t const* const left)
 {
 	type_t *const orig_type_left = revert_automatic_type_conversion(left);
 	type_t *const type_left      = skip_typeref(orig_type_left);
 
-	switch (left->kind)  {
-		case EXPR_REFERENCE:
-		case EXPR_ARRAY_ACCESS:
-		case EXPR_SELECT:
-		case EXPR_UNARY_DEREFERENCE:
-			break;
-
-		default:
-			errorf(HERE, "left hand side '%E' of assignment is not an lvalue", left);
-			return false;
+	if (!is_lvalue(left)) {
+		errorf(HERE, "left hand side '%E' of assignment is not an lvalue",
+		       left);
+		return false;
 	}
 
 	if (is_type_array(type_left)) {
@@ -6552,6 +6649,8 @@ static void semantic_arithmetic_addsubb_assign(binary_expression_t *expression)
 		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)) {
+		check_pointer_arithmetic(&expression->base.source_position,
+		                         type_left, orig_type_left);
 		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);
@@ -6986,40 +7085,44 @@ static void init_expression_parsers(void)
 }
 
 /**
- * Parse a asm statement constraints specification.
+ * Parse a asm statement arguments specification.
  */
-static asm_constraint_t *parse_asm_constraints(void)
+static asm_argument_t *parse_asm_arguments(bool is_out)
 {
-	asm_constraint_t *result = NULL;
-	asm_constraint_t *last   = NULL;
+	asm_argument_t *result = NULL;
+	asm_argument_t *last   = NULL;
 
 	while(token.type == T_STRING_LITERAL || token.type == '[') {
-		asm_constraint_t *constraint = allocate_ast_zero(sizeof(constraint[0]));
-		memset(constraint, 0, sizeof(constraint[0]));
+		asm_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
+		memset(argument, 0, sizeof(argument[0]));
 
 		if(token.type == '[') {
 			eat('[');
 			if(token.type != T_IDENTIFIER) {
-				parse_error_expected("while parsing asm constraint",
+				parse_error_expected("while parsing asm argument",
 				                     T_IDENTIFIER, NULL);
 				return NULL;
 			}
-			constraint->symbol = token.v.symbol;
+			argument->symbol = token.v.symbol;
 
 			expect(']');
 		}
 
-		constraint->constraints = parse_string_literals();
+		argument->constraints = parse_string_literals();
 		expect('(');
-		constraint->expression = parse_expression();
+		argument->expression = parse_expression();
+		if (is_out && !is_lvalue(argument->expression)) {
+			errorf(&argument->expression->base.source_position,
+			       "asm output argument is not an lvalue");
+		}
 		expect(')');
 
 		if(last != NULL) {
-			last->next = constraint;
+			last->next = argument;
 		} else {
-			result = constraint;
+			result = argument;
 		}
-		last = constraint;
+		last = argument;
 
 		if(token.type != ',')
 			break;
@@ -7086,14 +7189,14 @@ static statement_t *parse_asm_statement(void)
 	}
 	eat(':');
 
-	asm_statement->inputs = parse_asm_constraints();
+	asm_statement->outputs = parse_asm_arguments(true);
 	if(token.type != ':') {
 		rem_anchor_token(':');
 		goto end_of_asm;
 	}
 	eat(':');
 
-	asm_statement->outputs = parse_asm_constraints();
+	asm_statement->inputs = parse_asm_arguments(false);
 	if(token.type != ':') {
 		rem_anchor_token(':');
 		goto end_of_asm;