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