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
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <log.h>
#include <tokenize.h>
#include <treeify.h>
static void __expect(struct ctx *ctx, struct token *token, enum token_type type, const char *file,
int line, const char *func, const char *type_enum)
{
if (token->type != type) {
printf("[DBG] %s:%d: %s\n", file, line, func);
token_print(ctx, token);
err("Expected token of type %s!\n", type_enum);
}
}
#define expect(token, type) __expect(ctx, token, type, __FILE__, __LINE__, __func__, #type)
static struct token *next(struct token *token, size_t i)
{
return token + i;
}
static struct token *parse_declaration(struct ctx *ctx, struct token *token);
static struct token *parse_expression(struct ctx *ctx, struct token *token)
{
struct node_expression *node = malloc(sizeof(*node));
// TODO: Push expressions into tree (using subtrees)
struct token *iterator = token;
while ((iterator = next(iterator, 1))) {
if (iterator->type == LPAREN) {
iterator = parse_expression(ctx, iterator);
continue;
}
if (iterator->type == TYPE) {
iterator = parse_declaration(ctx, iterator);
continue;
}
if (iterator->type == RPAREN)
break;
if (iterator->type == EOL || iterator->type == END)
expect(iterator, RPAREN);
expect(iterator, IDENT);
}
return iterator;
}
static struct token *parse_declaration(struct ctx *ctx, struct token *token)
{
expect(next(token, 1), TYPEDELIM);
expect(next(token, 2), PARAM);
// Search for equal sign
struct token *iterator = token;
while ((iterator = next(iterator, 1))) {
if (iterator->type == EQUAL)
break;
if (iterator->type == EOL || iterator->type == END)
expect(iterator, EQUAL);
}
struct node_declaration *node = malloc(sizeof(*node));
node->callee.type = token->string;
node->callee.name = next(token, 2)->string;
// Magic
size_t diff = iterator - token - 3;
assert(diff % 3 == 0);
node->parameters = malloc((diff / 3 + 1) * sizeof(*node->parameters));
for (size_t i = 0; i < diff / 3; i++) {
struct token *param = token + (i + 1) * 3;
expect(param, TYPE);
expect(next(param, 2), PARAM);
node->parameters[i].type = param->string;
node->parameters[i].name = next(param, 2)->string;
}
tree_add(ctx, DECLARATION, node);
return next(iterator, 1);
}
static struct token *parse(struct ctx *ctx, struct token *token)
{
switch (token->type) {
case LPAREN:
return parse_expression(ctx, token);
case TYPE:
return parse_declaration(ctx, token);
case RPAREN:
return next(token, 1);
case END:
return NULL;
case UNKNOWN:
case TYPEDELIM:
case PARAM:
case IDENT:
case OPERATOR:
case EQUAL:
case NEWLINE:
case SOMETHING:
case EOL:
default:
expect(token, SOMETHING);
}
return NULL;
}
struct node *tree_create(void)
{
struct node *tree = malloc(sizeof(*tree));
tree->prev = NULL;
tree->next = NULL;
return tree;
}
void tree_add(struct ctx *ctx, enum node_type type, void *data)
{
assert(ctx->tree.head);
struct node *node = malloc(sizeof(*node));
node->type = type;
node->data = data;
if (!ctx->tree.current) {
ctx->tree.head->next = node;
node->prev = ctx->tree.head;
} else {
ctx->tree.current->next = node;
node->prev = ctx->tree.current;
}
ctx->tree.current = node;
}
void tree_destroy(struct node *tree)
{
// TODO: Destroy nodes
free(tree);
}
void treeify(struct ctx *ctx)
{
struct token *token = &ctx->tokens[1];
while (token) {
if (token->type == NEWLINE || token->type == EOL) {
token = next(token, 1);
continue;
}
if (token->type == END || token->type == UNKNOWN)
break;
token = parse(ctx, token);
}
}
|
