nsz Git - cparser/blob - type_t.h

   1 /*
   2  * This file is part of cparser.
   3  * Copyright (C) 2007-2008 Matthias Braun <matze@braunis.de>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18  * 02111-1307, USA.
  19  */
  20 #ifndef TYPE_T_H
  21 #define TYPE_T_H
  22
  23 #include <stdbool.h>
  24 #include <assert.h>
  25
  26 #include <libfirm/firm_types.h>
  27
  28 #include "type.h"
  29 #include "symbol.h"
  30 #include "token_t.h"
  31 #include "ast_t.h"
  32 #include "adt/obst.h"
  33
  34 extern struct obstack *type_obst;
  35
  36 typedef enum type_kind_t {
  37         TYPE_INVALID,
  38         TYPE_ERROR,
  39         TYPE_ATOMIC,
  40         TYPE_COMPLEX,
  41         TYPE_IMAGINARY,
  42         TYPE_COMPOUND_STRUCT,
  43         TYPE_COMPOUND_UNION,
  44         TYPE_ENUM,
  45         TYPE_FUNCTION,
  46         TYPE_POINTER,
  47         TYPE_ARRAY,
  48         TYPE_BITFIELD,
  49         TYPE_BUILTIN,
  50         TYPE_TYPEDEF,
  51         TYPE_TYPEOF,
  52 } type_kind_t;
  53
  54 typedef enum type_modifier_t {
  55         TYPE_MODIFIER_NONE              = 0,
  56         TYPE_MODIFIER_TRANSPARENT_UNION = 1 << 0,
  57 } type_modifier_t;
  58 typedef unsigned short type_modifiers_t;
  59
  60 struct type_base_t {
  61         type_kind_t       kind;
  62         il_size_t         size;           /**< The size of this type. */
  63         type_qualifiers_t qualifiers;
  64         type_modifiers_t  modifiers;
  65         il_alignment_t    alignment;      /**< The extra alignment of the type, 0 for default. */
  66
  67         ir_type          *firm_type;
  68 };
  69
  70 struct atomic_type_t {
  71         type_base_t         base;
  72         atomic_type_kind_t  akind;
  73 };
  74
  75 struct complex_type_t {
  76         type_base_t         base;
  77         atomic_type_kind_t  akind;
  78 };
  79
  80 struct imaginary_type_t {
  81         type_base_t         base;
  82         atomic_type_kind_t  akind;
  83 };
  84
  85 struct builtin_type_t {
  86         type_base_t  base;
  87         symbol_t    *symbol;
  88         type_t      *real_type;
  89 };
  90
  91 struct pointer_type_t {
  92         type_base_t  base;
  93         type_t      *points_to;
  94 };
  95
  96 struct array_type_t {
  97         type_base_t   base;
  98         type_t       *element_type;
  99         expression_t *size_expression;
 100         size_t        size;
 101
 102         ir_node      *size_node; /**< used by ast2firm phase */
 103
 104         unsigned      is_static         : 1; /**< a [static] type */
 105         unsigned      is_variable       : 1; /**< a [*] type */
 106         unsigned      has_implicit_size : 1;
 107         unsigned      size_constant     : 1; /**< size expression is constant */
 108         unsigned      is_vla            : 1; /**< it's a variable length array */
 109 };
 110
 111 /**
 112  * An entry in the parameter list of a function type.
 113  */
 114 struct function_parameter_t {
 115         type_t               *type;  /**< The parameter type. */
 116         function_parameter_t *next;  /**< Points to the next type inthe parameter list.*/
 117 };
 118
 119 /** Calling conventions. */
 120 typedef enum cc_kind_t {
 121         CC_DEFAULT,      /**< default calling convention. */
 122         CC_CDECL,        /**< cdecl calling convention. */
 123         CC_STDCALL,      /**< stdcall calling convention. */
 124         CC_FASTCALL,     /**< fastcall calling convention. */
 125         CC_THISCALL      /**< thiscall calling convention. */
 126 } cc_kind_t;
 127
 128 /**
 129  * A function type.
 130  */
 131 struct function_type_t {
 132         type_base_t           base;
 133         type_t               *return_type;        /**< The return type. */
 134         function_parameter_t *parameters;         /**< A list of the parameter types. */
 135         cc_kind_t             calling_convention; /**< The specified calling convention. */
 136         unsigned              variadic : 1;
 137         unsigned              unspecified_parameters : 1;
 138         unsigned              kr_style_parameters : 1;
 139 };
 140
 141 struct compound_type_t {
 142         type_base_t    base;
 143         unsigned       packed:1;       /** Set if packed was specified. */
 144         /** the declaration of the compound type, the scope of the declaration
 145          *  contains the compound entries. */
 146         declaration_t *declaration;
 147 };
 148
 149 struct enum_type_t {
 150         type_base_t    base;
 151         /** the declaration of the enum type. You can find the enum entries by
 152          *  walking the declaration->next list until you don't find
 153          *  STORAGE_CLASS_ENUM_ENTRY declarations anymore */
 154         declaration_t *declaration;
 155 };
 156
 157 struct typedef_type_t {
 158         type_base_t    base;
 159         declaration_t *declaration;
 160         type_t        *resolved_type;
 161 };
 162
 163 struct typeof_type_t {
 164         type_base_t   base;
 165         expression_t *expression;
 166         type_t       *typeof_type;
 167         type_t       *resolved_type;
 168 };
 169
 170 struct bitfield_type_t {
 171         type_base_t   base;
 172         type_t       *base_type;
 173         expression_t *size_expression; /**< The expression for the bit size. */
 174         il_size_t     bit_size;        /**< Size of this bitfield in bits. */
 175 };
 176
 177 union type_t {
 178         type_kind_t      kind;
 179         type_base_t      base;
 180         atomic_type_t    atomic;
 181         complex_type_t   complex;
 182         imaginary_type_t imaginary;
 183         builtin_type_t   builtin;
 184         pointer_type_t   pointer;
 185         array_type_t     array;
 186         function_type_t  function;
 187         compound_type_t  compound;
 188         enum_type_t      enumt;
 189         typedef_type_t   typedeft;
 190         bitfield_type_t  bitfield;
 191         typeof_type_t    typeoft;
 192 };
 193
 194 type_t *make_atomic_type(atomic_type_kind_t type, type_qualifiers_t qualifiers);
 195 type_t *make_complex_type(atomic_type_kind_t type, type_qualifiers_t qualifiers);
 196 type_t *make_imaginary_type(atomic_type_kind_t type, type_qualifiers_t qualifiers);
 197 type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers);
 198 type_t *make_array_type(type_t *element_type, size_t size,
 199                         type_qualifiers_t qualifiers);
 200
 201 type_t *duplicate_type(const type_t *type);
 202
 203 static inline bool is_typeref(const type_t *type)
 204 {
 205         return type->kind == TYPE_TYPEDEF || type->kind == TYPE_TYPEOF;
 206 }
 207
 208 static inline bool is_type_atomic(const type_t *type, atomic_type_kind_t atype)
 209 {
 210         assert(!is_typeref(type));
 211
 212         if(type->kind != TYPE_ATOMIC)
 213                 return false;
 214         const atomic_type_t *atomic_type = &type->atomic;
 215
 216         return atomic_type->akind == atype;
 217 }
 218
 219 static inline bool is_type_pointer(const type_t *type)
 220 {
 221         assert(!is_typeref(type));
 222         return type->kind == TYPE_POINTER;
 223 }
 224
 225 static inline bool is_type_array(const type_t *type)
 226 {
 227         assert(!is_typeref(type));
 228         return type->kind == TYPE_ARRAY;
 229 }
 230
 231 static inline bool is_type_function(const type_t *type)
 232 {
 233         assert(!is_typeref(type));
 234         return type->kind == TYPE_FUNCTION;
 235 }
 236
 237 static inline bool is_type_union(const type_t *type)
 238 {
 239         assert(!is_typeref(type));
 240         return type->kind == TYPE_COMPOUND_UNION;
 241 }
 242
 243 static inline bool is_type_struct(const type_t *type)
 244 {
 245         assert(!is_typeref(type));
 246         return type->kind == TYPE_COMPOUND_STRUCT;
 247 }
 248
 249 static inline bool is_type_builtin(const type_t *type)
 250 {
 251         assert(!is_typeref(type));
 252         return type->kind == TYPE_BUILTIN;
 253 }
 254
 255 static inline bool is_type_compound(const type_t *type)
 256 {
 257         assert(!is_typeref(type));
 258         return type->kind == TYPE_COMPOUND_STRUCT
 259                 || type->kind == TYPE_COMPOUND_UNION;
 260 }
 261
 262 static inline bool is_type_valid(const type_t *type)
 263 {
 264         assert(!is_typeref(type));
 265         return type->kind != TYPE_ERROR;
 266 }
 267
 268 #endif