ast.c - website - Website contents

ast.c (41427B)
      1 /* ast.c */
      2 #include <stdlib.h>
      3 #include <assert.h>
      4 #include "ast.h"
      5 /* Implementation - Common Node Structure */
      6 #define AST_MAGIC 0x4153544E4F44ULL // "ASTNOD"
      7 
      8 struct ast_node {
      9   long magic;
     10   int line;
     11   int column;
     12   int hasdata;
     13   short kind;
     14   long opt_data[0];
     15 };
     16 
     17 static void* ast_get_data(ast_node_t *node)
     18 {
     19   assert(node->magic == AST_MAGIC);
     20   assert(node->hasdata);
     21   return node->opt_data;
     22 }
     23 
     24 ast_node_type_t ast_get_node_type(ast_node_t *node)
     25 {
     26   assert(node->magic == AST_MAGIC);
     27   return node->kind;
     28 }
     29 
     30 int ast_get_node_line(ast_node_t *node)
     31 {
     32   assert(node->magic == AST_MAGIC);
     33   return node->line;
     34 }
     35 
     36 int ast_get_node_column(ast_node_t *node)
     37 {
     38   assert(node->magic == AST_MAGIC);
     39   return node->column;
     40 }
     41 
     42 static ast_node_t *ast_create_node(ast_node_type_t kind, int line, int column, size_t data_size)
     43 {
     44   ast_node_t *node = malloc(sizeof(ast_node_t) + data_size);
     45   node->magic = AST_MAGIC;
     46   node->line = line;
     47   node->column = column;
     48   node->hasdata = data_size > 0;
     49   node->kind = kind;
     50   return node;
     51 }
     52 
     53 /* Implementation - Nodes (Primary) */
     54 struct ast_int_node {
     55   int64_t value;
     56 };
     57 
     58 ast_node_t *ast_create_intu32_node(uint32_t value, int line, int column)
     59 {
     60   ast_node_t *node =
     61       ast_create_node(AST_INTU32, line, column, sizeof(struct ast_int_node));
     62   struct ast_int_node *data = ast_get_data(node);
     63   data->value = value;
     64   return node;
     65 }
     66 
     67 ast_node_t *ast_create_ints32_node(int32_t value, int line, int column)
     68 {
     69   ast_node_t *node =
     70       ast_create_node(AST_INTS32, line, column, sizeof(struct ast_int_node));
     71   struct ast_int_node *data = ast_get_data(node);
     72   data->value = value;
     73   return node;
     74 }
     75 
     76 ast_node_t *ast_create_intu64_node(uint64_t value, int line, int column)
     77 {
     78   ast_node_t *node =
     79       ast_create_node(AST_INTU64, line, column, sizeof(struct ast_int_node));
     80   struct ast_int_node *data = ast_get_data(node);
     81   data->value = value;
     82   return node;
     83 }
     84 
     85 ast_node_t *ast_create_ints64_node(int64_t value, int line, int column)
     86 {
     87   ast_node_t *node =
     88       ast_create_node(AST_INTS64, line, column, sizeof(struct ast_int_node));
     89   struct ast_int_node *data = ast_get_data(node);
     90   data->value = value;
     91   return node;
     92 }
     93 
     94 int64_t ast_get_int_value(ast_node_t *node) {
     95   assert(ast_get_node_type(node) == AST_INTU32 || ast_get_node_type(node) == AST_INTS32 || ast_get_node_type(node) == AST_INTU64 || ast_get_node_type(node) == AST_INTS64);
     96   struct ast_int_node *data = ast_get_data(node);
     97   return data->value;
     98 }
     99 
    100 struct ast_double_node {
    101   double value;
    102 };
    103 
    104 struct ast_float_node {
    105     float value;
    106 };
    107 
    108 ast_node_t *ast_create_float_node(float value, int line, int column)
    109 {
    110   ast_node_t *node = ast_create_node(AST_FLOAT, line, column, sizeof(struct ast_float_node));
    111   struct ast_float_node *data = ast_get_data(node);
    112   data->value = value;
    113   return node;
    114 }
    115 
    116 float ast_get_float_value(ast_node_t *node)
    117 {
    118   assert(ast_get_node_type(node) == AST_FLOAT);
    119   struct ast_float_node *data = ast_get_data(node);
    120   return data->value;
    121 }
    122 
    123 ast_node_t *ast_create_double_node(double value, int line, int column)
    124 {
    125   ast_node_t *node = ast_create_node(AST_DOUBLE, line, column, sizeof(struct ast_double_node));
    126   struct ast_double_node *data = ast_get_data(node);
    127   data->value = value;
    128   return node;
    129 }
    130 
    131 double ast_get_double_value(ast_node_t *node)
    132 {
    133   assert(ast_get_node_type(node) == AST_DOUBLE);
    134   struct ast_double_node *data = ast_get_data(node);
    135   return data->value;
    136 }
    137 
    138 struct ast_string_node {
    139   char *value;
    140 };
    141 
    142 ast_node_t *ast_create_string_node(char *value, int line, int column)
    143 {
    144   ast_node_t *node = ast_create_node(AST_STRING, line, column, sizeof(struct ast_string_node));
    145   struct ast_string_node *data = ast_get_data(node);
    146   data->value = value; // We don't duplicate here because the string is in the shared string table
    147   return node;
    148 }
    149 
    150 char *ast_get_string_value(ast_node_t *node)
    151 {
    152   assert(ast_get_node_type(node) == AST_STRING);
    153   struct ast_string_node *data = ast_get_data(node);
    154   return data->value;
    155 }
    156 
    157 struct ast_char_node {
    158   char value;
    159 };
    160 
    161 ast_node_t *ast_create_char_node(char value, int line, int column)
    162 {
    163   ast_node_t *node = ast_create_node(AST_CHAR, line, column, sizeof(struct ast_char_node));
    164   struct ast_char_node *data = ast_get_data(node);
    165   data->value = value;
    166   return node;
    167 }
    168 
    169 char ast_get_char_value(ast_node_t *node)
    170 {
    171   assert(ast_get_node_type(node) == AST_CHAR);
    172   struct ast_char_node *data = ast_get_data(node);
    173   return data->value;
    174 }
    175 
    176 ast_node_t *ast_create_var_node(char *value, int line, int column)
    177 {
    178   ast_node_t *node = ast_create_node(AST_VAR, line, column, sizeof(struct ast_string_node));
    179   struct ast_string_node *data = ast_get_data(node);
    180   data->value = value; // We don't duplicate here because the string is in the shared string table
    181   return node;
    182 }
    183 
    184 char *ast_get_var_value(ast_node_t *node)
    185 {
    186   assert(ast_get_node_type(node) == AST_VAR);
    187   struct ast_string_node *data = ast_get_data(node);
    188   return data->value;
    189 }
    190 
    191 /* Implementation - Nodes (Postfix) */
    192 struct ast_subscript_node {
    193   ast_node_t *expr;
    194   ast_node_t *subscript;
    195 };
    196 
    197 ast_node_t *ast_create_subscript_node(ast_node_t *expr, ast_node_t *subscript, int line, int column)
    198 {
    199   ast_node_t *node = ast_create_node(AST_SUBSCRIPT, line, column, sizeof(struct ast_subscript_node));
    200   struct ast_subscript_node *data = ast_get_data(node);
    201   data->expr = expr;
    202   data->subscript = subscript;
    203   return node;
    204 }
    205 
    206 ast_node_t *ast_get_subscript_expr(ast_node_t *node)
    207 {
    208   assert(ast_get_node_type(node) == AST_SUBSCRIPT);
    209   struct ast_subscript_node *data = ast_get_data(node);
    210   return data->expr;
    211 }
    212 
    213 ast_node_t *ast_get_subscript_idx(ast_node_t *node)
    214 {
    215   assert(ast_get_node_type(node) == AST_SUBSCRIPT);
    216   struct ast_subscript_node *data = ast_get_data(node);
    217   return data->subscript;
    218 }
    219 
    220 struct ast_component_selection_node {
    221   ast_node_t *expr;
    222   char *component;
    223 };
    224 
    225 ast_node_t *ast_create_direct_component_selection_node(ast_node_t *expr, char *component, int line, int column)
    226 {
    227   ast_node_t *node = ast_create_node(AST_DIRECT_COMPONENT_SELECTION, line, column, sizeof(struct ast_component_selection_node));
    228   struct ast_component_selection_node *data = ast_get_data(node);
    229   data->expr = expr;
    230   data->component = component;
    231   return node;
    232 }
    233 
    234 char *ast_get_component(ast_node_t *node)
    235 {
    236   assert(ast_get_node_type(node) == AST_DIRECT_COMPONENT_SELECTION);
    237   struct ast_component_selection_node *data = ast_get_data(node);
    238   return data->component;
    239 }
    240 
    241 ast_node_t *ast_get_component_expr(ast_node_t *node)
    242 {
    243   assert(ast_get_node_type(node) == AST_DIRECT_COMPONENT_SELECTION);
    244   struct ast_component_selection_node *data = ast_get_data(node);
    245   return data->expr;
    246 }
    247 
    248 ast_node_t *ast_create_indirect_component_selection_node(ast_node_t *expr, char *component, int line, int column)
    249 {
    250   ast_node_t *node = ast_create_node(AST_INDIRECT_COMPONENT_SELECTION, line, column, sizeof(struct ast_component_selection_node));
    251   struct ast_component_selection_node *data = ast_get_data(node);
    252   data->expr = expr;
    253   data->component = component;
    254   return node;
    255 }
    256 
    257 struct ast_function_call_node {
    258   ast_node_t *expr;
    259   ast_node_t **args;
    260   size_t num_args;
    261 };
    262 
    263 ast_node_t *ast_create_function_call_node(ast_node_t *expr, ast_node_t **args, size_t num_args, int line, int column)
    264 {
    265   ast_node_t *node = ast_create_node(AST_FUNCTION_CALL, line, column, sizeof(struct ast_function_call_node));
    266   struct ast_function_call_node *data = ast_get_data(node);
    267   data->expr = expr;
    268   data->args = args;
    269   data->num_args = num_args;
    270   return node;
    271 }
    272 
    273 ast_node_t *ast_get_function_call_expr(ast_node_t *node)
    274 {
    275   assert(ast_get_node_type(node) == AST_FUNCTION_CALL);
    276   struct ast_function_call_node *data = ast_get_data(node);
    277   return data->expr;
    278 }
    279 
    280 ast_node_t **ast_get_function_call_args(ast_node_t *node, size_t *num_args)
    281 {
    282   assert(ast_get_node_type(node) == AST_FUNCTION_CALL);
    283   struct ast_function_call_node *data = ast_get_data(node);
    284   *num_args = data->num_args;
    285   return data->args;
    286 }
    287 
    288 ast_node_t *ast_create_postfix_inc_node(ast_node_t *expr, int line, int column)
    289 {
    290   ast_node_t *node = ast_create_node(AST_POSTFIX_INC, line, column, sizeof(ast_node_t *));
    291   ast_node_t **data = ast_get_data(node);
    292   *data = expr;
    293   return node;
    294 }
    295 
    296 ast_node_t *ast_create_postfix_dec_node(ast_node_t *expr, int line, int column)
    297 {
    298   ast_node_t *node = ast_create_node(AST_POSTFIX_DEC, line, column, sizeof(ast_node_t *));
    299   ast_node_t **data = ast_get_data(node);
    300   *data = expr;
    301   return node;
    302 }
    303 
    304 ast_node_t *ast_get_postfix_expr(ast_node_t *node)
    305 {
    306   assert(ast_get_node_type(node) == AST_POSTFIX_INC || ast_get_node_type(node) == AST_POSTFIX_DEC);
    307   ast_node_t **data = ast_get_data(node);
    308   return *data;
    309 }
    310 
    311 /* Implementation - Nodes (Unary/Cast) */
    312 
    313 #define AST_CREATE_UNARY_NODE(NODE_TYPE, NODE_NAME) \
    314 ast_node_t *ast_create_##NODE_NAME##_node(ast_node_t *expr, int line, int column) \
    315 { \
    316   ast_node_t *node = ast_create_node(NODE_TYPE, line, column, sizeof(ast_node_t *)); \
    317   ast_node_t **data = ast_get_data(node); \
    318   *data = expr; \
    319   return node; \
    320 }
    321 
    322 AST_CREATE_UNARY_NODE(AST_UNARY_PLUS, unary_plus)
    323 AST_CREATE_UNARY_NODE(AST_UNARY_MINUS, unary_minus)
    324 AST_CREATE_UNARY_NODE(AST_LOGICAL_NOT, logical_not)
    325 AST_CREATE_UNARY_NODE(AST_BITWISE_NOT, bitwise_not)
    326 AST_CREATE_UNARY_NODE(AST_ADDRESS_OF, address_of)
    327 AST_CREATE_UNARY_NODE(AST_INDIRECTION, indirection)
    328 AST_CREATE_UNARY_NODE(AST_SIZEOF, sizeof)
    329 AST_CREATE_UNARY_NODE(AST_PRE_INC, pre_inc)
    330 AST_CREATE_UNARY_NODE(AST_PRE_DEC, pre_dec)
    331 
    332 ast_node_t *ast_create_cast_node(ast_node_t *type, ast_node_t *expr, int line, int column)
    333 {
    334   ast_node_t *node = ast_create_node(AST_CAST, line, column, 2 * sizeof(ast_node_t *));
    335   ast_node_t **data = ast_get_data(node);
    336   data[0] = type;
    337   data[1] = expr;
    338   return node;
    339 }
    340 
    341 ast_node_t *ast_get_unary_expr(ast_node_t *node)
    342 {
    343   assert(ast_get_node_type(node) == AST_UNARY_PLUS || ast_get_node_type(node) == AST_UNARY_MINUS || ast_get_node_type(node) == AST_LOGICAL_NOT || ast_get_node_type(node) == AST_BITWISE_NOT || ast_get_node_type(node) == AST_ADDRESS_OF || ast_get_node_type(node) == AST_INDIRECTION || ast_get_node_type(node) == AST_SIZEOF || ast_get_node_type(node) == AST_PRE_INC || ast_get_node_type(node) == AST_PRE_DEC || ast_get_node_type(node) == AST_CAST);
    344   ast_node_t **data = ast_get_data(node);
    345   return data[0];
    346 }
    347 
    348 ast_node_t *ast_get_cast_type(ast_node_t *node)
    349 {
    350   assert(ast_get_node_type(node) == AST_CAST);
    351   ast_node_t **data = ast_get_data(node);
    352   return data[0];
    353 }
    354 
    355 ast_node_t *ast_get_cast_expr(ast_node_t *node)
    356 {
    357   assert(ast_get_node_type(node) == AST_CAST);
    358   ast_node_t **data = ast_get_data(node);
    359   return data[1];
    360 }
    361 
    362 
    363 /* Implementation - Nodes (Binary/Assign/Comma) */
    364 struct ast_binary_node {
    365   ast_node_t *left;
    366   ast_node_t *right;
    367 };
    368 
    369 // Macro to generate binary AST node creation functions
    370 #define AST_CREATE_BINARY_NODE(NODE_TYPE, NODE_NAME) \
    371 ast_node_t *ast_create_##NODE_NAME##_node(ast_node_t *left, ast_node_t *right, int line, int column) \
    372 { \
    373   ast_node_t *node = ast_create_node(NODE_TYPE, line, column, sizeof(struct ast_binary_node)); \
    374   struct ast_binary_node *data = ast_get_data(node); \
    375   data->left = left; \
    376   data->right = right; \
    377   return node; \
    378 }
    379 
    380 AST_CREATE_BINARY_NODE(AST_MUL, mul)
    381 AST_CREATE_BINARY_NODE(AST_DIV, div)
    382 AST_CREATE_BINARY_NODE(AST_MOD, mod)
    383 AST_CREATE_BINARY_NODE(AST_ADD, add)
    384 AST_CREATE_BINARY_NODE(AST_SUB, sub)
    385 AST_CREATE_BINARY_NODE(AST_LEFT_SHIFT, left_shift)
    386 AST_CREATE_BINARY_NODE(AST_RIGHT_SHIFT, right_shift)
    387 AST_CREATE_BINARY_NODE(AST_LESS_THAN, less_than)
    388 AST_CREATE_BINARY_NODE(AST_GREATER_THAN, greater_than)
    389 AST_CREATE_BINARY_NODE(AST_LESS_THAN_OR_EQUAL, less_than_or_equal)
    390 AST_CREATE_BINARY_NODE(AST_GREATER_THAN_OR_EQUAL, greater_than_or_equal)
    391 AST_CREATE_BINARY_NODE(AST_EQUAL, equal)
    392 AST_CREATE_BINARY_NODE(AST_NOT_EQUAL, not_equal)
    393 AST_CREATE_BINARY_NODE(AST_BITWISE_AND, bitwise_and)
    394 AST_CREATE_BINARY_NODE(AST_BITWISE_XOR, bitwise_xor)
    395 AST_CREATE_BINARY_NODE(AST_BITWISE_OR, bitwise_or)
    396 AST_CREATE_BINARY_NODE(AST_LOGICAL_AND, logical_and)
    397 AST_CREATE_BINARY_NODE(AST_LOGICAL_OR, logical_or)
    398 AST_CREATE_BINARY_NODE(AST_ASSIGN, assign)
    399 AST_CREATE_BINARY_NODE(AST_ADD_ASSIGN, add_assign)
    400 AST_CREATE_BINARY_NODE(AST_SUB_ASSIGN, sub_assign)
    401 AST_CREATE_BINARY_NODE(AST_MUL_ASSIGN, mul_assign)
    402 AST_CREATE_BINARY_NODE(AST_DIV_ASSIGN, div_assign)
    403 AST_CREATE_BINARY_NODE(AST_MOD_ASSIGN, mod_assign)
    404 AST_CREATE_BINARY_NODE(AST_LEFT_SHIFT_ASSIGN, left_shift_assign)
    405 AST_CREATE_BINARY_NODE(AST_RIGHT_SHIFT_ASSIGN, right_shift_assign)
    406 AST_CREATE_BINARY_NODE(AST_AND_ASSIGN, bitwise_and_assign)
    407 AST_CREATE_BINARY_NODE(AST_XOR_ASSIGN, bitwise_xor_assign)
    408 AST_CREATE_BINARY_NODE(AST_OR_ASSIGN, bitwise_or_assign)
    409 AST_CREATE_BINARY_NODE(AST_COMMA, comma)
    410 
    411 ast_node_t *ast_get_left_expr(ast_node_t *node)
    412 {
    413   assert(ast_get_node_type(node) == AST_MUL || ast_get_node_type(node) == AST_DIV || ast_get_node_type(node) == AST_MOD
    414   || ast_get_node_type(node) == AST_ADD || ast_get_node_type(node) == AST_SUB || ast_get_node_type(node) == AST_LEFT_SHIFT 
    415   || ast_get_node_type(node) == AST_RIGHT_SHIFT || ast_get_node_type(node) == AST_LESS_THAN || ast_get_node_type(node) == AST_GREATER_THAN 
    416   || ast_get_node_type(node) == AST_LESS_THAN_OR_EQUAL || ast_get_node_type(node) == AST_GREATER_THAN_OR_EQUAL 
    417   || ast_get_node_type(node) == AST_EQUAL || ast_get_node_type(node) == AST_NOT_EQUAL 
    418   || ast_get_node_type(node) == AST_BITWISE_AND || ast_get_node_type(node) == AST_BITWISE_XOR || ast_get_node_type(node) == AST_BITWISE_OR 
    419   || ast_get_node_type(node) == AST_LOGICAL_AND || ast_get_node_type(node) == AST_LOGICAL_OR || ast_get_node_type(node) == AST_ASSIGN 
    420   || ast_get_node_type(node) == AST_ADD_ASSIGN || ast_get_node_type(node) == AST_SUB_ASSIGN || ast_get_node_type(node) == AST_MUL_ASSIGN || ast_get_node_type(node) == AST_DIV_ASSIGN 
    421   || ast_get_node_type(node) == AST_MOD_ASSIGN || ast_get_node_type(node) == AST_LEFT_SHIFT_ASSIGN || ast_get_node_type(node) == AST_RIGHT_SHIFT_ASSIGN || ast_get_node_type(node) == AST_AND_ASSIGN 
    422   || ast_get_node_type(node) == AST_XOR_ASSIGN || ast_get_node_type(node) == AST_OR_ASSIGN || ast_get_node_type(node) == AST_COMMA);
    423   struct ast_binary_node *data = ast_get_data(node);
    424   return data->left;
    425 }
    426 
    427 ast_node_t *ast_get_right_expr(ast_node_t *node)
    428 {
    429   assert(ast_get_node_type(node) == AST_MUL || ast_get_node_type(node) == AST_DIV || ast_get_node_type(node) == AST_MOD
    430   || ast_get_node_type(node) == AST_ADD || ast_get_node_type(node) == AST_SUB || ast_get_node_type(node) == AST_LEFT_SHIFT 
    431   || ast_get_node_type(node) == AST_RIGHT_SHIFT || ast_get_node_type(node) == AST_LESS_THAN || ast_get_node_type(node) == AST_GREATER_THAN 
    432   || ast_get_node_type(node) == AST_LESS_THAN_OR_EQUAL || ast_get_node_type(node) == AST_GREATER_THAN_OR_EQUAL 
    433   || ast_get_node_type(node) == AST_EQUAL || ast_get_node_type(node) == AST_NOT_EQUAL 
    434   || ast_get_node_type(node) == AST_BITWISE_AND || ast_get_node_type(node) == AST_BITWISE_XOR || ast_get_node_type(node) == AST_BITWISE_OR 
    435   || ast_get_node_type(node) == AST_LOGICAL_AND || ast_get_node_type(node) == AST_LOGICAL_OR || ast_get_node_type(node) == AST_ASSIGN 
    436   || ast_get_node_type(node) == AST_ADD_ASSIGN || ast_get_node_type(node) == AST_SUB_ASSIGN || ast_get_node_type(node) == AST_MUL_ASSIGN || ast_get_node_type(node) == AST_DIV_ASSIGN 
    437   || ast_get_node_type(node) == AST_MOD_ASSIGN || ast_get_node_type(node) == AST_LEFT_SHIFT_ASSIGN || ast_get_node_type(node) == AST_RIGHT_SHIFT_ASSIGN || ast_get_node_type(node) == AST_AND_ASSIGN 
    438   || ast_get_node_type(node) == AST_XOR_ASSIGN || ast_get_node_type(node) == AST_OR_ASSIGN || ast_get_node_type(node) == AST_COMMA);
    439   struct ast_binary_node *data = ast_get_data(node);
    440   return data->right;
    441 }
    442 
    443 
    444 /* Implementation - Nodes (Conditional) */
    445 struct ast_conditional_node {
    446   ast_node_t *condition;
    447   ast_node_t *true_expr;
    448   ast_node_t *false_expr;
    449 };
    450 
    451 ast_node_t *ast_create_conditional_node(ast_node_t *condition, ast_node_t *true_expr, ast_node_t *false_expr, int line, int column)
    452 {
    453   ast_node_t *node = ast_create_node(AST_CONDITIONAL, line, column, sizeof(struct ast_conditional_node));
    454   struct ast_conditional_node *data = ast_get_data(node);
    455   data->condition = condition;
    456   data->true_expr = true_expr;
    457   data->false_expr = false_expr;
    458   return node;
    459 }
    460 
    461 ast_node_t *ast_get_conditional_condition(ast_node_t *node)
    462 {
    463   assert(ast_get_node_type(node) == AST_CONDITIONAL);
    464   struct ast_conditional_node *data = ast_get_data(node);
    465   return data->condition;
    466 }
    467 
    468 ast_node_t *ast_get_conditional_true_expr(ast_node_t *node)
    469 {
    470   assert(ast_get_node_type(node) == AST_CONDITIONAL);
    471   struct ast_conditional_node *data = ast_get_data(node);
    472   return data->true_expr;
    473 }
    474 
    475 ast_node_t *ast_get_conditional_false_expr(ast_node_t *node)
    476 {
    477   assert(ast_get_node_type(node) == AST_CONDITIONAL);
    478   struct ast_conditional_node *data = ast_get_data(node);
    479   return data->false_expr;
    480 }
    481 
    482 
    483 /* Implementation - Nodes (Expression Statement Nodes) */
    484 struct ast_expression_statement_node {
    485   ast_node_t *expr;
    486 };
    487 
    488 ast_node_t *ast_create_expression_statement_node(ast_node_t *expr)
    489 {
    490   ast_node_t *node = ast_create_node(AST_EXPRESSION_STATEMENT, expr->line, expr->column, sizeof(struct ast_expression_statement_node));
    491   struct ast_expression_statement_node *data = ast_get_data(node);
    492   data->expr = expr;
    493   return node;
    494 }
    495 
    496 ast_node_t *ast_get_expression_statement_expr(ast_node_t *node)
    497 {
    498   assert(ast_get_node_type(node) == AST_EXPRESSION_STATEMENT);
    499   struct ast_expression_statement_node *data = ast_get_data(node);
    500   return data->expr;
    501 }
    502 
    503 
    504 /* Implementation - Nodes (Label/Case Statement Nodes) */
    505 struct ast_label_statement_node {
    506   char *label;
    507 };
    508 
    509 ast_node_t *ast_create_label_statement_node(char *label, int line, int col)
    510 {
    511   ast_node_t *node = ast_create_node(AST_LABEL_STATEMENT, line, col, sizeof(struct ast_label_statement_node));
    512   struct ast_label_statement_node *data = ast_get_data(node);
    513   data->label = label;
    514   return node;
    515 }
    516 
    517 char *ast_get_label_statement_label(ast_node_t *node)
    518 {
    519   assert(ast_get_node_type(node) == AST_LABEL_STATEMENT);
    520   struct ast_label_statement_node *data = ast_get_data(node);
    521   return data->label;
    522 }
    523 
    524 ast_node_t *ast_create_case_statement_node(ast_node_t *expr, int line, int col)
    525 {
    526   ast_node_t *node = ast_create_node(AST_CASE_STATEMENT, line, col, sizeof(ast_node_t *));
    527   ast_node_t **data = ast_get_data(node);
    528   *data = expr;
    529   return node;
    530 }
    531 
    532 ast_node_t *ast_get_case_statement_expr(ast_node_t *node)
    533 {
    534   assert(ast_get_node_type(node) == AST_CASE_STATEMENT);
    535   ast_node_t **data = ast_get_data(node);
    536   return *data;
    537 }
    538 
    539 ast_node_t *ast_create_default_statement_node(int line, int col)
    540 {
    541   return ast_create_node(AST_DEFAULT_STATEMENT, line, col, 0);
    542 }
    543 
    544 /* Implementation - Nodes (Compound Statement Nodes) */
    545 struct ast_compound_statement_node {
    546   ast_node_t **decls_and_stmts;
    547   size_t num_decls_and_stmts;
    548 };
    549 
    550 ast_node_t *ast_create_compound_statement_node(ast_node_t **decls_and_stmts, size_t num_decls_and_stmts, int line, int col)
    551 {
    552   ast_node_t *node = ast_create_node(AST_COMPOUND_STATEMENT, line, col, sizeof(struct ast_compound_statement_node));
    553   struct ast_compound_statement_node *data = ast_get_data(node);
    554   data->decls_and_stmts = decls_and_stmts;
    555   data->num_decls_and_stmts = num_decls_and_stmts;
    556   return node;
    557 }
    558 
    559 ast_node_t **ast_get_compound_statement_contents(ast_node_t *node, size_t *num_contents)
    560 {
    561   assert(ast_get_node_type(node) == AST_COMPOUND_STATEMENT);
    562   struct ast_compound_statement_node *data = ast_get_data(node);
    563   *num_contents = data->num_decls_and_stmts;
    564   return data->decls_and_stmts;
    565 }
    566 
    567 
    568 /* Implementation - Nodes (Conditional Statement Nodes) */
    569 struct ast_if_statement_node {
    570   ast_node_t *condition;
    571   ast_node_t *true_stmt;
    572   ast_node_t *false_stmt;
    573 };
    574 
    575 ast_node_t *ast_create_if_statement_node(ast_node_t *condition, ast_node_t *true_stmt, ast_node_t *false_stmt, int line, int col)
    576 {
    577   ast_node_t *node = ast_create_node(AST_IF_STATEMENT, line, col, sizeof(struct ast_if_statement_node));
    578   struct ast_if_statement_node *data = ast_get_data(node);
    579   data->condition = condition;
    580   data->true_stmt = true_stmt;
    581   data->false_stmt = false_stmt;
    582   return node;
    583 }
    584 
    585 ast_node_t *ast_get_if_statement_condition(ast_node_t *node)
    586 {
    587   assert(ast_get_node_type(node) == AST_IF_STATEMENT);
    588   struct ast_if_statement_node *data = ast_get_data(node);
    589   return data->condition;
    590 }
    591 
    592 ast_node_t *ast_get_if_statement_true_stmt(ast_node_t *node)
    593 {
    594   assert(ast_get_node_type(node) == AST_IF_STATEMENT);
    595   struct ast_if_statement_node *data = ast_get_data(node);
    596   return data->true_stmt;
    597 }
    598 
    599 ast_node_t *ast_get_if_statement_false_stmt(ast_node_t *node)
    600 {
    601   assert(ast_get_node_type(node) == AST_IF_STATEMENT);
    602   struct ast_if_statement_node *data = ast_get_data(node);
    603   return data->false_stmt;
    604 }
    605 
    606 
    607 /* Implementation - Nodes (Iteration Statement Nodes) */
    608 
    609 struct ast_iteration_statement_node {
    610   ast_node_t *condition;
    611   ast_node_t *stmt;
    612 };
    613 
    614 ast_node_t *ast_create_while_statement_node(ast_node_t *condition, ast_node_t *stmt, int line, int col)
    615 {
    616   ast_node_t *node = ast_create_node(AST_WHILE_STATEMENT, line, col, sizeof(struct ast_iteration_statement_node));
    617   struct ast_iteration_statement_node *data = ast_get_data(node);
    618   data->condition = condition;
    619   data->stmt = stmt;
    620   return node;
    621 }
    622 
    623 ast_node_t *ast_create_do_while_statement_node(ast_node_t *condition, ast_node_t *stmt, int line, int col)
    624 {
    625   ast_node_t *node = ast_create_node(AST_DO_WHILE_STATEMENT, line, col, sizeof(struct ast_iteration_statement_node));
    626   struct ast_iteration_statement_node *data = ast_get_data(node);
    627   data->condition = condition;
    628   data->stmt = stmt;
    629   return node;
    630 }
    631 
    632 // Shares the first two members with ast_iteration_statement_node
    633 struct ast_for_statement_node {  
    634   ast_node_t *condition;  
    635   ast_node_t *stmt;
    636   ast_node_t *init;
    637   ast_node_t *update;
    638 
    639 };
    640 
    641 ast_node_t *ast_create_for_statement_node(ast_node_t *init, ast_node_t *condition, ast_node_t *update, ast_node_t *stmt, int line, int col)
    642 {
    643   ast_node_t *node = ast_create_node(AST_FOR_STATEMENT, line, col, sizeof(struct ast_for_statement_node));
    644   struct ast_for_statement_node *data = ast_get_data(node);
    645   data->init = init;
    646   data->condition = condition;
    647   data->update = update;
    648   data->stmt = stmt;
    649   return node;
    650 }
    651 
    652 ast_node_t *ast_get_iteration_statement_condition(ast_node_t *node)
    653 {
    654   assert(ast_get_node_type(node) == AST_WHILE_STATEMENT || ast_get_node_type(node) == AST_DO_WHILE_STATEMENT || ast_get_node_type(node) == AST_FOR_STATEMENT);
    655   struct ast_iteration_statement_node *data = ast_get_data(node);
    656   return data->condition;
    657 }
    658 
    659 ast_node_t *ast_get_iteration_statement_stmt(ast_node_t *node)
    660 {
    661   assert(ast_get_node_type(node) == AST_WHILE_STATEMENT || ast_get_node_type(node) == AST_DO_WHILE_STATEMENT || ast_get_node_type(node) == AST_FOR_STATEMENT);
    662   struct ast_iteration_statement_node *data = ast_get_data(node);
    663   return data->stmt;
    664 }
    665 
    666 ast_node_t *ast_get_for_statement_init(ast_node_t *node)
    667 {
    668   assert(ast_get_node_type(node) == AST_FOR_STATEMENT);
    669   struct ast_for_statement_node *data = ast_get_data(node);
    670   return data->init;
    671 }
    672 
    673 ast_node_t *ast_get_for_statement_update(ast_node_t *node)
    674 {
    675   assert(ast_get_node_type(node) == AST_FOR_STATEMENT);
    676   struct ast_for_statement_node *data = ast_get_data(node);
    677   return data->update;
    678 }
    679 
    680 /* Implementation - Nodes (Jump Statement Nodes) */
    681 struct ast_goto_statement_node {
    682   char *label;
    683 };
    684 
    685 ast_node_t *ast_create_goto_statement_node(char *label, int line, int col)
    686 {
    687   ast_node_t *node = ast_create_node(AST_GOTO_STATEMENT, line, col, sizeof(struct ast_goto_statement_node));
    688   struct ast_goto_statement_node *data = ast_get_data(node);
    689   data->label = label;
    690   return node;
    691 }
    692 
    693 char *ast_get_goto_statement_label(ast_node_t *node)
    694 {
    695   assert(ast_get_node_type(node) == AST_GOTO_STATEMENT);
    696   struct ast_goto_statement_node *data = ast_get_data(node);
    697   return data->label;
    698 }
    699 
    700 ast_node_t *ast_create_continue_statement_node(int line, int col)
    701 {
    702   return ast_create_node(AST_CONTINUE_STATEMENT, line, col, 0);
    703 }
    704 
    705 ast_node_t *ast_create_break_statement_node(int line, int col)
    706 {
    707   return ast_create_node(AST_BREAK_STATEMENT, line, col, 0);
    708 }
    709 
    710 ast_node_t *ast_create_return_statement_node(ast_node_t *expr, int line, int col)
    711 {
    712   ast_node_t *node = ast_create_node(AST_RETURN_STATEMENT, line, col, sizeof(ast_node_t *));
    713   ast_node_t **data = ast_get_data(node);
    714   *data = expr;
    715   return node;
    716 }
    717 
    718 ast_node_t *ast_get_return_statement_expr(ast_node_t *node)
    719 {
    720   assert(ast_get_node_type(node) == AST_RETURN_STATEMENT);
    721   ast_node_t **data = ast_get_data(node);
    722   return *data;
    723 }
    724 
    725 
    726 /* Implementation - Nodes (Switch Statement Nodes) */
    727 
    728 struct ast_switch_statement_node {
    729   ast_node_t *expr;
    730   ast_node_t *stmt;
    731 };
    732 
    733 ast_node_t *ast_create_switch_statement_node(ast_node_t *expr, ast_node_t *stmt, int line, int col)
    734 {
    735   ast_node_t *node = ast_create_node(AST_SWITCH_STATEMENT, line, col, sizeof(struct ast_switch_statement_node));
    736   struct ast_switch_statement_node *data = ast_get_data(node);
    737   data->expr = expr;
    738   data->stmt = stmt;
    739   return node;
    740 }
    741 
    742 ast_node_t *ast_get_switch_statement_expr(ast_node_t *node)
    743 {
    744   assert(ast_get_node_type(node) == AST_SWITCH_STATEMENT);
    745   struct ast_switch_statement_node *data = ast_get_data(node);
    746   return data->expr;
    747 }
    748 
    749 ast_node_t *ast_get_switch_statement_stmt(ast_node_t *node)
    750 {
    751   assert(ast_get_node_type(node) == AST_SWITCH_STATEMENT);
    752   struct ast_switch_statement_node *data = ast_get_data(node);
    753   return data->stmt;
    754 }
    755 
    756 /* Implementation - Nodes (Simple Declaration Nodes) */
    757 struct var_decl_data {
    758   ast_node_t *type;
    759   char *id;
    760 };
    761 
    762 ast_node_t *ast_create_var_decl_node(ast_node_t *type, char *id, int line, int col)
    763 {
    764   ast_node_t *node = ast_create_node(AST_VAR_DECL, line, col, sizeof(struct var_decl_data));
    765     struct var_decl_data *data = ast_get_data(node);
    766   data->type = type;
    767   data->id = id;
    768   return (ast_node_t *)data;
    769 }
    770 
    771 ast_node_t *ast_get_var_decl_type(ast_node_t *node)
    772 {
    773   struct var_decl_data *data = ast_get_data(node);
    774   return data->type;
    775 }
    776 
    777 char *ast_get_var_decl_id(ast_node_t *node)
    778 {
    779   struct var_decl_data *data = ast_get_data(node);
    780   return data->id;
    781 }
    782 
    783 struct fun_decl_data {
    784   ast_node_t *type;
    785   char *id;
    786     ast_node_t **params;
    787   size_t num_params;
    788 };
    789 
    790 ast_node_t *ast_create_fun_decl_node(ast_node_t *type, char *id, ast_node_t **params, size_t num_params, int line, int col)
    791 {
    792   ast_node_t *node = ast_create_node(AST_FUN_DECL, line, col, sizeof(struct fun_decl_data));
    793     struct fun_decl_data *data = ast_get_data(node);
    794   data->type = type;
    795   data->id = id;
    796   data->params = params;
    797   data->num_params = num_params;
    798   return (ast_node_t *)data;
    799 }
    800 
    801 ast_node_t *ast_get_fun_decl_type(ast_node_t *node)
    802 {
    803   struct fun_decl_data *data = ast_get_data(node);
    804   return data->type;
    805 }
    806 
    807 char *ast_get_fun_decl_id(ast_node_t *node)
    808 {
    809   struct fun_decl_data *data = ast_get_data(node);
    810   return data->id;
    811 }
    812 
    813 ast_node_t **ast_get_fun_decl_params(ast_node_t *node, size_t *num_params)
    814 {
    815   struct fun_decl_data *data = ast_get_data(node);
    816   *num_params = data->num_params;
    817   return data->params;
    818 }
    819 
    820 
    821 /* Implementation - Nodes (Parameter Declaration Nodes) */
    822 struct param_data {
    823   ast_node_t *type;
    824   char *id;
    825 };
    826 
    827 ast_node_t *ast_create_param_node(ast_node_t *type, char *id, int line, int col)
    828 {
    829   ast_node_t *node = ast_create_node(AST_PARAM, line, col, sizeof(struct param_data));
    830     struct param_data *data = ast_get_data(node);
    831   data->type = type;
    832   data->id = id;
    833   return node;
    834 }
    835 
    836 ast_node_t *ast_get_param_type(ast_node_t *node)
    837 {
    838   struct param_data *data = ast_get_data(node);
    839   return data->type;
    840 }
    841 
    842 char *ast_get_param_id(ast_node_t *node)
    843 {
    844   struct param_data *data = ast_get_data(node);
    845   return data->id;
    846 }
    847 
    848 
    849 /* Implementation - Nodes (Function Definition Nodes) */
    850 
    851 struct fun_def_data {
    852   ast_node_t *type;
    853   char *id;
    854   ast_node_t **params;
    855   size_t num_params;
    856   ast_node_t *stmt;
    857 };
    858 
    859 ast_node_t *ast_create_fun_def_node(ast_node_t *type, char *id, ast_node_t **params, size_t num_params, ast_node_t *stmt, int line, int col)
    860 {
    861   ast_node_t *node = ast_create_node(AST_FUN_DEF, line, col, sizeof(struct fun_def_data));
    862     struct fun_def_data *data = ast_get_data(node);
    863   data->type = type;
    864   data->id = id;
    865   data->params = params;
    866   data->num_params = num_params;
    867   data->stmt = stmt;
    868   return node;
    869 }
    870 
    871 ast_node_t *ast_get_fun_def_type(ast_node_t *node)
    872 {
    873   struct fun_def_data *data = ast_get_data(node);
    874   return data->type;
    875 }
    876 
    877 char *ast_get_fun_def_id(ast_node_t *node)
    878 {
    879   struct fun_def_data *data = ast_get_data(node);
    880   return data->id;
    881 }
    882 
    883 ast_node_t **ast_get_fun_def_params(ast_node_t *node, size_t *num_params)
    884 {
    885   struct fun_def_data *data = ast_get_data(node);
    886   *num_params = data->num_params;
    887   return data->params;
    888 }
    889 
    890 ast_node_t *ast_get_fun_def_stmt(ast_node_t *node)
    891 {
    892   struct fun_def_data *data = ast_get_data(node);
    893   return data->stmt;
    894 }
    895 
    896 
    897 /* Implementation - Nodes (Struct Declaration Nodes) */
    898 struct struct_decl_data {
    899   char *id;
    900   ast_node_t **members;
    901   size_t num_members;
    902 };
    903 
    904 ast_node_t *ast_create_struct_decl_node(char *id, ast_node_t **members, size_t num_members, int line, int col)
    905 {
    906   ast_node_t *node = ast_create_node(AST_STRUCT_DECL, line, col, sizeof(struct struct_decl_data));
    907   struct struct_decl_data *data = ast_get_data(node);   
    908   data->id = id;
    909   data->members = members;
    910   data->num_members = num_members;
    911   return node;
    912 }
    913 
    914 char *ast_get_struct_decl_id(ast_node_t *node)
    915 {
    916   struct struct_decl_data *data = ast_get_data(node);
    917   return data->id;
    918 }
    919 
    920 ast_node_t **ast_get_struct_decl_members(ast_node_t *node, size_t *num_members)
    921 {
    922   struct struct_decl_data *data = ast_get_data(node);
    923   *num_members = data->num_members;
    924   return data->members;
    925 }
    926 
    927 /* Implementation - Nodes (Union Declaration Nodes) */
    928 struct union_decl_data {
    929   char *id;
    930   ast_node_t **members;
    931   size_t num_members;
    932 };
    933 
    934 ast_node_t *ast_create_union_decl_node(char *id, ast_node_t **members, size_t num_members, int line, int col)
    935 {
    936   ast_node_t *node = ast_create_node(AST_UNION_DECL, line, col, sizeof(struct union_decl_data));
    937     struct union_decl_data *data = ast_get_data(node);
    938   data->id = id;
    939   data->members = members;
    940   data->num_members = num_members;
    941   return node;
    942 }
    943 
    944 char *ast_get_union_decl_id(ast_node_t *node)
    945 {
    946   struct union_decl_data *data = ast_get_data(node);
    947   return data->id;
    948 }
    949 
    950 ast_node_t **ast_get_union_decl_members(ast_node_t *node, size_t *num_members)
    951 {
    952   struct union_decl_data *data = ast_get_data(node);
    953   *num_members = data->num_members;
    954   return data->members;
    955 }
    956 
    957 
    958 /* Implementation - Nodes (Enum Declaration Nodes) */
    959 struct enum_decl_data {
    960   char *id;
    961   ast_node_t **enums;
    962   size_t num_enums;
    963 };
    964 
    965 ast_node_t *ast_create_enum_decl_node(char *id, ast_node_t **enums, size_t num_enums, int line, int col)
    966 {
    967   ast_node_t *node = ast_create_node(AST_ENUM_DECL, line, col, sizeof(struct enum_decl_data));
    968     struct enum_decl_data *data = ast_get_data(node);
    969   data->id = id;
    970   data->enums = enums;
    971   data->num_enums = num_enums;
    972   return node;
    973 }
    974 
    975 char *ast_get_enum_decl_id(ast_node_t *node)
    976 {
    977   struct enum_decl_data *data = ast_get_data(node);
    978   return data->id;
    979 }
    980 
    981 ast_node_t **ast_get_enum_decl_enums(ast_node_t *node, size_t *num_enums)
    982 {
    983   struct enum_decl_data *data = ast_get_data(node);
    984   *num_enums = data->num_enums;
    985   return data->enums;
    986 }
    987 
    988 
    989 /* Implementation - Nodes (Typedef Declaration Nodes) */
    990 struct typedef_data {
    991   ast_node_t *type;
    992   char *id;
    993 };
    994 
    995 ast_node_t *ast_create_typedef_node(ast_node_t *type, char *id, int line, int col)
    996 {
    997   ast_node_t *node = ast_create_node(AST_TYPEDEF, line, col, sizeof(struct typedef_data));
    998     struct typedef_data *data = ast_get_data(node);
    999   data->type = type;
   1000   data->id = id;
   1001   return node;
   1002 }
   1003 
   1004 ast_node_t *ast_get_typedef_type(ast_node_t *node)
   1005 {
   1006   struct typedef_data *data = ast_get_data(node);
   1007   return data->type;
   1008 }
   1009 
   1010 char *ast_get_typedef_id(ast_node_t *node)
   1011 {
   1012   struct typedef_data *data = ast_get_data(node);
   1013   return data->id;
   1014 }
   1015 
   1016 
   1017 /* Implementation - Nodes (Types/Members) */
   1018 struct type_data {
   1019   token_t **type;
   1020   size_t num_type;
   1021 };
   1022 
   1023 ast_node_t *ast_create_type_node(token_t *type[], size_t num_type, int line, int col)
   1024 {
   1025   ast_node_t *node = ast_create_node(AST_TYPE, line, col, sizeof(struct type_data));
   1026     struct type_data *data = ast_get_data(node);
   1027   data->type = type;
   1028   data->num_type = num_type;
   1029   return node;
   1030 }
   1031 
   1032 token_t **ast_get_type(ast_node_t *node, size_t *num_type)
   1033 {
   1034   struct type_data *data = ast_get_data(node);
   1035   *num_type = data->num_type;
   1036   return data->type;
   1037 }
   1038 
   1039 struct member_data {
   1040   ast_node_t *type;
   1041   char *id;
   1042 };
   1043 
   1044 ast_node_t *ast_create_member_node(ast_node_t *type, char *id, int line, int col)
   1045 {
   1046   ast_node_t *node = ast_create_node(AST_MEMBER, line, col, sizeof(struct member_data));
   1047     struct member_data *data = ast_get_data(node);
   1048   data->type = type;
   1049   data->id = id;
   1050   return node;
   1051 }
   1052 
   1053 ast_node_t *ast_get_member_type(ast_node_t *node)
   1054 {
   1055   struct member_data *data = ast_get_data(node);
   1056   return data->type;
   1057 }
   1058 
   1059 char *ast_get_member_id(ast_node_t *node)
   1060 {
   1061   struct member_data *data = ast_get_data(node);
   1062   return data->id;
   1063 }
   1064 
   1065 struct enum_member_data {
   1066   char *id;
   1067   ast_node_t *value;
   1068 };
   1069 
   1070 ast_node_t *ast_create_enum_member_node(char *id, ast_node_t *value, int line, int col)
   1071 {
   1072   ast_node_t *node = ast_create_node(AST_ENUM_MEMBER, line, col, sizeof(struct enum_member_data));
   1073     struct enum_member_data *data = ast_get_data(node);
   1074   data->id = id;
   1075   data->value = value;
   1076   return node;
   1077 }
   1078 
   1079 char *ast_get_enum_member_id(ast_node_t *node)
   1080 {
   1081   struct enum_member_data *data = ast_get_data(node);
   1082   return data->id;
   1083 }
   1084 
   1085 ast_node_t *ast_get_enum_member_expr(ast_node_t *node)
   1086 {
   1087   struct enum_member_data *data = ast_get_data(node);
   1088   return data->value;
   1089 }
   1090 
   1091 
   1092 /* Implementation - Nodes (Translation Unit Nodes) */
   1093 struct translation_unit_data {
   1094   ast_node_t **items;
   1095   size_t num_items;
   1096 };
   1097 
   1098 ast_node_t *ast_create_translation_unit_node(ast_node_t **items, size_t num_items, int line, int col)
   1099 {
   1100   ast_node_t *node = ast_create_node(AST_TRANSLATION_UNIT, line, col, sizeof(struct translation_unit_data));
   1101     struct translation_unit_data *data = ast_get_data(node);
   1102   data->items = items;
   1103   data->num_items = num_items;
   1104   return node;
   1105 }
   1106 
   1107 ast_node_t **ast_get_translation_unit_items(ast_node_t *node, size_t *num_items)
   1108 {
   1109   struct translation_unit_data *data = ast_get_data(node);
   1110   *num_items = data->num_items;
   1111   return data->items;
   1112 }
   1113 
   1114 /* Implementation - Nodes (Freeing) */
   1115 void ast_free_node(ast_node_t *node) {
   1116   if (!node) {
   1117     return;
   1118   }
   1119   switch (ast_get_node_type(node)) {
   1120   case AST_INTU32:
   1121   case AST_INTU64:
   1122   case AST_INTS32:
   1123   case AST_INTS64:
   1124   case AST_FLOAT:
   1125   case AST_DOUBLE:
   1126   case AST_STRING:
   1127   case AST_CHAR:
   1128   case AST_VAR:
   1129     break;
   1130   case AST_SUBSCRIPT:
   1131     ast_free_node(ast_get_subscript_expr(node));
   1132     ast_free_node(ast_get_subscript_idx(node));
   1133     free(node);
   1134     break;
   1135   case AST_DIRECT_COMPONENT_SELECTION:
   1136   case AST_INDIRECT_COMPONENT_SELECTION:
   1137     ast_free_node(ast_get_component_expr(node));
   1138     free(node);
   1139     break;
   1140   case AST_FUNCTION_CALL: {
   1141     size_t num_args;
   1142     ast_node_t **args = ast_get_function_call_args(node, &num_args);
   1143     for (size_t i = 0; i < num_args; i++) {
   1144       ast_free_node(args[i]);
   1145     }
   1146     free(args);
   1147     ast_free_node(ast_get_function_call_expr(node));
   1148     free(node);
   1149     break;
   1150   }
   1151   case AST_POSTFIX_INC:
   1152   case AST_POSTFIX_DEC: {
   1153     ast_free_node(ast_get_postfix_expr(node));
   1154     free(node);
   1155     break;
   1156   }
   1157   case AST_UNARY_PLUS:
   1158   case AST_UNARY_MINUS:
   1159   case AST_LOGICAL_NOT:
   1160   case AST_BITWISE_NOT:
   1161   case AST_ADDRESS_OF:
   1162   case AST_INDIRECTION:
   1163   case AST_SIZEOF:
   1164   case AST_PRE_INC:
   1165   case AST_PRE_DEC: {
   1166     ast_free_node(ast_get_unary_expr(node));
   1167     free(node);
   1168     break;
   1169   }
   1170   case AST_CAST: {
   1171     ast_free_node(ast_get_cast_type(node));
   1172     ast_free_node(ast_get_cast_expr(node));
   1173     free(node);
   1174     break;
   1175   }
   1176   case AST_MUL:
   1177   case AST_DIV:
   1178   case AST_MOD:
   1179   case AST_ADD:
   1180   case AST_SUB:
   1181   case AST_LEFT_SHIFT:
   1182   case AST_RIGHT_SHIFT:
   1183   case AST_LESS_THAN:
   1184   case AST_GREATER_THAN:
   1185   case AST_LESS_THAN_OR_EQUAL:
   1186   case AST_GREATER_THAN_OR_EQUAL:
   1187   case AST_EQUAL:
   1188   case AST_NOT_EQUAL:
   1189   case AST_BITWISE_AND:
   1190   case AST_BITWISE_XOR:
   1191   case AST_BITWISE_OR:
   1192   case AST_LOGICAL_AND:
   1193   case AST_LOGICAL_OR:
   1194   case AST_COMMA:
   1195   case AST_ASSIGN:
   1196   case AST_ADD_ASSIGN:
   1197   case AST_SUB_ASSIGN:
   1198   case AST_MUL_ASSIGN:
   1199   case AST_DIV_ASSIGN:
   1200   case AST_MOD_ASSIGN:
   1201   case AST_LEFT_SHIFT_ASSIGN:
   1202   case AST_RIGHT_SHIFT_ASSIGN:
   1203   case AST_AND_ASSIGN:
   1204   case AST_XOR_ASSIGN:
   1205   case AST_OR_ASSIGN:
   1206  {
   1207     ast_free_node(ast_get_left_expr(node));
   1208     ast_free_node(ast_get_right_expr(node));
   1209     free(node);
   1210     break;
   1211   }
   1212   case AST_CONDITIONAL: {
   1213     ast_free_node(ast_get_conditional_condition(node));
   1214     ast_free_node(ast_get_conditional_true_expr(node));
   1215     ast_free_node(ast_get_conditional_false_expr(node));
   1216     free(node);
   1217     break;
   1218   }
   1219   case AST_EXPRESSION_STATEMENT:
   1220     ast_free_node(ast_get_expression_statement_expr(node));
   1221     free(node);
   1222     break;
   1223   case AST_LABEL_STATEMENT:
   1224     free(node);
   1225     break;
   1226   case AST_CASE_STATEMENT:
   1227     ast_free_node(ast_get_case_statement_expr(node));
   1228     free(node);
   1229     break;
   1230   case AST_DEFAULT_STATEMENT:
   1231     free(node);
   1232     break;
   1233   case AST_COMPOUND_STATEMENT:
   1234     {
   1235       size_t size = 0;
   1236       ast_node_t **comp_stmts = ast_get_compound_statement_contents(node, &size);
   1237       for(size_t i = 0; i < size; i++)
   1238       {
   1239         ast_free_node(comp_stmts[i]);
   1240       }
   1241       free(comp_stmts);
   1242       free(node);
   1243       break;
   1244     }
   1245   case AST_IF_STATEMENT:
   1246   {
   1247     ast_free_node(ast_get_if_statement_condition(node));
   1248     ast_free_node(ast_get_if_statement_true_stmt(node));
   1249     ast_free_node(ast_get_if_statement_false_stmt(node));
   1250     free(node);
   1251     break;
   1252   }
   1253   case AST_WHILE_STATEMENT:
   1254   case AST_DO_WHILE_STATEMENT:
   1255   {
   1256     ast_free_node(ast_get_iteration_statement_condition(node));
   1257     ast_free_node(ast_get_iteration_statement_stmt(node));
   1258     free(node);
   1259     break;
   1260   }
   1261   case AST_FOR_STATEMENT:
   1262   {
   1263     ast_free_node(ast_get_for_statement_init(node));
   1264     ast_free_node(ast_get_iteration_statement_condition(node));
   1265     ast_free_node(ast_get_for_statement_update(node));
   1266     ast_free_node(ast_get_iteration_statement_stmt(node));
   1267     free(node);
   1268     break;
   1269   }
   1270   case AST_GOTO_STATEMENT:
   1271     free(node);
   1272     break;
   1273   case AST_CONTINUE_STATEMENT:
   1274   case AST_BREAK_STATEMENT:
   1275     free(node);
   1276     break;
   1277   case AST_RETURN_STATEMENT:
   1278     ast_free_node(ast_get_return_statement_expr(node));
   1279     free(node);
   1280     break;
   1281   case AST_SWITCH_STATEMENT:
   1282   {
   1283     ast_free_node(ast_get_switch_statement_expr(node));
   1284     ast_free_node(ast_get_switch_statement_stmt(node));
   1285     free(node);
   1286     break;
   1287   }
   1288   case AST_NULL_STATEMENT:
   1289     free(node);
   1290     break;
   1291   case AST_VAR_DECL:
   1292   {
   1293     ast_node_t *type = ast_get_var_decl_type(node);
   1294     ast_free_node(type);
   1295     free(node);
   1296     break;
   1297   }
   1298   case AST_FUN_DECL:
   1299   {
   1300     ast_node_t *type = ast_get_fun_decl_type(node);
   1301     ast_free_node(type);
   1302     size_t num_params;
   1303     ast_node_t **params = ast_get_fun_decl_params(node, &num_params);
   1304     for(size_t i = 0; i < num_params; i++)
   1305     {
   1306       ast_free_node(params[i]);
   1307     }
   1308     free(params);
   1309     free(node);
   1310     break;
   1311   }
   1312   case AST_PARAM:
   1313   {
   1314     ast_node_t *type = ast_get_param_type(node);
   1315     ast_free_node(type);
   1316     free(node);
   1317     break;
   1318   }
   1319   case AST_FUN_DEF:
   1320   {
   1321     ast_node_t *type = ast_get_fun_def_type(node);
   1322     ast_free_node(type);
   1323     size_t num_params;
   1324     ast_node_t **params = ast_get_fun_def_params(node, &num_params);
   1325     for(size_t i = 0; i < num_params; i++)
   1326     {
   1327       ast_free_node(params[i]);
   1328     }
   1329     free(params);
   1330     ast_free_node(ast_get_fun_def_stmt(node));
   1331     free(node);
   1332     break;
   1333   }
   1334   case AST_STRUCT_DECL:
   1335   {
   1336     size_t num_members;
   1337     ast_node_t **members = ast_get_struct_decl_members(node, &num_members);
   1338     for(size_t i = 0; i < num_members; i++)
   1339     {
   1340       ast_free_node(members[i]);
   1341     }
   1342     free(members);
   1343     free(node);
   1344     break;
   1345   }
   1346   case AST_UNION_DECL:
   1347   {
   1348     size_t num_members;
   1349     ast_node_t **members = ast_get_union_decl_members(node, &num_members);
   1350     for(size_t i = 0; i < num_members; i++)
   1351     {
   1352       ast_free_node(members[i]);
   1353     }
   1354     free(members);
   1355     free(node);
   1356     break;
   1357   }
   1358   case AST_ENUM_DECL:
   1359   {
   1360     size_t num_enums;
   1361     ast_node_t **enums = ast_get_enum_decl_enums(node, &num_enums);
   1362     for(size_t i = 0; i < num_enums; i++)
   1363     {
   1364       ast_free_node(enums[i]);
   1365     }
   1366     free(enums);
   1367     free(node);
   1368     break;
   1369   }
   1370   case AST_TYPEDEF:
   1371   {
   1372     ast_node_t *type = ast_get_typedef_type(node);
   1373     ast_free_node(type);
   1374     free(node);
   1375     break;
   1376   }
   1377   case AST_TYPE:
   1378   {
   1379     token_t **type;
   1380     size_t num_type;
   1381     type = ast_get_type(node, &num_type);
   1382     for(size_t i = 0; i < num_type; i++)
   1383     {
   1384       free(type[i]);
   1385     }
   1386     free(type);
   1387     free(node);
   1388     break;
   1389   }
   1390   case AST_MEMBER:
   1391   {
   1392     ast_node_t *type = ast_get_member_type(node);
   1393     ast_free_node(type);
   1394     free(node);
   1395     break;
   1396   }
   1397   case AST_ENUM_MEMBER:
   1398   {
   1399     ast_node_t *value = ast_get_enum_member_expr(node);
   1400     ast_free_node(value);
   1401     free(node);
   1402     break;
   1403   }
   1404   case AST_TRANSLATION_UNIT:
   1405   {
   1406     size_t num_items;
   1407     ast_node_t **items = ast_get_translation_unit_items(node, &num_items);
   1408     for(size_t i = 0; i < num_items; i++)
   1409     {
   1410       ast_free_node(items[i]);
   1411     }
   1412     free(items);
   1413     free(node);
   1414     break;
   1415   }
   1416   default:
   1417     assert(0);
   1418   }
   1419 
   1420 }
   1421 
   1422
	website Website contents
	git clone git://git.reagancfischer.dev/website.git
	Log \| Files \| Refs