X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=parser.c;h=cca652ef7d266832e293a9c46dfc0b9be8967ea8;hb=b532880c7cfe1c5e69040f4e365c30e13d7c4c7d;hp=f8b9050bd79af2dabb0dea99f355e1c8e0b08aea;hpb=d2e6965a9bdae61491e0b88ac661559550999ce5;p=cparser

diff --git a/parser.c b/parser.c
index f8b9050..cca652e 100644
--- a/parser.c
+++ b/parser.c
@@ -65,7 +65,7 @@ struct gnu_attribute_t {
 	union {
 		size_t              value;
 		string_t            string;
-		atomic_type_kind_t  akind;
+		symbol_t           *symbol;
 		long                argument;  /**< Single argument. */
 		argument_list_t    *arguments; /**< List of argument expressions. */
 	} u;
@@ -579,14 +579,6 @@ static initializer_t *allocate_initializer_zero(initializer_kind_t kind)
 	return result;
 }
 
-/**
- * Free a type from the type obstack.
- */
-static void free_type(void *type)
-{
-	obstack_free(type_obst, type);
-}
-
 /**
  * Returns the index of the top element of the environment stack.
  */
@@ -757,7 +749,7 @@ static void eat_block(void)
 		next_token();
 }
 
-#define eat(token_type)  do { assert(token.type == (token_type)); next_token(); } while (0)
+#define eat(token_type) (assert(token.type == (token_type)), next_token())
 
 /**
  * Report a parse error because an expected token was not found.
@@ -977,13 +969,8 @@ static int get_akind_rank(atomic_type_kind_t akind)
 static int get_rank(const type_t *type)
 {
 	assert(!is_typeref(type));
-	/* The C-standard allows promoting enums to int or unsigned int (see § 7.2.2
-	 * and esp. footnote 108). However we can't fold constants (yet), so we
-	 * can't decide whether unsigned int is possible, while int always works.
-	 * (unsigned int would be preferable when possible... for stuff like
-	 *  struct { enum { ... } bla : 4; } ) */
 	if (type->kind == TYPE_ENUM)
-		return get_akind_rank(ATOMIC_TYPE_INT);
+		return get_akind_rank(type->enumt.akind);
 
 	assert(type->kind == TYPE_ATOMIC);
 	return get_akind_rank(type->atomic.akind);
@@ -1473,35 +1460,13 @@ static void parse_gnu_attribute_model_arg(gnu_attribute_t *attribute)
  */
 static void parse_gnu_attribute_mode_arg(gnu_attribute_t *attribute)
 {
-	/* TODO: find out what is allowed here... */
-
-	/* at least: byte, word, pointer, list of machine modes
-	 * __XXX___ is interpreted as XXX */
 	add_anchor_token(')');
 
 	if (token.type != T_IDENTIFIER) {
 		expect(T_IDENTIFIER, end_error);
 	}
 
-	/* This isn't really correct, the backend should provide a list of machine
-	 * specific modes (according to gcc philosophy that is...) */
-	const char *symbol_str = token.v.symbol->string;
-	if (strcmp_underscore("QI",   symbol_str) == 0 ||
-	    strcmp_underscore("byte", symbol_str) == 0) {
-		attribute->u.akind = ATOMIC_TYPE_CHAR;
-	} else if (strcmp_underscore("HI", symbol_str) == 0) {
-		attribute->u.akind = ATOMIC_TYPE_SHORT;
-	} else if (strcmp_underscore("SI",      symbol_str) == 0
-	        || strcmp_underscore("word",    symbol_str) == 0
-	        || strcmp_underscore("pointer", symbol_str) == 0) {
-		attribute->u.akind = ATOMIC_TYPE_INT;
-	} else if (strcmp_underscore("DI", symbol_str) == 0) {
-		attribute->u.akind = ATOMIC_TYPE_LONGLONG;
-	} else {
-		if (warning.other)
-			warningf(HERE, "ignoring unknown mode '%s'", symbol_str);
-		attribute->invalid = true;
-	}
+	attribute->u.symbol = token.v.symbol;
 	next_token();
 
 	rem_anchor_token(')');
@@ -2942,7 +2907,7 @@ static initializer_t *parse_initializer(parse_initializer_env_t *env)
 		result = parse_scalar_initializer(type, env->must_be_constant);
 	}
 
