X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=68880a27aced4c0a609cb2cf8fc1217e0ffaee2a;hb=11839325c556fdf4b749c536bb0966bb0565c4d7;hp=5bb7a5fb3f1e219e0d27a88ba5799ab0d3f70eac;hpb=4eade33d45008f90c8952a65a92cdda17d9598f9;p=cparser diff --git a/type.c b/type.c index 5bb7a5f..68880a2 100644 --- a/type.c +++ b/type.c @@ -9,9 +9,11 @@ static struct obstack _type_obst; struct obstack *type_obst = &_type_obst; static FILE *out; +static int type_visited = 0; +static bool print_compound_entries; -static void intern_print_type_pre(const type_t *type); -static void intern_print_type_post(const type_t *type); +static void intern_print_type_pre(type_t *type); +static void intern_print_type_post(type_t *type); void init_types(void) { @@ -28,13 +30,21 @@ void type_set_output(FILE *stream) out = stream; } -static +void set_print_compound_entries(bool enabled) +{ + print_compound_entries = enabled; +} + +void inc_type_visited(void) +{ + type_visited++; +} + void print_type_qualifiers(unsigned qualifiers) { if(qualifiers & TYPE_QUALIFIER_CONST) fputs("const ", out); if(qualifiers & TYPE_QUALIFIER_VOLATILE) fputs("volatile ", out); if(qualifiers & TYPE_QUALIFIER_RESTRICT) fputs("restrict ", out); - if(qualifiers & TYPE_QUALIFIER_INLINE) fputs("inline ", out); } static @@ -46,7 +56,7 @@ void print_atomic_type(const atomic_type_t *type) switch(type->atype) { case ATOMIC_TYPE_INVALID: s = "INVALIDATOMIC"; break; case ATOMIC_TYPE_VOID: s = "void"; break; - case ATOMIC_TYPE_BOOL: s = "bool"; break; + case ATOMIC_TYPE_BOOL: s = "_Bool"; break; case ATOMIC_TYPE_CHAR: s = "char"; break; case ATOMIC_TYPE_SCHAR: s = "signed char"; break; case ATOMIC_TYPE_UCHAR: s = "unsigned char"; break; @@ -66,8 +76,7 @@ void print_atomic_type(const atomic_type_t *type) fputs(s, out); } -static -void print_method_type_pre(const method_type_t *type) +static void print_function_type_pre(const function_type_t *type) { print_type_qualifiers(type->type.qualifiers); @@ -77,8 +86,8 @@ void print_method_type_pre(const method_type_t *type) fputc('(', out); } -static -void print_method_type_post(const method_type_t *type, const context_t *context) +static void print_function_type_post(const function_type_t *type, + const context_t *context) { /* TODO: don't emit braces if we're the toplevel type... */ intern_print_type_post(type->result_type); @@ -88,7 +97,7 @@ void print_method_type_post(const method_type_t *type, const context_t *context) int first = 1; if(context == NULL) { - method_parameter_t *parameter = type->parameters; + function_parameter_t *parameter = type->parameters; for( ; parameter != NULL; parameter = parameter->next) { if(first) { first = 0; @@ -123,8 +132,7 @@ void print_method_type_post(const method_type_t *type, const context_t *context) fputc(')', out); } -static -void print_pointer_type_pre(const pointer_type_t *type) +static void print_pointer_type_pre(const pointer_type_t *type) { intern_print_type_pre(type->points_to); fputs("*", out); @@ -136,6 +144,11 @@ static void print_pointer_type_post(const pointer_type_t *type) intern_print_type_post(type->points_to); } +static void print_array_type_pre(const array_type_t *type) +{ + intern_print_type_pre(type->element_type); +} + static void print_array_type_post(const array_type_t *type) { fputc('[', out); @@ -147,70 +160,144 @@ 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) +{ + fputs("{\n", out); + + change_indent(1); + + declaration_t *entry = declaration->next; + for( ; entry != NULL && entry->storage_class == STORAGE_CLASS_ENUM_ENTRY; + entry = entry->next) { + + print_indent(); + fprintf(out, "%s", entry->symbol->string); + if(entry->init.initializer != NULL) { + fprintf(out, " = "); + print_expression(entry->init.enum_value); + } + fprintf(out, ",\n"); + } + + change_indent(-1); + print_indent(); + fputs("}", out); } static void print_type_enum(const enum_type_t *type) { print_type_qualifiers(type->type.qualifiers); - if(type->symbol != NULL) { - fprintf(out, "enum %s", type->symbol->string); + fputs("enum ", out); + + declaration_t *declaration = type->declaration; + symbol_t *symbol = declaration->symbol; + if(symbol != NULL) { + fputs(symbol->string, out); } else { - fprintf(out, "enum {\n"); - - declaration_t *entry = type->entries_begin; - for( ; entry != type->entries_end->next; entry = entry->next) { - fprintf(out, "\t%s", entry->symbol->string); - if(entry->initializer != NULL) { - fprintf(out, " = "); - print_expression(entry->initializer); - } - fprintf(out, ",\n"); - } + print_enum_definition(declaration); + } +} + +void print_compound_definition(const declaration_t *declaration) +{ + fputs("{\n", out); + change_indent(1); + + declaration_t *iter = declaration->context.declarations; + for( ; iter != NULL; iter = iter->next) { + print_indent(); + print_declaration(iter); + fputc('\n', out); + } + + change_indent(-1); + print_indent(); + fputs("}", out); +} + +static void print_compound_type(const compound_type_t *type) +{ + print_type_qualifiers(type->type.qualifiers); + + if(type->type.type == TYPE_COMPOUND_STRUCT) { + fputs("struct ", out); + } else { + assert(type->type.type == TYPE_COMPOUND_UNION); + fputs("union ", out); + } - fprintf(out, "} "); + declaration_t *declaration = type->declaration; + symbol_t *symbol = declaration->symbol; + if(symbol != NULL) { + fputs(symbol->string, out); + } else { + print_compound_definition(declaration); + } +} + +static void print_typedef_type_pre(typedef_type_t *type) +{ + fputs(type->declaration->symbol->string, out); +} + +static void print_typeof_type_pre(typeof_type_t *type) +{ + fputs("typeof(", out); + if(type->expression != NULL) { + assert(type->typeof_type == NULL); + print_expression(type->expression); + } else { + print_type(type->typeof_type); } + fputc(')', out); } -static void intern_print_type_pre(const type_t *type) +static void intern_print_type_pre(type_t *type) { switch(type->type) { case TYPE_INVALID: fputs("invalid", out); return; case TYPE_ENUM: - print_type_enum((const enum_type_t*) type); + print_type_enum((enum_type_t*) type); return; case TYPE_ATOMIC: - print_atomic_type((const atomic_type_t*) type); + print_atomic_type((atomic_type_t*) type); return; case TYPE_COMPOUND_STRUCT: case TYPE_COMPOUND_UNION: - print_type_qualifiers(type->qualifiers); - if(((const compound_type_t*) type)->symbol != NULL) { - fprintf(out, "%s", ((const compound_type_t*) type)->symbol->string); - } + print_compound_type((compound_type_t*) type); return; case TYPE_BUILTIN: fputs(((builtin_type_t*) type)->symbol->string, out); return; - case TYPE_METHOD: - print_method_type_pre((const method_type_t*) type); + case TYPE_FUNCTION: + print_function_type_pre((function_type_t*) type); return; case TYPE_POINTER: - print_pointer_type_pre((const pointer_type_t*) type); + print_pointer_type_pre((pointer_type_t*) type); return; case TYPE_ARRAY: + print_array_type_pre((array_type_t*) type); + return; + case TYPE_TYPEDEF: + print_typedef_type_pre((typedef_type_t*) type); + return; + case TYPE_TYPEOF: + print_typeof_type_pre((typeof_type_t*) type); return; } fputs("unknown", out); } -static -void intern_print_type_post(const type_t *type) +static void intern_print_type_post(type_t *type) { switch(type->type) { - case TYPE_METHOD: - print_method_type_post((const method_type_t*) type, NULL); + case TYPE_FUNCTION: + print_function_type_post((const function_type_t*) type, NULL); return; case TYPE_POINTER: print_pointer_type_post((const pointer_type_t*) type); @@ -224,16 +311,18 @@ void intern_print_type_post(const type_t *type) case TYPE_COMPOUND_STRUCT: case TYPE_COMPOUND_UNION: case TYPE_BUILTIN: + case TYPE_TYPEOF: + case TYPE_TYPEDEF: break; } } -void print_type(const type_t *type) +void print_type(type_t *type) { print_type_ext(type, NULL, NULL); } -void print_type_ext(const type_t *type, const symbol_t *symbol, +void print_type_ext(type_t *type, const symbol_t *symbol, const context_t *context) { if(type == NULL) { @@ -246,8 +335,8 @@ void print_type_ext(const type_t *type, const symbol_t *symbol, fputc(' ', out); fputs(symbol->string, out); } - if(type->type == TYPE_METHOD) { - print_method_type_post((const method_type_t*) type, context); + if(type->type == TYPE_FUNCTION) { + print_function_type_post((const function_type_t*) type, context); } else { intern_print_type_post(type); } @@ -260,11 +349,15 @@ bool type_valid(const type_t *type) bool is_type_integer(const type_t *type) { + if(type->type == TYPE_ENUM) + return true; + if(type->type != TYPE_ATOMIC) - return 0; + return false; atomic_type_t *atomic_type = (atomic_type_t*) type; switch(atomic_type->atype) { + case ATOMIC_TYPE_BOOL: case ATOMIC_TYPE_CHAR: case ATOMIC_TYPE_SCHAR: case ATOMIC_TYPE_UCHAR: @@ -276,30 +369,53 @@ bool is_type_integer(const type_t *type) case ATOMIC_TYPE_ULONG: case ATOMIC_TYPE_LONGLONG: case ATOMIC_TYPE_ULONGLONG: - return 1; + return true; default: - return 0; + return false; } } -bool is_type_arithmetic(const type_t *type) +bool is_type_floating(const type_t *type) +{ + if(type->type != TYPE_ATOMIC) + return false; + + atomic_type_t *atomic_type = (atomic_type_t*) type; + switch(atomic_type->atype) { + case ATOMIC_TYPE_FLOAT: + case ATOMIC_TYPE_DOUBLE: + case ATOMIC_TYPE_LONG_DOUBLE: +#ifdef PROVIDE_COMPLEX + case ATOMIC_TYPE_FLOAT_COMPLEX: + case ATOMIC_TYPE_DOUBLE_COMPLEX: + case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX: + case ATOMIC_TYPE_FLOAT_IMAGINARY: + case ATOMIC_TYPE_DOUBLE_IMAGINARY: + case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY: +#endif + return true; + default: + return false; + } +} + +bool is_type_signed(const type_t *type) { + /* enum types are int for now */ + if(type->type == TYPE_ENUM) + return true; + if(type->type != TYPE_ATOMIC) - return 0; + return false; atomic_type_t *atomic_type = (atomic_type_t*) type; switch(atomic_type->atype) { case ATOMIC_TYPE_CHAR: case ATOMIC_TYPE_SCHAR: - case ATOMIC_TYPE_UCHAR: case ATOMIC_TYPE_SHORT: - case ATOMIC_TYPE_USHORT: case ATOMIC_TYPE_INT: - case ATOMIC_TYPE_UINT: case ATOMIC_TYPE_LONG: - case ATOMIC_TYPE_ULONG: case ATOMIC_TYPE_LONGLONG: - case ATOMIC_TYPE_ULONGLONG: case ATOMIC_TYPE_FLOAT: case ATOMIC_TYPE_DOUBLE: case ATOMIC_TYPE_LONG_DOUBLE: @@ -307,19 +423,34 @@ bool is_type_arithmetic(const type_t *type) case ATOMIC_TYPE_FLOAT_COMPLEX: case ATOMIC_TYPE_DOUBLE_COMPLEX: case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX: -#endif -#ifdef PROVIDE_IMAGINARY case ATOMIC_TYPE_FLOAT_IMAGINARY: case ATOMIC_TYPE_DOUBLE_IMAGINARY: case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY: #endif - return 1; + return true; + + case ATOMIC_TYPE_BOOL: + case ATOMIC_TYPE_UCHAR: + case ATOMIC_TYPE_USHORT: + case ATOMIC_TYPE_UINT: + case ATOMIC_TYPE_ULONG: + case ATOMIC_TYPE_ULONGLONG: + return false; + case ATOMIC_TYPE_INVALID: case ATOMIC_TYPE_VOID: - case ATOMIC_TYPE_BOOL: - return 0; + return false; } + panic("invalid atomic type found"); + return false; +} + +bool is_type_arithmetic(const type_t *type) +{ + if(is_type_integer(type) || is_type_floating(type)) + return 1; + return 0; } @@ -331,6 +462,145 @@ bool is_type_scalar(const type_t *type) return is_type_arithmetic(type); } +bool is_type_incomplete(const type_t *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; + return !declaration->init.is_defined; + } + case TYPE_FUNCTION: + return true; + + case TYPE_ARRAY: { + const array_type_t *array_type = (const array_type_t*) type; + + return array_type->size == NULL; + } + + case TYPE_ATOMIC: + case TYPE_POINTER: + case TYPE_ENUM: + return false; + + case TYPE_TYPEDEF: + case TYPE_TYPEOF: + case TYPE_BUILTIN: + panic("is_type_incomplete called without typerefs skipped"); + case TYPE_INVALID: + break; + } + + panic("invalid type found"); +} + +bool types_compatible(const type_t *type1, const type_t *type2) +{ + /* TODO: really incomplete */ + if(type1 == type2) + return true; + + if(type1->type == TYPE_ATOMIC && type2->type == TYPE_ATOMIC) { + const atomic_type_t *atomic1 = (const atomic_type_t*) type1; + const atomic_type_t *atomic2 = (const atomic_type_t*) type2; + + return atomic1->atype == atomic2->atype; + } + + return false; +} + +bool pointers_compatible(const type_t *type1, const type_t *type2) +{ + assert(type1->type == TYPE_POINTER); + assert(type2->type == TYPE_POINTER); +#if 0 + 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); +#endif + 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_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->qualifiers; + + while(1) { + switch(type->type) { + case TYPE_TYPEDEF: { + qualifiers |= type->qualifiers; + const typedef_type_t *typedef_type = (const typedef_type_t*) type; + 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; + if(typeof_type->typeof_type != NULL) { + type = typeof_type->typeof_type; + } else { + type = typeof_type->expression->datatype; + } + continue; + } + case TYPE_BUILTIN: { + const builtin_type_t *builtin_type = (const builtin_type_t*) type; + type = builtin_type->real_type; + continue; + } + default: + break; + } + break; + } + + return type; +} + + + static type_t *identify_new_type(type_t *type) { type_t *result = typehash_insert(type); @@ -340,7 +610,7 @@ static type_t *identify_new_type(type_t *type) return result; } -type_t *make_atomic_type(atomic_type_type_t type, unsigned qualifiers) +type_t *make_atomic_type(atomic_type_type_t type, type_qualifier_t qualifiers) { atomic_type_t *atomic_type = obstack_alloc(type_obst, sizeof(atomic_type[0])); @@ -352,7 +622,7 @@ type_t *make_atomic_type(atomic_type_type_t type, unsigned qualifiers) return identify_new_type((type_t*) atomic_type); } -type_t *make_pointer_type(type_t *points_to, unsigned qualifiers) +type_t *make_pointer_type(type_t *points_to, type_qualifier_t qualifiers) { pointer_type_t *pointer_type = obstack_alloc(type_obst, sizeof(pointer_type[0])); @@ -365,7 +635,7 @@ type_t *make_pointer_type(type_t *points_to, unsigned qualifiers) } static __attribute__((unused)) -void dbg_type(const type_t *type) +void dbg_type(type_t *type) { FILE *old_out = out; out = stderr;