#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);
-
- switch (type->base.kind) {
- case TYPE_COMPOUND_STRUCT: print_string("struct "); break;
- case TYPE_COMPOUND_UNION: print_string("union "); break;
- default: panic("invalid type");
- }
+ 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)
return true;
case TYPE_TYPEDEF:
case TYPE_TYPEOF:
- panic("typerefs not skipped in compatible types?!?");
+ panic("typeref not skipped");
}
}
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,
}
}
- 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) {
projects / cparser / blobdiff