X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=ba2938d14460d6f980f697d1f9530ed753d4208a;hb=b732f96b591a9c4a4333bd1c1d4356723f362f6d;hp=88c52b4121bc888751d9fdc8e6aac53c84614740;hpb=564a3cdfed70f6e7d7c75fa693ea2630b82cb8aa;p=cparser

diff --git a/type.c b/type.c
index 88c52b4..ba2938d 100644
--- a/type.c
+++ b/type.c
@@ -37,9 +37,143 @@ static bool             print_implicit_array_size = false;
 static void intern_print_type_pre(const type_t *type, bool top);
 static void intern_print_type_post(const type_t *type, bool top);
 
+typedef struct atomic_type_properties_t atomic_type_properties_t;
+struct atomic_type_properties_t {
+	unsigned   size;              /**< type size in bytes */
+	unsigned   alignment;         /**< type alignment in bytes */
+	unsigned   flags;             /**< type flags from atomic_type_flag_t */
+};
+
+static atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = {
+	//ATOMIC_TYPE_INVALID = 0,
+	[ATOMIC_TYPE_VOID] = {
+		.size       = 0,
+		.alignment  = 0,
+		.flags      = ATOMIC_TYPE_FLAG_NONE
+	},
+	[ATOMIC_TYPE_CHAR] = {
+		.size       = 1,
+		.alignment  = 1,
+		/* signed flag will be set when known */
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
+	},
+	[ATOMIC_TYPE_SCHAR] = {
+		.size       = 1,
+		.alignment  = 1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC
+		              | ATOMIC_TYPE_FLAG_SIGNED,
+	},
+	[ATOMIC_TYPE_UCHAR] = {
+		.size       = 1,
+		.alignment  = 1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
+	},
+	[ATOMIC_TYPE_SHORT] = {
+		.size       = 2,
+		.alignment  = 2,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC
+		              | ATOMIC_TYPE_FLAG_SIGNED
+	},
+	[ATOMIC_TYPE_USHORT] = {
+		.size       = 2,
+		.alignment  = 2,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
+	},
+	[ATOMIC_TYPE_INT] = {
+		.size       = (unsigned) -1,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC
+		              | ATOMIC_TYPE_FLAG_SIGNED,
+	},
+	[ATOMIC_TYPE_UINT] = {
+		.size       = (unsigned) -1,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
+	},
+	[ATOMIC_TYPE_LONG] = {
+		.size       = (unsigned) -1,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC
+		              | ATOMIC_TYPE_FLAG_SIGNED,
+	},
+	[ATOMIC_TYPE_ULONG] = {
+		.size       = (unsigned) -1,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
+	},
+	[ATOMIC_TYPE_LONGLONG] = {
+		.size       = (unsigned) -1,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC
+		              | ATOMIC_TYPE_FLAG_SIGNED,
+	},
+	[ATOMIC_TYPE_ULONGLONG] = {
+		.size       = (unsigned) -1,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
+	},
+	[ATOMIC_TYPE_BOOL] = {
+		.size       = (unsigned) -1,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
+	},
+	[ATOMIC_TYPE_FLOAT] = {
+		.size       = 4,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_FLOAT | ATOMIC_TYPE_FLAG_ARITHMETIC
+		              | ATOMIC_TYPE_FLAG_SIGNED,
+	},
+	[ATOMIC_TYPE_DOUBLE] = {
+		.size       = 8,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_FLOAT | ATOMIC_TYPE_FLAG_ARITHMETIC
+		              | ATOMIC_TYPE_FLAG_SIGNED,
+	},
+	[ATOMIC_TYPE_LONG_DOUBLE] = {
+		.size       = 12,
+		.alignment  = (unsigned) -1,
+		.flags      = ATOMIC_TYPE_FLAG_FLOAT | ATOMIC_TYPE_FLAG_ARITHMETIC
+		              | ATOMIC_TYPE_FLAG_SIGNED,
+	},
+	/* complex and imaginary types are set in init_types */
+};
+
 void init_types(void)
 {
 	obstack_init(type_obst);
+
+	atomic_type_properties_t *props = atomic_type_properties;
+
+	if(char_is_signed) {
+		props[ATOMIC_TYPE_CHAR].flags |= ATOMIC_TYPE_FLAG_SIGNED;
+	}
+
+	unsigned int_size   = machine_size < 32 ? 2 : 4;
+	unsigned long_size  = machine_size < 64 ? 4 : 8;
+	unsigned llong_size = machine_size < 32 ? 4 : 8;
+
+	props[ATOMIC_TYPE_INT].size            = int_size;
+	props[ATOMIC_TYPE_INT].alignment       = int_size;
+	props[ATOMIC_TYPE_UINT].size           = int_size;
+	props[ATOMIC_TYPE_UINT].alignment      = int_size;
+	props[ATOMIC_TYPE_LONG].size           = long_size;
+	props[ATOMIC_TYPE_LONG].alignment      = long_size;
+	props[ATOMIC_TYPE_ULONG].size          = long_size;
+	props[ATOMIC_TYPE_ULONG].alignment     = long_size;
+	props[ATOMIC_TYPE_LONGLONG].size       = llong_size;
+	props[ATOMIC_TYPE_LONGLONG].alignment  = llong_size;
+	props[ATOMIC_TYPE_ULONGLONG].size      = llong_size;
+	props[ATOMIC_TYPE_ULONGLONG].alignment = llong_size;
+
+	/* TODO: backend specific, need a way to query the backend for this.
+	 * The following are good settings for x86 */
+	props[ATOMIC_TYPE_FLOAT].alignment       = 4;
+	props[ATOMIC_TYPE_DOUBLE].alignment      = 4;
+	props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 4;
+	props[ATOMIC_TYPE_LONGLONG].alignment    = 4;
+	props[ATOMIC_TYPE_ULONGLONG].alignment   = 4;
+
+	props[ATOMIC_TYPE_BOOL] = props[ATOMIC_TYPE_UINT];
 }
 
 void exit_types(void)
