nsz Git - cparser/blob - entity_t.h

   1 /*
   2  * This file is part of cparser.
   3  * Copyright (C) 2007-2009 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 ENTITY_T_H
  21 #define ENTITY_T_H
  22
  23 #include "lexer.h"
  24 #include "symbol.h"
  25 #include "entity.h"
  26 #include "attribute.h"
  27 #include <libfirm/firm_types.h>
  28 #include "builtins.h"
  29
  30 typedef enum {
  31         ENTITY_INVALID,
  32         ENTITY_VARIABLE,
  33         ENTITY_COMPOUND_MEMBER,
  34         ENTITY_PARAMETER,
  35         ENTITY_FUNCTION,
  36         ENTITY_TYPEDEF,
  37         ENTITY_CLASS,
  38         ENTITY_STRUCT,
  39         ENTITY_UNION,
  40         ENTITY_ENUM,
  41         ENTITY_ENUM_VALUE,
  42         ENTITY_LABEL,
  43         ENTITY_LOCAL_LABEL,
  44         ENTITY_NAMESPACE
  45 } entity_kind_tag_t;
  46 typedef unsigned char entity_kind_t;
  47
  48 typedef enum namespace_tag_t {
  49         NAMESPACE_INVALID,
  50         NAMESPACE_NORMAL,
  51         NAMESPACE_TAG,
  52         NAMESPACE_LABEL
  53 } namespace_tag_t;
  54 typedef unsigned char entity_namespace_t;
  55
  56 typedef enum storage_class_tag_t {
  57         STORAGE_CLASS_NONE,
  58         STORAGE_CLASS_EXTERN,
  59         STORAGE_CLASS_STATIC,
  60         STORAGE_CLASS_TYPEDEF,
  61         STORAGE_CLASS_AUTO,
  62         STORAGE_CLASS_REGISTER,
  63 } storage_class_tag_t;
  64 typedef unsigned char storage_class_t;
  65
  66 typedef enum decl_modifier_t {
  67         DM_NONE              = 0,
  68         DM_DLLIMPORT         = 1 <<  0,
  69         DM_DLLEXPORT         = 1 <<  1,
  70         DM_THREAD            = 1 <<  2,
  71         DM_NAKED             = 1 <<  3,
  72         DM_MICROSOFT_INLINE  = 1 <<  4,
  73         DM_FORCEINLINE       = 1 <<  5,
  74         DM_SELECTANY         = 1 <<  6,
  75         DM_NOTHROW           = 1 <<  7,
  76         DM_NOVTABLE          = 1 <<  8,
  77         DM_NORETURN          = 1 <<  9,
  78         DM_NOINLINE          = 1 << 10,
  79         DM_RESTRICT          = 1 << 11,
  80         DM_NOALIAS           = 1 << 12,
  81         DM_TRANSPARENT_UNION = 1 << 13,
  82         DM_CONST             = 1 << 14,
  83         DM_PURE              = 1 << 15,
  84         DM_CONSTRUCTOR       = 1 << 16,
  85         DM_DESTRUCTOR        = 1 << 17,
  86         DM_UNUSED            = 1 << 18,
  87         DM_USED              = 1 << 19,
  88         DM_CDECL             = 1 << 20,
  89         DM_FASTCALL          = 1 << 21,
  90         DM_STDCALL           = 1 << 22,
  91         DM_THISCALL          = 1 << 23,
  92         DM_DEPRECATED        = 1 << 24,
  93         DM_RETURNS_TWICE     = 1 << 25,
  94         DM_MALLOC            = 1 << 26,
  95         DM_WEAK              = 1 << 27,
  96 } decl_modifier_t;
  97
  98 /**
  99  * A scope containing entities.
 100  */
 101 struct scope_t {
 102         entity_t *entities;
 103         entity_t *last_entity; /**< pointer to last entity (so appending is fast) */
 104         unsigned  depth;       /**< while parsing, the depth of this scope in the
 105                                     scope stack. */
 106 };
 107
 108 /**
 109  * a named entity is something which can be referenced by its name
 110  * (a symbol)
 111  */
 112 struct entity_base_t {
 113         entity_kind_t       kind;
 114         entity_namespace_t  namespc;
 115         symbol_t           *symbol;
 116         source_position_t   source_position;
 117         scope_t            *parent_scope;    /**< The scope where this entity
 118                                                                                       is contained in */
 119         entity_t           *parent_entity;
 120
 121         /** next declaration in a scope */
 122         entity_t           *next;
 123         /** next declaration with same symbol */
 124         entity_t           *symbol_next;
 125 };
 126
 127 struct compound_t {
 128         entity_base_t     base;
 129         entity_t         *alias; /* used for name mangling of anonymous types */
 130         scope_t           members;
 131         decl_modifiers_t  modifiers;
 132         bool              layouted          : 1;
 133         bool              complete          : 1;
 134         bool              transparent_union : 1;
 135         bool              packed            : 1;
 136
 137         il_alignment_t    alignment;
 138         il_size_t         size;
 139
 140         /* ast2firm info */
 141         ir_type          *irtype;
 142         bool              irtype_complete : 1;
 143 };
 144
 145 struct enum_t {
 146         entity_base_t  base;
 147         entity_t      *alias; /* used for name mangling of anonymous types */
 148         bool           complete : 1;
 149
 150         /* ast2firm info */
 151         ir_type       *irtype;
 152 };
 153
 154 struct enum_value_t {
 155         entity_base_t  base;
 156         expression_t  *value;
 157         type_t        *enum_type;
 158
 159         /* ast2firm info */
 160         tarval        *tv;
 161 };
 162
 163 struct label_t {
 164         entity_base_t  base;
 165         bool           used : 1;
 166         bool           address_taken : 1;
 167         statement_t   *statement;
 168
 169         /* ast2firm info */
 170         ir_node       *block;
 171 };
 172
 173 struct namespace_t {
 174         entity_base_t  base;
 175         scope_t        members;
 176 };
 177
 178 struct typedef_t {
 179         entity_base_t     base;
 180         decl_modifiers_t  modifiers;
 181         type_t           *type;
 182         il_alignment_t    alignment;
 183         bool              builtin : 1;
 184 };
 185
 186 struct declaration_t {
 187         entity_base_t     base;
 188         type_t           *type;
 189         storage_class_t   declared_storage_class;
 190         storage_class_t   storage_class;
 191         decl_modifiers_t  modifiers;
 192         il_alignment_t    alignment;
 193         attribute_t      *attributes;
 194         bool              used     : 1;  /**< Set if the declaration is used. */
 195         bool              implicit : 1;  /**< Set for implicit (not found in source code) declarations. */
 196
 197         /* ast2firm info */
 198         unsigned char     kind;
 199 };
 200
 201 struct compound_member_t {
 202         declaration_t  base;
 203         bool           read          : 1;
 204         bool           address_taken : 1;  /**< Set if the address of this declaration was taken. */
 205         unsigned short offset;     /**< the offset of this member in the compound */
 206         unsigned char  bit_offset; /**< extra bit offset for bitfield members */
 207
 208         /* ast2firm info */
 209         ir_entity *entity;
 210 };
 211
 212 struct variable_t {
 213         declaration_t     base;
 214         bool              thread_local  : 1;  /**< GCC __thread */
 215         bool              restricta     : 1;
 216         bool              deprecated    : 1;
 217         bool              noalias       : 1;
 218
 219         bool              address_taken : 1;  /**< Set if the address of this declaration was taken. */
 220         bool              read          : 1;
 221
 222         initializer_t    *initializer;
 223
 224         /* ast2firm info */
 225         union {
 226                 unsigned int  value_number;
 227                 ir_entity    *entity;
 228                 ir_node      *vla_base;
 229         } v;
 230 };
 231
 232 struct parameter_t {
 233         declaration_t  base;
 234         bool           address_taken : 1;
 235         bool           read          : 1;
 236
 237         /* ast2firm info */
 238         union {
 239                 unsigned int  value_number;
 240                 ir_entity    *entity;
 241         } v;
 242 };
 243
 244 struct function_t {
 245         declaration_t  base;
 246         bool           is_inline     : 1;
 247
 248         bool           need_closure  : 1;  /**< Inner function needs closure. */
 249         bool           goto_to_outer : 1;  /**< Inner function has goto to outer function. */
 250
 251         builtin_kind_t btk;
 252         scope_t        parameters;
 253         statement_t   *statement;
 254
 255         /* ast2firm info */
 256         ir_entity     *irentity;
 257         ir_node       *static_link;        /**< if need_closure is set, the node
 258                                                 representing the static link. */
 259 };
 260
 261 union entity_t {
 262         entity_kind_t      kind;
 263         entity_base_t      base;
 264         compound_t         structe;
 265         compound_t         unione;
 266         compound_t         compound;
 267         enum_t             enume;
 268         enum_value_t       enum_value;
 269         label_t            label;
 270         namespace_t        namespacee;
 271         typedef_t          typedefe;
 272         declaration_t      declaration;
 273         variable_t         variable;
 274         parameter_t        parameter;
 275         function_t         function;
 276         compound_member_t  compound_member;
 277 };
 278
 279 #define DECLARATION_KIND_CASES        \
 280         case ENTITY_FUNCTION:             \
 281         case ENTITY_VARIABLE:             \
 282         case ENTITY_PARAMETER:            \
 283         case ENTITY_COMPOUND_MEMBER:
 284
 285 static inline bool is_declaration(const entity_t *entity)
 286 {
 287         switch(entity->kind) {
 288         DECLARATION_KIND_CASES
 289                 return true;
 290         default:
 291                 return false;
 292         }
 293 }
 294
 295 const char *get_entity_kind_name(entity_kind_t kind);
 296
 297 entity_t *allocate_entity_zero(entity_kind_t kind);
 298
 299 #endif