add basic compiler code

This commit is contained in:
Luna 2019-06-01 20:33:43 -03:00
parent 7d7aabbdd7
commit e1d0e3ec0b
3 changed files with 109 additions and 28 deletions

View file

@ -1,54 +1,124 @@
const std = @import("std"); const std = @import("std");
const scanner = @import("new_scanner.zig"); const scanner = @import("new_scanner.zig");
const vm = @import("vm.zig"); const vm = @import("vm.zig");
const chunks = @import("chunk.zig");
const tokens = @import("token.zig");
const Allocator = std.mem.Allocator; const Allocator = std.mem.Allocator;
const TokenType = @import("token.zig").TokenType; const Scanner = scanner.Scanner;
const Chunk = chunks.Chunk;
const Token = tokens.Token;
const TokenType = tokens.TokenType;
pub const Parser = struct {
previous: Token = undefined,
current: Token = undefined,
// TODO are those needed
hadError: bool = false,
panicMode: bool = false,
};
pub const Compiler = struct { pub const Compiler = struct {
src: []const u8, src: []const u8,
stdout: vm.StdOut, stdout: vm.StdOut,
allocator: *Allocator, allocator: *Allocator,
parser: Parser,
scanr: Scanner = undefined,
chunk: *chunks.Chunk,
pub fn init( pub fn init(
allocator: *Allocator, allocator: *Allocator,
chunk: *chunks.Chunk,
stdout: vm.StdOut, stdout: vm.StdOut,
source: []const u8, source: []const u8,
) Compiler { ) Compiler {
return Compiler{ return Compiler{
.src = source, .src = source,
.chunk = chunk,
.allocator = allocator, .allocator = allocator,
.stdout = stdout, .stdout = stdout,
.parser = Parser{},
}; };
} }
pub fn compile(self: *Compiler) !void { fn errorAt(self: *Compiler, token: Token, msg: []const u8) void {
var scanr = try scanner.Scanner.init(self.allocator, self.src); if (self.parser.panicMode) return;
var line: usize = 0; self.parser.panicMode = true;
std.debug.warn("[line {}] Error", token.line);
if (token.ttype == TokenType.EOF) {
std.debug.warn(" at end");
} else {
std.debug.warn(" at '{}'", token.lexeme);
}
std.debug.warn(": {}\n", msg);
self.parser.hadError = true;
}
fn errorCurrent(self: *Compiler, msg: []const u8) void {
self.errorAt(self.parser.current, msg);
}
fn errorPrevious(self: *Compiler, msg: []const u8) void {
self.errorAt(self.parser.previous, msg);
}
fn advance(self: *Compiler) !void {
self.parser.previous = self.parser.current;
while (true) { while (true) {
var token_opt = scanr.scanToken() catch |err| { var token_opt = try self.scanr.scanToken();
std.debug.warn("Scan Error: {x}\n", err);
std.debug.warn(
"line: {}, cur lexeme: {}\n",
scanr.line,
scanr.currentLexeme(),
);
break;
};
if (token_opt) |token| { if (token_opt) |token| {
if (token.line != line) { self.parser.current = token;
try self.stdout.print("{} ", token.line); break;
line = token.line;
} else { } else {
try self.stdout.print(" | "); self.errorCurrent(self.parser.current.lexeme);
}
}
} }
try self.stdout.print("{} '{}'\n", token.ttype, token.lexeme); fn consume(self: *Compiler, ttype: TokenType, msg: []const u8) !void {
if (token.ttype == TokenType.EOF) break; if (self.parser.current.ttype == ttype) {
} else { try self.advance();
break; return;
} }
self.errorCurrent(msg);
} }
fn currentChunk(self: *Compiler) *chunks.Chunk {
return self.chunk;
}
fn emitByte(self: *Compiler, byte: u8) !void {
try self.currentChunk().write(byte, self.parser.previous.line);
}
fn emitBytes(self: *Compiler, byte1: u8, byte2: u82) !void {
try self.emitByte(byte1);
try self.emitByte(byte2);
}
fn writeReturn(self: *Compiler) !void {
try self.emitByte(chunks.OpCode.Return);
}
fn end(self: *Compiler) !void {
try self.writeReturn();
}
/// Compile the source given when initializing the compiler
/// into the given chunk.
pub fn compile(self: *Compiler, chunk: *Chunk) !bool {
self.scanr = try scanner.Scanner.init(self.allocator, self.src);
try self.advance();
//try self.expression();
try self.consume(.EOF, "Expect end of expression.");
try self.end();
return !self.parser.hadError;
} }
}; };

View file

@ -230,7 +230,11 @@ pub const Scanner = struct {
pub fn scanToken(self: *Scanner) !?Token { pub fn scanToken(self: *Scanner) !?Token {
self.skipWhitespace(); self.skipWhitespace();
self.start = self.current; self.start = self.current;
if (self.isAtEnd()) return self.makeToken(TokenType.EOF);
if (self.isAtEnd()) {
std.debug.warn("got at end\n");
return self.makeToken(TokenType.EOF);
}
var c = self.advance(); var c = self.advance();
if (isAlpha(c)) return self.doIdentifier(); if (isAlpha(c)) return self.doIdentifier();

View file

@ -165,9 +165,16 @@ pub const VM = struct {
//var res = try self.run(); //var res = try self.run();
//self.debug("VM end\n"); //self.debug("VM end\n");
//return res; //return res;
var cmpr = Compiler.init(self.allocator, self.stdout, self.src); var chk = try Chunk.init(self.allocator);
try cmpr.compile();
return InterpretResult.Ok; var cmpr = Compiler.init(self.allocator, &chk, self.stdout, self.src);
if (!try cmpr.compile(&chk)) {
return InterpretResult.CompileError;
}
self.chk = &chk;
self.ip = 0;
return try self.run();
} }
pub fn push(self: *VM, val: Value) !void { pub fn push(self: *VM, val: Value) !void {