X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type_t.h;h=f745e4f697455c0f31c3051a76cc5b937c132f7f;hb=9398959e7dda6fb86547df8a6d5ce6383cfc969f;hp=020f87d96e81de54658c701625f2d98d05c3190a;hpb=3f09e64eade51d0c8a4e21d2da68d0d48f2f7f53;p=cparser diff --git a/type_t.h b/type_t.h index 020f87d..f745e4f 100644 --- a/type_t.h +++ b/type_t.h @@ -1,26 +1,39 @@ #ifndef TYPE_T_H #define TYPE_T_H +#include +#include + +#include + #include "type.h" #include "symbol.h" #include "token_t.h" +#include "ast_t.h" #include "adt/obst.h" -struct obstack *type_obst; +extern struct obstack *type_obst; typedef enum { TYPE_INVALID, + TYPE_ERROR, TYPE_ATOMIC, TYPE_COMPOUND_STRUCT, TYPE_COMPOUND_UNION, TYPE_ENUM, - TYPE_METHOD, + TYPE_FUNCTION, TYPE_POINTER, - TYPE_BUILTIN -} type_type_t; + TYPE_ARRAY, + TYPE_BITFIELD, + TYPE_BUILTIN, + TYPE_TYPEDEF, + TYPE_TYPEOF, +} type_kind_t; +/* note that the constant values represent the rank of the types as defined + * in § 6.3.1 */ typedef enum { - ATOMIC_TYPE_INVALID, + ATOMIC_TYPE_INVALID = 0, ATOMIC_TYPE_VOID, ATOMIC_TYPE_CHAR, ATOMIC_TYPE_SCHAR, @@ -41,71 +54,167 @@ typedef enum { ATOMIC_TYPE_FLOAT_COMPLEX, ATOMIC_TYPE_DOUBLE_COMPLEX, ATOMIC_TYPE_LONG_DOUBLE_COMPLEX, -#endif -#ifdef PROVIDE_IMAGINARY ATOMIC_TYPE_FLOAT_IMAGINARY, ATOMIC_TYPE_DOUBLE_IMAGINARY, ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY, #endif -} atomic_type_type_t; + ATOMIC_TYPE_LAST +} atomic_type_kind_t; typedef enum { + TYPE_QUALIFIER_NONE = 0, TYPE_QUALIFIER_CONST = 1 << 0, TYPE_QUALIFIER_RESTRICT = 1 << 1, TYPE_QUALIFIER_VOLATILE = 1 << 2, - TYPE_QUALIFIER_INLINE = 1 << 3, } type_qualifier_t; -struct type_t { - type_type_t type; - unsigned qualifiers; +typedef unsigned int type_qualifiers_t; + +struct type_base_t { + type_kind_t kind; + type_qualifiers_t qualifiers; + source_position_t source_position; + + ir_type *firm_type; }; struct atomic_type_t { - type_t type; - atomic_type_type_t atype; + type_base_t type; + atomic_type_kind_t akind; }; struct builtin_type_t { - type_t type; - symbol_t *symbol; -}; - -struct enum_type_t { - type_t type; - symbol_t *symbol; - /* TODO: list of enum members */ - source_position_t source_position; + type_base_t type; + symbol_t *symbol; + type_t *real_type; }; struct pointer_type_t { - type_t type; - type_t *points_to; + type_base_t type; + type_t *points_to; }; -struct method_parameter_type_t { - type_t *type; - method_parameter_type_t *next; +struct array_type_t { + type_base_t type; + type_t *element_type; + expression_t *size; + unsigned is_static : 1; + unsigned is_variable : 1; + unsigned has_implicit_size : 1; }; -struct method_type_t { - type_t type; - type_t *result_type; - method_parameter_type_t *parameter_types; - const char *abi_style; +struct function_parameter_t { + type_t *type; + function_parameter_t *next; }; -struct compound_entry_t { - declaration_t *declaration; - compound_entry_t *next; - source_position_t source_position; +struct function_type_t { + type_base_t type; + type_t *return_type; + function_parameter_t *parameters; + unsigned variadic : 1; + unsigned unspecified_parameters : 1; + unsigned kr_style_parameters : 1; }; struct compound_type_t { - type_t type; - compound_entry_t *entries; - symbol_t *symbol; - source_position_t source_position; + type_base_t type; + /** the declaration of the compound type, the scope of the declaration + * contains the compound entries. */ + declaration_t *declaration; +}; + +struct enum_type_t { + type_base_t type; + /** 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; +}; + +struct typedef_type_t { + type_base_t type; + declaration_t *declaration; + type_t *resolved_type; +}; + +struct typeof_type_t { + type_base_t type; + expression_t *expression; + type_t *typeof_type; + type_t *resolved_type; }; +struct bitfield_type_t { + type_base_t type; + type_t *base; + expression_t *size; +}; + +union type_t { + type_kind_t kind; + type_base_t base; + atomic_type_t atomic; + builtin_type_t builtin; + pointer_type_t pointer; + array_type_t array; + function_type_t function; + compound_type_t compound; + enum_type_t enumt; + typedef_type_t typedeft; + bitfield_type_t bitfield; + typeof_type_t typeoft; +}; + +type_t *make_atomic_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 *duplicate_type(const type_t *type); + +static inline bool is_typeref(const type_t *type) +{ + return type->kind == TYPE_TYPEDEF || type->kind == TYPE_TYPEOF; +} + +static inline bool is_type_atomic(const type_t *type, atomic_type_kind_t atype) +{ + assert(!is_typeref(type)); + + if(type->kind != TYPE_ATOMIC) + return false; + const atomic_type_t *atomic_type = &type->atomic; + + return atomic_type->akind == atype; +} + +static inline bool is_type_pointer(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_POINTER; +} + +static inline bool is_type_array(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_ARRAY; +} + +static inline bool is_type_function(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_FUNCTION; +} + +static inline bool is_type_compound(const type_t *type) +{ + assert(!is_typeref(type)); + return type->kind == TYPE_COMPOUND_STRUCT + || type->kind == TYPE_COMPOUND_UNION; +} + +static inline bool is_type_valid(const type_t *type) +{ + return type->kind != TYPE_ERROR; +} + #endif