twc/rudus
5
0
Fork 0
Code Issues 25 Pull Requests Actions Packages Projects Releases Wiki Activity

maybe actually fix the loop stuff; lots of QOL improvements

Browse Source
This commit is contained in:
Scott Richmond 2025-06-22 19:42:25 -04:00
parent 86de66c4d2
commit e4a948ba94
6 changed files with 2825 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
sandbox.ld
View File

@ -1,13 +1,14 @@
let test = 2
let test = 3
loop ([1, 2, 3]) with {
let quux = loop ([1, 2]) with {
([]) -> false
([x]) -> eq? (x, test)
([x, ...xs]) -> if eq? (x, test)
then true
then :yes
else recur (xs)
}
let foo = :bar
fn not {
@ -16,11 +17,15 @@ fn not {
(_) -> false
}
& loop ([1, 2, 3]) with {
& ([]) -> false
& ([y]) -> eq? (y, test)
& ([y, ...ys]) -> if not (eq? (y, test))
& then recur (ys)
& else true
& }
let frob = loop ([1, 2, 3]) with {
([]) -> false
([y]) -> eq? (y, test)
([y, ...ys]) -> if not (eq? (y, test))
then recur (ys)
else true
}
[quux, frob]

2379
sandbox_run.txt Normal file
View File

File diff suppressed because it is too large Load Diff

86
src/chunk.rs Normal file
View File

@ -0,0 +1,86 @@
use crate::op::Op;
use crate::value::Value;
use imbl::HashMap;
use num_traits::FromPrimitive;
use regex::Regex;
#[derive(Clone, Debug)]
pub struct StrPattern {
pub words: Vec<String>,
pub re: Regex,
}
#[derive(Clone, Debug)]
pub struct Chunk {
pub constants: Vec<Value>,
pub bytecode: Vec<u8>,
pub keywords: Vec<&'static str>,
pub string_patterns: Vec<StrPattern>,
pub env: HashMap<&'static str, Value>,
pub msgs: Vec<String>,
}
impl Chunk {
pub fn dissasemble_instr(&self, i: &mut usize) {
let op = Op::from_u8(self.bytecode[*i]).unwrap();
use Op::*;
match op {
Pop | Store | Stash | Load | Nil | True | False | MatchNil | MatchTrue | MatchFalse
| PanicIfNoMatch | ResetMatch | GetKey | PanicNoWhen | PanicNoMatch | TypeOf
| Duplicate | Decrement | Truncate | Noop | LoadTuple | LoadList | Eq | Add | Sub
| Mult | Div | Unbox | BoxStore | Assert | Get | At | Not | Panic | EmptyString
| ConcatStrings | Stringify | MatchType | Return | Match | Print | AppendList
| ConcatList | PushList | PushDict | AppendDict | ConcatDict | Nothing | PushGlobal
| SetUpvalue => {
println!("{i:04}: {op}")
}
Constant | MatchConstant => {
let high = self.bytecode[*i + 1];
let low = self.bytecode[*i + 2];
let idx = ((high as usize) << 8) + low as usize;
let value = &self.constants[idx].show();
println!("{i:04}: {:16} {idx:05}: {value}", op.to_string());
*i += 2;
}
Msg => {
let msg_idx = self.bytecode[*i + 1];
let msg = &self.msgs[msg_idx as usize];
println!("{i:04}: {msg}");
*i += 1;
}
PushBinding | MatchTuple | MatchSplattedTuple | LoadSplattedTuple | MatchList
| MatchSplattedList | LoadSplattedList | MatchDict | MatchSplattedDict
| DropDictEntry | LoadDictValue | PushTuple | PushBox | MatchDepth | PopN | StoreN
| Call | GetUpvalue | Partial | MatchString | PushStringMatches | TailCall | LoadN => {
let next = self.bytecode[*i + 1];
println!("{i:04}: {:16} {next:03}", op.to_string());
*i += 1;
}
Jump | JumpIfFalse | JumpIfTrue | JumpIfNoMatch | JumpIfMatch | JumpBack
| JumpIfZero => {
let high = self.bytecode[*i + 1];
let low = self.bytecode[*i + 2];
let len = ((high as u16) << 8) + low as u16;
println!("{i:04}: {:16} {len:05}", op.to_string());
*i += 2;
}
}
}
pub fn dissasemble(&self) {
println!("IDX | CODE | INFO");
let mut i = 0;
while i < self.bytecode.len() {
self.dissasemble_instr(&mut i);
i += 1;
}
}
// pub fn kw_from(&self, kw: &str) -> Option<Value> {
// self.kw_index_from(kw).map(Value::Keyword)
// }
// pub fn kw_index_from(&self, kw: &str) -> Option<usize> {
// self.keywords.iter().position(|s| *s == kw)
// }
}

166
src/compiler.rs
View File

@ -17,6 +17,12 @@ pub struct Binding {
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,
@ -147,6 +153,11 @@ impl<'a> Compiler<'a> {
}
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);
@ -183,6 +194,11 @@ impl<'a> Compiler<'a> {
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,
@ -234,7 +250,14 @@ impl<'a> Compiler<'a> {
stack_pos: self.stack_depth - self.match_depth - 1,
};
self.bindings.push(binding);
self.msg(format!("locals are now: {:?}", self.bindings));
self.msg(format!(
"new locals: {}",
self.bindings
.iter()
.map(|binding| format!("{binding}"))
.collect::<Vec<_>>()
.join("|")
));
}
fn resolve_local(&self, name: &'static str) -> Option<usize> {
@ -252,8 +275,13 @@ impl<'a> Compiler<'a> {
fn resolve_binding(&mut self, name: &'static str) {
self.msg(format!(
"resolving binding `{name}` in {}\nlocals: {:?}",
self.name, self.bindings
"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}"));
@ -299,6 +327,28 @@ impl<'a> Compiler<'a> {
}
}
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;
}
@ -308,7 +358,7 @@ impl<'a> Compiler<'a> {
while let Some(binding) = self.bindings.last() {
if binding.depth == self.scope_depth {
let unbound = self.bindings.pop();
self.msg(format!("releasing binding {:?}", unbound));
self.msg(format!("releasing binding {}", unbound.unwrap()));
} else {
break;
}
@ -316,9 +366,9 @@ impl<'a> Compiler<'a> {
self.scope_depth -= 1;
}
fn enter_loop(&mut self) {
fn enter_loop(&mut self, arity: usize) {
self.loop_info
.push(LoopInfo::new(self.len(), self.stack_depth));
.push(LoopInfo::new(self.len(), self.stack_depth - arity));
}
fn leave_loop(&mut self) {
@ -340,6 +390,7 @@ impl<'a> Compiler<'a> {
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);
}
@ -397,11 +448,12 @@ impl<'a> Compiler<'a> {
// 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.emit_op(Op::ResetMatch);
// self.match_depth = 0;
// self.emit_op(Op::ResetMatch);
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);
@ -419,7 +471,8 @@ impl<'a> Compiler<'a> {
self.stack_depth += 1;
// store the value in the return register
self.emit_op(Op::Store);
// self.emit_op(Op::Store);
self.store();
// reset the scope
self.leave_scope();
@ -434,7 +487,8 @@ impl<'a> Compiler<'a> {
// reset the stack
self.pop_n(self.stack_depth - stack_depth - 1);
// load the value from the return register
self.emit_op(Op::Load);
self.load();
// self.emit_op(Op::Load);
}
If(cond, then, r#else) => {
let tail_pos = self.tail_pos;
@ -442,7 +496,7 @@ impl<'a> Compiler<'a> {
self.visit(cond);
self.report_depth("after condition");
let jif_idx = self.stub_jump(Op::JumpIfFalse);
self.stack_depth -= 1;
// self.stack_depth -= 1;
self.tail_pos = tail_pos;
self.visit(then);
self.report_depth("after consequent");
@ -459,11 +513,12 @@ impl<'a> Compiler<'a> {
}
Let(patt, expr) => {
self.report_depth("before let binding");
self.match_depth = 0;
self.emit_op(Op::ResetMatch);
// 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");
@ -819,7 +874,8 @@ impl<'a> Compiler<'a> {
for idx in jump_idxes {
self.patch_jump(idx, self.len() - idx);
}
self.emit_op(Op::Load);
// self.emit_op(Op::Load);
self.load();
} else {
self.emit_op(Op::False);
}
@ -837,7 +893,8 @@ impl<'a> Compiler<'a> {
for idx in jump_idxes {
self.patch_jump(idx, self.len() - idx);
}
self.emit_op(Op::Load);
// self.emit_op(Op::Load);
self.load();
} else {
self.emit_op(Op::True);
}
@ -961,7 +1018,8 @@ impl<'a> Compiler<'a> {
}
self.tail_pos = tail_pos;
self.visit(body);
self.emit_op(Op::Store);
// self.emit_op(Op::Store);
self.store();
self.leave_scope();
// self.scope_depth -= 1;
// while let Some(binding) = self.bindings.last() {
@ -1047,7 +1105,8 @@ impl<'a> Compiler<'a> {
self.chunk.env.clone(),
self.debug,
);
compiler.emit_op(Op::ResetMatch);
compiler.reset_match();
// compiler.emit_op(Op::ResetMatch);
compilers.insert(arity, compiler);
compilers.get_mut(&arity).unwrap()
}
@ -1090,7 +1149,8 @@ impl<'a> Compiler<'a> {
}
compiler.tail_pos = true;
compiler.visit(clause_body);
compiler.emit_op(Op::Store);
// compiler.emit_op(Op::Store);
compiler.store();
compiler.scope_depth -= 1;
while let Some(binding) = compiler.bindings.last() {
if binding.depth > compiler.scope_depth {
@ -1217,28 +1277,25 @@ impl<'a> Compiler<'a> {
self.visit(member);
}
self.report_depth("after loop args");
self.emit_op(Op::StoreN);
self.emit_byte(members.len());
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.msg(format!(
"***after store, stack depth is now {}",
self.stack_depth
));
self.report_depth("loop: after store");
//then, save the beginning of the loop
self.emit_op(Op::Load);
self.enter_loop();
// self.emit_op(Op::Load);
self.load_n(arity);
self.enter_loop(arity);
// self.stack_depth += arity;
//next, compile each clause:
self.msg(format!(
"***after load, stack depth is now {}",
self.stack_depth
));
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.emit_op(Op::ResetMatch);
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 {
@ -1259,19 +1316,17 @@ impl<'a> Compiler<'a> {
Box::leak(Box::new(guard.clone().unwrap()));
self.visit(guard_expr);
jnm_idxes.push(self.stub_jump(Op::JumpIfFalse));
self.stack_depth -= 1;
}
self.tail_pos = tail_pos;
self.msg(format!(
"***before visiting body, the stack depth is {}",
self.stack_depth
));
self.report_depth("loop: before body");
self.visit(body);
self.report_depth("after loop body, before store");
self.emit_op(Op::Store);
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 {stack_depth} to {}",
"resetting the stack after loop from {} to {stack_depth}",
self.stack_depth,
));
self.pop_n(self.stack_depth - stack_depth);
@ -1282,26 +1337,26 @@ impl<'a> Compiler<'a> {
for idx in jnm_idxes {
self.patch_jump(idx, self.len() - idx - 3);
}
// self.scope_depth -= 1;
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.stack_depth += 1;
// 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.msg(format!(
"before visiting recur args the compiler thinks the stack depth is {}",
self.stack_depth
));
self.report_depth("recur: before args");
let tail_pos = self.tail_pos;
self.tail_pos = false;
let mut argnum = 0;
@ -1310,15 +1365,14 @@ impl<'a> Compiler<'a> {
argnum += 1;
self.visit(arg);
}
self.msg(format!(
"after visiting recur args the compiler thinks the stack depth is {}",
self.stack_depth,
));
self.emit_op(Op::StoreN);
self.emit_byte(args.len());
self.emit_op(Op::PopN);
self.emit_byte(self.stack_depth - self.loop_root());
self.emit_op(Op::Load);
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;
}

226
src/op.rs Normal file
View File

@ -0,0 +1,226 @@
use num_derive::{FromPrimitive, ToPrimitive};
#[derive(Copy, Clone, Debug, PartialEq, Eq, FromPrimitive, ToPrimitive)]
pub enum Op {
Noop,
Nothing,
Nil,
True,
False,
Constant,
Jump,
JumpIfFalse,
JumpIfTrue,
Pop,
PopN,
PushBinding,
PushGlobal,
Store,
StoreN,
Stash,
Load,
LoadN,
ResetMatch,
Match,
MatchNil,
MatchTrue,
MatchFalse,
PanicIfNoMatch,
MatchConstant,
MatchString,
PushStringMatches,
MatchType,
MatchTuple,
MatchSplattedTuple,
PushTuple,
LoadTuple,
LoadSplattedTuple,
MatchList,
MatchSplattedList,
LoadList,
LoadSplattedList,
PushList,
AppendList,
ConcatList,
PushDict,
AppendDict,
ConcatDict,
LoadDictValue,
MatchDict,
MatchSplattedDict,
DropDictEntry,
PushBox,
GetKey,
PanicNoWhen,
JumpIfNoMatch,
JumpIfMatch,
PanicNoMatch,
TypeOf,
JumpBack,
JumpIfZero,
Duplicate,
Decrement,
Truncate,
MatchDepth,
Panic,
EmptyString,
ConcatStrings,
Stringify,
Call,
TailCall,
Return,
Partial,
Eq,
Add,
Sub,
Mult,
Div,
Unbox,
BoxStore,
Assert,
Get,
At,
Not,
Print,
SetUpvalue,
GetUpvalue,
Msg,
// Inc,
// Dec,
// Gt,
// Gte,
// Lt,
// Lte,
// Mod,
// Round,
// Ceil,
// Floor,
// Random,
// Sqrt,
// Assoc,
// Concat,
// Conj,
// Count,
// Disj,
// Dissoc,
// Range,
// Rest,
// Slice,
// "atan_2" math/atan2
// "chars" chars
// "cos" math/cos
// "doc" doc
// "downcase" string/ascii-lower
// "pi" math/pi
// "show" show
// "sin" math/sin
// "split" string/split
// "str_slice" string/slice
// "tan" math/tan
// "trim" string/trim
// "triml" string/triml
// "trimr" string/trimr
// "upcase" string/ascii-upper
}
impl std::fmt::Display for Op {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
use Op::*;
let rep = match self {
Msg => "msg",
Noop => "noop",
Nothing => "nothing",
Nil => "nil",
True => "true",
False => "false",
Constant => "constant",
Jump => "jump",
JumpIfFalse => "jump_if_false",
JumpIfTrue => "jump_if_true",
Pop => "pop",
PopN => "pop_n",
PushBinding => "push_binding",
PushGlobal => "push_global",
Store => "store",
StoreN => "store_n",
Stash => "stash",
Load => "load",
LoadN => "load_n",
Match => "match",
MatchNil => "match_nil",
MatchTrue => "match_true",
MatchFalse => "match_false",
ResetMatch => "reset_match",
PanicIfNoMatch => "panic_if_no_match",
MatchConstant => "match_constant",
MatchString => "match_string",
PushStringMatches => "push_string_matches",
MatchType => "match_type",
MatchTuple => "match_tuple",
MatchSplattedTuple => "match_splatted_tuple",
PushTuple => "push_tuple",
LoadTuple => "load_tuple",
LoadSplattedTuple => "load_splatted_tuple",
MatchList => "match_list",
MatchSplattedList => "match_splatted_list",
LoadList => "load_list",
LoadSplattedList => "load_splatted_list",
PushList => "push_list",
AppendList => "append_list",
ConcatList => "concat_list",
PushDict => "push_dict",
AppendDict => "append_dict",
ConcatDict => "concat_dict",
LoadDictValue => "load_dict_value",
MatchDict => "match_dict",
MatchSplattedDict => "match_splatted_dict",
DropDictEntry => "drop_dict_entry",
PushBox => "push_box",
GetKey => "get_key",
PanicNoWhen => "panic_no_when",
JumpIfNoMatch => "jump_if_no_match",
JumpIfMatch => "jump_if_match",
PanicNoMatch => "panic_no_match",
TypeOf => "type_of",
JumpBack => "jump_back",
JumpIfZero => "jump_if_zero",
Decrement => "decrement",
Truncate => "truncate",
Duplicate => "duplicate",
MatchDepth => "match_depth",
Panic => "panic",
EmptyString => "empty_string",
ConcatStrings => "concat_strings",
Stringify => "stringify",
Print => "print",
Eq => "eq",
Add => "add",
Sub => "sub",
Mult => "mult",
Div => "div",
Unbox => "unbox",
BoxStore => "box_store",
Assert => "assert",
Get => "get",
At => "at",
Not => "not",
Call => "call",
Return => "return",
Partial => "partial",
TailCall => "tail_call",
SetUpvalue => "set_upvalue",
GetUpvalue => "get_upvalue",
};
write!(f, "{rep}")
}
}

14
src/vm.rs
View File

@ -326,7 +326,6 @@ impl Vm {
}
Store => {
self.return_register[0] = self.pop();
self.push(Value::Nothing);
self.ip += 1;
}
StoreN => {
@ -341,14 +340,19 @@ impl Vm {
self.ip += 1;
}
Load => {
let mut i = 0;
while i < 8 && self.return_register[i] != Value::Nothing {
let mut value = Value::Nothing;
swap(&mut self.return_register[0], &mut value);
self.push(value);
self.ip += 1;
}
LoadN => {
let n = self.chunk().bytecode[self.ip + 1] as usize;
for i in 0..n {
let mut value = Value::Nothing;
swap(&mut self.return_register[i], &mut value);
self.push(value);
i += 1;
}
self.ip += 1;
self.ip += 2;
}
ResetMatch => {
self.matches = false;