adapt to latest libfirm

[cparser] / type.c

diff --git a/type.c b/type.c
index 5a3891a..9e7621e 100644 (file)
--- 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)
@@ -257,7 +260,6 @@ 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;
        case ATOMIC_TYPE_VOID:        return "void";
        case ATOMIC_TYPE_WCHAR_T:     return "wchar_t";
        case ATOMIC_TYPE_BOOL:        return c_mode & _CXX ? "bool" : "_Bool";
@@ -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(", ");
-                       }
+                       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(')');
@@ -788,16 +778,6 @@ bool is_type_float(const type_t *type)
        return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_FLOAT);
 }
 
-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);
-}
-
 bool is_type_signed(const type_t *type)
 {
        assert(!is_typeref(type));
@@ -837,10 +817,16 @@ 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_IMAGINARY:
+               return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_ARITHMETIC);
+       default:
+               return false;
+       }
 }
 
 bool is_type_incomplete(const type_t *type)
@@ -873,10 +859,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 +988,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 +1079,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 +1117,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");
 }
 
 /**
@@ -1173,7 +1159,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 +1222,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 +1250,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 +1504,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) {