X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type_t.h;h=9015589862e7ed286282a2bf33322028384fa304;hb=9fc5a3152558711a37406f79913f77cab1dc9db7;hp=3536fad038928f13267b66dfbdec4d550060b90b;hpb=70abad8ade78c811d76cc79741fccfc6bd7d58ab;p=cparser diff --git a/type_t.h b/type_t.h index 3536fad..9015589 100644 --- a/type_t.h +++ b/type_t.h @@ -33,15 +33,18 @@ extern struct obstack *type_obst; -typedef enum { +typedef enum type_kind_t { TYPE_INVALID, TYPE_ERROR, TYPE_ATOMIC, + TYPE_COMPLEX, + TYPE_IMAGINARY, TYPE_COMPOUND_STRUCT, TYPE_COMPOUND_UNION, TYPE_ENUM, TYPE_FUNCTION, TYPE_POINTER, + TYPE_REFERENCE, TYPE_ARRAY, TYPE_BITFIELD, TYPE_BUILTIN, @@ -49,26 +52,18 @@ typedef enum { TYPE_TYPEOF, } type_kind_t; -typedef enum { - TYPE_QUALIFIER_NONE = 0, - TYPE_QUALIFIER_CONST = 1 << 0, - TYPE_QUALIFIER_RESTRICT = 1 << 1, - TYPE_QUALIFIER_VOLATILE = 1 << 2, - /* microsoft extended qualifiers */ - TYPE_QUALIFIER_W64 = 1 << 3, - TYPE_QUALIFIER_PTR32 = 1 << 4, - TYPE_QUALIFIER_PTR64 = 1 << 5, - TYPE_QUALIFIER_SPTR = 1 << 6, - TYPE_QUALIFIER_UPTR = 1 << 7, -} type_qualifier_t; - -typedef unsigned int type_qualifiers_t; +typedef enum type_modifier_t { + TYPE_MODIFIER_NONE = 0, + TYPE_MODIFIER_TRANSPARENT_UNION = 1 << 0, +} type_modifier_t; +typedef unsigned short type_modifiers_t; struct type_base_t { type_kind_t kind; + il_size_t size; /**< The size of this type. */ type_qualifiers_t qualifiers; - unsigned char alignment; /**< The extra alignment of the type, 0 for default. */ - source_position_t source_position; + type_modifiers_t modifiers; + il_alignment_t alignment; /**< The extra alignment of the type, 0 for default. */ ir_type *firm_type; }; @@ -78,6 +73,16 @@ struct atomic_type_t { atomic_type_kind_t akind; }; +struct complex_type_t { + type_base_t base; + atomic_type_kind_t akind; +}; + +struct imaginary_type_t { + type_base_t base; + atomic_type_kind_t akind; +}; + struct builtin_type_t { type_base_t base; symbol_t *symbol; @@ -87,6 +92,12 @@ struct builtin_type_t { struct pointer_type_t { type_base_t base; type_t *points_to; + variable_t *base_variable; /**< Microsoft __based() extension */ +}; + +struct reference_type_t { + type_base_t base; + type_t *refers_to; }; struct array_type_t { @@ -97,46 +108,72 @@ struct array_type_t { ir_node *size_node; /**< used by ast2firm phase */ - unsigned is_static : 1; /**< a [static] type */ - unsigned is_variable : 1; /**< a [*] type */ - unsigned has_implicit_size : 1; - unsigned size_constant : 1; /**< size expression is constant */ - unsigned is_vla : 1; /**< it's a variable length array */ + bool is_static : 1; /**< a [static] type */ + bool is_variable : 1; /**< a [*] type */ + bool has_implicit_size : 1; + bool size_constant : 1; /**< size expression is constant */ + bool is_vla : 1; /**< it's a variable length array */ }; +/** + * An entry in the parameter list of a function type. + */ struct function_parameter_t { - type_t *type; - function_parameter_t *next; + type_t *type; /**< The parameter type. */ + function_parameter_t *next; /**< Points to the next type in the parameter list.*/ }; +/** Linkage specifications. */ +typedef enum linkage_kind_t { + LINKAGE_INVALID, + LINKAGE_C, /**< C linkage. */ + LINKAGE_CXX /**< C++ linkage. */ +} linkage_kind_t; + +/** Calling conventions. */ +typedef enum cc_kind_t { + CC_DEFAULT, /**< default calling convention. */ + CC_CDECL, /**< cdecl calling convention. */ + CC_STDCALL, /**< stdcall calling convention. */ + CC_FASTCALL, /**< fastcall calling convention. */ + CC_THISCALL /**< thiscall calling convention. */ +} cc_kind_t; + +/** + * A function type. + */ struct function_type_t { type_base_t base; - type_t *return_type; - function_parameter_t *parameters; - unsigned variadic : 1; - unsigned unspecified_parameters : 1; - unsigned kr_style_parameters : 1; + type_t *return_type; /**< The return type. */ + function_parameter_t *parameters; /**< A list of the parameter types. */ + linkage_kind_t linkage; + cc_kind_t calling_convention; /**< The specified calling convention. */ + bool variadic : 1; + bool unspecified_parameters : 1; + bool kr_style_parameters : 1; }; struct compound_type_t { - type_base_t base; + type_base_t base; + bool packed : 1; /**< Set if packed was specified. */ /** the declaration of the compound type, the scope of the declaration * contains the compound entries. */ - declaration_t *declaration; + compound_t *compound; }; struct enum_type_t { - type_base_t base; - /** the declaration of the enum type. You can find the enum entries by - * walking the declaration->next list until you don't find - * STORAGE_CLASS_ENUM_ENTRY declarations anymore */ - declaration_t *declaration; + type_base_t base; + atomic_type_kind_t akind; /**< underlying atomic type */ + /** the enum entity. You can find the enum entries by walking the + * enum->base.next list until you don't find ENTITY_ENUM_VALUE entities + * anymore */ + enum_t *enume; }; struct typedef_type_t { - type_base_t base; - declaration_t *declaration; - type_t *resolved_type; + type_base_t base; + typedef_t *typedefe; + type_t *resolved_type; }; struct typeof_type_t { @@ -149,15 +186,19 @@ struct typeof_type_t { struct bitfield_type_t { type_base_t base; type_t *base_type; - expression_t *size; + expression_t *size_expression; /**< The expression for the bit size. */ + il_size_t bit_size; /**< Size of this bitfield in bits. */ }; union type_t { type_kind_t kind; type_base_t base; atomic_type_t atomic; + complex_type_t complex; + imaginary_type_t imaginary; builtin_type_t builtin; pointer_type_t pointer; + reference_type_t reference; array_type_t array; function_type_t function; compound_type_t compound; @@ -168,11 +209,17 @@ union type_t { }; type_t *make_atomic_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); +type_t *make_complex_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); +type_t *make_imaginary_type(atomic_type_kind_t type, type_qualifiers_t qualifiers); type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers); +type_t *make_reference_type(type_t *refers_to); +type_t *make_based_pointer_type(type_t *points_to, + type_qualifiers_t qualifiers, variable_t *variable); type_t *make_array_type(type_t *element_type, size_t size, type_qualifiers_t qualifiers); type_t *duplicate_type(const type_t *type); +type_t *identify_new_type(type_t *type); static inline bool is_typeref(const type_t *type) { @@ -196,6 +243,12 @@ static inline bool is_type_pointer(const type_t *type) return type->kind == TYPE_POINTER; } +static inline bool is_type_reference(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_REFERENCE; +} + static inline bool is_type_array(const type_t *type) { assert(!is_typeref(type)); @@ -235,6 +288,7 @@ static inline bool is_type_compound(const type_t *type) static inline bool is_type_valid(const type_t *type) { + assert(!is_typeref(type)); return type->kind != TYPE_ERROR; }