#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),
const char *get_atomic_kind_name(atomic_type_kind_t kind)
{
- switch(kind) {
+ switch (kind) {
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(", ");
- }
+ for ( ; parameter != NULL; parameter = parameter->next) {
+ 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(')');
change_indent(1);
entity_t *entry = enume->base.next;
- for( ; entry != NULL && entry->kind == ENTITY_ENUM_VALUE;
+ for ( ; entry != NULL && entry->kind == ENTITY_ENUM_VALUE;
entry = entry->base.next) {
print_indent();
change_indent(1);
entity_t *entity = compound->members.entities;
- for( ; entity != NULL; entity = entity->base.next) {
+ for ( ; entity != NULL; entity = entity->base.next) {
if (entity->kind != ENTITY_COMPOUND_MEMBER)
continue;
*/
static void intern_print_type_pre(const type_t *const type)
{
- switch(type->kind) {
+ switch (type->kind) {
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;
*/
static void intern_print_type_post(const type_t *const type)
{
- switch(type->kind) {
+ switch (type->kind) {
case TYPE_FUNCTION:
print_function_type_post(&type->function, NULL);
return;
bool is_type_integer(const type_t *type)
{
assert(!is_typeref(type));
-
- if (type->kind == TYPE_ENUM)
- return true;
- if (type->kind != TYPE_ATOMIC)
+ if (!is_type_arithmetic(type))
return false;
-
return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_INTEGER);
}
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);
+ return type->kind == TYPE_COMPLEX;
}
bool is_type_signed(const type_t *type)
{
assert(!is_typeref(type));
-
- /* enum types are int for now */
- if (type->kind == TYPE_ENUM)
- return true;
- if (type->kind != TYPE_ATOMIC)
+ if (!is_type_arithmetic(type))
return false;
-
return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_SIGNED);
}
{
assert(!is_typeref(type));
- switch(type->kind) {
+ switch (type->kind) {
case TYPE_ENUM:
return true;
case TYPE_ATOMIC:
{
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_COMPLEX:
+ 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)
{
assert(!is_typeref(type));
- switch(type->kind) {
+ switch (type->kind) {
case TYPE_COMPOUND_STRUCT:
case TYPE_COMPOUND_UNION: {
const compound_type_t *compound_type = &type->compound;
decl_modifiers_t get_type_modifiers(const type_t *type)
{
- switch(type->kind) {
+ switch (type->kind) {
case TYPE_ERROR:
break;
case TYPE_COMPOUND_STRUCT:
}
}
- 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) {