X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=a35aa4477c3e46087f99107fb39d05b76fd4b423;hb=953a820405dfd857ff9f5e24f3b630b6103dad46;hp=bd8b50cfd74e52eaac848a2e3fa572e1ae65bfa5;hpb=f0acd842a34d249ac78dfbb2c2168695c466693e;p=cparser

diff --git a/type.c b/type.c
index bd8b50c..a35aa44 100644
--- a/type.c
+++ b/type.c
@@ -313,7 +313,7 @@ static void print_function_type_pre(const function_type_t *type, bool top)
 		break;
 	}
 
-	/* don't emit braces if we're the toplevel type... */
+	/* don't emit parenthesis if we're the toplevel type... */
 	if (!top)
 		fputc('(', out);
 }
@@ -327,7 +327,9 @@ static void print_function_type_pre(const function_type_t *type, bool top)
 static void print_function_type_post(const function_type_t *type,
                                      const scope_t *scope, bool top)
 {
-	intern_print_type_post(type->return_type, false);
+	/* don't emit parenthesis if we're the toplevel type... */
+	if (!top)
+		fputc(')', out);
 
 	fputc('(', out);
 	bool first = true;
@@ -366,9 +368,7 @@ static void print_function_type_post(const function_type_t *type,
 	}
 	fputc(')', out);
 
-	/* don't emit braces if we're the toplevel type... */
-	if (!top)
-		fputc(')', out);
+	intern_print_type_post(type->return_type, false);
 }
 
 /**
@@ -435,7 +435,7 @@ static void print_array_type_post(const array_type_t *type)
 static void print_bitfield_type_post(const bitfield_type_t *type)
 {
 	fputs(" : ", out);
-	print_expression(type->size);
+	print_expression(type->size_expression);
 	intern_print_type_post(type->base_type, false);
 }
 
@@ -747,6 +747,8 @@ type_t *duplicate_type(const type_t *type)
  */
 type_t *get_unqualified_type(type_t *type)
 {
+	assert(!is_typeref(type));
+
 	if (type->base.qualifiers == TYPE_QUALIFIER_NONE)
 		return type;
 
@@ -761,6 +763,38 @@ type_t *get_unqualified_type(type_t *type)
 	return result;
 }
 
+type_t *get_qualified_type(type_t *orig_type, type_qualifiers_t const qual)
+{
+	type_t *type = skip_typeref(orig_type);
+
+	type_t *copy;
+	if (is_type_array(type)) {
+		/* For array types the element type has to be adjusted */
+		type_t *element_type      = type->array.element_type;
+		type_t *qual_element_type = get_qualified_type(element_type, qual);
+
+		if (qual_element_type == element_type)
+			return orig_type;
+
+		copy                     = duplicate_type(type);
+		copy->array.element_type = qual_element_type;
+	} else if (is_type_valid(type)) {
+		if ((type->base.qualifiers & qual) == qual)
+			return orig_type;
+
+		copy                   = duplicate_type(type);
+		copy->base.qualifiers |= qual;
+	} else {
+		return type;
+	}
+
+	type = typehash_insert(copy);
+	if (type != copy)
+		obstack_free(type_obst, copy);
+
+	return type;
+}
+
 /**
  * Check if a type is valid.
  *
@@ -828,6 +862,22 @@ bool is_type_float(const type_t *type)
 	return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_FLOAT);
 }
 
+/**
+ * Returns true if the given type is an complex type.
+ *
+ * @param type  The type to check.
+ * @return True if type is a complex type.
+ */
+bool is_type_complex(const type_t *type)
+{
+	assert(!is_typeref(type));
+
+	if (type->kind != TYPE_ATOMIC)
+		return false;
+
+	return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_COMPLEX);
+}
+
 /**
  * Returns true if the given type is a signed type.
  *
@@ -883,9 +933,8 @@ bool is_type_arithmetic(const type_t *type)
  */
 bool is_type_real(const type_t *type)
 {
-	/* 6.2.5.17 */
-	return is_type_integer(type)
-		|| (type->kind == TYPE_ATOMIC && is_type_float(type));
+	/* 6.2.5 (17) */
+	return is_type_integer(type) || is_type_float(type);
 }
 
 /**
@@ -976,6 +1025,9 @@ static bool function_types_compatible(const function_type_t *func1,
 	if (!types_compatible(ret1, ret2))
 		return false;
 
+	if (func1->calling_convention != func2->calling_convention)
+		return false;
+
 	/* can parameters be compared? */
 	if (func1->unspecified_parameters || func2->unspecified_parameters)
 		return true;
@@ -983,9 +1035,6 @@ static bool function_types_compatible(const function_type_t *func1,
 	if (func1->variadic != func2->variadic)
 		return false;
 
-	if (func1->calling_convention != func2->calling_convention)
-		return false;
-
 	/* TODO: handling of unspecified parameters not correct yet */
 
 	/* all argument types must be compatible */
@@ -1038,12 +1087,15 @@ bool types_compatible(const type_t *type1, const type_t *type2)
 	if (type1 == type2)
 		return true;
 
+	if (!is_type_valid(type1) || !is_type_valid(type2))
+		return true;
+
 	if (type1->base.qualifiers != type2->base.qualifiers)
 		return false;
 	if (type1->kind != type2->kind)
 		return false;
 
-	switch(type1->kind) {
+	switch (type1->kind) {
 	case TYPE_FUNCTION:
 		return function_types_compatible(&type1->function, &type2->function);
 	case TYPE_ATOMIC:
@@ -1095,8 +1147,8 @@ type_t *skip_typeref(type_t *type)
 	type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
 	type_modifiers_t  modifiers  = TYPE_MODIFIER_NONE;
 
-	while(true) {
-		switch(type->kind) {
+	while (true) {
+		switch (type->kind) {
 		case TYPE_ERROR:
 			return type;
 		case TYPE_TYPEDEF: {
@@ -1267,8 +1319,9 @@ type_t *make_atomic_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
 	memset(type, 0, sizeof(atomic_type_t));
 
 	type->kind            = TYPE_ATOMIC;
-	type->base.qualifiers = qualifiers;
+	type->base.size       = get_atomic_type_size(akind);
 	type->base.alignment  = get_atomic_type_alignment(akind);
+	type->base.qualifiers = qualifiers;
 	type->atomic.akind    = akind;
 
 	return identify_new_type(type);