Reduce code duplication in semantic_comparison().

[cparser] / type.c

diff --git a/type.c b/type.c
index 7a406bd..c877093 100644 (file)
--- a/type.c
+++ b/type.c
@@ -33,7 +33,6 @@
 #include "warning.h"
 #include "diagnostic.h"
 #include "printer.h"
-#include "driver/firm_cmdline.h"
 
 /** The default calling convention. */
 cc_kind_t default_calling_convention = CC_CDECL;
@@ -70,7 +69,6 @@ static size_t get_type_struct_size(type_kind_t kind)
                [TYPE_FUNCTION]        = sizeof(function_type_t),
                [TYPE_POINTER]         = sizeof(pointer_type_t),
                [TYPE_ARRAY]           = sizeof(array_type_t),
-               [TYPE_BUILTIN]         = sizeof(builtin_type_t),
                [TYPE_TYPEDEF]         = sizeof(typedef_type_t),
                [TYPE_TYPEOF]          = sizeof(typeof_type_t),
        };
@@ -185,7 +183,7 @@ static atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = {
                              | ATOMIC_TYPE_FLAG_SIGNED,
        },
        [ATOMIC_TYPE_LONG_DOUBLE] = {
-               .size       = 12,
+               .size       = (unsigned) -1, /* will be filled in later */
                .alignment  = (unsigned) -1,
                .flags      = ATOMIC_TYPE_FLAG_FLOAT | ATOMIC_TYPE_FLAG_ARITHMETIC
                              | ATOMIC_TYPE_FLAG_SIGNED,
@@ -193,6 +191,11 @@ static atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = {
        /* complex and imaginary types are set in init_types */
 };
 
+static inline bool is_po2(unsigned x)
+{
+       return (x & (x-1)) == 0;
+}
+
 void init_types(void)
 {
        obstack_init(type_obst);
@@ -236,9 +239,14 @@ void init_types(void)
                props[ATOMIC_TYPE_LONGLONG].alignment    = 8;
                props[ATOMIC_TYPE_ULONGLONG].alignment   = 8;
        }
-       if (force_long_double_size > 0) {
-               props[ATOMIC_TYPE_LONG_DOUBLE].size      = force_long_double_size;
-               props[ATOMIC_TYPE_LONG_DOUBLE].alignment = force_long_double_size;
+
+       if (long_double_size > 0) {
+               props[ATOMIC_TYPE_LONG_DOUBLE].size      = long_double_size;
+               if (is_po2(long_double_size)) {
+                       props[ATOMIC_TYPE_LONG_DOUBLE].alignment = long_double_size;
+               }
+       } else {
+               props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE];
        }
 
        /* TODO: make this configurable for platforms which do not use byte sized
@@ -253,17 +261,23 @@ void exit_types(void)
        obstack_free(type_obst, NULL);
 }
 
-void print_type_qualifiers(type_qualifiers_t qualifiers)
+void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparators const q)
 {
+       size_t sep = q & QUAL_SEP_START ? 0 : 1;
        if (qualifiers & TYPE_QUALIFIER_CONST) {
-               print_string("const ");
+               print_string(" const" + sep);
+               sep = 0;
        }
        if (qualifiers & TYPE_QUALIFIER_VOLATILE) {
-               print_string("volatile ");
+               print_string(" volatile" + sep);
+               sep = 0;
        }
        if (qualifiers & TYPE_QUALIFIER_RESTRICT) {
-               print_string("restrict ");
+               print_string(" restrict" + sep);
+               sep = 0;
        }
+       if (sep == 0 && q & QUAL_SEP_END)
+               print_char(' ');
 }
 
 const char *get_atomic_kind_name(atomic_type_kind_t kind)
@@ -309,7 +323,7 @@ static void print_atomic_kinds(atomic_type_kind_t kind)
  */
 static void print_atomic_type(const atomic_type_t *type)
 {
-       print_type_qualifiers(type->base.qualifiers);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
        print_atomic_kinds(type->akind);
 }
 
@@ -320,7 +334,7 @@ static void print_atomic_type(const atomic_type_t *type)
  */
 static void print_complex_type(const complex_type_t *type)
 {
-       print_type_qualifiers(type->base.qualifiers);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
        print_string("_Complex");
        print_atomic_kinds(type->akind);
 }
@@ -332,7 +346,7 @@ static void print_complex_type(const complex_type_t *type)
  */
 static void print_imaginary_type(const imaginary_type_t *type)
 {
-       print_type_qualifiers(type->base.qualifiers);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
        print_string("_Imaginary ");
        print_atomic_kinds(type->akind);
 }
@@ -359,7 +373,7 @@ static void print_function_type_pre(const function_type_t *type)
                        break;
        }
 
-       print_type_qualifiers(type->base.qualifiers);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 
        intern_print_type_pre(type->return_type);
 
@@ -411,11 +425,11 @@ static void print_function_type_post(const function_type_t *type,
                        } else {
                                print_string(", ");
                        }
-                       const type_t *const type = parameter->declaration.type;
-                       if (type == NULL) {
+                       const type_t *const param_type = parameter->declaration.type;
+                       if (param_type == NULL) {
                                print_string(parameter->base.symbol->string);
                        } else {
-                               print_type_ext(type, parameter->base.symbol, NULL);
+                               print_type_ext(param_type, parameter->base.symbol, NULL);
                        }
                }
        }
