X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type_t.h;h=7b4fec9084641bc8cd890147b16012654a36513c;hb=2aa9a7c30d2961cbc240b4951849c308013a48d2;hp=4a0428c5fe2f8b651526e6c33f1ea1efb0090ef4;hpb=4aeae1b9325a9ea33361198efd19bae4b834b091;p=cparser diff --git a/type_t.h b/type_t.h index 4a0428c..7b4fec9 100644 --- a/type_t.h +++ b/type_t.h @@ -2,6 +2,7 @@ #define TYPE_T_H #include +#include #include @@ -11,10 +12,11 @@ #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, @@ -22,10 +24,11 @@ typedef enum { TYPE_FUNCTION, TYPE_POINTER, TYPE_ARRAY, + TYPE_BITFIELD, TYPE_BUILTIN, TYPE_TYPEDEF, - TYPE_TYPEOF -} type_type_t; + TYPE_TYPEOF, +} type_kind_t; /* note that the constant values represent the rank of the types as defined * in § 6.3.1 */ @@ -55,7 +58,8 @@ typedef enum { 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, @@ -66,73 +70,144 @@ typedef enum { typedef unsigned int type_qualifiers_t; +struct type_base_t { + type_kind_t kind; + type_qualifiers_t qualifiers; + + ir_type *firm_type; +}; + +struct atomic_type_t { + type_base_t type; + atomic_type_kind_t akind; +}; + +struct builtin_type_t { + type_base_t type; + symbol_t *symbol; + type_t *real_type; +}; + +struct pointer_type_t { + type_base_t type; + type_t *points_to; +}; + +struct array_type_t { + type_base_t type; + type_t *element_type; + expression_t *size; + bool is_static; + bool is_variable; +}; + struct function_parameter_t { type_t *type; function_parameter_t *next; }; -struct type_t { - type_type_t type; - type_qualifiers_t qualifiers; +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; +}; - union { - /* if type == TYPE_ATOMIC */ - struct { - atomic_type_type_t atype; - } atomic_type; - /* if type == TYPE_COMPOUND_STRUCT or type == TYPE_COMPOUND_UNION */ - struct { - /** the declaration of the compound type, its context field - * contains the compound entries. */ - declaration_t *declaration; - } compound_type; - /* if type == TYPE_ENUM */ - struct { - /** 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; - } enum_type; - /* if type == TYPE_FUNCTION */ - struct { - type_t *result_type; - function_parameter_t *parameters; - bool variadic; - bool unspecified_parameters; - } function_type; - /* if type == TYPE_POINTER */ - struct { - type_t *points_to; - } pointer_type; - /* if type == TYPE_ARRAY */ - struct { - type_t *element_type; - bool is_static; - bool is_variable; - expression_t *size; - } array_type; - /* if type == TYPE_BUILTIN */ - struct { - symbol_t *symbol; - type_t *real_type; - } builtin_type; - /* if type == TYPE_TYPEDEF */ - struct { - declaration_t *declaration; - type_t *resolved_type; - } typedef_type; - /* if type == TYPE_TYPEOF */ - struct { - expression_t *expression; - type_t *typeof_type; - type_t *resolved_type; - } typeof_type; - } v; +struct compound_type_t { + type_base_t type; + /** the declaration of the compound type, its context field + * contains the compound entries. */ + declaration_t *declaration; +}; - ir_type *firm_type; +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; }; -type_t *make_atomic_type(atomic_type_type_t type, type_qualifiers_t qualifiers); +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(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; +} + #endif