X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=6c8e25ef57baae329b3d105bb41dab2ede986a11;hb=8e32d3ef5acf95570f32c8f7a6c64e897170bdf6;hp=365b3fecaeccff31cbe932c7b07c3f91e6c868b6;hpb=57569ce27c909aa9cda1d4e1b405c83ae0ef29cb;p=cparser diff --git a/type.c b/type.c index 365b3fe..6c8e25e 100644 --- a/type.c +++ b/type.c @@ -40,8 +40,7 @@ void inc_type_visited(void) type_visited++; } -static -void print_type_qualifiers(unsigned qualifiers) +void print_type_qualifiers(type_qualifiers_t qualifiers) { if(qualifiers & TYPE_QUALIFIER_CONST) fputs("const ", out); if(qualifiers & TYPE_QUALIFIER_VOLATILE) fputs("volatile ", out); @@ -152,7 +151,6 @@ static void print_array_type_pre(const array_type_t *type) static void print_array_type_post(const array_type_t *type) { - intern_print_type_post(type->element_type); fputc('[', out); if(type->is_static) { fputs("static ", out); @@ -162,6 +160,7 @@ static void print_array_type_post(const array_type_t *type) print_expression(type->size); } fputc(']', out); + intern_print_type_post(type->element_type); } void print_enum_definition(const declaration_t *declaration) @@ -259,36 +258,37 @@ static void print_typeof_type_pre(typeof_type_t *type) static void intern_print_type_pre(type_t *type) { switch(type->type) { + case TYPE_COUNT: case TYPE_INVALID: fputs("invalid", out); return; case TYPE_ENUM: - print_type_enum((enum_type_t*) type); + print_type_enum(&type->enumt); return; case TYPE_ATOMIC: - print_atomic_type((atomic_type_t*) type); + print_atomic_type(&type->atomic); return; case TYPE_COMPOUND_STRUCT: case TYPE_COMPOUND_UNION: - print_compound_type((compound_type_t*) type); + print_compound_type(&type->compound); return; case TYPE_BUILTIN: - fputs(((builtin_type_t*) type)->symbol->string, out); + fputs(type->builtin.symbol->string, out); return; case TYPE_FUNCTION: - print_function_type_pre((function_type_t*) type); + print_function_type_pre(&type->function); return; case TYPE_POINTER: - print_pointer_type_pre((pointer_type_t*) type); + print_pointer_type_pre(&type->pointer); return; case TYPE_ARRAY: - print_array_type_pre((array_type_t*) type); + print_array_type_pre(&type->array); return; case TYPE_TYPEDEF: - print_typedef_type_pre((typedef_type_t*) type); + print_typedef_type_pre(&type->typedeft); return; case TYPE_TYPEOF: - print_typeof_type_pre((typeof_type_t*) type); + print_typeof_type_pre(&type->typeoft); return; } fputs("unknown", out); @@ -298,15 +298,16 @@ static void intern_print_type_post(type_t *type) { switch(type->type) { case TYPE_FUNCTION: - print_function_type_post((const function_type_t*) type, NULL); + print_function_type_post(&type->function, NULL); return; case TYPE_POINTER: - print_pointer_type_post((const pointer_type_t*) type); + print_pointer_type_post(&type->pointer); return; case TYPE_ARRAY: - print_array_type_post((const array_type_t*) type); + print_array_type_post(&type->array); return; case TYPE_INVALID: + case TYPE_COUNT: case TYPE_ATOMIC: case TYPE_ENUM: case TYPE_COMPOUND_STRUCT: @@ -350,14 +351,15 @@ bool type_valid(const type_t *type) bool is_type_integer(const type_t *type) { + assert(!is_typeref(type)); + if(type->type == TYPE_ENUM) return true; if(type->type != TYPE_ATOMIC) return false; - atomic_type_t *atomic_type = (atomic_type_t*) type; - switch(atomic_type->atype) { + switch(type->atomic.atype) { case ATOMIC_TYPE_BOOL: case ATOMIC_TYPE_CHAR: case ATOMIC_TYPE_SCHAR: @@ -378,11 +380,12 @@ bool is_type_integer(const type_t *type) bool is_type_floating(const type_t *type) { + assert(!is_typeref(type)); + if(type->type != TYPE_ATOMIC) return false; - atomic_type_t *atomic_type = (atomic_type_t*) type; - switch(atomic_type->atype) { + switch(type->atomic.atype) { case ATOMIC_TYPE_FLOAT: case ATOMIC_TYPE_DOUBLE: case ATOMIC_TYPE_LONG_DOUBLE: @@ -402,6 +405,8 @@ bool is_type_floating(const type_t *type) bool is_type_signed(const type_t *type) { + assert(!is_typeref(type)); + /* enum types are int for now */ if(type->type == TYPE_ENUM) return true; @@ -409,8 +414,7 @@ bool is_type_signed(const type_t *type) if(type->type != TYPE_ATOMIC) return false; - atomic_type_t *atomic_type = (atomic_type_t*) type; - switch(atomic_type->atype) { + switch(type->atomic.atype) { case ATOMIC_TYPE_CHAR: case ATOMIC_TYPE_SCHAR: case ATOMIC_TYPE_SHORT: @@ -449,6 +453,8 @@ bool is_type_signed(const type_t *type) bool is_type_arithmetic(const type_t *type) { + assert(!is_typeref(type)); + if(is_type_integer(type) || is_type_floating(type)) return 1; @@ -457,6 +463,8 @@ bool is_type_arithmetic(const type_t *type) bool is_type_scalar(const type_t *type) { + assert(!is_typeref(type)); + if(type->type == TYPE_POINTER) return 1; @@ -465,18 +473,21 @@ bool is_type_scalar(const type_t *type) bool is_type_incomplete(const type_t *type) { + assert(!is_typeref(type)); + switch(type->type) { case TYPE_COMPOUND_STRUCT: case TYPE_COMPOUND_UNION: { - const compound_type_t *compound_type - = (const compound_type_t*) type; - declaration_t *declaration = compound_type->declaration; + const compound_type_t *compound_type = &type->compound; + declaration_t *declaration = compound_type->declaration; return !declaration->init.is_defined; } case TYPE_FUNCTION: return true; case TYPE_ARRAY: + return type->array.size == NULL; + case TYPE_ATOMIC: case TYPE_POINTER: case TYPE_ENUM: @@ -486,6 +497,7 @@ bool is_type_incomplete(const type_t *type) case TYPE_TYPEOF: case TYPE_BUILTIN: panic("is_type_incomplete called without typerefs skipped"); + case TYPE_COUNT: case TYPE_INVALID: break; } @@ -495,32 +507,84 @@ bool is_type_incomplete(const type_t *type) bool types_compatible(const type_t *type1, const type_t *type2) { - (void) type1; - (void) type2; - return true; + assert(!is_typeref(type1)); + assert(!is_typeref(type2)); + + /* TODO: really incomplete */ + if(type1 == type2) + return true; + + if(type1->type == TYPE_ATOMIC && type2->type == TYPE_ATOMIC) { + return type1->atomic.atype == type2->atomic.atype; + } + + return false; } bool pointers_compatible(const type_t *type1, const type_t *type2) { + assert(!is_typeref(type1)); + assert(!is_typeref(type2)); + assert(type1->type == TYPE_POINTER); assert(type2->type == TYPE_POINTER); - pointer_type_t *pointer_type1 = (pointer_type_t*) type1; - pointer_type_t *pointer_type2 = (pointer_type_t*) type2; - return types_compatible(pointer_type1->points_to, - pointer_type2->points_to); + /* TODO */ + return true; +} + +static size_t get_type_size(type_t *type) +{ + switch(type->type) { + case TYPE_ATOMIC: return sizeof(atomic_type_t); break; + case TYPE_COMPOUND_STRUCT: + case TYPE_COMPOUND_UNION: return sizeof(compound_type_t); break; + case TYPE_ENUM: return sizeof(enum_type_t); break; + case TYPE_FUNCTION: return sizeof(function_type_t); break; + case TYPE_POINTER: return sizeof(pointer_type_t); break; + case TYPE_ARRAY: return sizeof(array_type_t); break; + case TYPE_BUILTIN: return sizeof(builtin_type_t); break; + case TYPE_TYPEDEF: return sizeof(typedef_type_t); break; + case TYPE_TYPEOF: return sizeof(typeof_type_t); break; + case TYPE_COUNT: + case TYPE_INVALID: panic("invalid type found"); break; + } + panic("unknown type found"); +} + +/** + * duplicates a type + * note that this does not produce a deep copy! + */ +static type_t *duplicate_type(type_t *type) +{ + size_t size = get_type_size(type); + + type_t *copy = obstack_alloc(type_obst, size); + memcpy(copy, type, size); + + (void) duplicate_type; + + return type; } type_t *skip_typeref(type_t *type) { + unsigned qualifiers = type->base.qualifiers; + while(1) { switch(type->type) { case TYPE_TYPEDEF: { - const typedef_type_t *typedef_type = (const typedef_type_t*) type; + qualifiers |= type->base.qualifiers; + const typedef_type_t *typedef_type = &type->typedeft; + if(typedef_type->resolved_type != NULL) { + type = typedef_type->resolved_type; + break; + } type = typedef_type->declaration->type; continue; } case TYPE_TYPEOF: { - const typeof_type_t *typeof_type = (const typeof_type_t *) type; + const typeof_type_t *typeof_type = &type->typeoft; if(typeof_type->typeof_type != NULL) { type = typeof_type->typeof_type; } else { @@ -529,7 +593,7 @@ type_t *skip_typeref(type_t *type) continue; } case TYPE_BUILTIN: { - const builtin_type_t *builtin_type = (const builtin_type_t*) type; + const builtin_type_t *builtin_type = &type->builtin; type = builtin_type->real_type; continue; } @@ -553,28 +617,28 @@ static type_t *identify_new_type(type_t *type) return result; } -type_t *make_atomic_type(atomic_type_type_t type, type_qualifier_t qualifiers) +type_t *make_atomic_type(atomic_type_type_t atype, type_qualifiers_t qualifiers) { - atomic_type_t *atomic_type - = obstack_alloc(type_obst, sizeof(atomic_type[0])); - memset(atomic_type, 0, sizeof(atomic_type[0])); - atomic_type->type.type = TYPE_ATOMIC; - atomic_type->type.qualifiers = qualifiers; - atomic_type->atype = type; + type_t *type = obstack_alloc(type_obst, sizeof(atomic_type_t)); + memset(type, 0, sizeof(atomic_type_t)); - return identify_new_type((type_t*) atomic_type); + type->type = TYPE_ATOMIC; + type->base.qualifiers = qualifiers; + type->atomic.atype = atype; + + return identify_new_type(type); } -type_t *make_pointer_type(type_t *points_to, type_qualifier_t qualifiers) +type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers) { - pointer_type_t *pointer_type - = obstack_alloc(type_obst, sizeof(pointer_type[0])); - memset(pointer_type, 0, sizeof(pointer_type[0])); - pointer_type->type.type = TYPE_POINTER; - pointer_type->type.qualifiers = qualifiers; - pointer_type->points_to = points_to; + type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t)); + memset(type, 0, sizeof(pointer_type_t)); + + type->type = TYPE_POINTER; + type->base.qualifiers = qualifiers; + type->pointer.points_to = points_to; - return identify_new_type((type_t*) pointer_type); + return identify_new_type(type); } static __attribute__((unused))