X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=56e0af5fafba024e5bbd748f5da52f4eb1e10f43;hb=e6d2de0a709adcb6b34f9a77f9a3a8944a3e0cf6;hp=aaefda1f6d717d47675c980ba77d9f32c1a9dd0b;hpb=aa8b7bf2f96c1f47a68e96a5a2a125fc91cb0cc2;p=cparser

diff --git a/type.c b/type.c
index aaefda1..56e0af5 100644
--- a/type.c
+++ b/type.c
@@ -193,9 +193,19 @@ void inc_type_visited(void)
 
 void print_type_qualifiers(type_qualifiers_t qualifiers)
 {
-	if (qualifiers & TYPE_QUALIFIER_CONST)    fputs("const ",    out);
-	if (qualifiers & TYPE_QUALIFIER_VOLATILE) fputs("volatile ", out);
-	if (qualifiers & TYPE_QUALIFIER_RESTRICT) fputs("restrict ", out);
+	int first = 1;
+	if (qualifiers & TYPE_QUALIFIER_CONST) {
+		fputs(" const" + first,    out);
+		first = 0;
+	}
+	if (qualifiers & TYPE_QUALIFIER_VOLATILE) {
+		fputs(" volatile" + first, out);
+		first = 0;
+	}
+	if (qualifiers & TYPE_QUALIFIER_RESTRICT) {
+		fputs(" restrict" + first, out);
+		first = 0;
+	}
 }
 
 /**
@@ -238,6 +248,8 @@ static
 void print_atomic_type(const atomic_type_t *type)
 {
 	print_type_qualifiers(type->base.qualifiers);
+	if (type->base.qualifiers != 0)
+		fputc(' ', out);
 	print_atomic_kinds(type->akind);
 }
 
@@ -249,8 +261,9 @@ void print_atomic_type(const atomic_type_t *type)
 static
 void print_complex_type(const complex_type_t *type)
 {
+	int empty = type->base.qualifiers == 0;
 	print_type_qualifiers(type->base.qualifiers);
-	fputs("_Complex ", out);
+	fputs(" _Complex " + empty, out);
 	print_atomic_kinds(type->akind);
 }
 
@@ -262,8 +275,9 @@ void print_complex_type(const complex_type_t *type)
 static
 void print_imaginary_type(const imaginary_type_t *type)
 {
+	int empty = type->base.qualifiers == 0;
 	print_type_qualifiers(type->base.qualifiers);
-	fputs("_Imaginary ", out);
+	fputs(" _Imaginary " + empty, out);
 	print_atomic_kinds(type->akind);
 }
 
@@ -276,27 +290,30 @@ void print_imaginary_type(const imaginary_type_t *type)
 static void print_function_type_pre(const function_type_t *type, bool top)
 {
 	print_type_qualifiers(type->base.qualifiers);
+	if (type->base.qualifiers != 0)
+		fputc(' ', out);
+
 
 	intern_print_type_pre(type->return_type, false);
 
 	switch (type->calling_convention) {
 	case CC_CDECL:
-		fputs(" __cdecl ", out);
+		fputs("__cdecl ", out);
 		break;
 	case CC_STDCALL:
-		fputs(" __stdcall ", out);
+		fputs("__stdcall ", out);
 		break;
 	case CC_FASTCALL:
-		fputs(" __fastcall ", out);
+		fputs("__fastcall ", out);
 		break;
 	case CC_THISCALL:
-		fputs(" __thiscall ", out);
+		fputs("__thiscall ", out);
 		break;
 	case CC_DEFAULT:
 		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);
 }
@@ -310,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;
@@ -349,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);
 }
 
 /**
@@ -364,6 +381,8 @@ static void print_pointer_type_pre(const pointer_type_t *type)
 	intern_print_type_pre(type->points_to, false);
 	fputs("*", out);
 	print_type_qualifiers(type->base.qualifiers);
+	if (type->base.qualifiers != 0)
+		fputc(' ', out);
 }
 
 /**
@@ -398,6 +417,8 @@ static void print_array_type_post(const array_type_t *type)
 		fputs("static ", out);
 	}
 	print_type_qualifiers(type->base.qualifiers);
+	if (type->base.qualifiers != 0)
+		fputc(' ', out);
 	if (type->size_expression != NULL
 			&& (print_implicit_array_size || !type->has_implicit_size)) {
 		print_expression(type->size_expression);
@@ -414,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);
 }
 
@@ -460,8 +481,9 @@ void print_enum_definition(const declaration_t *declaration)
  */
 static void print_type_enum(const enum_type_t *type)
 {
+	int empty = type->base.qualifiers == 0;
 	print_type_qualifiers(type->base.qualifiers);
-	fputs("enum ", out);
+	fputs(" enum " + empty, out);
 
 	declaration_t *declaration = type->declaration;
 	symbol_t      *symbol      = declaration->symbol;
@@ -501,13 +523,14 @@ void print_compound_definition(const declaration_t *declaration)
  */
 static void print_compound_type(const compound_type_t *type)
 {
+	int empty = type->base.qualifiers == 0;
 	print_type_qualifiers(type->base.qualifiers);
 
 	if (type->base.kind == TYPE_COMPOUND_STRUCT) {
-		fputs("struct ", out);
+		fputs(" struct " + empty, out);
 	} else {
 		assert(type->base.kind == TYPE_COMPOUND_UNION);
-		fputs("union ", out);
+		fputs(" union " + empty, out);
 	}
 
 	declaration_t *declaration = type->declaration;
@@ -527,6 +550,8 @@ static void print_compound_type(const compound_type_t *type)
 static void print_typedef_type_pre(const typedef_type_t *const type)
 {
 	print_type_qualifiers(type->base.qualifiers);
+	if (type->base.qualifiers != 0)
+		fputc(' ', out);
 	fputs(type->declaration->symbol->string, out);
 }
 
@@ -558,6 +583,7 @@ static void intern_print_type_pre(const type_t *const type, const bool top)
 	switch(type->kind) {
 	case TYPE_ERROR:
 		fputs("<error>", out);
+		return;
 	case TYPE_INVALID:
 		fputs("<invalid>", out);
 		return;
@@ -721,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;
 
@@ -735,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.
  *
@@ -774,6 +834,18 @@ bool is_type_integer(const type_t *type)
 	return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_INTEGER);
 }
 
+/**
+ * Returns true if the given type is an enum type.
+ *
+ * @param type  The type to check.
+ * @return True if type is an enum type.
+ */
+bool is_type_enum(const type_t *type)
+{
+	assert(!is_typeref(type));
+	return type->kind == TYPE_ENUM;
+}
+
 /**
  * Returns true if the given type is an floating point type.
  *
@@ -790,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.
  *
@@ -837,11 +925,16 @@ bool is_type_arithmetic(const type_t *type)
 	}
 }
 
+/**
+ * Returns true if the given type is an integer or float type.
+ *
+ * @param type  The type to check.
+ * @return True if type is an integer or float 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);
 }
 
 /**
@@ -932,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;
@@ -939,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 */
@@ -994,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:
@@ -1051,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: {
@@ -1106,6 +1202,44 @@ type_t *skip_typeref(type_t *type)
 	return type;
 }
 
+type_qualifiers_t get_type_qualifier(const type_t *type, bool skip_array_type) {
+	type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
+
+	while (true) {
+		switch (type->base.kind) {
+		case TYPE_ERROR:
+			return TYPE_QUALIFIER_NONE;
+		case TYPE_TYPEDEF:
+			qualifiers |= type->base.qualifiers;
+			const typedef_type_t *typedef_type = &type->typedeft;
+			if (typedef_type->resolved_type != NULL)
+				type = typedef_type->resolved_type;
+			else
+				type = typedef_type->declaration->type;
+			continue;
+		case TYPE_TYPEOF: {
+			const typeof_type_t *typeof_type = &type->typeoft;
+			if (typeof_type->typeof_type != NULL) {
+				type = typeof_type->typeof_type;
+			} else {
+				type = typeof_type->expression->base.type;
+			}
+			continue;
+		}
+		case TYPE_ARRAY:
+			if (skip_array_type) {
+				type = type->array.element_type;
+				continue;
+			}
+			break;
+		default:
+			break;
+		}
+		break;
+	}
+	return type->base.qualifiers | qualifiers;
+}
+
 unsigned get_atomic_type_size(atomic_type_kind_t kind)
 {
 	assert(kind <= ATOMIC_TYPE_LAST);
@@ -1223,8 +1357,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);