nsz Git - cparser/blob - ast_t.h

   1 #ifndef AST_T_H
   2 #define AST_T_H
   3
   4 #include <libfirm/firm_types.h>
   5
   6 #include "ast.h"
   7 #include "symbol.h"
   8 #include "token_t.h"
   9 #include "type.h"
  10 #include "adt/obst.h"
  11
  12 extern struct obstack ast_obstack;
  13
  14 typedef enum {
  15         EXPR_UNKNOWN = 0,
  16         EXPR_INVALID,
  17         EXPR_REFERENCE,
  18         EXPR_CONST,
  19         EXPR_STRING_LITERAL,
  20         EXPR_CALL,
  21         EXPR_UNARY,
  22         EXPR_BINARY,
  23         EXPR_CONDITIONAL,
  24         EXPR_SELECT,
  25         EXPR_ARRAY_ACCESS,
  26         EXPR_SIZEOF,
  27
  28         EXPR_FUNCTION,
  29         EXPR_PRETTY_FUNCTION,
  30         EXPR_BUILTIN_SYMBOL,
  31         EXPR_OFFSETOF,
  32         EXPR_VA_ARG,
  33         EXPR_STATEMENT
  34 } expresion_type_t;
  35
  36 struct context_t {
  37         declaration_t   *declarations;
  38 };
  39
  40 struct expression_t {
  41         expresion_type_t   type;
  42         type_t            *datatype;
  43         source_position_t  source_position;
  44 };
  45
  46 struct const_t {
  47         expression_t  expression;
  48         union {
  49                 int         int_value;
  50                 long double float_value;
  51         } v;
  52 };
  53
  54 struct string_literal_t {
  55         expression_t  expression;
  56         const char   *value;
  57 };
  58
  59 struct builtin_symbol_expression_t {
  60         expression_t  expression;
  61         symbol_t     *symbol;
  62 };
  63
  64 struct reference_expression_t {
  65         expression_t   expression;
  66         symbol_t      *symbol;
  67         declaration_t *declaration;
  68 };
  69
  70 struct call_argument_t {
  71         expression_t    *expression;
  72         call_argument_t *next;
  73 };
  74
  75 struct call_expression_t {
  76         expression_t     expression;
  77         expression_t    *function;
  78         call_argument_t *arguments;
  79 };
  80
  81 typedef enum {
  82         UNEXPR_INVALID = 0,
  83         UNEXPR_NEGATE,
  84         UNEXPR_PLUS,
  85         UNEXPR_BITWISE_NEGATE,
  86         UNEXPR_NOT,
  87         UNEXPR_DEREFERENCE,
  88         UNEXPR_TAKE_ADDRESS,
  89         UNEXPR_POSTFIX_INCREMENT,
  90         UNEXPR_POSTFIX_DECREMENT,
  91         UNEXPR_PREFIX_INCREMENT,
  92         UNEXPR_PREFIX_DECREMENT,
  93         UNEXPR_CAST
  94 } unary_expression_type_t;
  95
  96 struct unary_expression_t {
  97         expression_t             expression;
  98         unary_expression_type_t  type;
  99         expression_t            *value;
 100 };
 101
 102 typedef enum {
 103         BINEXPR_INVALID = 0,
 104         BINEXPR_ADD,
 105         BINEXPR_SUB,
 106         BINEXPR_MUL,
 107         BINEXPR_DIV,
 108         BINEXPR_MOD,
 109         BINEXPR_EQUAL,
 110         BINEXPR_NOTEQUAL,
 111         BINEXPR_LESS,
 112         BINEXPR_LESSEQUAL,
 113         BINEXPR_GREATER,
 114         BINEXPR_GREATEREQUAL,
 115         BINEXPR_BITWISE_AND,
 116         BINEXPR_BITWISE_OR,
 117         BINEXPR_BITWISE_XOR,
 118         BINEXPR_LOGICAL_AND,
 119         BINEXPR_LOGICAL_OR,
 120         BINEXPR_SHIFTLEFT,
 121         BINEXPR_SHIFTRIGHT,
 122         BINEXPR_ASSIGN,
 123         BINEXPR_MUL_ASSIGN,
 124         BINEXPR_DIV_ASSIGN,
 125         BINEXPR_MOD_ASSIGN,
 126         BINEXPR_ADD_ASSIGN,
 127         BINEXPR_SUB_ASSIGN,
 128         BINEXPR_SHIFTLEFT_ASSIGN,
 129         BINEXPR_SHIFTRIGHT_ASSIGN,
 130         BINEXPR_BITWISE_AND_ASSIGN,
 131         BINEXPR_BITWISE_XOR_ASSIGN,
 132         BINEXPR_BITWISE_OR_ASSIGN,
 133         BINEXPR_COMMA
 134 } binary_expression_type_t;
 135
 136 struct binary_expression_t {
 137         expression_t              expression;
 138         binary_expression_type_t  type;
 139         expression_t             *left;
 140         expression_t             *right;
 141 };
 142
 143 struct select_expression_t {
 144         expression_t   expression;
 145         expression_t  *compound;
 146         symbol_t      *symbol;
 147
 148         declaration_t *compound_entry;
 149 };
 150
 151 struct array_access_expression_t {
 152         expression_t  expression;
 153         expression_t *array_ref;
 154         expression_t *index;
 155 };
 156
 157 struct sizeof_expression_t {
 158         expression_t  expression;
 159         type_t       *type;
 160         expression_t *size_expression;
 161 };
 162
 163 struct designator_t {
 164         symbol_t     *symbol;
 165         expression_t *array_access;
 166         designator_t *next;
 167 };
 168
 169 struct offsetof_expression_t {
 170         expression_t  expression;
 171         type_t       *type;
 172         designator_t *designator;
 173 };
 174
 175 struct va_arg_expression_t {
 176         expression_t  expression;
 177         expression_t *arg;
 178         type_t       *type;
 179 };
 180
 181 struct conditional_expression_t {
 182         expression_t  expression;
 183         expression_t *condition;
 184         expression_t *true_expression;
 185         expression_t *false_expression;
 186 };
 187
 188 struct statement_expression_t {
 189         expression_t  expression;
 190         statement_t  *statement;
 191 };
 192
 193 typedef enum {
 194         STORAGE_CLASS_NONE,
 195         STORAGE_CLASS_TYPEDEF,
 196         STORAGE_CLASS_EXTERN,
 197         STORAGE_CLASS_STATIC,
 198         STORAGE_CLASS_AUTO,
 199         STORAGE_CLASS_REGISTER,
 200         STORAGE_CLASS_ENUM_ENTRY
 201 } storage_class_t;
 202
 203 typedef enum {
 204         NAMESPACE_NORMAL,
 205         NAMESPACE_STRUCT,
 206         NAMESPACE_UNION,
 207         NAMESPACE_ENUM,
 208         NAMESPACE_LABEL
 209 } namespace_t;
 210
 211 typedef enum {
 212         INITIALIZER_VALUE,
 213         INITIALIZER_LIST,
 214 } initializer_type_t;
 215
 216 struct initializer_t {
 217         initializer_type_t type;
 218         designator_t      *designator;
 219         union {
 220                 initializer_t *list;
 221                 expression_t  *value;
 222         } v;
 223         initializer_t *next;
 224 };
 225
 226 struct declaration_t {
 227         unsigned char       namespace;
 228         unsigned char       storage_class;
 229         unsigned int        address_taken : 1;
 230         unsigned int        is_inline     : 1;
 231         type_t             *type;
 232         symbol_t           *symbol;
 233         source_position_t   source_position;
 234         union {
 235                 bool            is_defined;
 236                 statement_t    *statement;
 237                 initializer_t  *initializer;
 238         } init;
 239         context_t           context;
 240         context_t          *parent_context;
 241
 242         /** next declaration in a context */
 243         declaration_t      *next;
 244         /** next declaration with same symbol */
 245         declaration_t      *symbol_next;
 246
 247         unsigned char       declaration_type; /* used in ast2firm module */
 248         union {
 249                 unsigned int    value_number;     /* used in ast2firm module */
 250                 ir_entity      *entity;           /* used in ast2firm module */
 251                 ir_node        *block;            /* used in ast2firm module */
 252         } v;
 253 };
 254
 255 typedef enum {
 256         STATEMENT_INVALID,
 257         STATEMENT_COMPOUND,
 258         STATEMENT_RETURN,
 259         STATEMENT_DECLARATION,
 260         STATEMENT_IF,
 261         STATEMENT_SWITCH,
 262         STATEMENT_EXPRESSION,
 263         STATEMENT_CONTINUE,
 264         STATEMENT_BREAK,
 265         STATEMENT_GOTO,
 266         STATEMENT_LABEL,
 267         STATEMENT_CASE_LABEL,
 268         STATEMENT_WHILE,
 269         STATEMENT_DO_WHILE,
 270         STATEMENT_FOR
 271 } statement_type_t;
 272
 273 struct statement_t {
 274         statement_type_t   type;
 275         statement_t       *next;
 276         source_position_t  source_position;
 277 };
 278
 279 struct return_statement_t {
 280         statement_t   statement;
 281         expression_t *return_value;
 282 };
 283
 284 struct compound_statement_t {
 285         statement_t  statement;
 286         statement_t *statements;
 287         context_t    context;
 288 };
 289
 290 struct declaration_statement_t {
 291         statement_t    statement;
 292         declaration_t *declarations_begin;
 293         declaration_t *declarations_end;
 294 };
 295
 296 struct if_statement_t {
 297         statement_t   statement;
 298         expression_t *condition;
 299         statement_t  *true_statement;
 300         statement_t  *false_statement;
 301 };
 302
 303 struct switch_statement_t {
 304         statement_t   statement;
 305         expression_t *expression;
 306         statement_t  *body;
 307 };
 308
 309 struct goto_statement_t {
 310         statement_t    statement;
 311         declaration_t *label;
 312 };
 313
 314 struct case_label_statement_t {
 315         statement_t   statement;
 316         expression_t *expression;
 317 };
 318
 319 struct label_statement_t {
 320         statement_t    statement;
 321         declaration_t *label;
 322         statement_t   *label_statement;
 323 };
 324
 325 struct expression_statement_t {
 326         statement_t   statement;
 327         expression_t *expression;
 328 };
 329
 330 struct while_statement_t {
 331         statement_t   statement;
 332         expression_t *condition;
 333         statement_t  *body;
 334 };
 335
 336 struct do_while_statement_t {
 337         statement_t   statement;
 338         expression_t *condition;
 339         statement_t  *body;
 340 };
 341
 342 struct for_statement_t {
 343         statement_t   statement;
 344         expression_t  *initialisation;
 345         expression_t  *condition;
 346         expression_t  *step;
 347         statement_t   *body;
 348         context_t      context;
 349 };
 350
 351 struct translation_unit_t {
 352         context_t context;
 353 };
 354
 355 static inline
 356 void *_allocate_ast(size_t size)
 357 {
 358         return obstack_alloc(&ast_obstack, size);
 359 }
 360
 361 #define allocate_ast(size)                 _allocate_ast(size)
 362
 363 #endif