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