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 #include <assert.h>
   6
   7 #include "ast.h"
   8 #include "symbol.h"
   9 #include "token_t.h"
  10 #include "type.h"
  11 #include "adt/obst.h"
  12
  13 extern struct obstack ast_obstack;
  14
  15 typedef enum {
  16         EXPR_UNKNOWN = 0,
  17         EXPR_INVALID,
  18         EXPR_REFERENCE,
  19         EXPR_CONST,
  20         EXPR_STRING_LITERAL,
  21         EXPR_WIDE_STRING_LITERAL,
  22         EXPR_CALL,
  23         EXPR_CONDITIONAL,
  24         EXPR_SELECT,
  25         EXPR_ARRAY_ACCESS,
  26         EXPR_SIZEOF,
  27         EXPR_CLASSIFY_TYPE,
  28         EXPR_ALIGNOF,
  29
  30         EXPR_FUNCTION,
  31         EXPR_PRETTY_FUNCTION,
  32         EXPR_BUILTIN_SYMBOL,
  33         EXPR_OFFSETOF,
  34         EXPR_VA_START,
  35         EXPR_VA_ARG,
  36         EXPR_STATEMENT,
  37
  38         EXPR_UNARY_FIRST,
  39         EXPR_UNARY_NEGATE = EXPR_UNARY_FIRST,
  40         EXPR_UNARY_PLUS,
  41         EXPR_UNARY_BITWISE_NEGATE,
  42         EXPR_UNARY_NOT,
  43         EXPR_UNARY_DEREFERENCE,
  44         EXPR_UNARY_TAKE_ADDRESS,
  45         EXPR_UNARY_POSTFIX_INCREMENT,
  46         EXPR_UNARY_POSTFIX_DECREMENT,
  47         EXPR_UNARY_PREFIX_INCREMENT,
  48         EXPR_UNARY_PREFIX_DECREMENT,
  49         EXPR_UNARY_CAST,
  50         EXPR_UNARY_CAST_IMPLICIT, /**< compiler generated cast */
  51         EXPR_UNARY_ASSUME,        /**< MS __assume() */
  52         EXPR_UNARY_LAST = EXPR_UNARY_ASSUME,
  53
  54         EXPR_BINARY_FIRST,
  55         EXPR_BINARY_ADD = EXPR_BINARY_FIRST,
  56         EXPR_BINARY_SUB,
  57         EXPR_BINARY_MUL,
  58         EXPR_BINARY_DIV,
  59         EXPR_BINARY_MOD,
  60         EXPR_BINARY_EQUAL,
  61         EXPR_BINARY_NOTEQUAL,
  62         EXPR_BINARY_LESS,
  63         EXPR_BINARY_LESSEQUAL,
  64         EXPR_BINARY_GREATER,
  65         EXPR_BINARY_GREATEREQUAL,
  66         EXPR_BINARY_BITWISE_AND,
  67         EXPR_BINARY_BITWISE_OR,
  68         EXPR_BINARY_BITWISE_XOR,
  69         EXPR_BINARY_LOGICAL_AND,
  70         EXPR_BINARY_LOGICAL_OR,
  71         EXPR_BINARY_SHIFTLEFT,
  72         EXPR_BINARY_SHIFTRIGHT,
  73         EXPR_BINARY_ASSIGN,
  74         EXPR_BINARY_MUL_ASSIGN,
  75         EXPR_BINARY_DIV_ASSIGN,
  76         EXPR_BINARY_MOD_ASSIGN,
  77         EXPR_BINARY_ADD_ASSIGN,
  78         EXPR_BINARY_SUB_ASSIGN,
  79         EXPR_BINARY_SHIFTLEFT_ASSIGN,
  80         EXPR_BINARY_SHIFTRIGHT_ASSIGN,
  81         EXPR_BINARY_BITWISE_AND_ASSIGN,
  82         EXPR_BINARY_BITWISE_XOR_ASSIGN,
  83         EXPR_BINARY_BITWISE_OR_ASSIGN,
  84         EXPR_BINARY_COMMA,
  85
  86         EXPR_BINARY_BUILTIN_EXPECT,
  87         EXPR_BINARY_ISGREATER,
  88         EXPR_BINARY_ISGREATEREQUAL,
  89         EXPR_BINARY_ISLESS,
  90         EXPR_BINARY_ISLESSEQUAL,
  91         EXPR_BINARY_ISLESSGREATER,
  92         EXPR_BINARY_ISUNORDERED,
  93         EXPR_BINARY_LAST = EXPR_BINARY_ISUNORDERED,
  94 } expression_kind_t;
  95
  96 /* convenience macros */
  97 #define EXPR_BINARY_CASES                  \
  98         case EXPR_BINARY_ADD:                  \
  99         case EXPR_BINARY_SUB:                  \
 100         case EXPR_BINARY_MUL:                  \
 101         case EXPR_BINARY_DIV:                  \
 102         case EXPR_BINARY_MOD:                  \
 103         case EXPR_BINARY_EQUAL:                \
 104         case EXPR_BINARY_NOTEQUAL:             \
 105         case EXPR_BINARY_LESS:                 \
 106         case EXPR_BINARY_LESSEQUAL:            \
 107         case EXPR_BINARY_GREATER:              \
 108         case EXPR_BINARY_GREATEREQUAL:         \
 109         case EXPR_BINARY_BITWISE_AND:          \
 110         case EXPR_BINARY_BITWISE_OR:           \
 111         case EXPR_BINARY_BITWISE_XOR:          \
 112         case EXPR_BINARY_LOGICAL_AND:          \
 113         case EXPR_BINARY_LOGICAL_OR:           \
 114         case EXPR_BINARY_SHIFTLEFT:            \
 115         case EXPR_BINARY_SHIFTRIGHT:           \
 116         case EXPR_BINARY_ASSIGN:               \
 117         case EXPR_BINARY_MUL_ASSIGN:           \
 118         case EXPR_BINARY_DIV_ASSIGN:           \
 119         case EXPR_BINARY_MOD_ASSIGN:           \
 120         case EXPR_BINARY_ADD_ASSIGN:           \
 121         case EXPR_BINARY_SUB_ASSIGN:           \
 122         case EXPR_BINARY_SHIFTLEFT_ASSIGN:     \
 123         case EXPR_BINARY_SHIFTRIGHT_ASSIGN:    \
 124         case EXPR_BINARY_BITWISE_AND_ASSIGN:   \
 125         case EXPR_BINARY_BITWISE_XOR_ASSIGN:   \
 126         case EXPR_BINARY_BITWISE_OR_ASSIGN:    \
 127         case EXPR_BINARY_COMMA:                \
 128         case EXPR_BINARY_BUILTIN_EXPECT:       \
 129         case EXPR_BINARY_ISGREATER:            \
 130         case EXPR_BINARY_ISGREATEREQUAL:       \
 131         case EXPR_BINARY_ISLESS:               \
 132         case EXPR_BINARY_ISLESSEQUAL:          \
 133         case EXPR_BINARY_ISLESSGREATER:        \
 134         case EXPR_BINARY_ISUNORDERED:
 135
 136 #define EXPR_UNARY_CASES                   \
 137         case EXPR_UNARY_NEGATE:                \
 138         case EXPR_UNARY_PLUS:                  \
 139         case EXPR_UNARY_BITWISE_NEGATE:        \
 140         case EXPR_UNARY_NOT:                   \
 141         case EXPR_UNARY_DEREFERENCE:           \
 142         case EXPR_UNARY_TAKE_ADDRESS:          \
 143         case EXPR_UNARY_POSTFIX_INCREMENT:     \
 144         case EXPR_UNARY_POSTFIX_DECREMENT:     \
 145         case EXPR_UNARY_PREFIX_INCREMENT:      \
 146         case EXPR_UNARY_PREFIX_DECREMENT:      \
 147         case EXPR_UNARY_CAST:                  \
 148         case EXPR_UNARY_CAST_IMPLICIT:         \
 149         case EXPR_UNARY_ASSUME:
 150
 151 struct context_t {
 152         declaration_t *declarations;
 153 };
 154
 155 struct expression_base_t {
 156         expression_kind_t   kind;
 157         type_t             *datatype;
 158         source_position_t   source_position;
 159 };
 160
 161 struct const_expression_t {
 162         expression_base_t  expression;
 163         union {
 164                 long long   int_value;
 165                 long double float_value;
 166         } v;
 167 };
 168
 169 struct string_literal_expression_t {
 170         expression_base_t  expression;
 171         const char        *value;
 172 };
 173
 174 struct wide_string_literal_expression_t {
 175         expression_base_t  expression;
 176         wide_string_t      value;
 177 };
 178
 179 struct builtin_symbol_expression_t {
 180         expression_base_t  expression;
 181         symbol_t          *symbol;
 182 };
 183
 184 struct reference_expression_t {
 185         expression_base_t  expression;
 186         symbol_t          *symbol;
 187         declaration_t     *declaration;
 188 };
 189
 190 struct call_argument_t {
 191         expression_t    *expression;
 192         call_argument_t *next;
 193 };
 194
 195 struct call_expression_t {
 196         expression_base_t  expression;
 197         expression_t      *function;
 198         call_argument_t   *arguments;
 199 };
 200
 201 struct unary_expression_t {
 202         expression_base_t  expression;
 203         expression_t      *value;
 204 };
 205
 206 struct binary_expression_t {
 207         expression_base_t  expression;
 208         expression_t      *left;
 209         expression_t      *right;
 210 };
 211
 212 struct select_expression_t {
 213         expression_base_t  expression;
 214         expression_t      *compound;
 215         symbol_t          *symbol;
 216
 217         declaration_t     *compound_entry;
 218 };
 219
 220 struct array_access_expression_t {
 221         expression_base_t  expression;
 222         expression_t      *array_ref;
 223         expression_t      *index;
 224         bool               flipped; /* index/ref was written in a 5[a] way */
 225 };
 226
 227 struct sizeof_expression_t {
 228         expression_base_t  expression;
 229         type_t            *type;
 230         expression_t      *size_expression;
 231 };
 232
 233 struct alignof_expression_t {
 234         expression_base_t  expression;
 235         type_t            *type;
 236 };
 237
 238 struct designator_t {
 239         symbol_t     *symbol;
 240         expression_t *array_access;
 241         designator_t *next;
 242 };
 243
 244 struct offsetof_expression_t {
 245         expression_base_t  expression;
 246         type_t            *type;
 247         designator_t      *designator;
 248 };
 249
 250 struct va_start_expression_t {
 251         expression_base_t  expression;
 252         expression_t      *ap;
 253         declaration_t     *parameter;
 254 };
 255
 256 struct va_arg_expression_t {
 257         expression_base_t  expression;
 258         expression_t      *ap;
 259 };
 260
 261 struct conditional_expression_t {
 262         expression_base_t  expression;
 263         expression_t      *condition;
 264         expression_t      *true_expression;
 265         expression_t      *false_expression;
 266 };
 267
 268 struct statement_expression_t {
 269         expression_base_t  expression;
 270         statement_t       *statement;
 271 };
 272
 273 struct classify_type_expression_t {
 274         expression_base_t  expression;
 275         expression_t      *type_expression;
 276 };
 277
 278 union expression_t {
 279         expression_kind_t                kind;
 280         expression_base_t                base;
 281         const_expression_t               conste;
 282         string_literal_expression_t      string;
 283         wide_string_literal_expression_t wide_string;
 284         builtin_symbol_expression_t      builtin_symbol;
 285         reference_expression_t           reference;
 286         call_expression_t                call;
 287         unary_expression_t               unary;
 288         binary_expression_t              binary;
 289         select_expression_t              select;
 290         array_access_expression_t        array_access;
 291         sizeof_expression_t              sizeofe;
 292         offsetof_expression_t            offsetofe;
 293         va_start_expression_t            va_starte;
 294         va_arg_expression_t              va_arge;
 295         conditional_expression_t         conditional;
 296         statement_expression_t           statement;
 297         classify_type_expression_t       classify_type;
 298         alignof_expression_t             alignofe;
 299 };
 300
 301 typedef enum {
 302         STORAGE_CLASS_NONE,
 303         STORAGE_CLASS_TYPEDEF,
 304         STORAGE_CLASS_EXTERN,
 305         STORAGE_CLASS_STATIC,
 306         STORAGE_CLASS_AUTO,
 307         STORAGE_CLASS_REGISTER,
 308         STORAGE_CLASS_ENUM_ENTRY,
 309         STORAGE_CLASS_THREAD,
 310         STORAGE_CLASS_THREAD_EXTERN,
 311         STORAGE_CLASS_THREAD_STATIC
 312 } storage_class_tag_t;
 313
 314 typedef enum {
 315         NAMESPACE_NORMAL,
 316         NAMESPACE_STRUCT,
 317         NAMESPACE_UNION,
 318         NAMESPACE_ENUM,
 319         NAMESPACE_LABEL,
 320 } namespace_t;
 321
 322 typedef enum {
 323         INITIALIZER_VALUE,
 324         INITIALIZER_LIST,
 325         INITIALIZER_STRING,
 326         INITIALIZER_WIDE_STRING
 327 } initializer_kind_t;
 328
 329 struct initializer_base_t {
 330         initializer_kind_t kind;
 331 };
 332
 333 struct initializer_value_t {
 334         initializer_base_t  initializer;
 335         expression_t       *value;
 336 };
 337
 338 struct initializer_list_t {
 339         initializer_base_t  initializer;
 340         size_t              len;
 341         initializer_t      *initializers[];
 342 };
 343
 344 struct initializer_string_t {
 345         initializer_base_t  initializer;
 346         const char         *string;
 347 };
 348
 349 struct initializer_wide_string_t {
 350         initializer_base_t  initializer;
 351         wide_string_t       string;
 352 };
 353
 354 union initializer_t {
 355         initializer_kind_t        kind;
 356         initializer_base_t        base;
 357         initializer_value_t       value;
 358         initializer_list_t        list;
 359         initializer_string_t      string;
 360         initializer_wide_string_t wide_string;
 361 };
 362
 363 typedef enum {
 364         DM_DLLIMPORT   = (1 << 0),
 365         DM_DLLEXPORT   = (1 << 1),
 366         DM_THREAD      = (1 << 2),
 367         DM_NAKED       = (1 << 3),
 368         DM_FORCEINLINE = (1 << 4),
 369         DM_NOTHROW     = (1 << 5),
 370         DM_NORETURN    = (1 << 6),
 371         DM_NOINLINE    = (1 << 7)
 372 } decl_modifier_t;
 373
 374 typedef unsigned short decl_modifiers_t;
 375
 376 struct declaration_t {
 377         unsigned char       namespc;
 378         unsigned char       storage_class;
 379         decl_modifiers_t    decl_modifiers;
 380         unsigned int        address_taken : 1;
 381         unsigned int        is_inline     : 1;
 382         type_t             *type;
 383         symbol_t           *symbol;
 384         source_position_t   source_position;
 385         union {
 386                 bool            is_defined;
 387                 statement_t    *statement;
 388                 initializer_t  *initializer;
 389                 expression_t   *enum_value;
 390         } init;
 391         context_t           context;
 392         context_t          *parent_context;
 393
 394         /** next declaration in a context */
 395         declaration_t      *next;
 396         /** next declaration with same symbol */
 397         declaration_t      *symbol_next;
 398
 399         /* the following fields are used in ast2firm module */
 400         unsigned char       declaration_type;
 401         union {
 402                 unsigned int    value_number;
 403                 ir_entity      *entity;
 404                 ir_node        *block;
 405                 tarval         *enum_val;
 406         } v;
 407 };
 408
 409 typedef enum {
 410         STATEMENT_INVALID,
 411         STATEMENT_COMPOUND,
 412         STATEMENT_RETURN,
 413         STATEMENT_DECLARATION,
 414         STATEMENT_IF,
 415         STATEMENT_SWITCH,
 416         STATEMENT_EXPRESSION,
 417         STATEMENT_CONTINUE,
 418         STATEMENT_BREAK,
 419         STATEMENT_GOTO,
 420         STATEMENT_LABEL,
 421         STATEMENT_CASE_LABEL,
 422         STATEMENT_WHILE,
 423         STATEMENT_DO_WHILE,
 424         STATEMENT_FOR,
 425         STATEMENT_ASM
 426 } statement_kind_t;
 427
 428 struct statement_base_t {
 429         statement_kind_t   kind;
 430         statement_t       *next;
 431         source_position_t  source_position;
 432 };
 433
 434 struct return_statement_t {
 435         statement_base_t  statement;
 436         expression_t     *return_value;
 437 };
 438
 439 struct compound_statement_t {
 440         statement_base_t  statement;
 441         statement_t      *statements;
 442         context_t         context;
 443 };
 444
 445 struct declaration_statement_t {
 446         statement_base_t  statement;
 447         declaration_t    *declarations_begin;
 448         declaration_t    *declarations_end;
 449 };
 450
 451 struct if_statement_t {
 452         statement_base_t  statement;
 453         expression_t     *condition;
 454         statement_t      *true_statement;
 455         statement_t      *false_statement;
 456 };
 457
 458 struct switch_statement_t {
 459         statement_base_t  statement;
 460         expression_t     *expression;
 461         statement_t      *body;
 462 };
 463
 464 struct goto_statement_t {
 465         statement_base_t  statement;
 466         declaration_t    *label;
 467 };
 468
 469 struct case_label_statement_t {
 470         statement_base_t  statement;
 471         expression_t     *expression;
 472         statement_t      *label_statement;
 473 };
 474
 475 struct label_statement_t {
 476         statement_base_t  statement;
 477         declaration_t    *label;
 478         statement_t      *label_statement;
 479 };
 480
 481 struct expression_statement_t {
 482         statement_base_t  statement;
 483         expression_t     *expression;
 484 };
 485
 486 struct while_statement_t {
 487         statement_base_t  statement;
 488         expression_t     *condition;
 489         statement_t      *body;
 490 };
 491
 492 struct do_while_statement_t {
 493         statement_base_t  statement;
 494         expression_t     *condition;
 495         statement_t      *body;
 496 };
 497
 498 struct for_statement_t {
 499         statement_base_t  statement;
 500         expression_t     *initialisation;
 501         expression_t     *condition;
 502         expression_t     *step;
 503         statement_t      *body;
 504         context_t         context;
 505 };
 506
 507 struct asm_constraint_t {
 508         const char       *constraints;
 509         expression_t     *expression;
 510         symbol_t         *symbol;
 511         asm_constraint_t *next;
 512 };
 513
 514 struct asm_clobber_t {
 515         const char    *clobber;
 516         asm_clobber_t *next;
 517 };
 518
 519 struct asm_statement_t {
 520         statement_base_t  statement;
 521         const char       *asm_text;
 522         asm_constraint_t *inputs;
 523         asm_constraint_t *outputs;
 524         asm_clobber_t    *clobbers;
 525         bool              is_volatile;
 526 };
 527
 528 union statement_t {
 529         statement_kind_t         kind;
 530         statement_base_t         base;
 531         return_statement_t       returns;
 532         compound_statement_t     compound;
 533         declaration_statement_t  declaration;
 534         if_statement_t           ifs;
 535         switch_statement_t       switchs;
 536         goto_statement_t         gotos;
 537         case_label_statement_t   case_label;
 538         label_statement_t        label;
 539         expression_statement_t   expression;
 540         while_statement_t        whiles;
 541         do_while_statement_t     do_while;
 542         for_statement_t          fors;
 543         asm_statement_t          asms;
 544 };
 545
 546 struct translation_unit_t {
 547         context_t context;
 548 };
 549
 550 static inline
 551 void *_allocate_ast(size_t size)
 552 {
 553         return obstack_alloc(&ast_obstack, size);
 554 }
 555
 556 #define allocate_ast(size)                 _allocate_ast(size)
 557
 558 #endif