}
}
+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.
*
declaration_t *declaration = enum_type->declaration;
return !declaration->init.complete;
}
- case TYPE_BITFIELD:
- return false;
-
- case TYPE_FUNCTION:
- return true;
case TYPE_ARRAY:
return type->array.size_expression == NULL
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:
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.
*/
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 */
/* 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);
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;
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.
*/
}
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) {