#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;
{
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),
{
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)
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";
static void print_complex_type(const atomic_type_t *type)
{
print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
- print_string("_Complex");
+ print_string("_Complex ");
print_atomic_kinds(type->akind);
}
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 {
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);
}
}
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(')');
/**
* Prints a compound type.
*
+ * @param kind The name of the compound kind.
* @param type The compound type.
*/
-static void print_compound_type(const compound_type_t *type)
+static void print_compound_type(char const *const kind, compound_type_t const *const type)
{
print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
-
- if (type->base.kind == TYPE_COMPOUND_STRUCT) {
- print_string("struct ");
- } else {
- assert(type->base.kind == TYPE_COMPOUND_UNION);
- print_string("union ");
- }
+ print_string(kind);
compound_t *compound = type->compound;
symbol_t *symbol = compound->base.symbol;
static void intern_print_type_pre(const type_t *const type)
{
switch(type->kind) {
- case TYPE_ERROR:
- print_string("<error>");
- return;
- case TYPE_ENUM:
- print_type_enum(&type->enumt);
- return;
- case TYPE_ATOMIC:
- print_atomic_type(&type->atomic);
- return;
- case TYPE_COMPLEX:
- print_complex_type(&type->atomic);
- return;
- case TYPE_IMAGINARY:
- print_imaginary_type(&type->atomic);
- return;
- case TYPE_COMPOUND_STRUCT:
- case TYPE_COMPOUND_UNION:
- print_compound_type(&type->compound);
- return;
- case TYPE_FUNCTION:
- print_function_type_pre(&type->function);
- return;
- case TYPE_POINTER:
- print_pointer_type_pre(&type->pointer);
- return;
- case TYPE_REFERENCE:
- print_reference_type_pre(&type->reference);
- return;
- case TYPE_ARRAY:
- print_array_type_pre(&type->array);
- return;
- case TYPE_TYPEDEF:
- print_typedef_type_pre(&type->typedeft);
- return;
- case TYPE_TYPEOF:
- print_typeof_type_pre(&type->typeoft);
- return;
+ case TYPE_ARRAY: print_array_type_pre( &type->array); return;
+ case TYPE_ATOMIC: print_atomic_type( &type->atomic); return;
+ case TYPE_COMPLEX: print_complex_type( &type->atomic); return;
+ case TYPE_COMPOUND_STRUCT: print_compound_type("struct ", &type->compound); return;
+ case TYPE_COMPOUND_UNION: print_compound_type("union ", &type->compound); return;
+ case TYPE_ENUM: print_type_enum( &type->enumt); return;
+ case TYPE_ERROR: print_string("<error>"); return;
+ case TYPE_FUNCTION: print_function_type_pre( &type->function); return;
+ case TYPE_IMAGINARY: print_imaginary_type( &type->atomic); return;
+ case TYPE_POINTER: print_pointer_type_pre( &type->pointer); return;
+ case TYPE_REFERENCE: print_reference_type_pre( &type->reference); return;
+ case TYPE_TYPEDEF: print_typedef_type_pre( &type->typedeft); return;
+ case TYPE_TYPEOF: print_typeof_type_pre( &type->typeoft); return;
}
print_string("unknown");
}
{
size_t size = get_type_struct_size(type->kind);
- type_t *const copy = obstack_alloc(&type_obst, size);
- memcpy(copy, type, size);
+ type_t *const copy = obstack_copy(&type_obst, type, size);
copy->base.firm_type = NULL;
return copy;
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));
{
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)
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)
if (type1 == type2)
return true;
- if (!is_type_valid(type1) || !is_type_valid(type2))
- return true;
-
- if (type1->base.qualifiers != type2->base.qualifiers)
- return false;
- if (type1->kind != type2->kind)
- return false;
+ if (type1->base.qualifiers == type2->base.qualifiers &&
+ type1->kind == type2->kind) {
+ switch (type1->kind) {
+ case TYPE_FUNCTION:
+ return function_types_compatible(&type1->function, &type2->function);
+ case TYPE_ATOMIC:
+ case TYPE_IMAGINARY:
+ case TYPE_COMPLEX:
+ return type1->atomic.akind == type2->atomic.akind;
+ case TYPE_ARRAY:
+ return array_types_compatible(&type1->array, &type2->array);
- switch (type1->kind) {
- case TYPE_FUNCTION:
- return function_types_compatible(&type1->function, &type2->function);
- case TYPE_ATOMIC:
- case TYPE_IMAGINARY:
- case TYPE_COMPLEX:
- return type1->atomic.akind == type2->atomic.akind;
- case TYPE_ARRAY:
- return array_types_compatible(&type1->array, &type2->array);
+ case TYPE_POINTER: {
+ const type_t *const to1 = skip_typeref(type1->pointer.points_to);
+ const type_t *const to2 = skip_typeref(type2->pointer.points_to);
+ return types_compatible(to1, to2);
+ }
- case TYPE_POINTER: {
- const type_t *const to1 = skip_typeref(type1->pointer.points_to);
- const type_t *const to2 = skip_typeref(type2->pointer.points_to);
- return types_compatible(to1, to2);
- }
+ case TYPE_REFERENCE: {
+ const type_t *const to1 = skip_typeref(type1->reference.refers_to);
+ const type_t *const to2 = skip_typeref(type2->reference.refers_to);
+ return types_compatible(to1, to2);
+ }
- case TYPE_REFERENCE: {
- const type_t *const to1 = skip_typeref(type1->reference.refers_to);
- const type_t *const to2 = skip_typeref(type2->reference.refers_to);
- return types_compatible(to1, to2);
- }
+ case TYPE_COMPOUND_STRUCT:
+ case TYPE_COMPOUND_UNION:
+ break;
- case TYPE_COMPOUND_STRUCT:
- case TYPE_COMPOUND_UNION: {
- break;
- }
- case TYPE_ENUM:
- /* TODO: not implemented */
- break;
+ case TYPE_ENUM:
+ /* TODO: not implemented */
+ break;
- case TYPE_ERROR:
- /* Hmm, the error type should be compatible to all other types */
- return true;
- case TYPE_TYPEDEF:
- case TYPE_TYPEOF:
- panic("typerefs not skipped in compatible types?!?");
+ case TYPE_ERROR:
+ /* Hmm, the error type should be compatible to all other types */
+ return true;
+ case TYPE_TYPEDEF:
+ case TYPE_TYPEOF:
+ panic("typeref not skipped");
+ }
}
- return false;
+ return !is_type_valid(type1) || !is_type_valid(type2);
}
/**
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)
case TYPE_TYPEOF:
return get_type_alignment(type->typeoft.typeof_type);
}
- panic("invalid type in get_type_alignment");
+ panic("invalid 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)
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,
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,
return;
if (type->compound->layouted)
return;
+ compound->layouted = true;
il_size_t offset = 0;
il_alignment_t alignment = compound->alignment;
}
}
- 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) {
compound->size = offset;
compound->alignment = alignment;
- compound->layouted = true;
}
void layout_union_type(compound_type_t *type)
compound_t *compound = type->compound;
if (! compound->complete)
return;
+ if (compound->layouted)
+ return;
+ compound->layouted = true;
il_size_t size = 0;
il_alignment_t alignment = compound->alignment;
projects / cparser / blobdiff