X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=06468841d0afd086c65597d027084203129dec41;hb=475688c25870a4482c503eaf17084f0f14f363b3;hp=59876f6ccb46dbaa76f52c2564220c9c49df45cd;hpb=28f3ec76a317d3e977bb200e5fd18841c1bf5619;p=cparser diff --git a/type.c b/type.c index 59876f6..0646884 100644 --- a/type.c +++ b/type.c @@ -52,6 +52,12 @@ static atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = { .alignment = 0, .flags = ATOMIC_TYPE_FLAG_NONE }, + [ATOMIC_TYPE_WCHAR_T] = { + .size = (unsigned)-1, + .alignment = (unsigned)-1, + /* signed flag will be set when known */ + .flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC, + }, [ATOMIC_TYPE_CHAR] = { .size = 1, .alignment = 1, @@ -177,6 +183,8 @@ void init_types(void) /* TODO: make this configurable for platforms which do not use byte sized * bools. */ props[ATOMIC_TYPE_BOOL] = props[ATOMIC_TYPE_UCHAR]; + + props[ATOMIC_TYPE_WCHAR_T] = props[wchar_atomic_kind]; } void exit_types(void) @@ -216,6 +224,7 @@ const char *get_atomic_kind_name(atomic_type_kind_t kind) switch(kind) { case ATOMIC_TYPE_INVALID: break; case ATOMIC_TYPE_VOID: return "void"; + case ATOMIC_TYPE_WCHAR_T: return "wchar_t"; case ATOMIC_TYPE_BOOL: return c_mode & _CXX ? "bool" : "_Bool"; case ATOMIC_TYPE_CHAR: return "char"; case ATOMIC_TYPE_SCHAR: return "signed char"; @@ -356,15 +365,19 @@ static void print_function_type_post(const function_type_t *type, } } else { entity_t *parameter = parameters->entities; - for( ; parameter != NULL; parameter = parameter->base.next) { + for (; parameter != NULL; parameter = parameter->base.next) { if (first) { first = false; } else { fputs(", ", out); } assert(is_declaration(parameter)); - print_type_ext(parameter->declaration.type, parameter->base.symbol, - NULL); + const type_t *const type = parameter->declaration.type; + if (type == NULL) { + fputs(parameter->base.symbol->string, out); + } else { + print_type_ext(type, parameter->base.symbol, NULL); + } } } if (type->variadic) { @@ -397,12 +410,23 @@ static void print_pointer_type_pre(const pointer_type_t *type) fputs(variable->base.base.symbol->string, out); fputs(") ", 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. * @@ -413,6 +437,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. * @@ -473,9 +507,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; @@ -484,12 +518,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); } /** @@ -532,7 +566,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); + } } /** @@ -631,6 +668,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; @@ -662,6 +702,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; @@ -681,6 +724,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); + } } /** @@ -729,6 +776,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); @@ -1010,6 +1058,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; @@ -1131,6 +1180,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: @@ -1441,6 +1496,24 @@ type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers) 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. *