@@ -65,44 +199,74 @@ void print_type_qualifiers(type_qualifiers_t qualifiers)
 }
 
 /**
- * Prints the name of a atomic type.
+ * Prints the name of an atomic type kinds.
  *
- * @param type  The type.
+ * @param kind  The type kind.
  */
 static
-void print_atomic_type(const atomic_type_t *type)
+void print_atomic_kinds(atomic_type_kind_t kind)
 {
-	print_type_qualifiers(type->type.qualifiers);
-
 	const char *s = "INVALIDATOMIC";
-	switch((atomic_type_kind_t) type->akind) {
-	case ATOMIC_TYPE_INVALID:     break;
-	case ATOMIC_TYPE_VOID:                  s = "void";               break;
-	case ATOMIC_TYPE_BOOL:                  s = "_Bool";              break;
-	case ATOMIC_TYPE_CHAR:                  s = "char";               break;
-	case ATOMIC_TYPE_SCHAR:                 s = "signed char";        break;
-	case ATOMIC_TYPE_UCHAR:                 s = "unsigned char";      break;
-	case ATOMIC_TYPE_INT:                   s = "int";                break;
-	case ATOMIC_TYPE_UINT:                  s = "unsigned int";       break;
-	case ATOMIC_TYPE_SHORT:                 s = "short";              break;
-	case ATOMIC_TYPE_USHORT:                s = "unsigned short";     break;
-	case ATOMIC_TYPE_LONG:                  s = "long";               break;
-	case ATOMIC_TYPE_ULONG:                 s = "unsigned long";      break;
-	case ATOMIC_TYPE_LONGLONG:              s = "long long";          break;
-	case ATOMIC_TYPE_ULONGLONG:             s = "unsigned long long"; break;
-	case ATOMIC_TYPE_LONG_DOUBLE:           s = "long double";        break;
-	case ATOMIC_TYPE_FLOAT:                 s = "float";              break;
-	case ATOMIC_TYPE_DOUBLE:                s = "double";             break;
-	case ATOMIC_TYPE_FLOAT_COMPLEX:         s = "_Complex float";     break;
-	case ATOMIC_TYPE_DOUBLE_COMPLEX:        s = "_Complex float";     break;
-	case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:   s = "_Complex float";     break;
-	case ATOMIC_TYPE_FLOAT_IMAGINARY:       s = "_Imaginary float";   break;
-	case ATOMIC_TYPE_DOUBLE_IMAGINARY:      s = "_Imaginary float";   break;
-	case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY: s = "_Imaginary float";   break;
+	switch(kind) {
+	case ATOMIC_TYPE_INVALID:                               break;
+	case ATOMIC_TYPE_VOID:        s = "void";               break;
+	case ATOMIC_TYPE_BOOL:        s = "_Bool";              break;
+	case ATOMIC_TYPE_CHAR:        s = "char";               break;
+	case ATOMIC_TYPE_SCHAR:       s = "signed char";        break;
+	case ATOMIC_TYPE_UCHAR:       s = "unsigned char";      break;
+	case ATOMIC_TYPE_INT:         s = "int";                break;
+	case ATOMIC_TYPE_UINT:        s = "unsigned int";       break;
+	case ATOMIC_TYPE_SHORT:       s = "short";              break;
+	case ATOMIC_TYPE_USHORT:      s = "unsigned short";     break;
+	case ATOMIC_TYPE_LONG:        s = "long";               break;
+	case ATOMIC_TYPE_ULONG:       s = "unsigned long";      break;
+	case ATOMIC_TYPE_LONGLONG:    s = "long long";          break;
+	case ATOMIC_TYPE_ULONGLONG:   s = "unsigned long long"; break;
+	case ATOMIC_TYPE_LONG_DOUBLE: s = "long double";        break;
+	case ATOMIC_TYPE_FLOAT:       s = "float";              break;
+	case ATOMIC_TYPE_DOUBLE:      s = "double";             break;
 	}
 	fputs(s, out);
 }
 
+/**
+ * Prints the name of an atomic type.
+ *
+ * @param type  The type.
+ */
+static
+void print_atomic_type(const atomic_type_t *type)
+{
+	print_type_qualifiers(type->base.qualifiers);
+	print_atomic_kinds(type->akind);
+}
+
+/**
+ * Prints the name of a complex type.
+ *
+ * @param type  The type.
+ */
+static
+void print_complex_type(const complex_type_t *type)
+{
+	print_type_qualifiers(type->base.qualifiers);
+	fputs("_Complex ", out);
+	print_atomic_kinds(type->akind);
+}
+
+/**
+ * Prints the name of an imaginary type.
+ *
+ * @param type  The type.
+ */
+static
+void print_imaginary_type(const imaginary_type_t *type)
+{
+	print_type_qualifiers(type->base.qualifiers);
+	fputs("_Imaginary ", out);
+	print_atomic_kinds(type->akind);
+}
+
 /**
  * Print the first part (the prefix) of a type.
  *
@@ -111,7 +275,7 @@ void print_atomic_type(const atomic_type_t *type)
  */
 static void print_function_type_pre(const function_type_t *type, bool top)
 {
-	print_type_qualifiers(type->type.qualifiers);
+	print_type_qualifiers(type->base.qualifiers);
 
 	intern_print_type_pre(type->return_type, false);
 
@@ -136,12 +300,12 @@ static void print_function_type_post(const function_type_t *type,
 
 	fputc('(', out);
 
-	int first = 1;
+	bool first = true;
 	if(scope == NULL) {
 		function_parameter_t *parameter = type->parameters;
 		for( ; parameter != NULL; parameter = parameter->next) {
 			if(first) {
-				first = 0;
+				first = false;
 			} else {
 				fputs(", ", out);
 			}
@@ -151,7 +315,7 @@ static void print_function_type_post(const function_type_t *type,
 		declaration_t *parameter = scope->declarations;
 		for( ; parameter != NULL; parameter = parameter->next) {
 			if(first) {
-				first = 0;
+				first = false;
 			} else {
 				fputs(", ", out);
 			}
@@ -161,7 +325,7 @@ static void print_function_type_post(const function_type_t *type,
 	}
 	if(type->variadic) {
 		if(first) {
-			first = 0;
+			first = false;
 		} else {
 			fputs(", ", out);
 		}
@@ -182,7 +346,7 @@ 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->type.qualifiers);
+	print_type_qualifiers(type->base.qualifiers);
 }
 
 /**
@@ -216,7 +380,7 @@ static void print_array_type_post(const array_type_t *type)
 	if(type->is_static) {
 		fputs("static ", out);
 	}
-	print_type_qualifiers(type->type.qualifiers);
+	print_type_qualifiers(type->base.qualifiers);
 	if(type->size_expression != NULL
 			&& (print_implicit_array_size || !type->has_implicit_size)) {
 		print_expression(type->size_expression);
@@ -234,7 +398,7 @@ static void print_bitfield_type_post(const bitfield_type_t *type)
 {
 	fputs(" : ", out);
 	print_expression(type->size);
-	intern_print_type_post(type->base, false);
+	intern_print_type_post(type->base_type, false);
 }
 
 /**
@@ -279,7 +443,7 @@ void print_enum_definition(const declaration_t *declaration)
  */
 static void print_type_enum(const enum_type_t *type)
 {
-	print_type_qualifiers(type->type.qualifiers);
+	print_type_qualifiers(type->base.qualifiers);
 	fputs("enum ", out);
 
 	declaration_t *declaration = type->declaration;
@@ -320,12 +484,12 @@ void print_compound_definition(const declaration_t *declaration)
  */
 static void print_compound_type(const compound_type_t *type)
 {
-	print_type_qualifiers(type->type.qualifiers);
+	print_type_qualifiers(type->base.qualifiers);
 
-	if(type->type.kind == TYPE_COMPOUND_STRUCT) {
+	if(type->base.kind == TYPE_COMPOUND_STRUCT) {
 		fputs("struct ", out);
 	} else {
-		assert(type->type.kind == TYPE_COMPOUND_UNION);
+		assert(type->base.kind == TYPE_COMPOUND_UNION);
 		fputs("union ", out);
 	}
 
@@ -345,7 +509,7 @@ 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->type.qualifiers);
+	print_type_qualifiers(type->base.qualifiers);
 	fputs(type->declaration->symbol->string, out);
 }
 
@@ -386,6 +550,12 @@ static void intern_print_type_pre(const type_t *const type, const bool top)
 	case TYPE_ATOMIC:
 		print_atomic_type(&type->atomic);
 		return;
+	case TYPE_COMPLEX:
+		print_complex_type(&type->complex);
+		return;
+	case TYPE_IMAGINARY:
+		print_imaginary_type(&type->imaginary);
+		return;
 	case TYPE_COMPOUND_STRUCT:
 	case TYPE_COMPOUND_UNION:
 		print_compound_type(&type->compound);
@@ -400,7 +570,7 @@ static void intern_print_type_pre(const type_t *const type, const bool top)
 		print_pointer_type_pre(&type->pointer);
 		return;
 	case TYPE_BITFIELD:
-		intern_print_type_pre(type->bitfield.base, top);
+		intern_print_type_pre(type->bitfield.base_type, top);
 		return;
 	case TYPE_ARRAY:
 		print_array_type_pre(&type->array);
@@ -439,6 +609,8 @@ static void intern_print_type_post(const type_t *const type, const bool top)
 	case TYPE_ERROR:
 	case TYPE_INVALID:
 	case TYPE_ATOMIC:
+	case TYPE_COMPLEX:
+	case TYPE_IMAGINARY:
 	case TYPE_ENUM:
 	case TYPE_COMPOUND_STRUCT:
 	case TYPE_COMPOUND_UNION:
@@ -488,6 +660,8 @@ static size_t get_type_size(const type_t *type)
 {
 	switch(type->kind) {
 	case TYPE_ATOMIC:          return sizeof(atomic_type_t);
+	case TYPE_COMPLEX:         return sizeof(complex_type_t);
+	case TYPE_IMAGINARY:       return sizeof(imaginary_type_t);
 	case TYPE_COMPOUND_STRUCT:
 	case TYPE_COMPOUND_UNION:  return sizeof(compound_type_t);
 	case TYPE_ENUM:            return sizeof(enum_type_t);
@@ -555,6 +729,13 @@ bool type_valid(const type_t *type)
 	return type->kind != TYPE_INVALID;
 }
 
+static bool test_atomic_type_flag(atomic_type_kind_t kind,
+                                  atomic_type_flag_t flag)
+{
+	assert(kind <= ATOMIC_TYPE_LAST);
+	return (atomic_type_properties[kind].flags & flag) != 0;
+}
+
 /**
  * Returns true if the given type is an integer type.
  *
@@ -571,36 +752,7 @@ bool is_type_integer(const type_t *type)
 	if(type->kind != TYPE_ATOMIC)
 		return false;
 
-	switch((atomic_type_kind_t) type->atomic.akind) {
-	case ATOMIC_TYPE_BOOL:
-	case ATOMIC_TYPE_CHAR:
-	case ATOMIC_TYPE_SCHAR:
-	case ATOMIC_TYPE_UCHAR:
-	case ATOMIC_TYPE_SHORT:
-	case ATOMIC_TYPE_USHORT:
-	case ATOMIC_TYPE_INT:
-	case ATOMIC_TYPE_UINT:
-	case ATOMIC_TYPE_LONG:
-	case ATOMIC_TYPE_ULONG:
-	case ATOMIC_TYPE_LONGLONG:
-	case ATOMIC_TYPE_ULONGLONG:
-		return true;
-
-	case ATOMIC_TYPE_INVALID:
-	case ATOMIC_TYPE_VOID:
-	case ATOMIC_TYPE_FLOAT:
-	case ATOMIC_TYPE_DOUBLE:
-	case ATOMIC_TYPE_LONG_DOUBLE:
-	case ATOMIC_TYPE_FLOAT_COMPLEX:
-	case ATOMIC_TYPE_DOUBLE_COMPLEX:
-	case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
-	case ATOMIC_TYPE_FLOAT_IMAGINARY:
-	case ATOMIC_TYPE_DOUBLE_IMAGINARY:
-	case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
-		return false;
-	}
-
-	panic("unexpected atomic type kind");
+	return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_INTEGER);
 }
 
 /**
@@ -616,36 +768,7 @@ bool is_type_float(const type_t *type)
 	if(type->kind != TYPE_ATOMIC)
 		return false;
 
-	switch((atomic_type_kind_t) type->atomic.akind) {
-	case ATOMIC_TYPE_FLOAT:
-	case ATOMIC_TYPE_DOUBLE:
-	case ATOMIC_TYPE_LONG_DOUBLE:
-	case ATOMIC_TYPE_FLOAT_COMPLEX:
-	case ATOMIC_TYPE_DOUBLE_COMPLEX:
-	case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
-	case ATOMIC_TYPE_FLOAT_IMAGINARY:
-	case ATOMIC_TYPE_DOUBLE_IMAGINARY:
-	case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
-		return true;
-
-	case ATOMIC_TYPE_INVALID:
-	case ATOMIC_TYPE_VOID:
-	case ATOMIC_TYPE_BOOL:
-	case ATOMIC_TYPE_CHAR:
-	case ATOMIC_TYPE_SCHAR:
-	case ATOMIC_TYPE_UCHAR:
-	case ATOMIC_TYPE_SHORT:
-	case ATOMIC_TYPE_USHORT:
-	case ATOMIC_TYPE_INT:
-	case ATOMIC_TYPE_UINT:
-	case ATOMIC_TYPE_LONG:
-	case ATOMIC_TYPE_ULONG:
-	case ATOMIC_TYPE_LONGLONG:
-	case ATOMIC_TYPE_ULONGLONG:
-		return false;
-	}
-
-	panic("unexpected atomic type kind");
+	return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_FLOAT);
 }
 
 /**
@@ -665,39 +788,7 @@ bool is_type_signed(const type_t *type)
 	if(type->kind != TYPE_ATOMIC)
 		return false;
 
-	switch((atomic_type_kind_t) type->atomic.akind) {
-	case ATOMIC_TYPE_CHAR:
-	case ATOMIC_TYPE_SCHAR:
-	case ATOMIC_TYPE_SHORT:
-	case ATOMIC_TYPE_INT:
-	case ATOMIC_TYPE_LONG:
-	case ATOMIC_TYPE_LONGLONG:
-	case ATOMIC_TYPE_FLOAT:
-	case ATOMIC_TYPE_DOUBLE:
-	case ATOMIC_TYPE_LONG_DOUBLE:
-	case ATOMIC_TYPE_FLOAT_COMPLEX:
-	case ATOMIC_TYPE_DOUBLE_COMPLEX:
-	case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
-	case ATOMIC_TYPE_FLOAT_IMAGINARY:
-	case ATOMIC_TYPE_DOUBLE_IMAGINARY:
-	case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
-		return true;
-
-	case ATOMIC_TYPE_BOOL:
-	case ATOMIC_TYPE_UCHAR:
-	case ATOMIC_TYPE_USHORT:
-	case ATOMIC_TYPE_UINT:
-	case ATOMIC_TYPE_ULONG:
-	case ATOMIC_TYPE_ULONGLONG:
-		return false;
-
-	case ATOMIC_TYPE_VOID:
-	case ATOMIC_TYPE_INVALID:
-		return false;
-	}
-
-	panic("invalid atomic type found");
-	return false;
+	return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_SIGNED);
 }
 
 /**
@@ -710,13 +801,19 @@ bool is_type_arithmetic(const type_t *type)
 {
 	assert(!is_typeref(type));
 
-	if(type->kind == TYPE_BITFIELD)
-		return true;
-
-	if(is_type_integer(type) || is_type_float(type))
+	switch(type->kind) {
+	case TYPE_BITFIELD:
+	case TYPE_ENUM:
 		return true;
-
-	return false;
+	case TYPE_ATOMIC:
+		return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_ARITHMETIC);
+	case TYPE_COMPLEX:
+		return test_atomic_type_flag(type->complex.akind, ATOMIC_TYPE_FLAG_ARITHMETIC);
+	case TYPE_IMAGINARY:
+		return test_atomic_type_flag(type->imaginary.akind, ATOMIC_TYPE_FLAG_ARITHMETIC);
+	default:
+		return false;
+	}
 }
 
 /**
@@ -732,7 +829,7 @@ bool is_type_scalar(const type_t *type)
 	switch (type->kind) {
 		case TYPE_POINTER: return true;
 		case TYPE_BUILTIN: return is_type_scalar(type->builtin.real_type);
-		default:            break;
+		default:           break;
 	}
 
 	return is_type_arithmetic(type);
@@ -753,14 +850,16 @@ bool is_type_incomplete(const type_t *type)
 	case TYPE_COMPOUND_UNION: {
 		const compound_type_t *compound_type = &type->compound;
 		declaration_t         *declaration   = compound_type->declaration;
-		return !declaration->init.is_defined;
+		return !declaration->init.complete;
 	}
 	case TYPE_ENUM: {
 		const enum_type_t *enum_type   = &type->enumt;
 		declaration_t     *declaration = enum_type->declaration;
-		return !declaration->init.is_defined;
+		return !declaration->init.complete;
 	}
 	case TYPE_BITFIELD:
+		return false;
+
 	case TYPE_FUNCTION:
 		return true;
 
@@ -770,6 +869,12 @@ bool is_type_incomplete(const type_t *type)
 	case TYPE_ATOMIC:
 		return type->atomic.akind == ATOMIC_TYPE_VOID;
 
+	case TYPE_COMPLEX:
+		return type->complex.akind == ATOMIC_TYPE_VOID;
+
+	case TYPE_IMAGINARY:
+		return type->imaginary.akind == ATOMIC_TYPE_VOID;
+
 	case TYPE_POINTER:
 	case TYPE_BUILTIN:
 	case TYPE_ERROR:
@@ -865,6 +970,10 @@ bool types_compatible(const type_t *type1, const type_t *type2)
 		return function_types_compatible(&type1->function, &type2->function);
 	case TYPE_ATOMIC:
 		return type1->atomic.akind == type2->atomic.akind;
+	case TYPE_COMPLEX:
+		return type1->complex.akind == type2->complex.akind;
+	case TYPE_IMAGINARY:
+		return type1->imaginary.akind == type2->imaginary.akind;
 	case TYPE_ARRAY:
 		return array_types_compatible(&type1->array, &type2->array);
 
@@ -967,57 +1076,40 @@ type_t *skip_typeref(type_t *type)
 
 unsigned get_atomic_type_size(atomic_type_kind_t kind)
 {
-	switch(kind) {
-	case ATOMIC_TYPE_CHAR:
-	case ATOMIC_TYPE_SCHAR:
-	case ATOMIC_TYPE_UCHAR:
-		return 1;
-
-	case ATOMIC_TYPE_SHORT:
-	case ATOMIC_TYPE_USHORT:
-		return 2;
-
-	case ATOMIC_TYPE_BOOL:
-	case ATOMIC_TYPE_INT:
-	case ATOMIC_TYPE_UINT:
-		return machine_size >> 3;
-
-	case ATOMIC_TYPE_LONG:
-	case ATOMIC_TYPE_ULONG:
-		return machine_size > 16 ? machine_size >> 3 : 4;
-
-	case ATOMIC_TYPE_LONGLONG:
-	case ATOMIC_TYPE_ULONGLONG:
-		return machine_size > 16 ? 8 : 4;
-
-	case ATOMIC_TYPE_FLOAT_IMAGINARY:
-	case ATOMIC_TYPE_FLOAT:
-		return 4;
-
-	case ATOMIC_TYPE_DOUBLE_IMAGINARY:
-	case ATOMIC_TYPE_DOUBLE:
-		return 8;
-
-	case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
-	case ATOMIC_TYPE_LONG_DOUBLE:
-		return 12;
-
-	case ATOMIC_TYPE_VOID:
-		return 1;
+	assert(kind <= ATOMIC_TYPE_LAST);
+	return atomic_type_properties[kind].size;
+}
 
-	case ATOMIC_TYPE_FLOAT_COMPLEX:
-		return 2 * get_atomic_type_size(ATOMIC_TYPE_FLOAT);
+unsigned get_atomic_type_alignment(atomic_type_kind_t kind)
+{
+	assert(kind <= ATOMIC_TYPE_LAST);
+	return atomic_type_properties[kind].alignment;
+}
 
-	case ATOMIC_TYPE_DOUBLE_COMPLEX:
-		return 2 * get_atomic_type_size(ATOMIC_TYPE_DOUBLE);
+unsigned get_atomic_type_flags(atomic_type_kind_t kind)
+{
+	assert(kind <= ATOMIC_TYPE_LAST);
+	return atomic_type_properties[kind].flags;
+}
 
-	case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
-		return 2 * get_atomic_type_size(ATOMIC_TYPE_LONG_DOUBLE);
+atomic_type_kind_t get_intptr_kind(void)
+{
+	if(machine_size <= 32)
+		return ATOMIC_TYPE_INT;
+	else if(machine_size <= 64)
+		return ATOMIC_TYPE_LONG;
+	else
+		return ATOMIC_TYPE_LONGLONG;
+}
 
-	case ATOMIC_TYPE_INVALID:
-		break;
-	}
-	panic("Trying to determine size of invalid atomic type");
+atomic_type_kind_t get_uintptr_kind(void)
+{
+	if(machine_size <= 32)
+		return ATOMIC_TYPE_UINT;
+	else if(machine_size <= 64)
+		return ATOMIC_TYPE_ULONG;
+	else
+		return ATOMIC_TYPE_ULONGLONG;
 }
 
 /**
@@ -1093,17 +1185,53 @@ static type_t *identify_new_type(type_t *type)
  * @param akind       The kind of the atomic type.
  * @param qualifiers  Type qualifiers for the new type.
  */
-type_t *make_atomic_type(atomic_type_kind_t atype, type_qualifiers_t qualifiers)
+type_t *make_atomic_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
 {
 	type_t *type = obstack_alloc(type_obst, sizeof(atomic_type_t));
 	memset(type, 0, sizeof(atomic_type_t));
 
 	type->kind            = TYPE_ATOMIC;
 	type->base.qualifiers = qualifiers;
-	type->base.alignment  = 0;
-	type->atomic.akind    = atype;
+	type->base.alignment  = get_atomic_type_alignment(akind);
+	type->atomic.akind    = akind;
+
+	return identify_new_type(type);
+}
+
+/**
+ * Creates a new complex type.
+ *
+ * @param akind       The kind of the atomic type.
+ * @param qualifiers  Type qualifiers for the new type.
+ */
+type_t *make_complex_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
+{
+	type_t *type = obstack_alloc(type_obst, sizeof(complex_type_t));
+	memset(type, 0, sizeof(complex_type_t));
+
+	type->kind            = TYPE_COMPLEX;
+	type->base.qualifiers = qualifiers;
+	type->base.alignment  = get_atomic_type_alignment(akind);
+	type->complex.akind   = akind;
+
+	return identify_new_type(type);
+}
+
+/**
+ * Creates a new imaginary type.
+ *
+ * @param akind       The kind of the atomic type.
+ * @param qualifiers  Type qualifiers for the new type.
+ */
+type_t *make_imaginary_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
+{
+	type_t *type = obstack_alloc(type_obst, sizeof(imaginary_type_t));
+	memset(type, 0, sizeof(imaginary_type_t));
 
-	/* TODO: set the alignment depending on the atype here */
+	type->kind            = TYPE_IMAGINARY;
+	type->base.qualifiers = qualifiers;
+	type->base.alignment  = get_atomic_type_alignment(akind);
+	type->imaginary.akind = akind;
 
 	return identify_new_type(type);
 }