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 "lexer_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 } expresion_type_t;
  24
  25 struct expression_t {
  26         expresion_type_t   type;
  27         type_t            *datatype;
  28         source_position_t  source_position;
  29 };
  30
  31 struct const_t {
  32         expression_t  expression;
  33         int           value;
  34 };
  35
  36 struct string_literal_t {
  37         expression_t  expression;
  38         const char   *value;
  39 };
  40
  41 struct reference_expression_t {
  42         expression_t                      expression;
  43         symbol_t                         *symbol;
  44         union {
  45                 declaration_t    *declaration;
  46         } r;
  47 };
  48
  49 struct call_argument_t {
  50         expression_t    *expression;
  51         call_argument_t *next;
  52 };
  53
  54 struct call_expression_t {
  55         expression_t     expression;
  56         expression_t    *method;
  57         call_argument_t *arguments;
  58 };
  59
  60 typedef enum {
  61         UNEXPR_INVALID = 0,
  62         UNEXPR_NEGATE,
  63         UNEXPR_PLUS,
  64         UNEXPR_BITWISE_NEGATE,
  65         UNEXPR_NOT,
  66         UNEXPR_DEREFERENCE,
  67         UNEXPR_TAKE_ADDRESS,
  68         UNEXPR_POSTFIX_INCREMENT,
  69         UNEXPR_POSTFIX_DECREMENT,
  70         UNEXPR_PREFIX_INCREMENT,
  71         UNEXPR_PREFIX_DECREMENT,
  72         UNEXPR_CAST
  73 } unary_expression_type_t;
  74
  75 struct unary_expression_t {
  76         expression_t             expression;
  77         unary_expression_type_t  type;
  78         expression_t            *value;
  79 };
  80
  81 typedef enum {
  82         BINEXPR_INVALID = 0,
  83         BINEXPR_ADD,
  84         BINEXPR_SUB,
  85         BINEXPR_MUL,
  86         BINEXPR_DIV,
  87         BINEXPR_MOD,
  88         BINEXPR_EQUAL,
  89         BINEXPR_NOTEQUAL,
  90         BINEXPR_LESS,
  91         BINEXPR_LESSEQUAL,
  92         BINEXPR_GREATER,
  93         BINEXPR_GREATEREQUAL,
  94         BINEXPR_BITWISE_AND,
  95         BINEXPR_BITWISE_OR,
  96         BINEXPR_BITWISE_XOR,
  97         BINEXPR_LOGICAL_AND,
  98         BINEXPR_LOGICAL_OR,
  99         BINEXPR_SHIFTLEFT,
 100         BINEXPR_SHIFTRIGHT,
 101         BINEXPR_ASSIGN,
 102         BINEXPR_MUL_ASSIGN,
 103         BINEXPR_DIV_ASSIGN,
 104         BINEXPR_MOD_ASSIGN,
 105         BINEXPR_ADD_ASSIGN,
 106         BINEXPR_SUB_ASSIGN,
 107         BINEXPR_SHIFTLEFT_ASSIGN,
 108         BINEXPR_SHIFTRIGHT_ASSIGN,
 109         BINEXPR_BITWISE_AND_ASSIGN,
 110         BINEXPR_BITWISE_XOR_ASSIGN,
 111         BINEXPR_BITWISE_OR_ASSIGN
 112 } binary_expression_type_t;
 113
 114 struct binary_expression_t {
 115         expression_t              expression;
 116         binary_expression_type_t  type;
 117         expression_t             *left;
 118         expression_t             *right;
 119 };
 120
 121 struct select_expression_t {
 122         expression_t      expression;
 123         expression_t     *compound;
 124         symbol_t         *symbol;
 125
 126         compound_entry_t *compound_entry;
 127 };
 128
 129 struct array_access_expression_t {
 130         expression_t  expression;
 131         expression_t *array_ref;
 132         expression_t *index;
 133 };
 134
 135 struct sizeof_expression_t {
 136         expression_t  expression;
 137         union {
 138                 type_t       *type;
 139                 expression_t *size_expression;
 140         } v;
 141 };
 142
 143 struct conditional_expression_t {
 144         expression_t  expression;
 145         expression_t *condition;
 146         expression_t *true_expression;
 147         expression_t *false_expression;
 148 };
 149
 150 struct expression_list_element_t {
 151         expression_t *expression;
 152         expression_t *next;
 153 };
 154
 155 struct comma_expression_t {
 156         expression_t               expression;
 157         expression_list_element_t *expressions;
 158 };
 159
 160 typedef enum {
 161         STORAGE_CLASS_NONE,
 162         STORAGE_CLASS_TYPEDEF,
 163         STORAGE_CLASS_EXTERN,
 164         STORAGE_CLASS_STATIC,
 165         STORAGE_CLASS_AUTO,
 166         STORAGE_CLASS_REGISTER
 167 } storage_class_t;
 168
 169 struct method_parameter_t {
 170         method_parameter_t *next;
 171         symbol_t           *symbol;
 172         type_t             *type;
 173         int                 num;
 174 };
 175
 176 struct declaration_t {
 177         storage_class_t     storage_class;
 178         type_t             *type;
 179         symbol_t           *symbol;
 180         method_parameter_t *parameters;
 181         statement_t        *statement;
 182         source_position_t   source_position;
 183 };
 184
 185 typedef enum {
 186         STATEMENT_INVALID,
 187         STATEMENT_BLOCK,
 188         STATEMENT_RETURN,
 189         STATEMENT_DECLARATION,
 190         STATEMENT_IF,
 191         STATEMENT_EXPRESSION,
 192         STATEMENT_GOTO,
 193         STATEMENT_LABEL
 194 } statement_type_t;
 195
 196 struct statement_t {
 197         statement_type_t   type;
 198         statement_t       *next;
 199         source_position_t  source_position;
 200 };
 201
 202 struct return_statement_t {
 203         statement_t   statement;
 204         expression_t *return_value;
 205 };
 206
 207 struct block_statement_t {
 208         statement_t  statement;
 209         statement_t *first_statement;
 210 };
 211
 212 struct declaration_statement_t {
 213         statement_t    statement;
 214         declaration_t  declaration;
 215
 216         int            value_number; /**< filled in by semantic phase */
 217         int            refs;
 218 };
 219
 220 struct if_statement_t {
 221         statement_t   statement;
 222         expression_t *condition;
 223         statement_t  *true_statement;
 224         statement_t  *false_statement;
 225 };
 226
 227 struct goto_statement_t {
 228         statement_t        statement;
 229         symbol_t          *label_symbol;
 230         label_statement_t *label;
 231 };
 232
 233 struct label_statement_t {
 234         statement_t        statement;
 235         symbol_t          *symbol;
 236 };
 237
 238 struct expression_statement_t {
 239         statement_t   statement;
 240         expression_t *expression;
 241 };
 242
 243 struct unit_entry_t {
 244         declaration_t  declaration;
 245         unit_entry_t  *next;
 246 };
 247
 248 struct translation_unit_t {
 249         unit_entry_t *entries;
 250 };
 251
 252 static inline
 253 void *_allocate_ast(size_t size)
 254 {
 255         return obstack_alloc(&ast_obstack, size);
 256 }
 257
 258 #define allocate_ast(size)                 _allocate_ast(size)
 259
 260 #endif