X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=9be93a76c851e08d83ccc0987806a6b66679d69d;hb=bfb4a8e78384d2b6e85e13be00e8d79b4083f725;hp=ce14faaf3a983fc69e2bf0e5672fb7e599efafb9;hpb=61a03a80a0c34c03dcf9bc227ca1c9355e8cf3ff;p=cparser diff --git a/type.c b/type.c index ce14faa..9be93a7 100644 --- a/type.c +++ b/type.c @@ -295,28 +295,33 @@ void print_imaginary_type(const imaginary_type_t *type) */ static void print_function_type_pre(const function_type_t *type, bool top) { + switch (type->linkage) { + case LINKAGE_INVALID: + break; + + case LINKAGE_C: + if (c_mode & _CXX) + fputs("extern \"C\" ", out); + break; + + case LINKAGE_CXX: + if (!(c_mode & _CXX)) + fputs("extern \"C++\" ", out); + break; + } + print_type_qualifiers(type->base.qualifiers); if (type->base.qualifiers != 0) fputc(' ', out); - intern_print_type_pre(type->return_type, false); switch (type->calling_convention) { - case CC_CDECL: - fputs("__cdecl ", out); - break; - case CC_STDCALL: - fputs("__stdcall ", out); - break; - case CC_FASTCALL: - fputs("__fastcall ", out); - break; - case CC_THISCALL: - fputs("__thiscall ", out); - break; - case CC_DEFAULT: - break; + case CC_CDECL: fputs("__cdecl ", out); break; + case CC_STDCALL: fputs("__stdcall ", out); break; + case CC_FASTCALL: fputs("__fastcall ", out); break; + case CC_THISCALL: fputs("__thiscall ", out); break; + case CC_DEFAULT: break; } /* don't emit parenthesis if we're the toplevel type... */ @@ -386,12 +391,29 @@ static void print_function_type_post(const function_type_t *type, static void print_pointer_type_pre(const pointer_type_t *type) { intern_print_type_pre(type->points_to, false); - fputs("*", out); + variable_t *const variable = type->base_variable; + if (variable != NULL) { + fputs(" __based(", out); + fputs(variable->base.base.symbol->string, out); + fputs(") ", out); + } + fputc('*', out); print_type_qualifiers(type->base.qualifiers); if (type->base.qualifiers != 0) fputc(' ', out); } +/** + * Prints the prefix part of a reference type. + * + * @param type The reference type. + */ +static void print_reference_type_pre(const reference_type_t *type) +{ + intern_print_type_pre(type->refers_to, false); + fputc('&', out); +} + /** * Prints the postfix part of a pointer type. * @@ -402,6 +424,16 @@ static void print_pointer_type_post(const pointer_type_t *type) intern_print_type_post(type->points_to, false); } +/** + * Prints the postfix part of a reference type. + * + * @param type The reference type. + */ +static void print_reference_type_post(const reference_type_t *type) +{ + intern_print_type_post(type->refers_to, false); +} + /** * Prints the prefix part of an array type. * @@ -462,9 +494,9 @@ void print_enum_definition(const enum_t *enume) entry = entry->base.next) { print_indent(); - fprintf(out, "%s", entry->base.symbol->string); + fputs(entry->base.symbol->string, out); if (entry->enum_value.value != NULL) { - fprintf(out, " = "); + fputs(" = ", out); /* skip the implicit cast */ expression_t *expression = entry->enum_value.value; @@ -473,12 +505,12 @@ void print_enum_definition(const enum_t *enume) } print_expression(expression); } - fprintf(out, ",\n"); + fputs(",\n", out); } change_indent(-1); print_indent(); - fputs("}", out); + fputc('}', out); } /** @@ -521,7 +553,10 @@ void print_compound_definition(const compound_t *compound) change_indent(-1); print_indent(); - fputs("}", out); + fputc('}', out); + if (compound->modifiers & DM_TRANSPARENT_UNION) { + fputs("__attribute__((__transparent_union__))", out); + } } /** @@ -620,6 +655,9 @@ static void intern_print_type_pre(const type_t *const type, const bool top) case TYPE_POINTER: print_pointer_type_pre(&type->pointer); return; + case TYPE_REFERENCE: + print_reference_type_pre(&type->reference); + return; case TYPE_BITFIELD: intern_print_type_pre(type->bitfield.base_type, top); return; @@ -651,6 +689,9 @@ static void intern_print_type_post(const type_t *const type, const bool top) case TYPE_POINTER: print_pointer_type_post(&type->pointer); return; + case TYPE_REFERENCE: + print_reference_type_post(&type->reference); + return; case TYPE_ARRAY: print_array_type_post(&type->array); return; @@ -670,6 +711,10 @@ static void intern_print_type_post(const type_t *const type, const bool top) case TYPE_TYPEDEF: break; } + + if (type->base.modifiers & DM_TRANSPARENT_UNION) { + fputs("__attribute__((__transparent_union__))", out); + } } /** @@ -718,6 +763,7 @@ static size_t get_type_size(const type_t *type) case TYPE_ENUM: return sizeof(enum_type_t); case TYPE_FUNCTION: return sizeof(function_type_t); case TYPE_POINTER: return sizeof(pointer_type_t); + case TYPE_REFERENCE: return sizeof(reference_type_t); case TYPE_ARRAY: return sizeof(array_type_t); case TYPE_BUILTIN: return sizeof(builtin_type_t); case TYPE_TYPEDEF: return sizeof(typedef_type_t); @@ -999,6 +1045,7 @@ bool is_type_incomplete(const type_t *type) case TYPE_BITFIELD: case TYPE_FUNCTION: case TYPE_POINTER: + case TYPE_REFERENCE: case TYPE_BUILTIN: case TYPE_ERROR: return false; @@ -1029,6 +1076,9 @@ static bool function_types_compatible(const function_type_t *func1, if (!types_compatible(ret1, ret2)) return false; + if (func1->linkage != func2->linkage) + return false; + if (func1->calling_convention != func2->calling_convention) return false; @@ -1117,6 +1167,12 @@ bool types_compatible(const type_t *type1, const type_t *type2) 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: case TYPE_ENUM: @@ -1418,14 +1474,56 @@ type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers) type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t)); memset(type, 0, sizeof(pointer_type_t)); - type->kind = TYPE_POINTER; - type->base.qualifiers = qualifiers; - type->base.alignment = 0; - type->pointer.points_to = points_to; + type->kind = TYPE_POINTER; + type->base.qualifiers = qualifiers; + type->base.alignment = 0; + type->pointer.points_to = points_to; + type->pointer.base_variable = NULL; + + return identify_new_type(type); +} + +/** + * Creates a new reference type. + * + * @param refers_to The referred-to type for the new type. + */ +type_t *make_reference_type(type_t *refers_to) +{ + type_t *type = obstack_alloc(type_obst, sizeof(reference_type_t)); + memset(type, 0, sizeof(reference_type_t)); + + type->kind = TYPE_REFERENCE; + type->base.qualifiers = 0; + type->base.alignment = 0; + type->reference.refers_to = refers_to; + + return identify_new_type(type); +} + +/** + * Creates a new based pointer type. + * + * @param points_to The points-to type for the new type. + * @param qualifiers Type qualifiers for the new type. + * @param variable The based variable + */ +type_t *make_based_pointer_type(type_t *points_to, + type_qualifiers_t qualifiers, variable_t *variable) +{ + type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t)); + memset(type, 0, sizeof(pointer_type_t)); + + type->kind = TYPE_POINTER; + type->base.qualifiers = qualifiers; + type->base.alignment = 0; + type->pointer.points_to = points_to; + type->pointer.base_variable = variable; return identify_new_type(type); } + type_t *make_array_type(type_t *element_type, size_t size, type_qualifiers_t qualifiers) {