nsz Git - cparser/blob - ast_t.h

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