/* 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_LONGLONG].alignment = 4;
- props[ATOMIC_TYPE_ULONGLONG].alignment = 4;
+ 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];
}
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);
}
declaration_t *parameter = scope->declarations;
for( ; parameter != NULL; parameter = parameter->next) {
if(first) {
- first = 0;
+ first = false;
} else {
fputs(", ", out);
}
}
if(type->variadic) {
if(first) {
- first = 0;
+ first = false;
} else {
fputs(", ", out);
}
if(type->kind == TYPE_ENUM)
return true;
+ if(type->kind == TYPE_BITFIELD)
+ return true;
if(type->kind != TYPE_ATOMIC)
return false;
/* 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;
}
}
+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.
*
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:
- 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;
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) {