nsz Git - cparser/blob - type_t.h

   1 #ifndef TYPE_T_H
   2 #define TYPE_T_H
   3
   4 #include <stdbool.h>
   5 #include <assert.h>
   6
   7 #include <libfirm/firm_types.h>
   8
   9 #include "type.h"
  10 #include "symbol.h"
  11 #include "token_t.h"
  12 #include "ast_t.h"
  13 #include "adt/obst.h"
  14
  15 extern struct obstack *type_obst;
  16
  17 typedef enum {
  18         TYPE_INVALID,
  19         TYPE_ERROR,
  20         TYPE_ATOMIC,
  21         TYPE_COMPOUND_STRUCT,
  22         TYPE_COMPOUND_UNION,
  23         TYPE_ENUM,
  24         TYPE_FUNCTION,
  25         TYPE_POINTER,
  26         TYPE_ARRAY,
  27         TYPE_BITFIELD,
  28         TYPE_BUILTIN,
  29         TYPE_TYPEDEF,
  30         TYPE_TYPEOF,
  31 } type_kind_t;
  32
  33 /* note that the constant values represent the rank of the types as defined
  34  * in § 6.3.1 */
  35 typedef enum {
  36         ATOMIC_TYPE_INVALID = 0,
  37         ATOMIC_TYPE_VOID,
  38         ATOMIC_TYPE_CHAR,
  39         ATOMIC_TYPE_SCHAR,
  40         ATOMIC_TYPE_UCHAR,
  41         ATOMIC_TYPE_SHORT,
  42         ATOMIC_TYPE_USHORT,
  43         ATOMIC_TYPE_INT,
  44         ATOMIC_TYPE_UINT,
  45         ATOMIC_TYPE_LONG,
  46         ATOMIC_TYPE_ULONG,
  47         ATOMIC_TYPE_LONGLONG,
  48         ATOMIC_TYPE_ULONGLONG,
  49         ATOMIC_TYPE_FLOAT,
  50         ATOMIC_TYPE_DOUBLE,
  51         ATOMIC_TYPE_LONG_DOUBLE,
  52         ATOMIC_TYPE_BOOL,
  53 #ifdef PROVIDE_COMPLEX
  54         ATOMIC_TYPE_FLOAT_COMPLEX,
  55         ATOMIC_TYPE_DOUBLE_COMPLEX,
  56         ATOMIC_TYPE_LONG_DOUBLE_COMPLEX,
  57         ATOMIC_TYPE_FLOAT_IMAGINARY,
  58         ATOMIC_TYPE_DOUBLE_IMAGINARY,
  59         ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY,
  60 #endif
  61         ATOMIC_TYPE_LAST
  62 } atomic_type_kind_t;
  63
  64 typedef enum {
  65         TYPE_QUALIFIER_NONE     = 0,
  66         TYPE_QUALIFIER_CONST    = 1 << 0,
  67         TYPE_QUALIFIER_RESTRICT = 1 << 1,
  68         TYPE_QUALIFIER_VOLATILE = 1 << 2,
  69 } type_qualifier_t;
  70
  71 typedef unsigned int type_qualifiers_t;
  72
  73 struct type_base_t {
  74         type_kind_t       kind;
  75         type_qualifiers_t qualifiers;
  76         source_position_t source_position;
  77
  78         ir_type          *firm_type;
  79 };
  80
  81 struct atomic_type_t {
  82         type_base_t         type;
  83         atomic_type_kind_t  akind;
  84 };
  85
  86 struct builtin_type_t {
  87         type_base_t  type;
  88         symbol_t    *symbol;
  89         type_t      *real_type;
  90 };
  91
  92 struct pointer_type_t {
  93         type_base_t  type;
  94         type_t      *points_to;
  95 };
  96
  97 struct array_type_t {
  98         type_base_t   type;
  99         type_t       *element_type;
 100         expression_t *size_expression;
 101         size_t        size;
 102
 103         ir_node      *size_node; /**< used by ast2firm phase */
 104
 105         unsigned      is_static         : 1; /**< a [static] type */
 106         unsigned      is_variable       : 1; /**< a [*] type */
 107         unsigned      has_implicit_size : 1;
 108         unsigned      size_constant     : 1; /**< size expression is constant */
 109         unsigned      is_vla            : 1; /**< it's a variable length array */
 110 };
 111
 112 struct function_parameter_t {
 113         type_t               *type;
 114         function_parameter_t *next;
 115 };
 116
 117 struct function_type_t {
 118         type_base_t           type;
 119         type_t               *return_type;
 120         function_parameter_t *parameters;
 121         unsigned              variadic : 1;
 122         unsigned              unspecified_parameters : 1;
 123         unsigned              kr_style_parameters : 1;
 124 };
 125
 126 struct compound_type_t {
 127         type_base_t    type;
 128         /** the declaration of the compound type, the scope of the declaration
 129          *  contains the compound entries. */
 130         declaration_t *declaration;
 131 };
 132
 133 struct enum_type_t {
 134         type_base_t    type;
 135         /** the declaration of the enum type. You can find the enum entries by
 136          *  walking the declaration->next list until you don't find
 137          *  STORAGE_CLASS_ENUM_ENTRY declarations anymore */
 138         declaration_t *declaration;
 139 };
 140
 141 struct typedef_type_t {
 142         type_base_t    type;
 143         declaration_t *declaration;
 144         type_t        *resolved_type;
 145 };
 146
 147 struct typeof_type_t {
 148         type_base_t   type;
 149         expression_t *expression;
 150         type_t       *typeof_type;
 151         type_t       *resolved_type;
 152 };
 153
 154 struct bitfield_type_t {
 155         type_base_t   type;
 156         type_t       *base;
 157         expression_t *size;
 158 };
 159
 160 union type_t {
 161         type_kind_t      kind;
 162         type_base_t      base;
 163         atomic_type_t    atomic;
 164         builtin_type_t   builtin;
 165         pointer_type_t   pointer;
 166         array_type_t     array;
 167         function_type_t  function;
 168         compound_type_t  compound;
 169         enum_type_t      enumt;
 170         typedef_type_t   typedeft;
 171         bitfield_type_t  bitfield;
 172         typeof_type_t    typeoft;
 173 };
 174
 175 type_t *make_atomic_type(atomic_type_kind_t type, type_qualifiers_t qualifiers);
 176 type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers);
 177 type_t *make_array_type(type_t *element_type, size_t size,
 178                         type_qualifiers_t qualifiers);
 179
 180 type_t *duplicate_type(const type_t *type);
 181
 182 static inline bool is_typeref(const type_t *type)
 183 {
 184         return type->kind == TYPE_TYPEDEF || type->kind == TYPE_TYPEOF;
 185 }
 186
 187 static inline bool is_type_atomic(const type_t *type, atomic_type_kind_t atype)
 188 {
 189         assert(!is_typeref(type));
 190
 191         if(type->kind != TYPE_ATOMIC)
 192                 return false;
 193         const atomic_type_t *atomic_type = &type->atomic;
 194
 195         return atomic_type->akind == atype;
 196 }
 197
 198 static inline bool is_type_pointer(const type_t *type)
 199 {
 200         assert(!is_typeref(type));
 201         return type->kind == TYPE_POINTER;
 202 }
 203
 204 static inline bool is_type_array(const type_t *type)
 205 {
 206         assert(!is_typeref(type));
 207         return type->kind == TYPE_ARRAY;
 208 }
 209
 210 static inline bool is_type_function(const type_t *type)
 211 {
 212         assert(!is_typeref(type));
 213         return type->kind == TYPE_FUNCTION;
 214 }
 215
 216 static inline bool is_type_union(const type_t *type)
 217 {
 218         assert(!is_typeref(type));
 219         return type->kind == TYPE_COMPOUND_UNION;
 220 }
 221
 222 static inline bool is_type_struct(const type_t *type)
 223 {
 224         assert(!is_typeref(type));
 225         return type->kind == TYPE_COMPOUND_STRUCT;
 226 }
 227
 228 static inline bool is_type_builtin(const type_t *type)
 229 {
 230         assert(!is_typeref(type));
 231         return type->kind == TYPE_BUILTIN;
 232 }
 233
 234 static inline bool is_type_compound(const type_t *type)
 235 {
 236         assert(!is_typeref(type));
 237         return type->kind == TYPE_COMPOUND_STRUCT
 238                 || type->kind == TYPE_COMPOUND_UNION;
 239 }
 240
 241 static inline bool is_type_valid(const type_t *type)
 242 {
 243         return type->kind != TYPE_ERROR;
 244 }
 245
 246 #endif