simplify testcase

[cparser] / type.c

diff --git a/type.c b/type.c
index 4069148..59d7722 100644 (file)
--- a/type.c
+++ b/type.c
@@ -748,6 +748,8 @@ bool is_type_integer(const type_t *type)
 
        if(type->kind == TYPE_ENUM)
                return true;
+       if(type->kind == TYPE_BITFIELD)
+               return true;
 
        if(type->kind != TYPE_ATOMIC)
                return false;
@@ -784,6 +786,8 @@ bool is_type_signed(const type_t *type)
        /* enum types are int for now */
        if(type->kind == TYPE_ENUM)
                return true;
+       if(type->kind == TYPE_BITFIELD)
+               return is_type_signed(type->bitfield.base_type);
 
        if(type->kind != TYPE_ATOMIC)
                return false;
@@ -816,6 +820,13 @@ bool is_type_arithmetic(const type_t *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));
+}
+
 /**
  * Returns true if the given type represents a scalar type.
  *
@@ -857,12 +868,10 @@ bool is_type_incomplete(const type_t *type)
                declaration_t     *declaration = enum_type->declaration;
                return !declaration->init.complete;
        }
-       case TYPE_BITFIELD:
-       case TYPE_FUNCTION:
-               return true;
 
        case TYPE_ARRAY:
-               return type->array.size_expression == NULL;
+               return type->array.size_expression == NULL
+                       && !type->array.size_constant;
 
        case TYPE_ATOMIC:
                return type->atomic.akind == ATOMIC_TYPE_VOID;
@@ -873,6 +882,8 @@ bool is_type_incomplete(const type_t *type)
        case TYPE_IMAGINARY:
                return type->imaginary.akind == ATOMIC_TYPE_VOID;
 
+       case TYPE_BITFIELD:
+       case TYPE_FUNCTION:
        case TYPE_POINTER:
        case TYPE_BUILTIN:
        case TYPE_ERROR:
@@ -888,6 +899,11 @@ bool is_type_incomplete(const type_t *type)
        panic("invalid type found");
 }
 
+bool is_type_object(const type_t *type)
+{
+       return !is_type_function(type) && !is_type_incomplete(type);
+}
+
 /**
  * Check if two function types are compatible.
  */
@@ -900,10 +916,10 @@ static bool function_types_compatible(const function_type_t *func1,
                return false;
 
        /* can parameters be compared? */
-       if(func1->unspecified_parameters || func2->unspecified_parameters)
+       if (func1->unspecified_parameters || func2->unspecified_parameters)
                return true;
 
-       if(func1->variadic != func2->variadic)
+       if (func1->variadic != func2->variadic)
                return false;
 
        /* TODO: handling of unspecified parameters not correct yet */
@@ -911,7 +927,7 @@ static bool function_types_compatible(const function_type_t *func1,
        /* all argument types must be compatible */
        function_parameter_t *parameter1 = func1->parameters;
        function_parameter_t *parameter2 = func2->parameters;
-       for( ; parameter1 != NULL && parameter2 != NULL;
+       for ( ; parameter1 != NULL && parameter2 != NULL;
                        parameter1 = parameter1->next, parameter2 = parameter2->next) {
                type_t *parameter1_type = skip_typeref(parameter1->type);
                type_t *parameter2_type = skip_typeref(parameter2->type);
@@ -919,11 +935,11 @@ static bool function_types_compatible(const function_type_t *func1,
                parameter1_type = get_unqualified_type(parameter1_type);
                parameter2_type = get_unqualified_type(parameter2_type);
 
-               if(!types_compatible(parameter1_type, parameter2_type))
+               if (!types_compatible(parameter1_type, parameter2_type))
                        return false;
        }
        /* same number of arguments? */
-       if(parameter1 != NULL || parameter2 != NULL)
+       if (parameter1 != NULL || parameter2 != NULL)
                return false;
 
        return true;
@@ -1007,22 +1023,6 @@ bool types_compatible(const type_t *type1, const type_t *type2)
        return false;
 }
 
-/**
- * Check if two pointer types are compatible.
- */
-bool pointers_compatible(const type_t *type1, const type_t *type2)
-{
-       assert(!is_typeref(type1));
-       assert(!is_typeref(type2));
-
-       assert(type1->kind == TYPE_POINTER);
-       assert(type2->kind == TYPE_POINTER);
-       (void) type1;
-       (void) type2;
-       /* TODO */
-       return true;
-}
-
 /**
  * Skip all typerefs and return the underlying type.
  */
@@ -1060,8 +1060,18 @@ type_t *skip_typeref(type_t *type)
        }
 
        if (qualifiers != TYPE_QUALIFIER_NONE) {
-               type_t *const copy     = duplicate_type(type);
-               copy->base.qualifiers |= qualifiers;
+               type_t *const copy = duplicate_type(type);
+
+               /* for const with typedefed array type the element type has to be
+                * adjusted */
+               if (is_type_array(copy)) {
+                       type_t *element_type           = copy->array.element_type;
+                       element_type                   = duplicate_type(element_type);
+                       element_type->base.qualifiers |= qualifiers;
+                       copy->array.element_type       = element_type;
+               } else {
+                       copy->base.qualifiers |= qualifiers;
+               }
 
                type = typehash_insert(copy);
                if (type != copy) {