@@ -453,10 +467,7 @@ static void print_pointer_type_pre(const pointer_type_t *type)
                print_string(") ");
        }
        print_string("*");
-       type_qualifiers_t const qual = type->base.qualifiers;
-       if (qual != 0)
-               print_string(" ");
-       print_type_qualifiers(qual);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_START);
 }
 
 /**
@@ -520,7 +531,7 @@ static void print_array_type_post(const array_type_t *type)
        if (type->is_static) {
                print_string("static ");
        }
-       print_type_qualifiers(type->base.qualifiers);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
        if (type->size_expression != NULL
                        && (print_implicit_array_size || !type->has_implicit_size)) {
                print_expression(type->size_expression);
@@ -583,7 +594,7 @@ void print_enum_definition(const enum_t *enume)
  */
 static void print_type_enum(const enum_type_t *type)
 {
-       print_type_qualifiers(type->base.qualifiers);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
        print_string("enum ");
 
        enum_t   *enume  = type->enume;
@@ -628,7 +639,7 @@ void print_compound_definition(const compound_t *compound)
  */
 static void print_compound_type(const compound_type_t *type)
 {
-       print_type_qualifiers(type->base.qualifiers);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 
        if (type->base.kind == TYPE_COMPOUND_STRUCT) {
                print_string("struct ");
@@ -653,7 +664,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->base.qualifiers);
+       print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
        print_string(type->typedefe->base.symbol->string);
 }
 
@@ -703,9 +714,6 @@ static void intern_print_type_pre(const type_t *const type)
        case TYPE_COMPOUND_UNION:
                print_compound_type(&type->compound);
                return;
-       case TYPE_BUILTIN:
-               print_string(type->builtin.symbol->string);
-               return;
        case TYPE_FUNCTION:
                print_function_type_pre(&type->function);
                return;
@@ -762,7 +770,6 @@ static void intern_print_type_post(const type_t *const type)
        case TYPE_ENUM:
        case TYPE_COMPOUND_STRUCT:
        case TYPE_COMPOUND_UNION:
-       case TYPE_BUILTIN:
        case TYPE_TYPEOF:
        case TYPE_TYPEDEF:
                break;
@@ -848,7 +855,7 @@ type_t *get_qualified_type(type_t *orig_type, type_qualifiers_t const qual)
                copy                     = duplicate_type(type);
                copy->array.element_type = qual_element_type;
        } else if (is_type_valid(type)) {
-               if ((type->base.qualifiers & qual) == qual)
+               if ((type->base.qualifiers & qual) == (int)qual)
                        return orig_type;
 
                copy                   = duplicate_type(type);
@@ -1012,11 +1019,8 @@ bool is_type_scalar(const type_t *type)
 {
        assert(!is_typeref(type));
 
-       switch (type->kind) {
-       case TYPE_POINTER: return true;
-       case TYPE_BUILTIN: return is_type_scalar(type->builtin.real_type);
-       default:           break;
-       }
+       if (type->kind == TYPE_POINTER)
+               return true;
 
        return is_type_arithmetic(type);
 }
@@ -1057,7 +1061,6 @@ bool is_type_incomplete(const type_t *type)
        case TYPE_FUNCTION:
        case TYPE_POINTER:
        case TYPE_REFERENCE:
-       case TYPE_BUILTIN:
        case TYPE_ERROR:
                return false;
 
@@ -1076,14 +1079,6 @@ bool is_type_object(const type_t *type)
        return !is_type_function(type) && !is_type_incomplete(type);
 }
 
-bool is_builtin_va_list(type_t *type)
-{
-       type_t *tp = skip_typeref(type);
-
-       return tp->kind == type_valist->kind &&
-              tp->builtin.symbol == type_valist->builtin.symbol;
-}
-
 /**
  * Check if two function types are compatible.
  */
@@ -1207,7 +1202,6 @@ bool types_compatible(const type_t *type1, const type_t *type2)
                break;
        }
        case TYPE_ENUM:
-       case TYPE_BUILTIN:
                /* TODO: not implemented */
                break;
 
@@ -1316,8 +1310,6 @@ unsigned get_type_size(type_t *type)
        }
        case TYPE_BITFIELD:
                return 0;
-       case TYPE_BUILTIN:
-               return get_type_size(type->builtin.real_type);
        case TYPE_TYPEDEF:
                return get_type_size(type->typedeft.typedefe->type);
        case TYPE_TYPEOF:
@@ -1362,8 +1354,6 @@ unsigned get_type_alignment(type_t *type)
                return get_type_alignment(type->array.element_type);
        case TYPE_BITFIELD:
                return 0;
-       case TYPE_BUILTIN:
-               return get_type_alignment(type->builtin.real_type);
        case TYPE_TYPEDEF: {
                il_alignment_t alignment
                        = get_type_alignment(type->typedeft.typedefe->type);
@@ -1402,8 +1392,6 @@ decl_modifiers_t get_type_modifiers(const type_t *type)
        case TYPE_BITFIELD:
        case TYPE_ARRAY:
                return 0;
-       case TYPE_BUILTIN:
-               return get_type_modifiers(type->builtin.real_type);
        case TYPE_TYPEDEF: {
                decl_modifiers_t modifiers = type->typedeft.typedefe->modifiers;
                modifiers |= get_type_modifiers(type->typedeft.typedefe->type);