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
|
#include <assert.h>
#include <stdlib.h>
#include <log.h>
#include <tokenize.h>
#include <treeify.h>
static void expected(enum token_type type)
{
err("Expected token of type %d while creating tree!\n", type);
}
static void unexpected(struct ctx *ctx, struct token *token)
{
token_print(ctx, token);
err("Unexpected token while creating tree!\n");
}
static struct token *next(struct token *token, size_t i)
{
return token + i;
}
static struct token *parse_declaration(struct ctx *ctx, struct token *token)
{
if (next(token, 1)->type != TYPEDELIM)
unexpected(ctx, next(token, 1));
if (next(token, 2)->type != PARAM)
unexpected(ctx, next(token, 2));
// 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)
expected(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;
assert(param->type == TYPE);
assert(next(param, 2)->type == PARAM);
node->parameters[i].type = param->string;
node->parameters[i].name = next(param, 2)->string;
}
return next(iterator, 1);
}
static struct token *parse(struct ctx *ctx, struct token *token)
{
switch (token->type) {
case TYPE:
return parse_declaration(ctx, token);
case UNKNOWN:
case TYPEDELIM:
case PARAM:
case IDENT:
case OPERATOR:
case LPAREN:
case RPAREN:
case EQUAL:
case NEWLINE:
case EOL:
case END:
default:
unexpected(ctx, token);
}
return NULL;
}
struct tree *tree_create(void)
{
struct tree *tree = malloc(sizeof(*tree));
tree->node = NULL;
return tree;
}
void tree_destroy(struct tree *tree)
{
// TODO: Destroy nodes
free(tree);
}
void treeify(struct ctx *ctx)
{
struct token *token = &ctx->tokens[1];
while (token) {
assert(token->type != UNKNOWN);
if (token->type == NEWLINE || token->type == EOL) {
token = next(token, 1);
continue;
}
if (token->type == END)
break;
token = parse(ctx, token);
}
}
|