-	/* § 6.7.8 (22) array initializers for arrays with unknown size determine
+	/* § 6.7.8:22 array initializers for arrays with unknown size determine
 	 * the array type size */
 	if (is_type_array(type) && type->array.size_expression == NULL
 			&& result != NULL) {
@@ -3175,6 +3140,7 @@ static type_t *parse_enum_specifier(void)
 
 	type_t *const type = allocate_type_zero(TYPE_ENUM);
 	type->enumt.enume  = &entity->enume;
+	type->enumt.akind  = ATOMIC_TYPE_INT;
 
 	if (token.type == '{') {
 		if (symbol != NULL) {
@@ -3289,13 +3255,7 @@ static type_t *create_builtin_type(symbol_t *const symbol,
 	type_t *type            = allocate_type_zero(TYPE_BUILTIN);
 	type->builtin.symbol    = symbol;
 	type->builtin.real_type = real_type;
-
-	type_t *result = typehash_insert(type);
-	if (type != result) {
-		free_type(type);
-	}
-
-	return result;
+	return identify_new_type(type);
 }
 
 static type_t *get_typedef_type(symbol_t *symbol)
@@ -3624,72 +3584,72 @@ static void finish_union_type(compound_type_t *type)
 	type->base.alignment = alignment;
 }
 
-static type_t *handle_mode_attribute(const gnu_attribute_t *attribute,
+static type_t *handle_attribute_mode(const gnu_attribute_t *attribute,
                                      type_t *orig_type)
 {
 	type_t *type = skip_typeref(orig_type);
-	if (type->kind != TYPE_ATOMIC) {
-		errorf(HERE,
-			   "__attribute__(mode)) only allowed for atomic types");
-		return orig_type;
-	}
-	atomic_type_kind_t  akind = attribute->u.akind;
-	if (!is_type_signed(type)) {
-		switch (akind) {
-		case ATOMIC_TYPE_CHAR: akind = ATOMIC_TYPE_UCHAR; break;
-		case ATOMIC_TYPE_SHORT: akind = ATOMIC_TYPE_USHORT; break;
-		case ATOMIC_TYPE_INT: akind = ATOMIC_TYPE_UINT; break;
-		case ATOMIC_TYPE_LONGLONG: akind = ATOMIC_TYPE_ULONGLONG; break;
-		default:
-			errorf(HERE, "invalid akind in mode attribute");
-			return orig_type;
-		}
+
+	/* at least: byte, word, pointer, list of machine modes
+	 * __XXX___ is interpreted as XXX */
+
+	/* This isn't really correct, the backend should provide a list of machine
+	 * specific modes (according to gcc philosophy that is...) */
+	const char         *symbol_str = attribute->u.symbol->string;
+	bool                sign       = is_type_signed(type);
+	atomic_type_kind_t  akind;
+	if (strcmp_underscore("QI",   symbol_str) == 0 ||
+	    strcmp_underscore("byte", symbol_str) == 0) {
+		akind = sign ? ATOMIC_TYPE_CHAR : ATOMIC_TYPE_UCHAR;
+	} else if (strcmp_underscore("HI", symbol_str) == 0) {
+		akind = sign ? ATOMIC_TYPE_SHORT : ATOMIC_TYPE_USHORT;
+	} else if (strcmp_underscore("SI",      symbol_str) == 0
+	        || strcmp_underscore("word",    symbol_str) == 0
+	        || strcmp_underscore("pointer", symbol_str) == 0) {
+		akind = sign ? ATOMIC_TYPE_INT : ATOMIC_TYPE_UINT;
+	} else if (strcmp_underscore("DI", symbol_str) == 0) {
+		akind = sign ? ATOMIC_TYPE_LONGLONG : ATOMIC_TYPE_ULONGLONG;
 	} else {
-		switch (akind) {
-		case ATOMIC_TYPE_CHAR: akind = ATOMIC_TYPE_SCHAR; break;
-		case ATOMIC_TYPE_SHORT: akind = ATOMIC_TYPE_SHORT; break;
-		case ATOMIC_TYPE_INT: akind = ATOMIC_TYPE_INT; break;
-		case ATOMIC_TYPE_LONGLONG: akind = ATOMIC_TYPE_LONGLONG; break;
-		default:
-			errorf(HERE, "invalid akind in mode attribute");
-			return orig_type;
-		}
+		if (warning.other)
+			warningf(HERE, "ignoring unknown mode '%s'", symbol_str);
+		return orig_type;
 	}
 
-	type_t *copy       = duplicate_type(type);
-	copy->atomic.akind = akind;
-
-	type = typehash_insert(copy);
-	if (type != copy) {
-		obstack_free(type_obst, copy);
+	if (type->kind == TYPE_ATOMIC) {
+		type_t *copy       = duplicate_type(type);
+		copy->atomic.akind = akind;
+		return identify_new_type(copy);
+	} else if (type->kind == TYPE_ENUM) {
+		type_t *copy      = duplicate_type(type);
+		copy->enumt.akind = akind;
+		return identify_new_type(copy);
+	} else if (is_type_pointer(type)) {
+		warningf(HERE, "__attribute__((mode)) on pointers not implemented yet (ignored)");
+		return type;
 	}
-	return type;
+
+	errorf(HERE, "__attribute__((mode)) only allowed on integer, enum or pointer type");
+	return orig_type;
 }
 
 static type_t *handle_type_attributes(const gnu_attribute_t *attributes,
                                       type_t *type)
 {
-	/* handle these strange/stupid mode attributes */
 	const gnu_attribute_t *attribute = attributes;
 	for ( ; attribute != NULL; attribute = attribute->next) {
 		if (attribute->invalid)
 			continue;
 
 		if (attribute->kind == GNU_AK_MODE) {
-			type = handle_mode_attribute(attribute, type);
+			type = handle_attribute_mode(attribute, type);
 		} else if (attribute->kind == GNU_AK_ALIGNED) {
-			int alignment = 32; /* TODO: fill in maximum usefull alignment for
+			int alignment = 32; /* TODO: fill in maximum useful alignment for
 			                       target machine */
 			if (attribute->has_arguments)
 				alignment = attribute->u.argument;
 
-			type_t *copy = duplicate_type(type);
+			type_t *copy         = duplicate_type(type);
 			copy->base.alignment = attribute->u.argument;
-
-			type = typehash_insert(copy);
-			if (type != copy) {
-				obstack_free(type_obst, copy);
-			}
+			type                 = identify_new_type(copy);
 		}
 	}
 
@@ -4127,13 +4087,10 @@ warn_about_long_long:
 	type->base.qualifiers = qualifiers;
 	type->base.modifiers  = modifiers;
 
-	type_t *result = typehash_insert(type);
-	if (newtype && result != type) {
-		free_type(type);
-	}
+	type = identify_new_type(type);
 
-	result = handle_type_attributes(specifiers->gnu_attributes, result);
-	specifiers->type = result;
+	type = handle_type_attributes(specifiers->gnu_attributes, type);
+	specifiers->type = type;
 	return;
 
 end_error:
@@ -4633,27 +4590,22 @@ static void parse_declaration_attributes(entity_t *entity)
 	if (type == NULL)
 		return;
 
-	/* handle these strange/stupid mode attributes */
 	gnu_attribute_t *attribute = attributes;
 	for ( ; attribute != NULL; attribute = attribute->next) {
 		if (attribute->invalid)
 			continue;
 
 		if (attribute->kind == GNU_AK_MODE) {
-			type = handle_mode_attribute(attribute, type);
+			type = handle_attribute_mode(attribute, type);
 		} else if (attribute->kind == GNU_AK_ALIGNED) {
 			int alignment = 32; /* TODO: fill in maximum usefull alignment for target machine */
 			if (attribute->has_arguments)
 				alignment = attribute->u.argument;
 
 			if (entity->kind == ENTITY_TYPEDEF) {
-				type_t *copy = duplicate_type(type);
+				type_t *copy         = duplicate_type(type);
 				copy->base.alignment = attribute->u.argument;
-
-				type = typehash_insert(copy);
-				if (type != copy) {
-					obstack_free(type_obst, copy);
-				}
+				type                 = identify_new_type(copy);
 			} else if(entity->kind == ENTITY_VARIABLE) {
 				entity->variable.alignment = alignment;
 			} else if(entity->kind == ENTITY_COMPOUND_MEMBER) {
@@ -4667,13 +4619,9 @@ static void parse_declaration_attributes(entity_t *entity)
 		type_modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
 
 	if (type->base.modifiers != type_modifiers) {
-		type_t *copy = duplicate_type(type);
+		type_t *copy         = duplicate_type(type);
 		copy->base.modifiers = type_modifiers;
-
-		type = typehash_insert(copy);
-		if (type != copy) {
-			obstack_free(type_obst, copy);
-		}
+		type                 = identify_new_type(copy);
 	}
 
 	if (entity->kind == ENTITY_TYPEDEF) {
@@ -4701,7 +4649,7 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, type_
 			function_type->function.return_type = type;
 
 			type_t *skipped_return_type = skip_typeref(type);
-			/* §6.7.5.3(1) */
+			/* §6.7.5.3:1 */
 			if (is_type_function(skipped_return_type)) {
 				errorf(HERE, "function returning function is not allowed");
 			} else if (is_type_array(skipped_return_type)) {
@@ -4763,7 +4711,7 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, type_
 			}
 
 			type_t *skipped_type = skip_typeref(type);
-			/* §6.7.5.2(1) */
+			/* §6.7.5.2:1 */
 			if (is_type_incomplete(skipped_type)) {
 				errorf(HERE, "array of incomplete type '%T' is not allowed", type);
 			} else if (is_type_function(skipped_type)) {
@@ -4774,14 +4722,12 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, type_
 		}
 		}
 
-		type_t *hashed_type = typehash_insert(type);
-		if (hashed_type != type) {
-			/* the function type was constructed earlier freeing it here will
-			 * destroy other types... */
-			if (iter->kind != CONSTRUCT_FUNCTION) {
-				free_type(type);
-			}
-			type = hashed_type;
+		/* The function type was constructed earlier.  Freeing it here will
+		 * destroy other types. */
+		if (iter->kind == CONSTRUCT_FUNCTION) {
+			type = typehash_insert(type);
+		} else {
+			type = identify_new_type(type);
 		}
 	}
 
@@ -5344,7 +5290,7 @@ static void parse_init_declarator_rest(entity_t *entity)
 	current_init_decl = NULL;
 
 	if (entity->kind == ENTITY_VARIABLE) {
-		/* § 6.7.5 (22)  array initializers for arrays with unknown size
+		/* § 6.7.5:22  array initializers for arrays with unknown size
 		 * determine the array type size */
 		declaration->type            = env.type;
 		entity->variable.initializer = initializer;
@@ -5611,12 +5557,9 @@ decl_list_end:
 	new_type->function.parameters             = parameters;
 	new_type->function.unspecified_parameters = true;
 
-	type = typehash_insert(new_type);
-	if (type != new_type) {
-		obstack_free(type_obst, new_type);
-	}
+	new_type = identify_new_type(new_type);
 
-	entity->declaration.type = type;
+	entity->declaration.type = new_type;
 
 	rem_anchor_token('{');
 }
@@ -6426,18 +6369,15 @@ static void parse_external_declaration(void)
 			ndeclaration->base.symbol);
 	}
 
-	/* § 6.7.5.3 (14) a function definition with () means no
+	/* § 6.7.5.3:14 a function definition with () means no
 	 * parameters (and not unspecified parameters) */
-	if (type->function.unspecified_parameters
-			&& type->function.parameters == NULL
-			&& !type->function.kr_style_parameters) {
-		type_t *duplicate = duplicate_type(type);
-		duplicate->function.unspecified_parameters = false;
+	if (type->function.unspecified_parameters &&
+			type->function.parameters == NULL     &&
+			!type->function.kr_style_parameters) {
+		type_t *copy                          = duplicate_type(type);
+		copy->function.unspecified_parameters = false;
+		type                                  = identify_new_type(copy);
 
-		type = typehash_insert(duplicate);
-		if (type != duplicate) {
-			obstack_free(type_obst, duplicate);
-		}
 		ndeclaration->declaration.type = type;
 	}
 
@@ -6878,11 +6818,7 @@ static entity_t *create_implicit_function(symbol_t *symbol,
 	ntype->function.return_type            = type_int;
 	ntype->function.unspecified_parameters = true;
 	ntype->function.linkage                = LINKAGE_C;
-
-	type_t *type = typehash_insert(ntype);
-	if (type != ntype) {
-		free_type(ntype);
-	}
+	type_t *type                           = identify_new_type(ntype);
 
 	entity_t *entity = allocate_entity_zero(ENTITY_FUNCTION);
 	entity->declaration.storage_class          = STORAGE_CLASS_EXTERN;
@@ -6922,12 +6858,7 @@ static type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
 	type->function.return_type = return_type;
 	type->function.parameters  = parameter1;
 
-	type_t *result = typehash_insert(type);
-	if (result != type) {
-		free_type(type);
-	}
-
-	return result;
+	return identify_new_type(type);
 }
 
 /**
@@ -6948,12 +6879,7 @@ static type_t *make_function_1_type(type_t *return_type, type_t *argument_type)
 	type->function.return_type = return_type;
 	type->function.parameters  = parameter;
 
-	type_t *result = typehash_insert(type);
-	if (result != type) {
-		free_type(type);
-	}
-
-	return result;
+	return identify_new_type(type);
 }
 
 static type_t *make_function_0_type(type_t *return_type)
@@ -6962,12 +6888,7 @@ static type_t *make_function_0_type(type_t *return_type)
 	type->function.return_type = return_type;
 	type->function.parameters  = NULL;
 
-	type_t *result = typehash_insert(type);
-	if (result != type) {
-		free_type(type);
-	}
-
-	return result;
+	return identify_new_type(type);
 }
 
 /**
@@ -8615,7 +8536,7 @@ static bool check_pointer_arithmetic(const source_position_t *source_position,
 
 static bool is_lvalue(const expression_t *expression)
 {
-	/* TODO: doesn't seem to be consistent with §6.3.2.1 (1) */
+	/* TODO: doesn't seem to be consistent with §6.3.2.1:1 */
 	switch (expression->kind) {
 	case EXPR_ARRAY_ACCESS:
 	case EXPR_COMPOUND_LITERAL:
@@ -11451,9 +11372,7 @@ static void complete_incomplete_arrays(void)
 		new_type->array.has_implicit_size = true;
 		new_type->array.size              = 1;
 
-		type_t *const result = typehash_insert(new_type);
-		if (type != result)
-			free_type(type);
+		type_t *const result = identify_new_type(new_type);
 
 		decl->type = result;
 	}