2019-06-05 01:11:11 +00:00
|
|
|
const std = @import("std");
|
|
|
|
const scanners = @import("scanner.zig");
|
|
|
|
const main = @import("main.zig");
|
|
|
|
const ast = @import("ast.zig");
|
|
|
|
const tokens = @import("tokens.zig");
|
2019-06-06 01:06:12 +00:00
|
|
|
const err = @import("errors.zig");
|
2019-06-05 01:11:11 +00:00
|
|
|
|
|
|
|
const Allocator = std.mem.Allocator;
|
|
|
|
const Scanner = scanners.Scanner;
|
|
|
|
const Token = tokens.Token;
|
|
|
|
const TokenType = tokens.TokenType;
|
|
|
|
const Result = main.Result;
|
2019-07-01 18:01:43 +00:00
|
|
|
const Node = ast.Node;
|
2019-06-06 01:06:12 +00:00
|
|
|
|
2019-06-05 01:11:11 +00:00
|
|
|
pub const Parser = struct {
|
|
|
|
allocator: *Allocator,
|
|
|
|
scanner: *Scanner,
|
2019-06-06 01:06:12 +00:00
|
|
|
|
|
|
|
tokens: []Token = undefined,
|
2019-06-05 01:11:11 +00:00
|
|
|
|
2019-08-23 14:57:49 +00:00
|
|
|
hadError: bool = false,
|
|
|
|
|
2019-06-05 01:11:11 +00:00
|
|
|
pub fn init(allocator: *Allocator, scanner: *Scanner) Parser {
|
|
|
|
return Parser{ .allocator = allocator, .scanner = scanner };
|
|
|
|
}
|
|
|
|
|
2019-08-23 14:57:49 +00:00
|
|
|
fn doError(self: *Parser, comptime fmt: []const u8, args: ...) void {
|
|
|
|
self.hadError = true;
|
|
|
|
|
2019-06-05 01:11:11 +00:00
|
|
|
std.debug.warn("parser error at line {}\n\t", self.scanner.line);
|
|
|
|
std.debug.warn(fmt, args);
|
|
|
|
std.debug.warn("\n");
|
|
|
|
}
|
|
|
|
|
2019-06-06 01:06:12 +00:00
|
|
|
fn peek(self: *Parser) Token {
|
2019-07-01 18:39:48 +00:00
|
|
|
return self.tokens[self.tokens.len - 1];
|
2019-06-06 01:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn previous(self: *Parser) Token {
|
2019-07-01 18:39:48 +00:00
|
|
|
return self.tokens[self.tokens.len - 2];
|
2019-06-06 01:06:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn tokenError(self: *Parser, token: Token, msg: []const u8) Result!void {
|
|
|
|
if (token.ttype == .EOF) {
|
|
|
|
err.report(token.line, " at end", msg);
|
|
|
|
} else {
|
|
|
|
err.reportFmt(token.line, " at '{}': {}", token.lexeme, msg);
|
2019-06-05 01:11:11 +00:00
|
|
|
}
|
2019-06-06 01:06:12 +00:00
|
|
|
|
|
|
|
return Result.CompileError;
|
2019-06-05 01:11:11 +00:00
|
|
|
}
|
|
|
|
|
2019-06-06 01:06:12 +00:00
|
|
|
fn isAtEnd(self: *Parser) bool {
|
|
|
|
return self.peek().ttype == .EOF;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check(self: *Parser, ttype: TokenType) bool {
|
|
|
|
if (self.isAtEnd()) return false;
|
|
|
|
return self.peek().ttype == ttype;
|
|
|
|
}
|
|
|
|
|
2019-07-01 18:39:48 +00:00
|
|
|
fn nextToken(self: *Parser) !Token {
|
|
|
|
var token: Token = undefined;
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
var next_token_opt = try self.scanner.nextToken();
|
|
|
|
if (next_token_opt) |token_nice| {
|
|
|
|
token = token_nice;
|
|
|
|
break;
|
2019-06-06 01:06:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-01 18:39:48 +00:00
|
|
|
self.tokens = try self.allocator.realloc(
|
|
|
|
self.tokens,
|
|
|
|
self.tokens.len + 1,
|
|
|
|
);
|
2019-06-06 01:06:12 +00:00
|
|
|
|
2019-07-01 18:39:48 +00:00
|
|
|
self.tokens[self.tokens.len - 1] = token;
|
2019-08-23 19:34:41 +00:00
|
|
|
std.debug.warn("skip to {}\n", token);
|
2019-07-01 18:39:48 +00:00
|
|
|
return token;
|
2019-06-06 01:06:12 +00:00
|
|
|
}
|
|
|
|
|
2019-07-01 18:39:48 +00:00
|
|
|
fn consume(self: *Parser, ttype: TokenType, comptime msg: []const u8) !Token {
|
|
|
|
if (self.check(ttype)) return try self.nextToken();
|
2019-06-06 01:06:12 +00:00
|
|
|
|
|
|
|
try self.tokenError(self.peek(), msg);
|
|
|
|
return Result.CompileError;
|
2019-06-05 01:11:11 +00:00
|
|
|
}
|
|
|
|
|
2019-07-01 18:25:07 +00:00
|
|
|
fn consumeSingle(self: *Parser, ttype: TokenType) !Token {
|
2019-07-01 18:39:48 +00:00
|
|
|
if (self.check(ttype)) {
|
|
|
|
var cur = self.peek();
|
|
|
|
_ = try self.nextToken();
|
|
|
|
std.debug.warn("now has {}\n", self.peek());
|
|
|
|
return cur;
|
|
|
|
}
|
2019-07-01 18:25:07 +00:00
|
|
|
|
|
|
|
var buf_main: [1000]u8 = undefined;
|
|
|
|
var buf = try std.fmt.bufPrint(
|
|
|
|
buf_main[0..],
|
|
|
|
"expected {}, got {}",
|
|
|
|
ttype,
|
|
|
|
self.peek().ttype,
|
|
|
|
);
|
|
|
|
try self.tokenError(self.peek(), buf);
|
|
|
|
|
|
|
|
return Result.CompileError;
|
|
|
|
}
|
|
|
|
|
2019-07-01 18:55:19 +00:00
|
|
|
fn mkFnDecl(self: *Parser, name: Token, params: ast.ParamList) !*ast.Node {
|
2019-07-01 18:25:07 +00:00
|
|
|
var node = try self.allocator.create(Node);
|
2019-07-01 18:55:19 +00:00
|
|
|
node.* = Node{
|
|
|
|
.FnDecl = ast.FnDecl{
|
|
|
|
.func_name = name,
|
|
|
|
.params = params,
|
|
|
|
|
|
|
|
// TODO replace by arg when statements work
|
|
|
|
.body = ast.NodeList.init(self.allocator),
|
|
|
|
},
|
|
|
|
};
|
2019-07-01 18:01:43 +00:00
|
|
|
return node;
|
2019-06-06 01:06:12 +00:00
|
|
|
}
|
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
fn mkConstDecl(self: *Parser, consts: ast.ConstList) !*ast.Node {
|
|
|
|
var node = try self.allocator.create(Node);
|
|
|
|
node.* = Node{ .ConstDecl = consts };
|
|
|
|
return node;
|
|
|
|
}
|
2019-07-01 18:55:19 +00:00
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
fn functionDecl(self: *Parser) !*ast.Node {
|
2019-07-01 18:55:19 +00:00
|
|
|
|
|
|
|
// function body
|
2019-07-01 20:45:13 +00:00
|
|
|
_ = try self.nextToken();
|
2019-07-01 18:55:19 +00:00
|
|
|
_ = try self.consumeSingle(.LeftBrace);
|
2019-08-23 14:57:49 +00:00
|
|
|
var body = ast.NodeList.init(self.allocator);
|
|
|
|
|
2019-07-01 18:55:19 +00:00
|
|
|
while (true) {
|
|
|
|
var tok = self.peek();
|
|
|
|
if (tok.ttype == .RightBrace) break;
|
2019-08-23 14:57:49 +00:00
|
|
|
|
|
|
|
// TODO statements
|
|
|
|
//var node = try self.processToken(tok);
|
|
|
|
//std.debug.warn("stmt:{}\n", node);
|
|
|
|
//try body.append(node);
|
|
|
|
|
|
|
|
tok = try self.nextToken();
|
2019-07-01 18:55:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
_ = try self.consumeSingle(.RightBrace);
|
|
|
|
|
|
|
|
return try self.mkFnDecl(name, param_list);
|
2019-06-06 01:06:12 +00:00
|
|
|
}
|
|
|
|
|
2019-08-23 14:57:49 +00:00
|
|
|
fn processToken(self: *Parser, token: Token) anyerror!*ast.Node {
|
2019-07-01 18:25:07 +00:00
|
|
|
var node = switch (token.ttype) {
|
|
|
|
.Fn => try self.functionDecl(),
|
2019-08-23 14:57:49 +00:00
|
|
|
.Identifier => try self.functionCall(),
|
2019-07-01 18:01:43 +00:00
|
|
|
else => blk: {
|
|
|
|
try self.doError("TODO handle {}\n", token.ttype);
|
|
|
|
return Result.CompileError;
|
|
|
|
},
|
2019-07-01 18:25:07 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
return node;
|
2019-06-06 01:06:12 +00:00
|
|
|
}
|
|
|
|
|
2019-08-23 14:57:49 +00:00
|
|
|
fn block(self: *Parser) anyerror!*ast.Node {
|
|
|
|
|
|
|
|
// while receiving functions, process more
|
|
|
|
while (self.accept(.Fn)) {
|
|
|
|
try self.consumeSingle(.LeftParen);
|
|
|
|
try self.consumeSingle(.RightParen);
|
|
|
|
var block = try self.block();
|
|
|
|
}
|
|
|
|
|
|
|
|
self.statement();
|
|
|
|
}
|
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
fn fnDecl(self: *@This()) !?*Node {
|
|
|
|
var param_list = ast.ParamList.init(self.allocator);
|
|
|
|
errdefer param_list.deinit();
|
|
|
|
|
|
|
|
_ = try self.consumeSingle(.Fn);
|
|
|
|
var name = try self.consumeSingle(.Identifier);
|
|
|
|
|
|
|
|
_ = try self.consumeSingle(.LeftParen);
|
2019-08-23 18:52:04 +00:00
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
while (self.peek().ttype != .RightParen) {
|
|
|
|
const param_name = try self.consumeSingle(.Identifier);
|
|
|
|
const param_type = try self.consumeSingle(.Identifier);
|
2019-08-23 18:52:04 +00:00
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
try param_list.append(ast.ParamDecl{
|
|
|
|
.name = param_name,
|
|
|
|
.typ = param_type,
|
|
|
|
});
|
|
|
|
}
|
2019-08-23 18:52:04 +00:00
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
_ = try self.consumeSingle(.RightParen);
|
2019-08-23 18:52:04 +00:00
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
_ = try self.consumeSingle(.LeftBrace);
|
|
|
|
// TODO block
|
|
|
|
_ = try self.consumeSingle(.RightBrace);
|
2019-08-23 18:52:04 +00:00
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
std.debug.warn("!fn name: {}\n", name);
|
|
|
|
return try self.mkFnDecl(name, param_list);
|
|
|
|
}
|
2019-08-23 18:52:04 +00:00
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
fn constDecl(self: *@This()) !?*Node {
|
|
|
|
var consts = ast.ConstList.init(self.allocator);
|
|
|
|
errdefer consts.deinit();
|
|
|
|
|
|
|
|
_ = try self.consumeSingle(.Const);
|
|
|
|
|
|
|
|
_ = try self.consumeSingle(.LeftParen);
|
|
|
|
|
|
|
|
while (self.peek().ttype != .RightParen) {
|
|
|
|
const const_name = try self.consumeSingle(.Identifier);
|
|
|
|
_ = try self.consumeSingle(.Equal);
|
|
|
|
|
|
|
|
// TODO expr
|
|
|
|
const const_value = self.peek();
|
|
|
|
_ = try self.nextToken();
|
|
|
|
//const const_value = try self.consumeSingle(.Identifier);
|
|
|
|
|
|
|
|
try consts.append(ast.SingleConst{ .name = const_name, .value = const_value });
|
|
|
|
}
|
|
|
|
|
|
|
|
_ = try self.consumeSingle(.RightParen);
|
|
|
|
|
|
|
|
return self.mkConstDecl(consts);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn topDecl(self: *@This()) !?*Node {
|
|
|
|
return switch (self.peek().ttype) {
|
|
|
|
.Fn => try self.fnDecl(),
|
|
|
|
.Const => try self.constDecl(),
|
2019-08-23 18:52:04 +00:00
|
|
|
|
2019-08-23 14:57:49 +00:00
|
|
|
else => |ttype| blk: {
|
2019-08-23 19:34:41 +00:00
|
|
|
self.doError("(basic) expected fn/const, got {}\n", ttype);
|
2019-08-23 14:57:49 +00:00
|
|
|
break :blk null;
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-07-01 18:01:43 +00:00
|
|
|
pub fn parse(self: *Parser) !*ast.Node {
|
2019-06-06 01:06:12 +00:00
|
|
|
self.tokens = try self.allocator.alloc(Token, 0);
|
2019-07-01 18:01:43 +00:00
|
|
|
var root = try ast.mkRoot(self.allocator);
|
2019-06-06 01:06:12 +00:00
|
|
|
|
2019-08-23 19:34:41 +00:00
|
|
|
var token_opt: ?Token = null;
|
|
|
|
|
2019-06-06 01:06:12 +00:00
|
|
|
while (true) {
|
2019-08-23 19:34:41 +00:00
|
|
|
if (token_opt == null) {
|
|
|
|
token_opt = try self.nextToken();
|
|
|
|
} else {
|
|
|
|
token_opt = self.peek();
|
|
|
|
}
|
|
|
|
|
|
|
|
var token = token_opt.?;
|
2019-07-01 18:39:48 +00:00
|
|
|
if (token.ttype == .EOF) break;
|
2019-07-01 18:01:43 +00:00
|
|
|
|
2019-08-23 14:57:49 +00:00
|
|
|
var node = try self.topDecl();
|
|
|
|
if (node == null) continue;
|
|
|
|
try root.Root.append(node.?);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (self.hadError) {
|
|
|
|
return error.ParseError;
|
2019-06-06 01:06:12 +00:00
|
|
|
}
|
|
|
|
|
2019-07-01 18:01:43 +00:00
|
|
|
return root;
|
2019-06-05 01:11:11 +00:00
|
|
|
}
|
|
|
|
};
|