X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=09b38eb7dcbbf7eae72b9785a23c169f2d18d368;hb=227b0eb126a28cde3726b5618a6767dba1393bf5;hp=5a3891a869d68d5ec53f474e076a14933215f850;hpb=71140ac05a9296af61a0dd4fe8361c3091d38cd9;p=cparser

diff --git a/type.c b/type.c
index 5a3891a..09b38eb 100644
--- a/type.c
+++ b/type.c
@@ -33,6 +33,7 @@
 #include "warning.h"
 #include "diagnostic.h"
 #include "printer.h"
+#include "separator_t.h"
 
 /** The default calling convention. */
 cc_kind_t default_calling_convention = CC_CDECL;
@@ -52,6 +53,8 @@ static size_t get_type_struct_size(type_kind_t kind)
 {
 	static const size_t sizes[] = {
 		[TYPE_ATOMIC]          = sizeof(atomic_type_t),
+		[TYPE_IMAGINARY]       = sizeof(atomic_type_t),
+		[TYPE_COMPLEX]         = sizeof(atomic_type_t),
 		[TYPE_COMPOUND_STRUCT] = sizeof(compound_type_t),
 		[TYPE_COMPOUND_UNION]  = sizeof(compound_type_t),
 		[TYPE_ENUM]            = sizeof(enum_type_t),
@@ -239,15 +242,15 @@ void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparato
 {
 	size_t sep = q & QUAL_SEP_START ? 0 : 1;
 	if (qualifiers & TYPE_QUALIFIER_CONST) {
-		print_string(" const" + sep);
+		print_string(&" const"[sep]);
 		sep = 0;
 	}
 	if (qualifiers & TYPE_QUALIFIER_VOLATILE) {
-		print_string(" volatile" + sep);
+		print_string(&" volatile"[sep]);
 		sep = 0;
 	}
 	if (qualifiers & TYPE_QUALIFIER_RESTRICT) {
-		print_string(" restrict" + sep);
+		print_string(&" restrict"[sep]);
 		sep = 0;
 	}
 	if (sep == 0 && q & QUAL_SEP_END)
@@ -256,8 +259,7 @@ void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparato
 
 const char *get_atomic_kind_name(atomic_type_kind_t kind)
 {
-	switch(kind) {
-	case ATOMIC_TYPE_INVALID: break;
+	switch (kind) {
 	case ATOMIC_TYPE_VOID:        return "void";
 	case ATOMIC_TYPE_WCHAR_T:     return "wchar_t";
 	case ATOMIC_TYPE_BOOL:        return c_mode & _CXX ? "bool" : "_Bool";
@@ -309,7 +311,7 @@ static void print_atomic_type(const atomic_type_t *type)
 static void print_complex_type(const atomic_type_t *type)
 {
 	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
-	print_string("_Complex");
+	print_string("_Complex ");
 	print_atomic_kinds(type->akind);
 }
 
@@ -374,15 +376,11 @@ static void print_function_type_post(const function_type_t *type,
                                      const scope_t *parameters)
 {
 	print_char('(');
-	bool first = true;
+	separator_t sep = { "", ", " };
 	if (parameters == NULL) {
 		function_parameter_t *parameter = type->parameters;
-		for( ; parameter != NULL; parameter = parameter->next) {
-			if (first) {
-				first = false;
-			} else {
-				print_string(", ");
-			}
+		for ( ; parameter != NULL; parameter = parameter->next) {
+			print_string(sep_next(&sep));
 			print_type(parameter->type);
 		}
 	} else {
@@ -391,11 +389,7 @@ static void print_function_type_post(const function_type_t *type,
 			if (parameter->kind != ENTITY_PARAMETER)
 				continue;
 
-			if (first) {
-				first = false;
-			} else {
-				print_string(", ");
-			}
+			print_string(sep_next(&sep));
 			const type_t *const param_type = parameter->declaration.type;
 			if (param_type == NULL) {
 				print_string(parameter->base.symbol->string);
@@ -405,14 +399,10 @@ static void print_function_type_post(const function_type_t *type,
 		}
 	}
 	if (type->variadic) {
-		if (first) {
-			first = false;
-		} else {
-			print_string(", ");
-		}
+		print_string(sep_next(&sep));
 		print_string("...");
 	}
-	if (first && !type->unspecified_parameters) {
+	if (sep_at_first(&sep) && !type->unspecified_parameters) {
 		print_string("void");
 	}
 	print_char(')');
@@ -518,7 +508,7 @@ void print_enum_definition(const enum_t *enume)
 	change_indent(1);
 
 	entity_t *entry = enume->base.next;
-	for( ; entry != NULL && entry->kind == ENTITY_ENUM_VALUE;
+	for ( ; entry != NULL && entry->kind == ENTITY_ENUM_VALUE;
 	       entry = entry->base.next) {
 
 		print_indent();
@@ -560,7 +550,7 @@ void print_compound_definition(const compound_t *compound)
 	change_indent(1);
 
 	entity_t *entity = compound->members.entities;
-	for( ; entity != NULL; entity = entity->base.next) {
+	for ( ; entity != NULL; entity = entity->base.next) {
 		if (entity->kind != ENTITY_COMPOUND_MEMBER)
 			continue;
 
@@ -631,7 +621,7 @@ static void print_typeof_type_pre(const typeof_type_t *const type)
  */
 static void intern_print_type_pre(const type_t *const type)
 {
-	switch(type->kind) {
+	switch (type->kind) {
 	case TYPE_ARRAY:           print_array_type_pre(          &type->array);     return;
 	case TYPE_ATOMIC:          print_atomic_type(             &type->atomic);    return;
 	case TYPE_COMPLEX:         print_complex_type(            &type->atomic);    return;
@@ -656,7 +646,7 @@ static void intern_print_type_pre(const type_t *const type)
  */
 static void intern_print_type_post(const type_t *const type)
 {
-	switch(type->kind) {
+	switch (type->kind) {
 	case TYPE_FUNCTION:
 		print_function_type_post(&type->function, NULL);
 		return;
@@ -763,12 +753,8 @@ static bool test_atomic_type_flag(atomic_type_kind_t kind,
 bool is_type_integer(const type_t *type)
 {
 	assert(!is_typeref(type));
-
-	if (type->kind == TYPE_ENUM)
-		return true;
-	if (type->kind != TYPE_ATOMIC)
+	if (!is_type_arithmetic(type))
 		return false;
-
 	return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_INTEGER);
 }
 
@@ -791,23 +777,14 @@ bool is_type_float(const type_t *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);
+	return type->kind == TYPE_COMPLEX;
 }
 
 bool is_type_signed(const type_t *type)
 {
 	assert(!is_typeref(type));
-
-	/* enum types are int for now */
-	if (type->kind == TYPE_ENUM)
-		return true;
-	if (type->kind != TYPE_ATOMIC)
+	if (!is_type_arithmetic(type))
 		return false;
-
 	return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_SIGNED);
 }
 
@@ -815,7 +792,7 @@ bool is_type_arithmetic(const type_t *type)
 {
 	assert(!is_typeref(type));
 
-	switch(type->kind) {
+	switch (type->kind) {
 	case TYPE_ENUM:
 		return true;
 	case TYPE_ATOMIC:
@@ -837,17 +814,24 @@ bool is_type_scalar(const type_t *type)
 {
 	assert(!is_typeref(type));
 
-	if (type->kind == TYPE_POINTER)
+	switch (type->kind) {
+	case TYPE_POINTER:
+	case TYPE_ENUM:
 		return true;
-
-	return is_type_arithmetic(type);
+	case TYPE_ATOMIC:
+	case TYPE_COMPLEX:
+	case TYPE_IMAGINARY:
+		return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_ARITHMETIC);
+	default:
+		return false;
+	}
 }
 
 bool is_type_incomplete(const type_t *type)
 {
 	assert(!is_typeref(type));
 
-	switch(type->kind) {
+	switch (type->kind) {
 	case TYPE_COMPOUND_STRUCT:
 	case TYPE_COMPOUND_UNION: {
 		const compound_type_t *compound_type = &type->compound;
@@ -873,10 +857,10 @@ bool is_type_incomplete(const type_t *type)
 
 	case TYPE_TYPEDEF:
 	case TYPE_TYPEOF:
-		panic("is_type_incomplete called without typerefs skipped");
+		panic("typedef not skipped");
 	}
 
-	panic("invalid type found");
+	panic("invalid type");
 }
 
 bool is_type_object(const type_t *type)
@@ -1002,7 +986,7 @@ bool types_compatible(const type_t *type1, const type_t *type2)
 			return true;
 		case TYPE_TYPEDEF:
 		case TYPE_TYPEOF:
-			panic("typerefs not skipped in compatible types?!?");
+			panic("typeref not skipped");
 		}
 	}
 
@@ -1093,7 +1077,7 @@ unsigned get_type_size(type_t *type)
 	case TYPE_TYPEOF:
 		return get_type_size(type->typeoft.typeof_type);
 	}
-	panic("invalid type in get_type_size");
+	panic("invalid type");
 }
 
 unsigned get_type_alignment(type_t *type)
@@ -1131,7 +1115,7 @@ unsigned get_type_alignment(type_t *type)
 	case TYPE_TYPEOF:
 		return get_type_alignment(type->typeoft.typeof_type);
 	}
-	panic("invalid type in get_type_alignment");
+	panic("invalid type");
 }
 
 /**
@@ -1149,7 +1133,7 @@ static unsigned get_type_alignment_compound(type_t *const type)
 
 decl_modifiers_t get_type_modifiers(const type_t *type)
 {
-	switch(type->kind) {
+	switch (type->kind) {
 	case TYPE_ERROR:
 		break;
 	case TYPE_COMPOUND_STRUCT:
@@ -1173,7 +1157,7 @@ decl_modifiers_t get_type_modifiers(const type_t *type)
 	case TYPE_TYPEOF:
 		return get_type_modifiers(type->typeoft.typeof_type);
 	}
-	panic("invalid type found in get_type_modifiers");
+	panic("invalid type");
 }
 
 type_qualifiers_t get_type_qualifier(const type_t *type, bool skip_array_type)
@@ -1236,7 +1220,7 @@ atomic_type_kind_t find_signed_int_atomic_type_kind_for_size(unsigned size)
 
 	assert(size < 32);
 	atomic_type_kind_t kind = kinds[size];
-	if (kind == ATOMIC_TYPE_INVALID) {
+	if (kind == (atomic_type_kind_t)0) {
 		static const atomic_type_kind_t possible_kinds[] = {
 			ATOMIC_TYPE_SCHAR,
 			ATOMIC_TYPE_SHORT,
@@ -1264,7 +1248,7 @@ atomic_type_kind_t find_unsigned_int_atomic_type_kind_for_size(unsigned size)
 
 	assert(size < 32);
 	atomic_type_kind_t kind = kinds[size];
-	if (kind == ATOMIC_TYPE_INVALID) {
+	if (kind == (atomic_type_kind_t)0) {
 		static const atomic_type_kind_t possible_kinds[] = {
 			ATOMIC_TYPE_UCHAR,
 			ATOMIC_TYPE_USHORT,
@@ -1518,7 +1502,7 @@ next:
 		}
 	}
 
-	source_position_t const *const pos = &compound->base.source_position;
+	position_t const *const pos = &compound->base.pos;
 	if (need_pad) {
 		warningf(WARN_PADDED, pos, "'%T' needs padding", type);
 	} else if (compound->packed) {