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
|
const std = @import("std");
const tokenizer = @import("tokenizer.zig");
const NodeType = enum {
PROGRAM,
VARIABLE_STATEMENT,
PRINT_STATEMENT,
NUMBER,
IDENTIFIER,
};
pub const Node = union(NodeType) {
PROGRAM: struct {
statements: []*Node,
},
VARIABLE_STATEMENT: struct {
is_declaration: bool,
name: []const u8,
expression: *Node,
},
PRINT_STATEMENT: struct {
expression: *Node,
},
NUMBER: struct {
value: i32,
},
IDENTIFIER: struct {
name: []const u8,
},
};
pub const Parser = struct {
tokens: []tokenizer.Token,
offset: u32,
pub fn init(tokens: []tokenizer.Token) *Parser {
return @constCast(&Parser{
.tokens = tokens,
.offset = 0,
});
}
pub fn parse(parser: *Parser) !Node {
return parser.parse_program();
}
fn parse_program(_: *Parser) !Node {
return Node{
.NUMBER = .{ .value = 9 },
};
}
fn parse_identifier(self: *Parser) !Node {
const token = self.peek_token() orelse return error.InvalidArgument;
if (token != .IDENTIFIER) return error.InvalidArgument;
_ = self.consume_token();
return Node{ .IDENTIFIER = .{
.name = token.IDENTIFIER,
} };
}
fn consume_token(self: *Parser) ?tokenizer.Token {
if (self.offset >= self.tokens.len) return null;
defer self.offset += 1;
return self.tokens[self.offset];
}
fn peek_token(self: Parser) ?tokenizer.Token {
if (self.offset >= self.tokens.len) return null;
return self.tokens[self.offset];
}
};
test "parse identifier" {
const tokens: []tokenizer.Token = @constCast(&[_]tokenizer.Token{
tokenizer.Token{ .IDENTIFIER = @constCast("i") },
});
var parser = Parser.init(tokens);
const ident = try parser.parse_identifier();
try std.testing.expectEqualDeep(Node{ .IDENTIFIER = .{
.name = @constCast("i"),
} }, ident);
}
test "simple e2e" {
const tokens: []tokenizer.Token = @constCast(&[_]tokenizer.Token{
tokenizer.Token{ .LET = void{} },
tokenizer.Token{ .IDENTIFIER = @constCast("i") },
tokenizer.Token{ .EQUALS = void{} },
tokenizer.Token{ .NUMBER = 2 },
tokenizer.Token{ .SEMICOLON = void{} },
});
const ast = try Parser.init(tokens).parse();
try std.testing.expectEqualDeep(Node{ .PROGRAM = .{ .statements = @constCast(&[_]*Node{
@constCast(&Node{ .VARIABLE_STATEMENT = .{ .is_declaration = true, .name = @constCast("i"), .expression = @constCast(&Node{
.NUMBER = .{ .value = 2 },
}) } }),
}) } }, ast);
}
|
