blob: 69173bd7df4586c198453919daa338844373b85c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
#include "ast.h"
#include "scope.h"
#include <stdlib.h>
static void expr_destroy(struct expr_node* node);
static void stmt_destroy(struct stmt_node* node);
static void lval_destroy(struct lval_node* node) {
switch (node->type) {
case LVAL_VAR_DECL:
break;
case LVAL_VAR_REF:
break;
}
}
static void assign_destroy(struct assign_node* node) {
lval_destroy(&node->lval);
expr_destroy(node->rval);
free(node->rval);
}
static void group_destroy(struct group_node* node) {
struct stmt_node* body_node = node->head;
while (body_node != NULL) {
struct stmt_node* next = body_node->next;
stmt_destroy(body_node);
free(body_node);
body_node = next;
}
scope_destroy(node->scope);
free(node->scope);
}
static void args_decl_destroy(struct args_decl_node* node) {
if (node != NULL) {
free(node->decl);
args_decl_destroy(node->next);
}
}
static void fn_decl_destroy(struct fn_decl_node* node) {
args_decl_destroy(node->args);
free(node->args);
group_destroy(&node->body);
scope_destroy(node->scope);
free(node->scope);
}
static void return_destroy(struct return_node* node) {
if (node->ret_val != NULL) {
expr_destroy(node->ret_val);
free(node->ret_val);
}
}
static void str_lit_destroy(struct str_lit_node* node) {
free(node->val);
}
static void args_list_destroy(struct args_eval_node* node) {
if (node != NULL) {
expr_destroy(node->expr);
free(node->expr);
args_list_destroy(node->next);
}
}
static void call_destroy(struct call_node* node) {
args_list_destroy(node->args);
free(node->args);
}
static void unary_destroy(struct unary_node* node) {
expr_destroy(node->expr);
free(node->expr);
}
static void binary_destroy(struct binary_node* node) {
expr_destroy(node->lhs);
free(node->lhs);
expr_destroy(node->rhs);
free(node->rhs);
}
static void expr_destroy(struct expr_node* node) {
switch (node->type) {
case EXPR_INT_LIT:
case EXPR_FLOAT_LIT:
case EXPR_CHAR_LIT:
break;
case EXPR_STR_LIT:
str_lit_destroy(&node->inner.str_lit);
break;
case EXPR_VAR_REF:
break;
case EXPR_ASSIGN:
assign_destroy(&node->inner.assign);
break;
case EXPR_CALL:
call_destroy(&node->inner.call);
break;
case EXPR_UNARY:
unary_destroy(&node->inner.unary);
break;
case EXPR_BINARY:
binary_destroy(&node->inner.binary);
break;
}
}
static void if_destroy(struct if_node* node) {
expr_destroy(node->cond);
free(node->cond);
stmt_destroy(node->true_branch);
free(node->true_branch);
if (node->false_branch != NULL) {
stmt_destroy(node->false_branch);
free(node->false_branch);
}
}
static void stmt_destroy(struct stmt_node* node) {
switch (node->type) {
case STMT_EMPTY:
break;
case STMT_EXPR:
expr_destroy(&node->inner.expr);
break;
case STMT_VAR_DECL:
break;
case STMT_RETURN:
return_destroy(&node->inner.return_);
break;
case STMT_GROUP:
group_destroy(&node->inner.group);
break;
case STMT_IF:
if_destroy(&node->inner.if_);
break;
}
}
static void root_node_destroy(struct root_node* node) {
switch (node->type) {
case ROOT_FN_DECL:
fn_decl_destroy(&node->inner.fn_decl);
break;
}
}
void ast_destroy(struct ast* ast) {
struct root_node* node = ast->root_node;
while (node != NULL) {
struct root_node* next = node->next;
root_node_destroy(node);
free(node);
node = next;
}
scope_destroy(ast->root_scope);
free(ast->root_scope);
}
|
