X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=fd3b4ceddb62759776673360782ce22a1fc29941;hb=8845feb009950d2c76a394660a5bd81a0be0f2a6;hp=da737e50492a98a359bffd8de5ea81bd589635e7;hpb=2e75b0923573fe37b5930d60067e202860e6ef3d;p=cparser diff --git a/type.c b/type.c index da737e5..fd3b4ce 100644 --- a/type.c +++ b/type.c @@ -1,21 +1,6 @@ /* * This file is part of cparser. - * Copyright (C) 2007-2009 Matthias Braun - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - * 02111-1307, USA. + * Copyright (C) 2012 Matthias Braun */ #include @@ -33,6 +18,7 @@ #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; @@ -52,6 +38,8 @@ static size_t get_type_struct_size(type_kind_t kind) { 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), @@ -239,15 +227,15 @@ void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparato { 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) @@ -256,8 +244,7 @@ void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparato const char *get_atomic_kind_name(atomic_type_kind_t kind) { - switch(kind) { - case ATOMIC_TYPE_INVALID: break; + 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"; @@ -309,7 +296,7 @@ static void print_atomic_type(const atomic_type_t *type) 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); } @@ -374,15 +361,11 @@ static void print_function_type_post(const function_type_t *type, 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 { @@ -391,11 +374,7 @@ static void print_function_type_post(const function_type_t *type, 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); @@ -405,14 +384,10 @@ static void print_function_type_post(const function_type_t *type, } } 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(')'); @@ -518,7 +493,7 @@ void print_enum_definition(const enum_t *enume) 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(); @@ -560,7 +535,7 @@ void print_compound_definition(const compound_t *compound) 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; @@ -580,18 +555,13 @@ void print_compound_definition(const compound_t *compound) /** * 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; @@ -636,44 +606,20 @@ static void print_typeof_type_pre(const typeof_type_t *const type) */ static void intern_print_type_pre(const type_t *const type) { - switch(type->kind) { - case TYPE_ERROR: - print_string(""); - 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; + 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; + 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(""); 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"); } @@ -685,7 +631,7 @@ static void intern_print_type_pre(const type_t *const type) */ 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; @@ -735,8 +681,7 @@ type_t *duplicate_type(const type_t *type) { 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; @@ -793,12 +738,8 @@ static bool test_atomic_type_flag(atomic_type_kind_t kind, 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); } @@ -821,23 +762,14 @@ bool is_type_float(const type_t *type) 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); } @@ -845,7 +777,7 @@ bool is_type_arithmetic(const type_t *type) { assert(!is_typeref(type)); - switch(type->kind) { + switch (type->kind) { case TYPE_ENUM: return true; case TYPE_ATOMIC: @@ -867,17 +799,24 @@ bool is_type_scalar(const type_t *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_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; @@ -903,10 +842,10 @@ 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) @@ -995,53 +934,48 @@ bool types_compatible(const type_t *type1, const type_t *type2) 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); } /** @@ -1128,7 +1062,7 @@ unsigned get_type_size(type_t *type) 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) @@ -1166,7 +1100,7 @@ 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"); } /** @@ -1184,7 +1118,7 @@ static unsigned get_type_alignment_compound(type_t *const type) decl_modifiers_t get_type_modifiers(const type_t *type) { - switch(type->kind) { + switch (type->kind) { case TYPE_ERROR: break; case TYPE_COMPOUND_STRUCT: @@ -1208,7 +1142,7 @@ decl_modifiers_t get_type_modifiers(const type_t *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) @@ -1271,7 +1205,7 @@ atomic_type_kind_t find_signed_int_atomic_type_kind_for_size(unsigned size) 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, @@ -1299,7 +1233,7 @@ atomic_type_kind_t find_unsigned_int_atomic_type_kind_for_size(unsigned size) 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, @@ -1553,7 +1487,7 @@ next: } } - 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) {