1437 lines
54 KiB
Rust
1437 lines
54 KiB
Rust
use crate::chunk::{Chunk, StrPattern};
|
|
use crate::op::Op;
|
|
use crate::parser::Ast;
|
|
use crate::parser::StringPart;
|
|
use crate::spans::Spanned;
|
|
use crate::value::*;
|
|
use chumsky::prelude::SimpleSpan;
|
|
use regex::Regex;
|
|
use std::cell::RefCell;
|
|
use std::collections::HashMap;
|
|
use std::rc::Rc;
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Binding {
|
|
name: &'static str,
|
|
depth: isize,
|
|
stack_pos: usize,
|
|
}
|
|
|
|
impl std::fmt::Display for Binding {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
write!(f, "{}@{}//{}", self.name, self.stack_pos, self.depth)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Upvalue {
|
|
name: &'static str,
|
|
stack_pos: usize,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
struct LoopInfo {
|
|
start: usize,
|
|
stack_root: usize,
|
|
}
|
|
|
|
impl LoopInfo {
|
|
fn new(start: usize, stack_root: usize) -> LoopInfo {
|
|
LoopInfo { start, stack_root }
|
|
}
|
|
}
|
|
|
|
fn get_builtin(name: &str, arity: usize) -> Option<Op> {
|
|
// match (name, arity) {
|
|
// ("type", 1) => Some(Op::TypeOf),
|
|
// ("eq?", 2) => Some(Op::Eq),
|
|
// ("add", 2) => Some(Op::Add),
|
|
// ("sub", 2) => Some(Op::Sub),
|
|
// ("mult", 2) => Some(Op::Mult),
|
|
// ("div", 2) => Some(Op::Div),
|
|
// ("unbox", 1) => Some(Op::Unbox),
|
|
// ("store!", 2) => Some(Op::BoxStore),
|
|
// ("assert!", 1) => Some(Op::Assert),
|
|
// ("get", 2) => Some(Op::Get),
|
|
// ("at", 2) => Some(Op::At),
|
|
// ("not", 1) => Some(Op::Not),
|
|
// ("print!", 1) => Some(Op::Print),
|
|
|
|
// _ => None,
|
|
// }
|
|
None
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Compiler<'a> {
|
|
pub chunk: Chunk,
|
|
pub bindings: Vec<Binding>,
|
|
pub scope_depth: isize,
|
|
pub match_depth: usize,
|
|
pub stack_depth: usize,
|
|
pub spans: Vec<SimpleSpan>,
|
|
pub nodes: Vec<&'static Ast>,
|
|
pub ast: &'static Ast,
|
|
pub span: SimpleSpan,
|
|
pub src: &'static str,
|
|
pub name: &'static str,
|
|
pub enclosing: Option<&'a Compiler<'a>>,
|
|
pub upvalues: Vec<&'static str>,
|
|
loop_info: Vec<LoopInfo>,
|
|
tail_pos: bool,
|
|
debug: bool,
|
|
}
|
|
|
|
fn is_binding(expr: &Spanned<Ast>) -> bool {
|
|
let (ast, _) = expr;
|
|
use Ast::*;
|
|
match ast {
|
|
Let(..) | LBox(..) | FnDeclaration(..) => true,
|
|
Fn(name, ..) => !name.is_empty(),
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn has_placeholder(args: &[Spanned<Ast>]) -> bool {
|
|
args.iter().any(|arg| matches!(arg, (Ast::Placeholder, _)))
|
|
}
|
|
|
|
impl<'a> Compiler<'a> {
|
|
pub fn new(
|
|
ast: &'static Spanned<Ast>,
|
|
name: &'static str,
|
|
src: &'static str,
|
|
enclosing: Option<&'a Compiler>,
|
|
env: imbl::HashMap<&'static str, Value>,
|
|
debug: bool,
|
|
) -> Compiler<'a> {
|
|
let chunk = Chunk {
|
|
constants: vec![],
|
|
bytecode: vec![],
|
|
keywords: vec![],
|
|
string_patterns: vec![],
|
|
env,
|
|
msgs: vec![],
|
|
};
|
|
Compiler {
|
|
chunk,
|
|
bindings: vec![],
|
|
scope_depth: -1,
|
|
match_depth: 0,
|
|
stack_depth: 0,
|
|
spans: vec![],
|
|
nodes: vec![],
|
|
ast: &ast.0,
|
|
span: ast.1,
|
|
loop_info: vec![],
|
|
enclosing,
|
|
upvalues: vec![],
|
|
src,
|
|
name,
|
|
tail_pos: false,
|
|
debug,
|
|
}
|
|
}
|
|
|
|
pub fn visit(&mut self, node: &'static Spanned<Ast>) {
|
|
let root_node = self.ast;
|
|
let root_span = self.span;
|
|
let (ast, span) = node;
|
|
self.ast = ast;
|
|
self.span = *span;
|
|
self.compile();
|
|
self.ast = root_node;
|
|
self.span = root_span;
|
|
}
|
|
|
|
fn jump(&mut self, op: Op, len: usize) {
|
|
let low = len as u8;
|
|
let high = (len >> 8) as u8;
|
|
self.emit_op(op);
|
|
self.chunk.bytecode.push(high);
|
|
self.chunk.bytecode.push(low);
|
|
}
|
|
|
|
fn stub_jump(&mut self, op: Op) -> usize {
|
|
use Op::*;
|
|
match op {
|
|
JumpIfFalse | JumpIfTrue | JumpIfZero => self.stack_depth -= 1,
|
|
_ => (),
|
|
}
|
|
let out = self.chunk.bytecode.len();
|
|
self.emit_op(op);
|
|
self.emit_byte(0xff);
|
|
self.emit_byte(0xff);
|
|
out
|
|
}
|
|
|
|
fn patch_jump(&mut self, i: usize, len: usize) {
|
|
let low = len as u8;
|
|
let high = (len >> 8) as u8;
|
|
self.chunk.bytecode[i + 1] = high;
|
|
self.chunk.bytecode[i + 2] = low;
|
|
}
|
|
|
|
pub fn emit_constant(&mut self, val: Value) {
|
|
let const_idx = if let Some(idx) = self.chunk.constants.iter().position(|v| *v == val) {
|
|
idx
|
|
} else {
|
|
self.chunk.constants.push(val);
|
|
self.chunk.constants.len() - 1
|
|
};
|
|
|
|
if const_idx > u16::MAX as usize {
|
|
panic!(
|
|
"internal Ludus compiler error: too many constants in chunk:{}:: {}",
|
|
self.span, self.ast
|
|
)
|
|
}
|
|
self.emit_op(Op::Constant);
|
|
let low = const_idx as u8;
|
|
let high = (const_idx >> 8) as u8;
|
|
self.chunk.bytecode.push(high);
|
|
self.chunk.bytecode.push(low);
|
|
self.stack_depth += 1;
|
|
}
|
|
|
|
fn reset_match(&mut self) {
|
|
self.emit_op(Op::ResetMatch);
|
|
self.match_depth = 0;
|
|
}
|
|
|
|
fn match_constant(&mut self, val: Value) {
|
|
let const_idx = match self.chunk.constants.iter().position(|v| *v == val) {
|
|
Some(idx) => idx,
|
|
None => {
|
|
self.chunk.constants.push(val);
|
|
self.chunk.constants.len() - 1
|
|
}
|
|
};
|
|
if const_idx > u16::MAX as usize {
|
|
panic!(
|
|
"internal Ludus compiler error: too many constants in chunk:{}:: {}",
|
|
self.span, self.ast
|
|
)
|
|
}
|
|
self.emit_op(Op::MatchConstant);
|
|
let low = const_idx as u8;
|
|
let high = (const_idx >> 8) as u8;
|
|
self.chunk.bytecode.push(high);
|
|
self.chunk.bytecode.push(low);
|
|
}
|
|
|
|
fn emit_op(&mut self, op: Op) {
|
|
self.chunk.bytecode.push(op as u8);
|
|
self.spans.push(self.span);
|
|
}
|
|
|
|
fn emit_byte(&mut self, byte: usize) {
|
|
self.chunk.bytecode.push(byte as u8);
|
|
self.spans.push(self.span);
|
|
}
|
|
|
|
fn len(&self) -> usize {
|
|
self.chunk.bytecode.len()
|
|
}
|
|
|
|
pub fn bind(&mut self, name: &'static str) {
|
|
self.msg(format!("binding `{name}` in {}", self.name));
|
|
self.msg(format!(
|
|
"stack depth: {}; match depth: {}",
|
|
self.stack_depth, self.match_depth
|
|
));
|
|
self.msg(format!(
|
|
"at stack index: {}",
|
|
self.stack_depth - self.match_depth - 1
|
|
));
|
|
let binding = Binding {
|
|
name,
|
|
depth: self.scope_depth,
|
|
stack_pos: self.stack_depth - self.match_depth - 1,
|
|
};
|
|
self.bindings.push(binding);
|
|
self.msg(format!(
|
|
"new locals: {}",
|
|
self.bindings
|
|
.iter()
|
|
.map(|binding| format!("{binding}"))
|
|
.collect::<Vec<_>>()
|
|
.join("|")
|
|
));
|
|
}
|
|
|
|
fn resolve_local(&self, name: &'static str) -> Option<usize> {
|
|
for binding in self.bindings.iter() {
|
|
if binding.name == name {
|
|
return Some(binding.stack_pos);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn resolve_upvalue(&self, name: &'static str) -> Option<usize> {
|
|
self.upvalues.iter().position(|uv| *uv == name)
|
|
}
|
|
|
|
fn resolve_binding(&mut self, name: &'static str) {
|
|
self.msg(format!(
|
|
"resolving binding `{name}` in {}\nlocals: {}",
|
|
self.name,
|
|
self.bindings
|
|
.iter()
|
|
.map(|binding| format!("{binding}"))
|
|
.collect::<Vec<_>>()
|
|
.join("|")
|
|
));
|
|
if let Some(pos) = self.resolve_local(name) {
|
|
self.msg(format!("at locals position {pos}"));
|
|
self.emit_op(Op::PushBinding);
|
|
self.emit_byte(pos);
|
|
self.stack_depth += 1;
|
|
return;
|
|
}
|
|
if let Some(pos) = self.resolve_upvalue(name) {
|
|
self.msg(format!("as upvalue {pos}"));
|
|
self.emit_op(Op::GetUpvalue);
|
|
self.emit_byte(pos);
|
|
self.stack_depth += 1;
|
|
return;
|
|
}
|
|
if self.chunk.env.contains_key(name) {
|
|
self.msg("as global".to_string());
|
|
self.emit_constant(Value::Keyword(name));
|
|
self.emit_op(Op::PushGlobal);
|
|
return;
|
|
}
|
|
self.msg(format!("as enclosing upvalue {}", self.upvalues.len()));
|
|
self.emit_op(Op::GetUpvalue);
|
|
self.emit_byte(self.upvalues.len());
|
|
self.upvalues.push(name);
|
|
self.stack_depth += 1;
|
|
}
|
|
|
|
fn duplicate(&mut self) {
|
|
self.emit_op(Op::Duplicate);
|
|
self.stack_depth += 1;
|
|
}
|
|
|
|
fn pop(&mut self) {
|
|
self.emit_op(Op::Pop);
|
|
self.stack_depth -= 1;
|
|
}
|
|
|
|
fn pop_n(&mut self, n: usize) {
|
|
match n {
|
|
0 => (),
|
|
1 => self.pop(),
|
|
n => {
|
|
self.emit_op(Op::PopN);
|
|
self.emit_byte(n);
|
|
self.stack_depth -= n;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn store(&mut self) {
|
|
self.emit_op(Op::Store);
|
|
self.stack_depth -= 1;
|
|
}
|
|
|
|
fn store_n(&mut self, n: usize) {
|
|
self.emit_op(Op::StoreN);
|
|
self.emit_byte(n);
|
|
self.stack_depth -= n;
|
|
}
|
|
|
|
fn load(&mut self) {
|
|
self.emit_op(Op::Load);
|
|
self.stack_depth += 1;
|
|
}
|
|
|
|
fn load_n(&mut self, n: usize) {
|
|
self.emit_op(Op::LoadN);
|
|
self.emit_byte(n);
|
|
self.stack_depth += n;
|
|
}
|
|
|
|
fn enter_scope(&mut self) {
|
|
self.scope_depth += 1;
|
|
}
|
|
|
|
fn leave_scope(&mut self) {
|
|
self.msg(format!("leaving scope {}", self.scope_depth));
|
|
while let Some(binding) = self.bindings.last() {
|
|
if binding.depth == self.scope_depth {
|
|
let unbound = self.bindings.pop();
|
|
self.msg(format!("releasing binding {}", unbound.unwrap()));
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
self.scope_depth -= 1;
|
|
}
|
|
|
|
fn enter_loop(&mut self, arity: usize) {
|
|
self.loop_info
|
|
.push(LoopInfo::new(self.len(), self.stack_depth - arity));
|
|
}
|
|
|
|
fn leave_loop(&mut self) {
|
|
self.loop_info.pop();
|
|
}
|
|
|
|
fn loop_info(&self) -> LoopInfo {
|
|
self.loop_info.last().unwrap().clone()
|
|
}
|
|
|
|
fn loop_idx(&self) -> usize {
|
|
self.loop_info.last().unwrap().start
|
|
}
|
|
|
|
fn loop_root(&self) -> usize {
|
|
self.loop_info.last().unwrap().stack_root
|
|
}
|
|
|
|
fn msg(&mut self, str: String) {
|
|
self.emit_op(Op::Msg);
|
|
self.emit_byte(self.chunk.msgs.len());
|
|
println!("{str}");
|
|
self.chunk.msgs.push(str);
|
|
}
|
|
|
|
fn report_depth(&mut self, label: &'static str) {
|
|
self.msg(format!("***{label} stack depth: {}", self.stack_depth));
|
|
}
|
|
|
|
fn report_depth_str(&mut self, label: String) {
|
|
self.msg(format!("***{label} stack depth: {}", self.stack_depth));
|
|
}
|
|
|
|
fn report_ast(&mut self, label: String, node: &'static Spanned<Ast>) {
|
|
self.msg(format!("***{label}: {}", node.0.show()))
|
|
}
|
|
|
|
pub fn compile(&mut self) {
|
|
use Ast::*;
|
|
match self.ast {
|
|
Error => unreachable!(),
|
|
Nil => {
|
|
self.emit_op(Op::Nil);
|
|
self.stack_depth += 1;
|
|
}
|
|
Number(n) => self.emit_constant(Value::Number(*n)),
|
|
Boolean(b) => {
|
|
self.emit_op(if *b { Op::True } else { Op::False });
|
|
self.stack_depth += 1;
|
|
}
|
|
String(s) => {
|
|
self.emit_constant(Value::Interned(s));
|
|
}
|
|
Keyword(s) => self.emit_constant(Value::Keyword(s)),
|
|
Block(lines) => {
|
|
let tail_pos = self.tail_pos;
|
|
self.tail_pos = false;
|
|
// increase the scope
|
|
self.enter_scope();
|
|
// stash the stack depth
|
|
let stack_depth = self.stack_depth;
|
|
// evaluate all the lines but the last
|
|
for expr in lines.iter().take(lines.len() - 1) {
|
|
// evaluate the expression
|
|
self.visit(expr);
|
|
// if it doesn't bind a name, pop the result from the stack
|
|
if !is_binding(expr) {
|
|
self.pop();
|
|
}
|
|
}
|
|
|
|
// now, evaluate the last expression in the block
|
|
let last_expr = lines.last().unwrap();
|
|
match last_expr {
|
|
// if the last expression is a let form,
|
|
// return the evaluated rhs instead of whatever is last on the stack
|
|
// we do this by pretending it's a binding
|
|
(Let(patt, expr), _) => {
|
|
// self.match_depth = 0;
|
|
self.visit(expr);
|
|
let expr_pos = self.stack_depth - 1;
|
|
self.report_ast("let binding: matching".to_string(), patt);
|
|
self.reset_match();
|
|
self.visit(patt);
|
|
self.emit_op(Op::PanicIfNoMatch);
|
|
self.emit_op(Op::PushBinding);
|
|
self.emit_byte(expr_pos);
|
|
self.stack_depth += 1;
|
|
}
|
|
// otherwise, just evaluate it and leave the value on the stack
|
|
_ => {
|
|
self.tail_pos = tail_pos;
|
|
self.visit(last_expr);
|
|
}
|
|
}
|
|
|
|
// store the value in the return register
|
|
self.store();
|
|
|
|
// reset the scope
|
|
self.leave_scope();
|
|
// reset the stack
|
|
self.report_depth("leaving block before pop");
|
|
self.msg(format!(
|
|
"popping back from {} to {}",
|
|
self.stack_depth, stack_depth,
|
|
));
|
|
self.pop_n(self.stack_depth - stack_depth);
|
|
// load the value from the return register
|
|
self.load();
|
|
}
|
|
If(cond, then, r#else) => {
|
|
let tail_pos = self.tail_pos;
|
|
self.tail_pos = false;
|
|
self.visit(cond);
|
|
self.report_depth("after condition");
|
|
let jif_idx = self.stub_jump(Op::JumpIfFalse);
|
|
// self.stack_depth -= 1;
|
|
self.tail_pos = tail_pos;
|
|
self.visit(then);
|
|
self.report_depth("after consequent");
|
|
let jump_idx = self.stub_jump(Op::Jump);
|
|
self.stack_depth -= 1;
|
|
self.visit(r#else);
|
|
self.report_depth("after alternative");
|
|
// self.stack_depth += 1;
|
|
let end_idx = self.len();
|
|
let jif_offset = jump_idx - jif_idx;
|
|
let jump_offset = end_idx - jump_idx - 3;
|
|
self.patch_jump(jif_idx, jif_offset);
|
|
self.patch_jump(jump_idx, jump_offset);
|
|
}
|
|
Let(patt, expr) => {
|
|
self.report_depth("before let binding");
|
|
// self.match_depth = 0;
|
|
// self.emit_op(Op::ResetMatch);
|
|
self.visit(expr);
|
|
self.report_depth("after let expr");
|
|
self.report_ast("let binding: matching".to_string(), patt);
|
|
self.reset_match();
|
|
self.visit(patt);
|
|
self.emit_op(Op::PanicIfNoMatch);
|
|
self.report_depth("after let binding");
|
|
}
|
|
WordPattern(name) => {
|
|
self.emit_op(Op::Match);
|
|
self.bind(name);
|
|
}
|
|
Word(name) | Splat(name) => self.resolve_binding(name),
|
|
PlaceholderPattern => {
|
|
self.emit_op(Op::Match);
|
|
}
|
|
NilPattern => {
|
|
self.emit_op(Op::MatchNil);
|
|
}
|
|
BooleanPattern(b) => {
|
|
if *b {
|
|
self.emit_op(Op::MatchTrue);
|
|
} else {
|
|
self.emit_op(Op::MatchFalse);
|
|
}
|
|
}
|
|
NumberPattern(n) => {
|
|
self.match_constant(Value::Number(*n));
|
|
}
|
|
KeywordPattern(s) => {
|
|
let existing_kw = self.chunk.keywords.iter().position(|kw| kw == s);
|
|
let kw_index = match existing_kw {
|
|
Some(index) => index,
|
|
None => self.chunk.keywords.len(),
|
|
};
|
|
if kw_index == self.chunk.keywords.len() {
|
|
self.chunk.keywords.push(s);
|
|
}
|
|
self.match_constant(Value::Keyword(s));
|
|
}
|
|
AsPattern(word, typ) => {
|
|
self.emit_constant(Value::Keyword(typ));
|
|
self.emit_op(Op::MatchType);
|
|
self.stack_depth -= 1;
|
|
self.bind(word);
|
|
}
|
|
StringPattern(s) => {
|
|
self.match_constant(Value::Interned(s));
|
|
}
|
|
TuplePattern(members) => {
|
|
// first, test the tuple against length
|
|
// check if we're splatted
|
|
// different opcodes w/ splats, but same logic
|
|
let mut is_splatted = false;
|
|
if let Some((Splattern(_), _)) = members.last() {
|
|
is_splatted = true;
|
|
self.emit_op(Op::MatchSplattedTuple);
|
|
} else {
|
|
self.emit_op(Op::MatchTuple);
|
|
}
|
|
|
|
self.emit_byte(members.len());
|
|
// skip everything if tuple lengths don't match
|
|
let before_load_tup_idx = self.stub_jump(Op::JumpIfNoMatch);
|
|
|
|
// set up the per-member conditional logic
|
|
let mut jump_idxes = vec![];
|
|
// stash match_depth, and set it to the tuple len
|
|
let match_depth = self.match_depth;
|
|
self.match_depth = members.len();
|
|
|
|
// load the tuple and update the stack len
|
|
if is_splatted {
|
|
self.emit_op(Op::LoadSplattedTuple);
|
|
self.emit_byte(members.len());
|
|
} else {
|
|
self.emit_op(Op::LoadTuple);
|
|
}
|
|
self.stack_depth += members.len();
|
|
|
|
// visit each member
|
|
for member in members {
|
|
// reduce the match depth to start
|
|
self.match_depth -= 1;
|
|
self.emit_op(Op::MatchDepth);
|
|
self.emit_byte(self.match_depth);
|
|
// visit the pattern member
|
|
self.visit(member);
|
|
// and jump if there's no match
|
|
jump_idxes.push(self.stub_jump(Op::JumpIfNoMatch));
|
|
}
|
|
|
|
// if we get here--not having jumped on no match--we're matched; jump the "no match" code
|
|
let jump_idx = self.stub_jump(Op::Jump);
|
|
|
|
// patch up the previous no match jumps to jump to clean-up code
|
|
for idx in jump_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 2)
|
|
}
|
|
// pop everything that was pushed
|
|
// don't change the compiler stack representation, tho
|
|
// we need this as cleanup code with no matches
|
|
// the compiler should still have access to the bindings in this pattern
|
|
self.emit_op(Op::PopN);
|
|
self.emit_byte(members.len());
|
|
|
|
// patch up the tuple length match jump
|
|
self.patch_jump(before_load_tup_idx, self.len() - before_load_tup_idx - 3);
|
|
|
|
// patch up the yes-matches unconditional jump
|
|
self.patch_jump(jump_idx, self.len() - jump_idx - 3);
|
|
|
|
// finally, for any further matches (e.g. nested lists/tuples)
|
|
// add increase the match depth, since we've added a bunch
|
|
// of bindings to the stack
|
|
self.match_depth = match_depth + members.len();
|
|
}
|
|
ListPattern(members) => {
|
|
let mut is_splatted = false;
|
|
if let Some((Splattern(_), _)) = members.last() {
|
|
is_splatted = true;
|
|
self.emit_op(Op::MatchSplattedList)
|
|
} else {
|
|
self.emit_op(Op::MatchList);
|
|
}
|
|
// TODO: lists must be able to be longer than 256 elements; fix this
|
|
self.emit_byte(members.len());
|
|
let before_load_tup_idx = self.stub_jump(Op::JumpIfNoMatch);
|
|
|
|
let mut jump_idxes = vec![];
|
|
let match_depth = self.match_depth;
|
|
self.match_depth = members.len();
|
|
|
|
if is_splatted {
|
|
self.emit_op(Op::LoadSplattedList);
|
|
self.emit_byte(members.len());
|
|
} else {
|
|
self.emit_op(Op::LoadList);
|
|
}
|
|
self.stack_depth += members.len();
|
|
|
|
for member in members {
|
|
self.match_depth -= 1;
|
|
self.emit_op(Op::MatchDepth);
|
|
self.emit_byte(self.match_depth);
|
|
self.visit(member);
|
|
jump_idxes.push(self.stub_jump(Op::JumpIfNoMatch));
|
|
}
|
|
|
|
let jump_idx = self.stub_jump(Op::Jump);
|
|
|
|
for idx in jump_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 2)
|
|
}
|
|
|
|
self.emit_op(Op::PopN);
|
|
self.emit_byte(members.len());
|
|
|
|
self.patch_jump(before_load_tup_idx, self.len() - before_load_tup_idx - 3);
|
|
|
|
self.patch_jump(jump_idx, self.len() - jump_idx - 3);
|
|
|
|
self.match_depth = match_depth + members.len();
|
|
}
|
|
DictPattern(pairs) => {
|
|
// here's an algorithm for dealing with splatted dicts
|
|
// check len to see it's at least as long as the pattern
|
|
// then, match against all the values
|
|
// then push the dict itself as last value
|
|
// and then emit an opcode and constant/keyword to OMIT that key from the dict
|
|
let mut is_splatted = false;
|
|
if let Some((Splattern(_), _)) = pairs.last() {
|
|
is_splatted = true;
|
|
self.emit_op(Op::MatchSplattedDict);
|
|
} else {
|
|
self.emit_op(Op::MatchDict);
|
|
}
|
|
self.emit_byte(pairs.len());
|
|
let before_load_dict_idx = self.stub_jump(Op::JumpIfNoMatch);
|
|
|
|
let mut jump_idxes = vec![];
|
|
let dict_stack_pos = self.stack_depth - self.match_depth - 1;
|
|
let mut splattern = None;
|
|
let mut pairs_len = pairs.len();
|
|
if is_splatted {
|
|
splattern = pairs.last();
|
|
pairs_len -= 1;
|
|
}
|
|
|
|
let match_depth = self.match_depth;
|
|
self.match_depth = 0;
|
|
for pair in pairs.iter().take(pairs_len) {
|
|
let (PairPattern(key, pattern), _) = pair else {
|
|
unreachable!()
|
|
};
|
|
self.emit_constant(Value::Keyword(key));
|
|
self.emit_op(Op::LoadDictValue);
|
|
self.emit_byte(dict_stack_pos);
|
|
self.visit(pattern);
|
|
jump_idxes.push(self.stub_jump(Op::JumpIfNoMatch));
|
|
}
|
|
|
|
if is_splatted {
|
|
// pull the dict out of the stack
|
|
// drop every value in the pattern
|
|
self.emit_op(Op::PushBinding);
|
|
self.emit_byte(dict_stack_pos);
|
|
|
|
for pair in pairs.iter().take(pairs_len) {
|
|
let (PairPattern(key, _), _) = pair else {
|
|
unreachable!()
|
|
};
|
|
self.emit_constant(Value::Keyword(key));
|
|
self.emit_op(Op::DropDictEntry);
|
|
}
|
|
|
|
if let Some(splatt) = splattern {
|
|
self.visit(splatt);
|
|
}
|
|
}
|
|
|
|
self.match_depth = match_depth + pairs.len();
|
|
|
|
let jump_idx = self.stub_jump(Op::Jump);
|
|
|
|
for idx in jump_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 2);
|
|
}
|
|
|
|
self.emit_op(Op::PopN);
|
|
self.emit_byte(pairs.len());
|
|
|
|
self.patch_jump(before_load_dict_idx, self.len() - before_load_dict_idx - 3);
|
|
self.patch_jump(jump_idx, self.len() - jump_idx - 3);
|
|
}
|
|
Splattern(patt) => self.visit(patt),
|
|
InterpolatedPattern(parts, _) => {
|
|
println!("An interpolated pattern of {} parts", parts.len());
|
|
let mut pattern = "".to_string();
|
|
let mut words = vec![];
|
|
for (part, _) in parts {
|
|
match part {
|
|
StringPart::Word(word) => {
|
|
println!("wordpart: {word}");
|
|
words.push(word.clone());
|
|
pattern.push_str("(.*)");
|
|
}
|
|
StringPart::Data(data) => {
|
|
println!("datapart: {data}");
|
|
let data = regex::escape(data);
|
|
pattern.push_str(data.as_str());
|
|
}
|
|
StringPart::Inline(..) => unreachable!(),
|
|
}
|
|
}
|
|
let re = Regex::new(pattern.as_str()).unwrap();
|
|
let moar_words = words.clone();
|
|
let string_pattern = StrPattern { words, re };
|
|
|
|
let pattern_idx = self.chunk.string_patterns.len();
|
|
self.chunk.string_patterns.push(string_pattern);
|
|
|
|
self.emit_op(Op::MatchString);
|
|
self.emit_byte(pattern_idx);
|
|
|
|
let jnm_idx = self.stub_jump(Op::JumpIfNoMatch);
|
|
|
|
self.emit_op(Op::PushStringMatches);
|
|
self.emit_byte(pattern_idx);
|
|
|
|
for word in moar_words {
|
|
let name: &'static str = std::string::String::leak(word);
|
|
let binding = Binding {
|
|
name,
|
|
depth: self.scope_depth,
|
|
stack_pos: self.stack_depth,
|
|
};
|
|
self.bindings.push(binding);
|
|
self.stack_depth += 1;
|
|
}
|
|
|
|
self.patch_jump(jnm_idx, self.len() - jnm_idx - 3);
|
|
}
|
|
PairPattern(_, _) => unreachable!(),
|
|
Tuple(members) => {
|
|
for member in members {
|
|
self.visit(member);
|
|
}
|
|
self.emit_op(Op::PushTuple);
|
|
self.emit_byte(members.len());
|
|
self.stack_depth = self.stack_depth + 1 - members.len();
|
|
}
|
|
List(members) => {
|
|
self.emit_op(Op::PushList);
|
|
self.stack_depth += 1;
|
|
for member in members {
|
|
self.visit(member);
|
|
if matches!(member, (Splat(..), _)) {
|
|
self.emit_op(Op::ConcatList);
|
|
} else {
|
|
self.emit_op(Op::AppendList);
|
|
}
|
|
self.stack_depth -= 1;
|
|
}
|
|
}
|
|
LBox(name, expr) => {
|
|
self.visit(expr);
|
|
self.emit_op(Op::PushBox);
|
|
self.bind(name);
|
|
}
|
|
Dict(pairs) => {
|
|
self.emit_op(Op::PushDict);
|
|
self.stack_depth += 1;
|
|
for pair in pairs.iter().rev() {
|
|
self.visit(pair);
|
|
if matches!(pair, (Splat(..), _)) {
|
|
self.emit_op(Op::ConcatDict);
|
|
self.stack_depth -= 1;
|
|
} else {
|
|
self.emit_op(Op::AppendDict);
|
|
self.stack_depth -= 2;
|
|
}
|
|
}
|
|
}
|
|
Pair(key, value) => {
|
|
self.emit_constant(Value::Keyword(key));
|
|
self.visit(value);
|
|
}
|
|
// TODO: thread tail position through this
|
|
Synthetic(first, second, rest) => {
|
|
let tail_pos = self.tail_pos;
|
|
self.tail_pos = false;
|
|
match (&first.0, &second.0) {
|
|
(Word(name), Keyword(key)) => {
|
|
self.report_depth_str(format!("accessing keyword: {name} :{key}"));
|
|
self.visit(first);
|
|
self.visit(second);
|
|
self.emit_op(Op::GetKey);
|
|
self.stack_depth -= 1;
|
|
self.report_depth("after keyword access");
|
|
}
|
|
(Keyword(_), Arguments(args)) => {
|
|
self.visit(&args[0]);
|
|
self.visit(first);
|
|
self.emit_op(Op::GetKey);
|
|
self.stack_depth -= 1;
|
|
}
|
|
(Or, Arguments(args)) => {
|
|
let mut jump_idxes = vec![];
|
|
if !args.is_empty() {
|
|
let mut args = args.iter().rev();
|
|
let last = args.next().unwrap();
|
|
for arg in args.rev() {
|
|
self.visit(arg);
|
|
self.duplicate();
|
|
jump_idxes.push(self.stub_jump(Op::JumpIfTrue));
|
|
self.pop();
|
|
}
|
|
self.visit(last);
|
|
for idx in jump_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 3);
|
|
}
|
|
} else {
|
|
self.emit_op(Op::False);
|
|
self.stack_depth += 1;
|
|
}
|
|
}
|
|
(And, Arguments(args)) => {
|
|
let mut jump_idxes = vec![];
|
|
if !args.is_empty() {
|
|
let mut args = args.iter().rev();
|
|
let last = args.next().unwrap();
|
|
for arg in args.rev() {
|
|
self.visit(arg);
|
|
self.duplicate();
|
|
jump_idxes.push(self.stub_jump(Op::JumpIfFalse));
|
|
self.pop();
|
|
}
|
|
self.visit(last);
|
|
for idx in jump_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 3);
|
|
}
|
|
} else {
|
|
self.emit_op(Op::True);
|
|
self.stack_depth += 1;
|
|
}
|
|
}
|
|
(Word(fn_name), Arguments(args)) => {
|
|
self.report_depth_str(format!("calling function {fn_name}"));
|
|
if has_placeholder(args) {
|
|
let arity = args.len();
|
|
for arg in args {
|
|
self.visit(arg);
|
|
}
|
|
self.resolve_binding(fn_name);
|
|
self.emit_op(Op::Partial);
|
|
self.emit_byte(arity);
|
|
self.stack_depth -= 1;
|
|
} else {
|
|
match get_builtin(fn_name, args.len()) {
|
|
Some(code) => {
|
|
for arg in args {
|
|
self.visit(arg);
|
|
}
|
|
self.emit_op(code);
|
|
self.stack_depth -= args.len() - 1;
|
|
}
|
|
None => {
|
|
let arity = args.len();
|
|
for arg in args {
|
|
self.visit(arg);
|
|
}
|
|
self.resolve_binding(fn_name);
|
|
// if we're in tail position AND there aren't any rest args, this should be a tail call (I think)
|
|
self.report_depth_str(format!("after {arity} args"));
|
|
if rest.is_empty() && tail_pos {
|
|
self.emit_op(Op::TailCall);
|
|
} else {
|
|
self.emit_op(Op::Call);
|
|
}
|
|
self.emit_byte(arity);
|
|
self.stack_depth -= arity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
// the last term in rest should be in tail position if we are in tail position
|
|
let num_rest_terms = rest.len();
|
|
for (i, (term, _)) in rest.iter().enumerate() {
|
|
match term {
|
|
Keyword(str) => {
|
|
self.emit_constant(Value::Keyword(str));
|
|
self.emit_op(Op::GetKey);
|
|
self.stack_depth -= 1;
|
|
}
|
|
Arguments(args) => {
|
|
self.store();
|
|
let arity = args.len();
|
|
for arg in args {
|
|
self.visit(arg);
|
|
}
|
|
self.load();
|
|
if tail_pos && i == num_rest_terms - 1 {
|
|
self.emit_op(Op::TailCall)
|
|
} else {
|
|
self.emit_op(Op::Call);
|
|
}
|
|
self.emit_byte(arity);
|
|
self.stack_depth -= arity;
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
self.tail_pos = tail_pos;
|
|
}
|
|
When(clauses) => {
|
|
let tail_pos = self.tail_pos;
|
|
let mut jump_idxes = vec![];
|
|
let mut clauses = clauses.iter();
|
|
while let Some((WhenClause(cond, body), _)) = clauses.next() {
|
|
self.tail_pos = false;
|
|
self.visit(cond.as_ref());
|
|
let jif_jump_idx = self.stub_jump(Op::JumpIfFalse);
|
|
self.stack_depth -= 1;
|
|
self.tail_pos = tail_pos;
|
|
self.visit(body);
|
|
self.stack_depth -= 1;
|
|
jump_idxes.push(self.stub_jump(Op::Jump));
|
|
self.patch_jump(jif_jump_idx, self.len() - jif_jump_idx - 3);
|
|
}
|
|
self.emit_op(Op::PanicNoWhen);
|
|
for idx in jump_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 3);
|
|
}
|
|
self.stack_depth += 1;
|
|
}
|
|
WhenClause(..) => unreachable!(),
|
|
Match(scrutinee, clauses) => {
|
|
let tail_pos = self.tail_pos;
|
|
self.tail_pos = false;
|
|
self.visit(scrutinee.as_ref());
|
|
let stack_depth = self.stack_depth;
|
|
let mut jump_idxes = vec![];
|
|
let mut clauses = clauses.iter();
|
|
while let Some((MatchClause(pattern, guard, body), _)) = clauses.next() {
|
|
self.tail_pos = false;
|
|
let mut no_match_jumps = vec![];
|
|
self.report_ast("match clause: ".to_string(), pattern);
|
|
// self.scope_depth += 1;
|
|
self.enter_scope();
|
|
self.match_depth = 0;
|
|
self.visit(pattern);
|
|
no_match_jumps.push(self.stub_jump(Op::JumpIfNoMatch));
|
|
if guard.is_some() {
|
|
let guard_expr: &'static Spanned<Ast> =
|
|
Box::leak(Box::new(guard.clone().unwrap()));
|
|
self.visit(guard_expr);
|
|
no_match_jumps.push(self.stub_jump(Op::JumpIfFalse));
|
|
self.stack_depth -= 1;
|
|
}
|
|
self.tail_pos = tail_pos;
|
|
self.visit(body);
|
|
// self.emit_op(Op::Store);
|
|
self.store();
|
|
self.leave_scope();
|
|
// self.scope_depth -= 1;
|
|
// while let Some(binding) = self.bindings.last() {
|
|
// if binding.depth > self.scope_depth {
|
|
// self.bindings.pop();
|
|
// } else {
|
|
// break;
|
|
// }
|
|
// }
|
|
self.pop_n(self.stack_depth - stack_depth);
|
|
jump_idxes.push(self.stub_jump(Op::Jump));
|
|
for idx in no_match_jumps {
|
|
self.patch_jump(idx, self.len() - idx - 3);
|
|
}
|
|
}
|
|
self.emit_op(Op::PanicNoMatch);
|
|
|
|
for idx in jump_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 3);
|
|
}
|
|
self.pop_n(self.stack_depth - stack_depth);
|
|
self.emit_op(Op::Load);
|
|
self.stack_depth += 1;
|
|
}
|
|
MatchClause(..) => unreachable!(),
|
|
Fn(name, body, doc) => {
|
|
let is_anon = name.is_empty();
|
|
let mut name = name;
|
|
|
|
if !is_anon {
|
|
let declared = self.chunk.constants.iter().any(|val| match val {
|
|
Value::Fn(lfn) => {
|
|
if matches!(lfn.as_ref(), LFn::Declared { .. }) {
|
|
lfn.name() == *name
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
_ => false,
|
|
});
|
|
if !declared {
|
|
let declaration = Value::Fn(Rc::new(LFn::Declared { name }));
|
|
self.emit_constant(declaration);
|
|
self.bind(name);
|
|
}
|
|
} else {
|
|
name = &"_anon";
|
|
}
|
|
|
|
let FnBody(fn_body) = &body.as_ref().0 else {
|
|
unreachable!()
|
|
};
|
|
|
|
let mut compilers: HashMap<u8, Compiler> = HashMap::new();
|
|
|
|
let mut upvalues = vec![];
|
|
|
|
let mut has_splat = false;
|
|
|
|
for clause in fn_body {
|
|
let MatchClause(pattern, guard, clause_body) = &clause.0 else {
|
|
unreachable!()
|
|
};
|
|
let full_pattern = pattern;
|
|
let TuplePattern(pattern) = &pattern.0 else {
|
|
unreachable!()
|
|
};
|
|
|
|
if matches!(pattern.last(), Some((Splattern(_), _))) {
|
|
has_splat = true;
|
|
};
|
|
|
|
let arity = pattern.len() as u8;
|
|
|
|
let compiler = match compilers.get_mut(&arity) {
|
|
Some(compiler) => compiler,
|
|
None => {
|
|
let mut compiler = Compiler::new(
|
|
clause,
|
|
name,
|
|
self.src,
|
|
Some(self),
|
|
self.chunk.env.clone(),
|
|
self.debug,
|
|
);
|
|
compiler.reset_match();
|
|
// compiler.emit_op(Op::ResetMatch);
|
|
compilers.insert(arity, compiler);
|
|
compilers.get_mut(&arity).unwrap()
|
|
}
|
|
};
|
|
compiler.tail_pos = false;
|
|
|
|
compiler.stack_depth += arity as usize;
|
|
compiler.scope_depth += 1;
|
|
compiler.match_depth = arity as usize;
|
|
|
|
std::mem::swap(&mut upvalues, &mut compiler.upvalues);
|
|
|
|
let mut tup_jump_idxes = vec![];
|
|
compiler.report_ast("function clause matching: ".to_string(), full_pattern);
|
|
for member in pattern {
|
|
compiler.match_depth -= 1;
|
|
compiler.emit_op(Op::MatchDepth);
|
|
compiler.emit_byte(compiler.match_depth);
|
|
compiler.visit(member);
|
|
tup_jump_idxes.push(compiler.stub_jump(Op::JumpIfNoMatch));
|
|
}
|
|
if pattern.is_empty() {
|
|
compiler.emit_op(Op::Match);
|
|
}
|
|
let jump_idx = compiler.stub_jump(Op::Jump);
|
|
for idx in tup_jump_idxes {
|
|
compiler.patch_jump(idx, compiler.len() - idx - 3);
|
|
}
|
|
// compiler.emit_op(Op::PopN);
|
|
// compiler.emit_byte(arity as usize);
|
|
compiler.patch_jump(jump_idx, compiler.len() - jump_idx - 3);
|
|
let mut no_match_jumps = vec![];
|
|
no_match_jumps.push(compiler.stub_jump(Op::JumpIfNoMatch));
|
|
if guard.is_some() {
|
|
let guard_expr: &'static Spanned<Ast> =
|
|
Box::leak(Box::new(guard.clone().unwrap()));
|
|
compiler.visit(guard_expr);
|
|
no_match_jumps.push(compiler.stub_jump(Op::JumpIfFalse));
|
|
compiler.stack_depth -= 1;
|
|
}
|
|
compiler.tail_pos = true;
|
|
compiler.visit(clause_body);
|
|
compiler.store();
|
|
compiler.scope_depth -= 1;
|
|
while let Some(binding) = compiler.bindings.last() {
|
|
if binding.depth > compiler.scope_depth {
|
|
compiler.bindings.pop();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
compiler.pop_n(compiler.stack_depth);
|
|
compiler.stack_depth = 0;
|
|
compiler.emit_op(Op::Return);
|
|
for idx in no_match_jumps {
|
|
compiler.patch_jump(idx, compiler.len() - idx - 3);
|
|
}
|
|
// compiler.scope_depth -= 1;
|
|
|
|
std::mem::swap(&mut compiler.upvalues, &mut upvalues);
|
|
}
|
|
|
|
let mut compilers = compilers.into_iter().collect::<Vec<_>>();
|
|
compilers.sort_by(|(a, _), (b, _)| a.cmp(b));
|
|
|
|
let mut arities = vec![];
|
|
let mut chunks = vec![];
|
|
|
|
for (arity, mut compiler) in compilers {
|
|
compiler.emit_op(Op::PanicNoMatch);
|
|
let chunk = compiler.chunk;
|
|
if self.debug {
|
|
println!("=== function chuncktion: {name}/{arity} ===");
|
|
chunk.dissasemble();
|
|
}
|
|
|
|
arities.push(arity);
|
|
chunks.push(chunk);
|
|
}
|
|
|
|
let splat = if has_splat {
|
|
arities.iter().fold(0, |max, curr| max.max(*curr))
|
|
} else {
|
|
0
|
|
};
|
|
|
|
let lfn = crate::value::LFn::Defined {
|
|
name,
|
|
doc: *doc,
|
|
arities,
|
|
chunks,
|
|
splat,
|
|
closed: RefCell::new(vec![]),
|
|
};
|
|
|
|
// TODO: check if the function is already declared, and pull out the relevant OnceCell if need be
|
|
let the_fn = Value::Fn(Rc::new(lfn));
|
|
// self.emit_constant(the_fn);
|
|
// self.bind(name);
|
|
|
|
if !is_anon {
|
|
let declaration_idx = self
|
|
.chunk
|
|
.constants
|
|
.iter()
|
|
.position(|val| match val {
|
|
Value::Fn(lfn) => {
|
|
if matches!(lfn.as_ref(), LFn::Declared { .. }) {
|
|
lfn.name() == *name
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
_ => false,
|
|
})
|
|
.unwrap();
|
|
self.chunk.constants[declaration_idx] = the_fn;
|
|
} else {
|
|
self.emit_constant(the_fn)
|
|
}
|
|
|
|
for upvalue in upvalues {
|
|
self.resolve_binding(upvalue);
|
|
self.emit_op(Op::SetUpvalue);
|
|
self.stack_depth -= 1;
|
|
}
|
|
}
|
|
FnDeclaration(name) => {
|
|
let lfn = Value::Fn(Rc::new(LFn::Declared { name }));
|
|
self.emit_constant(lfn);
|
|
self.bind(name);
|
|
}
|
|
FnBody(_) => unreachable!(),
|
|
Repeat(times, body) => {
|
|
self.visit(times);
|
|
self.emit_op(Op::Truncate);
|
|
// skip the decrement the first time
|
|
self.emit_op(Op::Jump);
|
|
self.emit_byte(0);
|
|
self.emit_byte(1);
|
|
// begin repeat
|
|
self.emit_op(Op::Decrement);
|
|
let repeat_begin = self.len();
|
|
self.emit_op(Op::Duplicate);
|
|
let jiz_idx = self.stub_jump(Op::JumpIfZero);
|
|
// compile the body
|
|
self.visit(body);
|
|
// pop whatever value the body returns
|
|
self.pop();
|
|
let jump_back = self.stub_jump(Op::JumpBack);
|
|
// set jump points
|
|
self.patch_jump(jump_back, self.len() - repeat_begin - 2);
|
|
self.patch_jump(jiz_idx, self.len() - repeat_begin - 4);
|
|
self.pop();
|
|
self.emit_constant(Value::Nil);
|
|
}
|
|
Loop(value, clauses) => {
|
|
self.report_depth("entering loop");
|
|
let tail_pos = self.tail_pos;
|
|
self.tail_pos = false;
|
|
//algo:
|
|
//first, put the values on the stack
|
|
let (Ast::Tuple(members), _) = value.as_ref() else {
|
|
unreachable!()
|
|
};
|
|
for member in members {
|
|
self.visit(member);
|
|
}
|
|
self.report_depth("after loop args");
|
|
let arity = members.len();
|
|
// self.emit_op(Op::StoreN);
|
|
// self.emit_byte(members.len());
|
|
self.store_n(arity);
|
|
let stack_depth = self.stack_depth;
|
|
self.report_depth("loop: after store");
|
|
//then, save the beginning of the loop
|
|
// self.emit_op(Op::Load);
|
|
self.load_n(arity);
|
|
self.enter_loop(arity);
|
|
// self.stack_depth += arity;
|
|
//next, compile each clause:
|
|
let mut clauses = clauses.iter();
|
|
let mut jump_idxes = vec![];
|
|
while let Some((Ast::MatchClause(pattern, guard, body), _)) = clauses.next() {
|
|
self.tail_pos = false;
|
|
self.report_depth("loop: after load");
|
|
self.reset_match();
|
|
// self.emit_op(Op::ResetMatch);
|
|
self.enter_scope();
|
|
// self.scope_depth += 1;
|
|
let (Ast::TuplePattern(members), _) = pattern.as_ref() else {
|
|
unreachable!()
|
|
};
|
|
self.match_depth = arity;
|
|
let mut jnm_idxes = vec![];
|
|
self.report_ast("loop clause matching: ".to_string(), pattern);
|
|
for member in members {
|
|
self.match_depth -= 1;
|
|
self.emit_op(Op::MatchDepth);
|
|
self.emit_byte(self.match_depth);
|
|
self.visit(member);
|
|
jnm_idxes.push(self.stub_jump(Op::JumpIfNoMatch));
|
|
}
|
|
if guard.is_some() {
|
|
let guard_expr: &'static Spanned<Ast> =
|
|
Box::leak(Box::new(guard.clone().unwrap()));
|
|
self.visit(guard_expr);
|
|
jnm_idxes.push(self.stub_jump(Op::JumpIfFalse));
|
|
}
|
|
self.tail_pos = tail_pos;
|
|
self.report_depth("loop: before body");
|
|
self.visit(body);
|
|
self.report_depth("loop: after body, before store");
|
|
// self.emit_op(Op::Store);
|
|
self.store();
|
|
self.report_depth("loop: after body, after store");
|
|
self.leave_scope();
|
|
self.report_depth_str(format!(
|
|
"resetting the stack after loop from {} to {stack_depth}",
|
|
self.stack_depth,
|
|
));
|
|
self.pop_n(self.stack_depth - stack_depth);
|
|
// while self.stack_depth > stack_depth {
|
|
// self.pop();
|
|
// }
|
|
jump_idxes.push(self.stub_jump(Op::Jump));
|
|
for idx in jnm_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 3);
|
|
}
|
|
self.stack_depth += arity;
|
|
}
|
|
self.emit_op(Op::PanicNoMatch);
|
|
for idx in jump_idxes {
|
|
self.patch_jump(idx, self.len() - idx - 3);
|
|
}
|
|
self.report_depth("before loop arity adjustment");
|
|
self.stack_depth -= arity;
|
|
// pop back to the original depth before load
|
|
// i.e. clear loop args
|
|
// self.pop();
|
|
// self.emit_op(Op::Load);
|
|
self.load();
|
|
// self.stack_depth += 1;
|
|
self.leave_loop();
|
|
self.report_depth("at very end of loop after load");
|
|
}
|
|
Recur(args) => {
|
|
// self.emit_op(Op::Nothing);
|
|
self.report_depth("recur: before args");
|
|
let tail_pos = self.tail_pos;
|
|
self.tail_pos = false;
|
|
let mut argnum = 0;
|
|
for arg in args {
|
|
self.msg(format!("recur arg: {argnum}"));
|
|
argnum += 1;
|
|
self.visit(arg);
|
|
}
|
|
self.report_depth("recur: after args");
|
|
self.store_n(args.len());
|
|
self.report_depth("recur: after store");
|
|
self.msg(format!("loop root depth: {}", self.loop_root()));
|
|
self.pop_n(self.stack_depth - self.loop_root());
|
|
self.report_depth("recur: after stack reset");
|
|
self.load_n(args.len());
|
|
self.report_depth("recur: after load, end of compilation");
|
|
self.jump(Op::JumpBack, self.len() - self.loop_idx());
|
|
self.tail_pos = tail_pos;
|
|
}
|
|
Panic(msg) => {
|
|
self.visit(msg);
|
|
self.emit_op(Op::Panic);
|
|
}
|
|
Interpolated(parts) => {
|
|
self.emit_op(Op::EmptyString);
|
|
self.stack_depth += 1;
|
|
for part in parts {
|
|
let str = &part.0;
|
|
match str {
|
|
StringPart::Inline(_) => unreachable!(),
|
|
StringPart::Data(str) => {
|
|
let allocated = Value::String(Rc::new(str.clone()));
|
|
self.emit_constant(allocated);
|
|
self.emit_op(Op::ConcatStrings);
|
|
}
|
|
StringPart::Word(word) => {
|
|
self.resolve_binding(word);
|
|
self.emit_op(Op::Stringify);
|
|
self.emit_op(Op::ConcatStrings);
|
|
}
|
|
}
|
|
self.stack_depth -= 1;
|
|
}
|
|
}
|
|
Do(terms) => {
|
|
let mut terms = terms.iter();
|
|
let first = terms.next().unwrap();
|
|
let mut terms = terms.rev();
|
|
let last = terms.next().unwrap();
|
|
let terms = terms.rev();
|
|
// put the first value on the stack
|
|
let tail_pos = self.tail_pos;
|
|
self.tail_pos = false;
|
|
self.visit(first);
|
|
for term in terms {
|
|
self.visit(term);
|
|
self.emit_op(Op::Call);
|
|
self.emit_byte(1);
|
|
self.stack_depth -= 1;
|
|
}
|
|
self.visit(last);
|
|
if tail_pos {
|
|
self.emit_op(Op::TailCall)
|
|
} else {
|
|
self.emit_op(Op::Call);
|
|
}
|
|
self.emit_byte(1);
|
|
self.tail_pos = tail_pos;
|
|
self.stack_depth -= 1;
|
|
}
|
|
Placeholder => {
|
|
self.emit_op(Op::Nothing);
|
|
}
|
|
And | Or | Arguments(..) => unreachable!(),
|
|
}
|
|
}
|
|
|
|
pub fn disassemble(&self) {
|
|
println!("=== chunk: {} ===", self.name);
|
|
self.chunk.dissasemble();
|
|
}
|
|
}
|