This commit is contained in:
Freya Murphy 2024-02-26 19:00:42 -05:00
parent ad8700371f
commit 158bcae00d
Signed by: freya
GPG key ID: 744AB800E383AE52
21 changed files with 3452 additions and 863 deletions

12
Cargo.lock generated
View file

@ -415,12 +415,24 @@ dependencies = [
"memchr", "memchr",
"nix", "nix",
"radix_trie", "radix_trie",
"rustyline-derive",
"unicode-segmentation", "unicode-segmentation",
"unicode-width", "unicode-width",
"utf8parse", "utf8parse",
"winapi", "winapi",
] ]
[[package]]
name = "rustyline-derive"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e5af959c8bf6af1aff6d2b463a57f71aae53d1332da58419e30ad8dc7011d951"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.48",
]
[[package]] [[package]]
name = "smallvec" name = "smallvec"
version = "1.13.1" version = "1.13.1"

View file

@ -12,4 +12,4 @@ clap = { version = "4", features = [ "derive" ] }
ctrlc = "3" ctrlc = "3"
matrix = { path = "../matrix" } matrix = { path = "../matrix" }
matrix-stdlib = { path = "../matrix-stdlib" } matrix-stdlib = { path = "../matrix-stdlib" }
rustyline = "13" rustyline = { version = "13", features = [ "derive" ] }

312
matrix-bin/src/helper.rs Normal file
View file

@ -0,0 +1,312 @@
use std::{borrow::Cow, rc::Rc, cell::RefCell};
use matrix::{lex::{Lexer, TokenData, Token}, vm::Vm};
use rustyline::{validate::{Validator, ValidationResult, ValidationContext}, highlight::Highlighter, Helper, Hinter, completion::Completer};
#[derive(Helper, Hinter)]
pub struct MatrixHelper {
vm: Rc<RefCell<Vm>>
}
impl MatrixHelper {
pub fn new(vm: Rc<RefCell<Vm>>) -> Self {
Self { vm }
}
}
macro_rules! unmatched {
($token:expr, $matched:expr) => {
Ok(::rustyline::validate::ValidationResult::Invalid(Some(format!("Token '{:?}' at {}:{} does not have a matching '{:?}'", $token.data, $token.pos.row, $token.pos.col, $matched))))
};
}
impl Validator for MatrixHelper {
fn validate(&self, ctx: &mut ValidationContext) -> rustyline::Result<ValidationResult> {
let mut lexer = Lexer::new(ctx.input());
let mut stack = Vec::new();
loop {
use TokenData as T;
let token = match lexer.next_token() {
Ok(t) if t.data == T::Eof => break,
Ok(t) => t,
Err(err) => return Ok(ValidationResult::Invalid(Some(format!("{err}"))))
};
match token.data {
T::LeftParen |
T::LeftBrack |
T::LeftBrace |
T::For |
T::Try => { stack.push(token.data); },
T::RightParen =>
match stack.pop() {
Some(T::LeftParen) => {},
_ => return unmatched!(token, T::LeftParen)
},
T::RightBrack =>
match stack.pop() {
Some(T::LeftBrack) => {},
_ => return unmatched!(token, T::LeftBrack)
},
T::RightBrace =>
match stack.pop() {
Some(T::LeftBrace) => {},
_ => return unmatched!(token, T::LeftBrace)
},
T::In =>
match stack.pop() {
Some(T::For) => {},
_ => return unmatched!(token, T::For)
},
T::Catch =>
match stack.pop() {
Some(T::Try) => {},
_ => return unmatched!(token, T::Try)
},
_ => {}
};
}
if stack.is_empty() {
return Ok(ValidationResult::Valid(None))
} else {
return Ok(ValidationResult::Incomplete)
}
}
fn validate_while_typing(&self) -> bool {
true
}
}
fn find_matching_bracket(line: &str, pos: usize) -> Option<usize> {
if pos >= line.len() {
return None
}
let c = line.as_bytes()[pos];
let (target, fwd) = match c {
b'(' => (b')', true),
b')' => (b'(', false),
b'[' => (b']', true),
b']' => (b'[', false),
b'{' => (b'}', true),
b'}' => (b'{', false),
_ => return None,
};
let mut depth = 0;
let mut idx = 0;
if fwd {
let bytes = &line.as_bytes()[pos+1..];
for &b in bytes {
if b == c {
depth += 1;
} else if b == target {
if depth == 0 {
return Some(pos + idx + 1)
} else {
depth -= 1;
}
}
idx += 1;
}
} else {
let bytes = &line.as_bytes()[..pos];
for &b in bytes.iter().rev() {
if b == c {
depth += 1;
} else if b == target {
if depth == 0 {
return Some(pos - idx - 1)
} else {
depth -= 1;
}
}
idx += 1;
}
}
None
}
fn get_token_at(line: &str, pos: usize) -> Option<Token> {
use TokenData as T;
let mut lexer = Lexer::new(line);
loop {
match lexer.next_token() {
Ok(Token { data: T::Eof, ..}) => return None,
Ok(t) if t.bidx <= pos && (t.bidx + t.blen) > pos => return Some(t),
Err(_) => return None,
_ => continue
}
}
}
fn find_matching_ident(line: &str, pos: usize) -> Option<Rc<str>> {
use TokenData as T;
match get_token_at(line, pos) {
Some(Token { data: T::Ident(ident), ..}) => Some(ident),
_ => return None
}
}
impl Highlighter for MatrixHelper {
fn highlight<'l>(&self, line: &'l str, pos: usize) -> Cow<'l, str> {
let matching = find_matching_bracket(line, pos);
let ident = find_matching_ident(line, pos);
use TokenData as T;
let mut lexer = Lexer::new(line);
let mut buf = String::new();
let mut last = 0;
loop {
let token = match lexer.next_token() {
Ok(t) if t.data == T::Eof => break,
Ok(t) => t,
Err(_) => break
};
let bl = token.bidx;
let br = token.bidx + token.blen;
buf += &line[last..bl];
last = br;
let color = match token.data {
T::LeftParen |
T::RightParen |
T::LeftBrack |
T::RightBrack |
T::LeftBrace |
T::RightBrace
=> {
match matching {
Some(idx) if bl == idx || bl == pos => "\x1b[33;40m",
_ => ""
}
}
T::Int(_) |
T::True |
T::False |
T::Nil |
T::Float(_) |
T::Complex(_)
=> "\x1b[33m",
T::Ident(tok) => {
match (ident.as_ref(), lexer.peek_token()) {
(Some(ident), Ok(t)) if t.data == T::LeftParen && ident.as_ref() == tok.as_ref() => "\x1b[34;40m",
(Some(ident), _) if ident.as_ref() == tok.as_ref() => "\x1b[40m",
(_, Ok(t)) if t.data == T::LeftParen => "\x1b[34m",
_ => ""
}
}
T::Regex(_) => "\x1b[31m",
T::String(_) => "\x1b[32m",
T::If |
T::Else |
T::While |
T::Let |
T::Function |
T::Continue |
T::Break |
T::Do |
T::Loop |
T::Return |
T::For |
T::In |
T::Try |
T::Catch
=> "\x1b[38;2;203;166;247m",
_ => {
buf += &token.str;
continue;
}
};
let clear = "\x1b[0m";
buf += &format!("{color}{}{clear}", token.str);
}
buf += &line[last..];
Cow::Owned(buf)
}
fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
&'s self,
prompt: &'p str,
default: bool,
) -> std::borrow::Cow<'b, str> {
let _ = default;
Cow::Owned(format!("\x1b[35m{prompt}\x1b[0m"))
}
fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
Cow::Owned(format!(" \x1b[31;40m Error: \x1b[0;40m{hint} \x1b[0m"))
}
fn highlight_candidate<'c>(
&self,
candidate: &'c str,
completion: rustyline::CompletionType,
) -> std::borrow::Cow<'c, str> {
let _ = completion;
Cow::Borrowed(candidate)
}
fn highlight_char(&self, line: &str, _pos: usize, forced: bool) -> bool {
forced || !line.is_empty()
}
}
impl Completer for MatrixHelper {
type Candidate = Rc<str>;
fn complete(
&self,
line: &str,
pos: usize,
ctx: &rustyline::Context<'_>,
) -> rustyline::Result<(usize, Vec<Self::Candidate>)> {
let mut idx = 0;
let mut buf = String::new();
let mut start = 0;
for char in line.chars() {
if buf.is_empty() && char.is_alphabetic() {
start = idx;
buf.push(char);
} else if !buf.is_empty() && char.is_alphanumeric() {
buf.push(char);
} else {
if idx >= pos {
break;
} else {
buf.clear();
}
}
idx += char.len_utf8();
}
let _ = (line, pos, ctx);
let globals = self.vm.borrow().global_names();
let names: Vec<Rc<str>> = globals
.borrow()
.clone()
.into_iter()
.filter(|n| n.starts_with(&buf))
.collect();
if buf.is_empty() {
start = pos;
}
Ok((start, names))
}
fn update(&self, line: &mut rustyline::line_buffer::LineBuffer, start: usize, elected: &str, cl: &mut rustyline::Changeset) {
let end = line.pos();
line.replace(start..end, elected, cl);
}
}

View file

@ -1,9 +1,10 @@
use std::{path::PathBuf, io::{self, Read, IsTerminal}, fs}; use std::{path::PathBuf, io::{self, Read, IsTerminal}, fs, cell::RefCell, rc::Rc};
use clap::Parser as ArgParser; use clap::{Parser as ArgParser, ColorChoice};
use matrix::{compiler::{Compiler, CompilerBuilder}, vm::Vm, parse::{Parser, ParserBuilder}, value::Value}; use matrix::{compiler::{Compiler, CompilerBuilder}, vm::Vm, parse::{Parser, ParserBuilder}, value::Value};
use repl::Repl; use repl::Repl;
mod repl; mod repl;
mod helper;
#[derive(Debug, ArgParser)] #[derive(Debug, ArgParser)]
#[command(version, long_about = None)] #[command(version, long_about = None)]
@ -19,6 +20,10 @@ pub struct Args {
#[arg(short, long)] #[arg(short, long)]
debug: bool, debug: bool,
/// Choses color
#[arg(short, long)]
color: Option<ColorChoice>,
/// Disables optimizations /// Disables optimizations
#[arg(long)] #[arg(long)]
disable_optimizations: bool, disable_optimizations: bool,
@ -27,8 +32,11 @@ pub struct Args {
pub struct State<'a> { pub struct State<'a> {
parser: Parser, parser: Parser,
compiler: Compiler<'a>, compiler: Compiler<'a>,
vm: Vm, vm: Rc<RefCell<Vm>>,
repl: bool repl: bool,
color: bool,
#[allow(unused)]
debug: bool,
} }
impl<'a> State<'a> { impl<'a> State<'a> {
@ -60,20 +68,32 @@ impl<'a> State<'a> {
matrix_stdlib::load(&mut vm); matrix_stdlib::load(&mut vm);
(Self { parser, vm, compiler, repl }, file) let color = match args.color {
Some(ColorChoice::Auto) | None => {
io::stdout().is_terminal()
},
Some(ColorChoice::Always) => true,
Some(ColorChoice::Never) => false,
};
(Self { parser, vm: Rc::new(RefCell::new(vm)), compiler, repl, debug: args.debug, color }, file)
} }
pub fn execute(&mut self, code: String) -> matrix::Result<Value> { pub fn execute(&mut self, code: String) -> matrix::Result<Value> {
let ast = self.parser.parse(code)?; let ast = self.parser.parse(code)?;
let fun = self.compiler.compile(&ast)?; let fun = self.compiler.compile(&ast)?;
let val = self.vm.run(fun)?; let val = self.vm.try_borrow_mut().unwrap().run(fun)?;
Ok(val) Ok(val)
} }
} }
pub fn error(err: matrix::Error) { pub fn error(err: matrix::Error, state: &State) {
if state.color {
println!("\x1b[31m\x1b[1mError:\x1b[0m {err}"); println!("\x1b[31m\x1b[1mError:\x1b[0m {err}");
} else {
println!("Error: {err}");
}
} }
fn read_stdin() -> String { fn read_stdin() -> String {
@ -93,7 +113,7 @@ fn main() {
if let Some(file) = file { if let Some(file) = file {
if let Err(err) = state.execute(file) { if let Err(err) = state.execute(file) {
error(err); error(err, &state);
} }
} }

View file

@ -1,9 +1,9 @@
use std::{io::Write, sync::atomic::Ordering}; use std::{io::Write, sync::atomic::Ordering};
use matrix::{value::Value, vm::Interupt}; use matrix::{value::Value, vm::Interupt};
use rustyline::Config; use rustyline::{Config, EditMode, ColorMode, Editor, CompletionType};
use crate::State; use crate::{State, helper::MatrixHelper};
pub struct Repl<'a> { pub struct Repl<'a> {
state: State<'a> state: State<'a>
@ -17,27 +17,42 @@ impl<'a> Repl<'a> {
pub fn run(&mut self) { pub fn run(&mut self) {
let interupt = self.state.vm.interupt(); let interupt = self.state.vm.borrow().interupt();
ctrlc::set_handler(move || { ctrlc::set_handler(move || {
interupt.store(Interupt::KeyboardInterupt as usize, Ordering::SeqCst); interupt.store(Interupt::KeyboardInterupt as usize, Ordering::SeqCst);
}).unwrap(); }).unwrap();
let config = Config::builder() let config = Config::builder()
.check_cursor_position(true) .check_cursor_position(true)
.completion_type(CompletionType::List)
.edit_mode(EditMode::Emacs)
.color_mode(if self.state.color { ColorMode::Enabled } else { ColorMode::Disabled })
.build(); .build();
let mut rl = rustyline::DefaultEditor::with_config(config).unwrap();
let helper = MatrixHelper::new(self.state.vm.clone());
let mut rl = Editor::with_config(config).unwrap();
rl.set_helper(Some(helper));
loop { loop {
let Ok(line) = rl.readline(">> ") else { let Ok(line) = rl.readline(">> ") else {
break; break;
}; };
if let Err(_) = rl.add_history_entry(&line) {
break;
};
match self.state.execute(line) { match self.state.execute(line) {
Err(err) => crate::error(err), Err(err) => crate::error(err, &self.state),
Ok(val) => { Ok(val) => {
if val != Value::Nil { if val != Value::Nil {
if self.state.color {
println!("{val:#}");
} else {
println!("{val}"); println!("{val}");
} }
} }
} }
}
let _ = std::io::stdout().flush(); let _ = std::io::stdout().flush();
} }
} }

View file

@ -1,16 +1,15 @@
use proc_macro::TokenStream; use proc_macro::TokenStream;
use syn::{ItemFn, parse::Parse, Token, LitBool, LitInt}; use syn::{ItemFn, parse::Parse, Token, LitInt};
use quote::quote; use quote::quote;
struct NativeFuncParams { struct NativeFuncParams {
arity: LitInt, arity: LitInt,
variadic: LitBool, variadic: Option<Token![..]>,
} }
impl Parse for NativeFuncParams { impl Parse for NativeFuncParams {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> { fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let arity = input.parse()?; let arity = input.parse()?;
input.parse::<Token![,]>()?;
let variadic = input.parse()?; let variadic = input.parse()?;
Ok(Self { arity , variadic }) Ok(Self { arity , variadic })
} }
@ -22,7 +21,7 @@ pub fn native_func(input: TokenStream, annotated_item: TokenStream) -> TokenStre
let input: NativeFuncParams = syn::parse(input).unwrap(); let input: NativeFuncParams = syn::parse(input).unwrap();
let arity = input.arity; let arity = input.arity;
let variadic = input.variadic; let variadic = input.variadic.is_some();
let visibility = itemfn.vis; let visibility = itemfn.vis;
let block = itemfn.block; let block = itemfn.block;
@ -43,7 +42,11 @@ pub fn native_func(input: TokenStream, annotated_item: TokenStream) -> TokenStre
name: ::std::rc::Rc::from( #name_str ), name: ::std::rc::Rc::from( #name_str ),
arity: #arity, arity: #arity,
variadic: #variadic, variadic: #variadic,
fun: ::matrix::chunk::InnerFunction::Native(Box::new(|#inputs| #output #block)) fun: ::matrix::chunk::InnerFunction::Native(
::std::rc::Rc::new(
|#inputs| #output #block
)
)
}) })
} }
}; };

181
matrix-stdlib/src/core.rs Normal file
View file

@ -0,0 +1,181 @@
use std::hash::{DefaultHasher, Hash, Hasher};
use matrix::{vm::Vm, value::Value, unpack_args, Result, unpack_varargs};
use matrix_macros::native_func;
use crate::{VmArgs, error};
fn to_radix(r: i64, mut n: i64) -> String {
let mut result = String::new();
let mut idx = 0;
if n == 0 {
result.push('0');
return result
} else if n < 0 {
n = -n;
idx = 1;
result.push('-');
}
while n != 0 {
let c = std::char::from_digit((n % r) as u32, r as u32).unwrap();
result.insert(idx, c);
n /= r;
}
result
}
#[native_func(1)]
fn bin(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
match value {
Value::Int(n) => Ok(Value::String(to_radix(2, n).into())),
_ => error!("bin requires a integer agument")
}
}
#[native_func(1)]
fn sex(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
match value {
Value::Int(n) => Ok(Value::String(to_radix(6, n).into())),
_ => error!("sex requires a integer agument")
}
}
#[native_func(1)]
fn oct(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
match value {
Value::Int(n) => Ok(Value::String(to_radix(8, n).into())),
_ => error!("oct requires a integer agument")
}
}
#[native_func(1)]
fn hex(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
match value {
Value::Int(n) => Ok(Value::String(to_radix(16, n).into())),
_ => error!("hex requires a integer agument")
}
}
#[native_func(2)]
fn radix(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [radix, value] = unpack_args!(args);
match (radix, value) {
(Value::Int(r), Value::Int(n)) => Ok(Value::String(to_radix(r, n).into())),
_ => error!("radix requires two integer aguments")
}
}
#[native_func(1..)]
fn append(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let ([list], args) = unpack_varargs!(args);
let Value::List(mut list) = list else {
return error!("append requires a list")
};
for arg in args {
list.push(arg);
};
Ok(Value::List(list))
}
#[native_func(2)]
fn push(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [list, value] = unpack_args!(args);
let Value::List(mut list) = list else {
return error!("push requires a list")
};
list.push(value);
Ok(Value::List(list))
}
#[native_func(1)]
fn pop(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [list] = unpack_args!(args);
let Value::List(mut list) = list else {
return error!("pop requires a list")
};
match list.pop() {
Some(v) => Ok(v),
None => Ok(Value::Nil)
}
}
#[native_func(2)]
fn remove(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [list, index] = unpack_args!(args);
let Value::List(mut list) = list else {
return error!("remove requires a list")
};
let Value::Int(i) = index else {
return error!("remove reuqires a int index");
};
if i < 0 || i as usize >= list.len() {
Ok(Value::Nil)
} else {
Ok(list.remove(i as usize))
}
}
#[native_func(1)]
fn hash(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
if let Err(e) = value.can_hash() {
return Err(e)
};
let mut hasher = DefaultHasher::new();
value.hash(&mut hasher);
let fin = hasher.finish();
Ok(Value::Int(fin as u32 as i64))
}
#[native_func(1)]
fn ord(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let Value::String(str) = value else {
return error!("ord requires a 1 length string")
};
if str.len() != 1 {
return error!("ord requires a 1 length string")
}
let char = str.chars().next().unwrap();
Ok(Value::Int(char as i64))
}
#[native_func(1)]
fn chr(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let Value::Int(i) = value else {
return error!("chr requires an int")
};
match char::from_u32(i as u32) {
Some(c) => Ok(Value::String(String::from(c).into())),
None => error!("unable to get char from: {}", i as u32)
}
}
#[native_func(1)]
fn str(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
Ok(Value::String(format!("{value}").into()))
}
pub fn load(vm: &mut Vm) {
vm.load_global_fn(bin(), "bin");
vm.load_global_fn(sex(), "sex");
vm.load_global_fn(oct(), "oct");
vm.load_global_fn(hex(), "hex");
vm.load_global_fn(radix(), "radix");
vm.load_global_fn(str(), "str");
vm.load_global_fn(append(), "append");
vm.load_global_fn(push(), "push");
vm.load_global_fn(pop(), "pop");
vm.load_global_fn(remove(), "remove");
vm.load_global_fn(hash(), "hash");
vm.load_global_fn(ord(), "ord");
vm.load_global_fn(chr(), "chr");
}

View file

@ -1,36 +1,175 @@
use matrix::{value::Value, self, vm::Vm, Result}; use std::{io::{self, Read, Write}, cell::RefCell, fs::OpenOptions, rc::Rc};
use matrix_macros::native_func;
#[native_func(1, true)] use matrix::{value::Value, self, vm::Vm, Result, unpack_varargs, iter, unpack_args};
fn print(_vm: &mut Vm, args: Vec<Value>) -> Result<Value> { use matrix_macros::native_func;
let [values] = args.try_into().unwrap(); use crate::{error, VmArgs};
if let Value::List(list) = values {
for (i, value) in list.iter().enumerate() { #[native_func(0..)]
print!("{}", value.boring_print()); fn print(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let ([], varags) = unpack_varargs!(args);
for (i, value) in varags.into_iter().enumerate() {
if i != 0 { if i != 0 {
print!(" "); print!(" ");
} }
} print!("{value}");
} }
Ok(Value::Nil) Ok(Value::Nil)
} }
#[native_func(1, true)] #[native_func(0..)]
fn println(_vm: &mut Vm, args: Vec<Value>) -> Result<Value> { fn println(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [values] = args.try_into().unwrap(); let ([], varags) = unpack_varargs!(args);
if let Value::List(list) = values { for (i, value) in varags.into_iter().enumerate() {
for (i, value) in list.iter().enumerate() {
print!("{}", value.boring_print());
if i != 0 { if i != 0 {
print!(" "); print!(" ");
} }
} print!("{value}");
} }
print!("\n"); print!("\n");
Ok(Value::Nil) Ok(Value::Nil)
} }
pub fn load(vm: &mut Vm) { #[native_func(0)]
vm.load_native_fn(print()); fn readln(_: VmArgs, _: Vec<Value>) -> Result<Value> {
vm.load_native_fn(println()); let mut input = String::new();
match io::stdin().read_line(&mut input) {
Ok(_) => {
match input.pop() {
Some(c) if c == '\n' => {},
Some(c) => input.push(c),
None => {}
};
Ok(Value::String(input.into()))
},
Err(err) => error!("cant read from stdin: {err}")
}
}
#[native_func(1)]
fn input(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [prompt] = unpack_args!(args);
let mut input = String::new();
print!("{prompt}");
let _ = io::stdout().flush();
match io::stdin().read_line(&mut input) {
Ok(_) => {
match input.pop() {
Some(c) if c == '\n' => {},
Some(c) => input.push(c),
None => {}
};
Ok(Value::String(input.into()))
},
Err(err) => error!("cant read from stdin: {err}")
}
}
#[native_func(0)]
fn readlines(_: VmArgs, _: Vec<Value>) -> Result<Value> {
let lines = RefCell::new(io::stdin().lines());
Ok(iter!(move |_,_| {
match lines.borrow_mut().next() {
Some(Ok(line)) => Ok(Value::String(line.into())),
_ => Ok(Value::Nil)
}
}))
}
#[native_func(2)]
fn file_open(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [path, mode] = unpack_args!(args);
let Value::String(mode) = mode else {
return error!("open mode must be a string")
};
let Value::String(path) = path else {
return error!("open path must be a string")
};
let file = match mode.as_ref() {
"r" => OpenOptions::new().read(true).open(path.as_ref()),
"w" => OpenOptions::new().write(true).create(true).truncate(true).open(path.as_ref()),
"a" => OpenOptions::new().write(true).create(true).append(true).open(path.as_ref()),
"r+" => OpenOptions::new().read(true).write(true).open(path.as_ref()),
"w+" => OpenOptions::new().read(true).write(true).create(true).truncate(true).open(path.as_ref()),
"a+" => OpenOptions::new().read(true).write(true).create(true).append(true).open(path.as_ref()),
_ => return error!("invalid open mode: {mode}")
};
match file {
Ok(file) => Ok(Value::File(Rc::new(RefCell::new(file)))),
Err(err) => return error!("cannot open '{path}': {err}")
}
}
#[native_func(1)]
fn file_read(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [file] = unpack_args!(args);
let Value::File(file) = file else {
return error!("file read requires a file")
};
let mut contents = String::new();
if let Err(err) = file.try_borrow_mut().unwrap().read_to_string(&mut contents) {
return error!("cannot read file: '{err}'")
};
Ok(Value::String(contents.into()))
}
#[native_func(1)]
fn file_lines(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [file] = unpack_args!(args);
let Value::File(file) = file else {
return error!("file read requires a file")
};
let mut contents = String::new();
if let Err(err) = file.try_borrow_mut().unwrap().read_to_string(&mut contents) {
return error!("cannot read file: '{err}'")
};
let lines: Vec<Rc<str>> = contents.split_inclusive("\n").map(|s| Rc::from(s)).collect();
let lines = RefCell::new(lines.into_iter());
Ok(iter!(move |_,_| {
match lines.borrow_mut().next() {
Some(line) => Ok(Value::String(line)),
None => Ok(Value::Nil)
}
}))
}
#[native_func(2)]
fn file_write(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [file, content] = unpack_args!(args);
let Value::File(file) = file else {
return error!("file write requires a file")
};
let content = format!("{content}");
if let Err(err) = file.try_borrow_mut().unwrap().write_all(content.as_bytes()) {
return error!("cannot write file: '{err}'")
};
Ok(Value::Nil)
}
#[native_func(0..)]
fn throw(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let ([], varargs) = unpack_varargs!(args);
let mut str = String::new();
for (i, v) in varargs.into_iter().enumerate() {
if i != 0 {
str.push_str(" ");
}
str.push_str(&format!("{v}"));
}
error!("{str}")
}
pub fn load(vm: &mut Vm) {
vm.load_global_fn(print(), "print");
vm.load_global_fn(println(), "println");
vm.load_global_fn(readln(), "readln");
vm.load_global_fn(input(), "input");
vm.load_global_fn(readlines(), "readlines");
vm.load_global_fn(file_open(), "file_open");
vm.load_global_fn(file_read(), "file_read");
vm.load_global_fn(file_lines(), "file_lines");
vm.load_global_fn(file_write(), "file_write");
vm.load_global_fn(throw(), "throw");
} }

544
matrix-stdlib/src/iter.rs Normal file
View file

@ -0,0 +1,544 @@
use std::{cell::RefCell, rc::Rc};
use matrix::{iter, vm::Vm, value::Value, Result, unpack_varargs, unpack_args};
use matrix_macros::native_func;
use crate::{error, VmArgs};
use Value as V;
macro_rules! next {
($vm:expr, $frame:expr, $iter:expr) => {
$vm.run_fn($frame, $iter.clone(), vec![])
};
}
#[native_func(1)]
fn len(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let len = match value {
V::List(l) => l.len(),
V::Matrix(m) => m.values.len(),
V::String(s) => s.len(),
V::Table(t) => t.len(),
_ => 1
};
Ok(V::Int(len as i64))
}
#[native_func(1)]
fn sum((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut res = next!(vm, frame, iter)?;
if res == Value::Nil {
return Ok(res)
};
loop {
let next = next!(vm, frame, iter)?;
if next == Value::Nil { break }
res = (res + next)?;
}
Ok(res)
}
#[native_func(0..)]
fn range(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let ([], varargs) = unpack_varargs!(args);
let (min, max, step) = match varargs.as_slice() {
[V::Int(max)] => {
(0, *max, 1)
},
[V::Int(min), V::Int(max)] => {
(*min, *max, 1)
},
[V::Int(min), V::Int(max), V::Int(step)] => {
(*min, *max, *step)
},
_ => return error!("range takes 1 to 3 [Int]'s")
};
let i = RefCell::new(min);
Ok(iter!(move |_,_| {
let curr = *(i.borrow());
*(i.borrow_mut()) = curr + step;
if curr >= max {
return Ok(V::Nil)
} else {
return Ok(V::Int(curr))
}
}))
}
#[native_func(1)]
fn iter(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
Ok(value.into_iter()?)
}
#[native_func(1)]
fn once(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let first = RefCell::new(false);
Ok(iter!(move |_,_| {
if *first.borrow() == false {
*first.borrow_mut() = true;
Ok(value.clone())
} else {
Ok(Value::Nil)
}
}))
}
#[native_func(1)]
fn list((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut list = Vec::new();
loop {
let res = next!(vm, frame, iter)?;
if res == Value::Nil { break }
list.push(res);
}
Ok(Value::List(list.into()))
}
#[native_func(2)]
fn map(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [fun, iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let Value::Function(fun) = fun else {
return error!("map 1st arg must be a function")
};
Ok(iter!(move |(vm,frame),_| {
let input = next!(vm, frame, iter)?;
if input == Value::Nil {
return Ok(input)
}
vm.run_fn(frame, fun.clone(), vec![input])
}))
}
#[native_func(2)]
fn fold((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [fun, iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let Value::Function(fun) = fun else {
return error!("fold 1st arg must be a function")
};
let mut res = next!(vm, frame, iter)?;
if res == Value::Nil {
return Ok(Value::Nil)
};
loop {
let next = next!(vm, frame, iter)?;
if next == Value::Nil {
return Ok(res)
};
res = vm.run_fn(frame, fun.clone(), vec![res, next])?;
}
}
#[native_func(3)]
fn foldi((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [init, fun, iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let Value::Function(fun) = fun else {
return error!("foldi 1st arg must be a function")
};
let mut res = init;
loop {
let next = next!(vm, frame, iter)?;
if next == Value::Nil {
return Ok(res)
};
res = vm.run_fn(frame, fun.clone(), vec![res, next])?;
}
}
#[native_func(1)]
fn count((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut len = 0;
loop {
let res = vm.run_fn(frame, iter.clone(), vec![])?;
if res == Value::Nil { break };
len += 1;
}
Ok(Value::Int(len))
}
#[native_func(3)]
fn scan(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [init, fun, iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let Value::Function(fun) = fun else {
return error!("scan 2nd arg must be a function")
};
let res = RefCell::new(init);
Ok(iter!(move |(vm,frame),_| {
let next = next!(vm, frame, iter)?;
if next == Value::Nil {
return Ok(Value::Nil)
};
let res_next = vm.run_fn(frame, fun.clone(), vec![res.borrow().clone(), next])?;
*res.borrow_mut() = res_next;
Ok(res.borrow().clone())
}))
}
#[native_func(2)]
fn filter(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [fun, iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let Value::Function(fun) = fun else {
return error!("filter 1st arg must be a function")
};
Ok(iter!(move |(vm,frame),_| {
loop {
let next = next!(vm, frame, iter)?;
if next == Value::Nil {
return Ok(Value::Nil)
}
let res = vm.run_fn(frame, fun.clone(), vec![next.clone()])?;
if !!res {
return Ok(next)
}
}
}))
}
#[native_func(0..)]
fn chain(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let ([], iters) = unpack_varargs!(args);
let mut chaind = Vec::new();
for iter in iters {
chaind.push(iter.into_iter_fn()?);
}
chaind.reverse();
let chaind = RefCell::new(chaind);
Ok(iter!(move |(vm,frame), _| {
loop {
let curr = match chaind.borrow_mut().last() {
Some(iter) => iter.clone(),
None => return Ok(Value::Nil)
};
match vm.run_fn(frame, curr.clone(), vec![]) {
Ok(Value::Nil) => {
chaind.borrow_mut().pop();
continue;
},
v => return v
};
}
}))
}
#[native_func(1)]
fn lines(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [str] = unpack_args!(args);
let Value::String(str) = str else {
return error!("lines arg must be a string")
};
let lines: Vec<Rc<str>> = str.split_inclusive("\n").map(|s| Rc::from(s)).collect();
let res = RefCell::new(lines.into_iter());
Ok(iter!(move |_,_| {
match res.borrow_mut().next() {
Some(line) => Ok(Value::String(line)),
None => Ok(Value::Nil)
}
}))
}
#[native_func(1)]
fn skip((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [count, iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let Value::Int(i) = count else {
return error!("skip count requires a int")
};
for _ in 0..i {
next!(vm, frame, iter)?;
}
Ok(Value::Iter(iter))
}
#[native_func(2)]
fn alternate(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [il, ir] = unpack_args!(args);
let il = il.into_iter_fn()?;
let ir = ir.into_iter_fn()?;
let flag = RefCell::new(Some(0));
Ok(iter!(move |(vm, frame),_| {
let f = *flag.borrow();
match f {
Some(0) => {
let val = next!(vm, frame, il)?;
if val == Value::Nil {
*flag.borrow_mut() = None;
} else {
*flag.borrow_mut() = Some(1);
}
Ok(val)
},
Some(1) => {
let val = next!(vm, frame, ir)?;
if val == Value::Nil {
*flag.borrow_mut() = None;
} else {
*flag.borrow_mut() = Some(0);
}
Ok(val)
},
_ => Ok(Value::Nil)
}
}))
}
#[native_func(2)]
fn intersperse(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value, iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let flag = RefCell::new(Some(0));
Ok(iter!(move |(vm, frame),_| {
let f = *flag.borrow();
match f {
Some(0) => {
let val = next!(vm, frame, iter)?;
if val == Value::Nil {
*flag.borrow_mut() = None;
} else {
*flag.borrow_mut() = Some(1);
}
Ok(val)
},
Some(1) => {
let val = value.clone();
*flag.borrow_mut() = Some(0);
Ok(val)
},
_ => Ok(Value::Nil)
}
}))
}
#[native_func(2)]
fn zip(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [il, ir] = unpack_args!(args);
let il = il.into_iter_fn()?;
let ir = ir.into_iter_fn()?;
let flag = RefCell::new(true);
Ok(iter!(move |(vm, frame),_| {
let f = *flag.borrow();
match f {
true => {
let vl = next!(vm, frame, il)?;
let vr = next!(vm, frame, ir)?;
if vl == Value::Nil || vr == Value::Nil {
*flag.borrow_mut() = false;
}
Ok(Value::List(vec![vl, vr].into()))
},
_ => Ok(Value::Nil)
}
}))
}
#[native_func(1)]
fn unzip((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut ll = Vec::new();
let mut lr = Vec::new();
loop {
let val = next!(vm, frame, iter)?;
if val == Value::Nil {
break;
}
let Value::List(vals) = val else {
return error!("unzip only works over a iterator of pairs");
};
let vals = vals.into_inner();
if vals.len() != 2 {
return error!("unzip only works over a iterator of pairs");
}
let [l, r] = vals.try_into().unwrap();
ll.push(l);
lr.push(r);
}
let ll = Value::List(ll.into());
let lr = Value::List(lr.into());
Ok(Value::List(vec![ll, lr].into()))
}
#[native_func(1)]
fn cycle((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut values = Vec::new();
loop {
let val = next!(vm, frame, iter)?;
if val == Value::Nil { break };
values.push(val);
}
let idx = RefCell::new(0_usize);
Ok(iter!(move |_,_| {
let i = *idx.borrow();
*idx.borrow_mut() += 1;
*idx.borrow_mut() %= values.len();
Ok(values[i].clone())
}))
}
#[native_func(2)]
fn take((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [count, iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let Value::Int(count) = count else {
return error!("take requires an int amount to collect")
};
let mut values = Vec::new();
for _ in 0..count {
let val = next!(vm, frame, iter)?;
if val == Value::Nil { break };
values.push(val);
}
Ok(Value::List(values.into()))
}
#[native_func(2)]
fn last((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut last = Value::Nil;
loop {
let val = next!(vm, frame, iter)?;
if val == Value::Nil { break };
last = val;
}
Ok(last)
}
#[native_func(2)]
fn next((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let val = next!(vm, frame, iter)?;
Ok(val)
}
#[native_func(1)]
fn min((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut min = Value::Nil;
loop {
let val = next!(vm, frame, iter)?;
if val == Value::Nil { break };
if min == Value::Nil || val < min {
min = val;
}
}
Ok(min)
}
#[native_func(1)]
fn max((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut max = Value::Nil;
loop {
let val = next!(vm, frame, iter)?;
if val == Value::Nil { break };
if max == Value::Nil || val > max {
max = val;
}
}
Ok(max)
}
#[native_func(1)]
fn rev((vm, frame): VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let mut values = Vec::new();
loop {
let val = next!(vm, frame, iter)?;
if val == Value::Nil { break };
values.push(val);
}
let values = RefCell::new(values);
Ok(iter!(move |_,_| {
match values.borrow_mut().pop() {
Some(v) => Ok(v),
None => Ok(Value::Nil)
}
}))
}
#[native_func(1)]
fn enumerate(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [iter] = unpack_args!(args);
let iter = iter.into_iter_fn()?;
let idx = RefCell::new(0_i64);
Ok(iter!(move |(vm, frame),_| {
let val = next!(vm, frame, iter)?;
if val == Value::Nil {
return Ok(Value::Nil)
};
let curr = *idx.borrow();
*idx.borrow_mut() += 1;
Ok(Value::List(vec![Value::Int(curr), val].into()))
}))
}
#[native_func(1)]
fn iterable(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
use Value as V;
match value {
V::Function(_) |
V::List(_) |
V::Range(_) |
V::Iter(_)
=> Ok(V::Bool(true)),
_ => Ok(V::Bool(false))
}
}
pub fn load(vm: &mut Vm) {
vm.load_global_fn(take(), "take");
vm.load_global_fn(unzip(), "unzip");
vm.load_global_fn(count(), "count");
vm.load_global_fn(len(), "len");
vm.load_global_fn(sum(), "sum");
vm.load_global_fn(min(), "min");
vm.load_global_fn(max(), "max");
vm.load_global_fn(next(), "next");
vm.load_global_fn(last(), "last");
vm.load_global_fn(list(), "list");
vm.load_global_fn(fold(), "fold");
vm.load_global_fn(foldi(), "foldi");
vm.load_global_fn(scan(), "scan");
vm.load_global_fn(chain(), "chain");
vm.load_global_fn(lines(), "lines");
vm.load_global_fn(skip(), "skip");
vm.load_global_fn(once(), "once");
vm.load_global_fn(iter(), "iter");
vm.load_global_fn(range(), "range");
vm.load_global_fn(map(), "map");
vm.load_global_fn(filter(), "filter");
vm.load_global_fn(skip(), "skip");
vm.load_global_fn(zip(), "zip");
vm.load_global_fn(cycle(), "cycle");
vm.load_global_fn(alternate(), "alternate");
vm.load_global_fn(intersperse(), "intersperse");
vm.load_global_fn(rev(), "rev");
vm.load_global_fn(enumerate(), "enumerate");
vm.load_global_fn(iterable(), "iterable");
}

View file

@ -1,7 +1,25 @@
use matrix::vm::Vm; use matrix::vm::{Vm, StackFrame};
mod core;
mod sys;
mod math;
mod io; mod io;
mod iter;
pub(crate) type VmArgs<'a, 'b> = (&'a mut Vm, &'b mut StackFrame);
macro_rules! error {
($($arg:tt)*) => {
Err(format!($($arg)*).into())
};
}
pub(crate) use error;
pub fn load(vm: &mut Vm) { pub fn load(vm: &mut Vm) {
core::load(vm);
sys::load(vm);
io::load(vm); io::load(vm);
iter::load(vm);
math::load(vm);
} }

518
matrix-stdlib/src/math.rs Normal file
View file

@ -0,0 +1,518 @@
use core::f64;
use std::f64::{consts::{PI, E, TAU}, NAN, INFINITY};
use matrix::{vm::Vm, value::{Value, Matrix}, Result, unpack_args, Rational64, Complex64};
use matrix_macros::native_func;
use crate::{error, VmArgs};
#[native_func(1)]
fn trans(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let mat = match value {
Value::Matrix(m) => m,
Value::List(l) => Matrix::from_list(l.to_vec()).into(),
_ => return error!("trans must be given a matrix")
};
let values = mat
.cols()
.reduce(|mut a, b| {a.extend(b); a})
.unwrap()
.into_iter()
.map(|e| e.clone())
.collect();
Ok(Value::Matrix(Matrix::new(mat.codomain, mat.domain, values).into()))
}
fn mat_gauss_row_operation(
r1: usize,
r2: usize,
scale: Value,
mat: &mut Matrix
) -> Result<()> {
for col in 0..mat.domain {
let r1v = mat.get(r1, col)?;
let r2v = mat.get(r2, col)?;
let res = (r1v - (r2v * scale.clone())?)?;
mat.set(r1, col, res)?;
}
Ok(())
}
fn mat_swap_rows(
r1: usize,
r2: usize,
mat: &mut Matrix
) -> Result<()> {
let cols = mat.domain;
for col in 0..cols {
let a = mat.get(r1, col)?;
let b = mat.get(r2, col)?;
mat.set(r2, col, a)?;
mat.set(r1, col, b)?;
}
Ok(())
}
fn mat_find_non_zero_col(
mat: &Matrix
) -> Option<usize> {
for (i,col) in mat.cols().enumerate() {
for val in col.iter() {
if **val != Value::Int(0) {
return Some(i)
}
}
}
return None
}
fn mat_scale_pivot_row(
row: usize,
mat: &mut Matrix
) -> Result<()> {
let scale = mat.get(row, row)?;
if scale.is_zero() {
return Ok(())
}
for col in 0..mat.domain {
let res = (mat.get(row, col)?.clone() / scale.clone())?;
mat.set(row, col, res)?;
}
Ok(())
}
fn mat_get_non_zero_pivot_row(
row: usize,
mat: &mut Matrix,
) -> Result<()> {
let col = row;
let test = mat.get(row, col)?;
if test.is_zero() {
for r in row..mat.codomain {
let cur = mat.get(r, col)?;
if !cur.is_zero() {
mat_swap_rows(row, r, mat)?;
break;
}
}
}
mat_scale_pivot_row(row, mat)?;
Ok(())
}
fn mat_rref(mat: Matrix) -> Result<Matrix> {
let mut mat = mat;
let Some(start) = mat_find_non_zero_col(&mat) else {
return Ok(mat)
};
let end = mat.domain.min(mat.codomain);
for col in start..end {
let pivot_row = col;
mat_get_non_zero_pivot_row(pivot_row, &mut mat)?;
if mat.get(pivot_row, col)?.is_zero() {
break
}
for row in 0..mat.codomain {
if row == pivot_row { continue; };
let scale = mat.get(row, col)?;
mat_gauss_row_operation(row, pivot_row, scale, &mut mat)?;
}
}
Ok(mat)
}
#[native_func(1)]
fn rref(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let mat = match value {
Value::Matrix(m) => m,
Value::List(l) => Matrix::from_list(l.to_vec()).into(),
_ => return error!("trans must be given a matrix")
};
Ok(Value::Matrix(mat_rref(mat.into_inner())?.into()))
}
fn mat_det(mat: Matrix) -> Result<Value> {
if mat.domain == 1 {
return Ok(mat.get(0,0)?)
}
if mat.domain == 2 {
let a = mat.get(0,0)? * mat.get(1,1)?;
let b = mat.get(0,1)? * mat.get(1,0)?;
return Ok((a? - b?)?)
}
let mut res = Value::Int(0);
for col in 0..mat.domain {
let sub_values = mat.rows()
.skip(1)
.map(|r|
r.into_iter()
.enumerate()
.filter(|(idx,_)| *idx != col)
.map(|(_, v)| v.clone())
.collect::<Vec<Value>>()
)
.reduce(|mut a, b| {a.extend(b); a})
.unwrap();
let sub = Matrix::new(mat.domain - 1, mat.domain - 1, sub_values);
let val = mat.get(0, col)?;
let part = (val * mat_det(sub)?)?;
if col % 2 == 0 {
res = (res + part)?;
} else {
res = (res - part)?;
}
}
Ok(res)
}
#[native_func(1)]
fn det(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let mat = match value {
Value::Matrix(m) if m.domain == m.codomain => m,
Value::List(l) if l.len() == 1 => Matrix::from_list(l.to_vec()).into(),
_ => return error!("det requires a square matrix")
};
let mat = mat.into_inner();
Ok(mat_det(mat)?)
}
fn mat_ident(dim: usize) -> Matrix {
let len = dim * dim;
let mut values = vec![Value::Int(0); len];
let mut idx = 0;
loop {
if idx >= len { break };
values[idx] = Value::Int(1);
idx += dim + 1;
}
Matrix::new(dim, dim, values)
}
#[native_func(1)]
fn ident(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let dim = match value {
Value::Int(i) if i > 0 => i,
Value::Ratio(r)
if *r.denom() == 1 &&
*r.numer() > 0
=> *r.numer(),
_ => return error!("ident requries a positive [Int] dimension")
};
Ok(Value::Matrix(mat_ident(dim as usize).into()))
}
fn mat_splith(mat: Matrix) -> (Matrix, Matrix) {
let mut m1 = Vec::new();
let mut m2 = Vec::new();
mat.rows()
.for_each(|r| {
let split = r.len() / 2;
r.into_iter().enumerate().for_each(|(i, v)| {
if i < split {
m1.push(v.clone());
} else {
m2.push(v.clone());
}
})
});
let m1 = Matrix::new(mat.domain/2, mat.codomain, m1);
let m2 = Matrix::new(mat.domain/2, mat.codomain, m2);
(m1, m2)
}
#[native_func(1)]
fn inv(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let mat = match value {
Value::Matrix(m) if m.domain == m.codomain => m,
Value::List(l) if l.len() == 1 => Matrix::from_list(l.to_vec()).into(),
_ => return error!("det requires a square matrix")
};
let mat = mat.into_inner();
let ident = mat_ident(mat.domain);
let joined = mat.join_right(&ident)?;
let refed = mat_rref(joined)?;
let (new_ident, new_inv) = mat_splith(refed);
if new_ident == ident {
Ok(Value::Matrix(new_inv.into()))
} else {
error!("matrix does not have an inverse")
}
}
macro_rules! mathr {
($type:ident) => {
#[native_func(1)]
fn $type(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(i) => Ok(V::Int(i)),
V::Ratio(r) => Ok(V::Ratio(r.$type())),
V::Float(f) => Ok(V::Float(f.$type())),
v => error!("cannot compute {} on {v}", stringify!($type))
}
}
};
}
macro_rules! trig {
($type:ident) => {
#[native_func(1)]
fn $type(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value.promote_trig() {
V::Float(f) => Ok(V::Float(f.$type())),
V::Complex(c) => Ok(V::Complex(c.$type())),
v => error!("cannot compute {} on {v}", stringify!($type))
}
}
};
}
macro_rules! trigf {
($type:ident, $str:ident) => {
#[native_func(1)]
fn $str(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value.promote_trig() {
V::Float(f) => Ok(V::Float(f.$type())),
v => error!("cannot compute {} on {v}", stringify!($str))
}
}
};
}
#[native_func(2)]
fn log(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [base, value] = unpack_args!(args);
match (base.promote_trig(), value.promote_trig()) {
(V::Float(base), V::Float(arg)) => Ok(V::Float(arg.log(base))),
(V::Float(base), V::Complex(arg)) => Ok(V::Complex(arg.log(base))),
(V::Complex(base), V::Float(arg)) => Ok(V::Complex(arg.ln() / base.ln())),
(V::Complex(base), V::Complex(arg)) => Ok(V::Complex(arg.ln() / base.ln())),
(base, arg) => error!("cannot compute log base {base} argument {arg}")
}
}
#[native_func(1)]
fn abs(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(i) => Ok(V::Int(i.abs())),
V::Float(f) => Ok(V::Float(f.abs())),
V::Ratio(r) => Ok(V::Ratio(Rational64::new(r.numer().abs(), r.denom().abs()))),
V::Complex(c) => Ok(V::Float(c.norm())),
arg => error!("cannot compute abs for {arg}")
}
}
#[native_func(1)]
fn fract(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(_) => Ok(V::Int(0)),
V::Float(f) => Ok(V::Float(f.fract())),
V::Ratio(r) => Ok(V::Ratio(r.fract())),
arg => error!("cannot compute fract for {arg}")
}
}
#[native_func(1)]
fn sign(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(i) => Ok(V::Int(i.signum())),
V::Ratio(r) => Ok(V::Int(r.numer().signum())),
V::Float(f) => Ok(V::Float(f.signum())),
arg => error!("cannot compute sign for {arg}")
}
}
#[native_func(1)]
fn int(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(i) => Ok(V::Int(i)),
V::Ratio(r) => Ok(V::Int(r.numer() / r.denom())),
V::Float(f) => Ok(V::Int(f as i64)),
V::Complex(c) => Ok(V::Int(c.re as i64)),
arg => error!("cannot cast {arg} to int")
}
}
#[native_func(1)]
fn ratio(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(i) => Ok(V::Ratio(Rational64::new(i, 1))),
V::Ratio(r) => Ok(V::Ratio(r)),
V::Float(f) => Ok(V::Ratio(Rational64::approximate_float(f).unwrap_or(Rational64::new(0, 1)))),
V::Complex(c) => Ok(V::Ratio(Rational64::approximate_float(c.re).unwrap_or(Rational64::new(0, 1)))),
arg => error!("cannot cast {arg} to ratio")
}
}
#[native_func(1)]
fn float(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(i) => Ok(V::Float(i as f64)),
V::Ratio(r) => Ok(V::Float((*r.numer() as f64) / (*r.denom() as f64))),
V::Float(f) => Ok(V::Float(f)),
V::Complex(c) => Ok(V::Float(c.re)),
arg => error!("cannot cast {arg} to float")
}
}
#[native_func(1)]
fn complex(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(i) => Ok(V::Complex(Complex64::new(i as f64, 0.0))),
V::Ratio(r) => Ok(V::Complex(Complex64::new((*r.numer() as f64) / (*r.denom() as f64), 0.0))),
V::Float(f) => Ok(V::Complex(Complex64::new(f, 0.0))),
V::Complex(c) => Ok(V::Complex(c)),
arg => error!("cannot cast {arg} to float")
}
}
#[native_func(1)]
fn numer(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(i) => Ok(V::Int(i)),
V::Ratio(r) => Ok(V::Int(*r.numer())),
_ => error!("numer can only take a integer or ratio")
}
}
#[native_func(1)]
fn denom(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(_) => Ok(V::Int(1)),
V::Ratio(r) => Ok(V::Int(*r.denom())),
_ => error!("denom can only take a integer or ratio")
}
}
#[native_func(1)]
fn re(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(_) | V::Ratio(_) | V::Float(_) => Ok(value),
V::Complex(c) => Ok(V::Float(c.re)),
_ => error!("re can only take a valid number")
}
}
#[native_func(1)]
fn im(_: VmArgs, args: Vec<Value>) -> Result<Value> {
use Value as V;
let [value] = unpack_args!(args);
match value {
V::Int(_) | V::Ratio(_) | V::Float(_ )=> Ok(V::Int(0)),
V::Complex(c) => Ok(V::Float(c.im)),
_ => error!("re can only take a valid number")
}
}
mathr!(floor);
mathr!(ceil);
mathr!(round);
mathr!(trunc);
trig!(sqrt);
trig!(cbrt);
trig!(ln);
trig!(log2);
trig!(log10);
trig!(exp);
trig!(exp2);
trig!(sin);
trig!(cos);
trig!(tan);
trig!(sinh);
trig!(cosh);
trig!(tanh);
trig!(asin);
trig!(acos);
trig!(atan);
trig!(asinh);
trig!(acosh);
trig!(atanh);
trigf!(to_degrees, deg);
trigf!(to_radians, rad);
pub fn load(vm: &mut Vm) {
vm.load_global_fn(trans(), "trans");
vm.load_global_fn(rref(), "rref");
vm.load_global_fn(det(), "det");
vm.load_global_fn(ident(), "ident");
vm.load_global_fn(inv(), "inv");
vm.load_global(Value::Float(PI), "pi");
vm.load_global(Value::Float(TAU), "tau");
vm.load_global(Value::Float(E), "e");
vm.load_global(Value::Float(NAN), "nan");
vm.load_global(Value::Float(NAN), "NaN");
vm.load_global(Value::Float(INFINITY), "inf");
vm.load_global_fn(int(), "int");
vm.load_global_fn(ratio(), "ratio");
vm.load_global_fn(float(), "float");
vm.load_global_fn(complex(), "complex");
vm.load_global_fn(abs(), "abs");
vm.load_global_fn(sign(), "sign");
vm.load_global_fn(floor(), "floor");
vm.load_global_fn(ceil(), "ceil");
vm.load_global_fn(round(), "round");
vm.load_global_fn(trunc(), "trunc");
vm.load_global_fn(fract(), "fract");
vm.load_global_fn(sqrt(), "sqrt");
vm.load_global_fn(cbrt(), "cbrt");
vm.load_global_fn(ln(), "ln");
vm.load_global_fn(log(), "log");
vm.load_global_fn(log2(), "log2");
vm.load_global_fn(log10(), "log10");
vm.load_global_fn(exp(), "exp");
vm.load_global_fn(exp2(), "exp2");
vm.load_global_fn(sin(), "sin");
vm.load_global_fn(cos(), "cos");
vm.load_global_fn(tan(), "tan");
vm.load_global_fn(sinh(), "sinh");
vm.load_global_fn(cosh(), "cosh");
vm.load_global_fn(tanh(), "tanh");
vm.load_global_fn(asin(), "asin");
vm.load_global_fn(acos(), "acos");
vm.load_global_fn(atan(), "atan");
vm.load_global_fn(asinh(), "asinh");
vm.load_global_fn(acosh(), "acosh");
vm.load_global_fn(atanh(), "atanh");
vm.load_global_fn(deg(), "deg");
vm.load_global_fn(rad(), "rad");
vm.load_global_fn(denom(), "denom");
vm.load_global_fn(numer(), "numer");
vm.load_global_fn(re(), "re");
vm.load_global_fn(im(), "im");
}

99
matrix-stdlib/src/sys.rs Normal file
View file

@ -0,0 +1,99 @@
use std::{process::{exit, Command, Stdio}, env, rc::Rc, io::Read};
use matrix::{vm::Vm, value::{Value, ValueMap}, unpack_args, Result, gc::Gc};
use matrix_macros::native_func;
use crate::{VmArgs, error};
#[native_func(1)]
fn sys_exit(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let Value::Int(i) = value else {
return error!("exit requires a int exit code")
};
exit(i as i32);
}
#[native_func(0)]
fn argv(_: VmArgs, _: Vec<Value>) -> Result<Value> {
Ok(Value::List(
Gc::new(
env::args()
.map(|a| Value::String(Rc::from(a.as_str())))
.collect()
)))
}
#[native_func(1)]
fn env(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [value] = unpack_args!(args);
let Value::String(value) = value else {
return error!("env requires a string name")
};
match std::env::var(value.as_ref()) {
Ok(v) => Ok(Value::String(v.into())),
Err(e) => error!("couldn't read env var: {e}")
}
}
#[native_func(2)]
fn exec(_: VmArgs, args: Vec<Value>) -> Result<Value> {
let [cmd, args] = unpack_args!(args);
let (cmd, args) = match (cmd, args) {
(Value::String(s), Value::List(l)) => (s, l.into_inner()),
_ => return error!("exec requires a string cmd and string argument list")
};
let mut sargs = Vec::new();
for arg in args {
let Value::String(arg) = arg else {
return error!("exec requires a string cmd and string argument list")
};
sargs.push(arg.to_string());
};
let cmd = Command::new(cmd.to_string())
.args(sargs)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn();
let mut child = match cmd {
Ok(c) => c,
Err(e) => return error!("error executing command: {e}")
};
let status = match child.wait() {
Ok(s) => s,
Err(e) => return error!("error executing command: {e}")
};
let stdout = match child.stdout {
Some(ref mut out) => {
let mut buf = String::new();
let _ = out.read_to_string(&mut buf);
buf
},
None => String::new()
};
let stderr = match child.stderr {
Some(ref mut err) => {
let mut buf = String::new();
let _ = err.read_to_string(&mut buf);
buf
},
None => String::new()
};
let mut res = ValueMap::new();
res.insert(Value::from("success"), Value::Bool(status.success()))?;
res.insert(Value::from("code"), Value::Int(status.code().unwrap_or(0) as i64))?;
res.insert(Value::from("out"), Value::String(stdout.into()))?;
res.insert(Value::from("err"), Value::String(stderr.into()))?;
Ok(Value::Table(res.into()))
}
pub fn load(vm: &mut Vm) {
vm.load_global_fn(sys_exit(), "exit");
vm.load_global_fn(argv(), "argv");
vm.load_global_fn(exec(), "exec");
vm.load_global_fn(env(), "env");
}

View file

@ -1,5 +1,5 @@
use std::{rc::Rc, ops::{Neg, Not}}; use std::{rc::Rc, ops::{Neg, Not}, fmt::Debug};
use crate::{lex::Token, value::{Value, InlineList, InlineMatrix, InlineTable}, Result}; use crate::{lex::{Position, TokenData}, value::{Value, InlineList, InlineMatrix, InlineTable}, Result};
#[derive(Debug, Clone, Copy, Eq, PartialEq)] #[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum UnaryOp { pub enum UnaryOp {
@ -31,10 +31,15 @@ pub enum BinaryOp {
LessEquals, LessEquals,
GreaterThan, GreaterThan,
LessThan, LessThan,
// iter
Range,
RangeEq
} }
pub type AstName = (Rc<str>, Position);
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum Expr { pub enum ExprData {
NoOp, NoOp,
Literal(Value), Literal(Value),
@ -45,7 +50,7 @@ pub enum Expr {
Index(Box<Expr>, Vec<Expr>), Index(Box<Expr>, Vec<Expr>),
FnCall(Box<Expr>, Vec<Expr>), FnCall(Box<Expr>, Vec<Expr>),
FieldAccess(Box<Expr>, Rc<str>), FieldAccess(Box<Expr>, AstName),
List(InlineList), List(InlineList),
Matrix(InlineMatrix), Matrix(InlineMatrix),
@ -57,22 +62,49 @@ pub enum Expr {
Assign(Box<Expr>, Box<Expr>), Assign(Box<Expr>, Box<Expr>),
If(Box<Expr>, Box<Expr>, Option<Box<Expr>>), If(Box<Expr>, Box<Expr>, Option<Box<Expr>>),
Function(Rc<str>, Vec<Rc<str>>, Box<Expr>, bool), Function(AstName, Vec<AstName>, Box<Expr>, bool),
Lambda(Vec<Rc<str>>, Box<Expr>, bool), Lambda(Vec<AstName>, Box<Expr>, bool),
Loop(Box<Expr>), Loop(Box<Expr>),
While(Box<Expr>, Box<Expr>), While(Box<Expr>, Box<Expr>),
DoWhile(Box<Expr>, Box<Expr>), DoWhile(Box<Expr>, Box<Expr>),
For(AstName, Box<Expr>, Box<Expr>),
Block(Vec<Expr>), Block(Vec<Expr>),
Let(Rc<str>, Box<Expr>), Try(Box<Expr>, AstName, Box<Expr>),
Let(AstName, Box<Expr>),
Pipeline(Box<Expr>, Box<Expr>),
Continue, Continue,
Break, Break,
Return(Box<Expr>), Return(Box<Expr>),
} }
#[derive(Clone, PartialEq)]
pub struct Expr {
pub data: ExprData,
pub pos: Position
}
impl Debug for Expr {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if f.alternate() {
write!(f, "{:#?}", self.data)
} else {
write!(f, "{:?}", self.data)
}
}
}
impl From<(ExprData, Position)> for Expr {
fn from(value: (ExprData, Position)) -> Self {
Self { data: value.0, pos: value.1 }
}
}
impl Neg for BinaryOp { impl Neg for BinaryOp {
type Output = Option<Self>; type Output = Option<Self>;
fn neg(self) -> Self::Output { fn neg(self) -> Self::Output {
@ -103,73 +135,94 @@ impl Not for BinaryOp {
impl Neg for Expr { impl Neg for Expr {
type Output = std::result::Result<Self, Self>; type Output = std::result::Result<Self, Self>;
fn neg(self) -> Self::Output { fn neg(mut self) -> Self::Output {
use Expr::*; use ExprData as E;
Ok(match self { let mut pos = self.pos;
Literal(v) => Literal(-v), let data = match self.data {
BinaryOp(lhs, rhs, op) => { E::Literal(v) => E::Literal(-v),
E::BinaryOp(lhs, rhs, op) => {
let Some(op_n) = -op else { let Some(op_n) = -op else {
return Err(BinaryOp(lhs, rhs, op)); return Err((E::BinaryOp(lhs, rhs, op), pos).into());
}; };
if let Ok(lhs) = -*lhs.clone() { if let Ok(lhs) = -*lhs.clone() {
BinaryOp(Box::new(lhs), rhs, op_n) pos = lhs.pos;
E::BinaryOp(Box::new(lhs), rhs, op_n)
} else if let Ok(rhs) = -*rhs.clone() { } else if let Ok(rhs) = -*rhs.clone() {
BinaryOp(lhs, Box::new(rhs), op_n) pos = rhs.pos;
E::BinaryOp(lhs, Box::new(rhs), op_n)
} else { } else {
return Err(BinaryOp(lhs, rhs, op)) return Err((E::BinaryOp(lhs, rhs, op), pos).into());
} }
}, },
UnaryOp(expr, op) => { E::UnaryOp(expr, op) => {
match op { match op {
self::UnaryOp::Negate => *expr, UnaryOp::Negate => {
_ => return Err(UnaryOp(expr, op)) pos = expr.pos;
expr.data
},
_ => return Err((E::UnaryOp(expr, op), pos).into())
} }
} }
_ => return Err(self) data => return Err((data, pos).into())
}) };
self.data = data;
self.pos = pos;
Ok(self)
} }
} }
impl Not for Expr { impl Not for Expr {
type Output = std::result::Result<Self, Self>; type Output = std::result::Result<Self, Self>;
fn not(self) -> Self::Output { fn not(mut self) -> Self::Output {
use Expr::*; use ExprData as E;
Ok(match self { let mut pos = self.pos;
Literal(v) => Literal(Value::Bool(!v)), let data = match self.data {
UnaryOp(expr, op) => { E::Literal(v) => E::Literal(Value::Bool(!v)),
E::UnaryOp(expr, op) => {
match op { match op {
self::UnaryOp::Not => *expr, self::UnaryOp::Not => {
_ => return Err(UnaryOp(expr, op)) pos = expr.pos;
expr.data
},
_ => return Err((E::UnaryOp(expr, op), pos).into())
} }
} }
_ => return Err(self) data => return Err((data, pos).into())
}) };
self.data = data;
self.pos = pos;
Ok(self)
} }
} }
pub fn optimize(expr: Expr) -> Result<Expr> { pub fn optimize(mut expr: Expr) -> Result<Expr> {
use Expr as E; use ExprData as E;
Ok(match expr { let mut pos = expr.pos;
let data: ExprData = match expr.data {
E::UnaryOp(expr, op) => { E::UnaryOp(expr, op) => {
let expr = optimize(*expr)?; let expr = optimize(*expr)?;
match match op { match match op {
UnaryOp::Negate => -expr, UnaryOp::Negate => -expr,
UnaryOp::Not => !expr, UnaryOp::Not => !expr,
} { } {
Ok(expr) => expr, Ok(expr) => {
pos = expr.pos;
expr.data
},
Err(expr) => E::UnaryOp(Box::new(expr), op) Err(expr) => E::UnaryOp(Box::new(expr), op)
} }
}, },
E::BinaryOp(lhs, rhs, op) => { E::BinaryOp(lhs, rhs, op) => {
let lhs = optimize(*lhs)?; let lhs = optimize(*lhs)?;
let rhs = optimize(*rhs)?; let rhs = optimize(*rhs)?;
if let (E::Literal(l), E::Literal(r)) = (lhs.clone(), rhs.clone()) { if let (E::Literal(l), E::Literal(r)) = (lhs.clone().data, rhs.clone().data) {
match Value::binary_op(op, l, r) { match Value::binary_op(op, l, r) {
Err(err) => return Err(err), Err(err) => return Err(err),
Ok(value) => return Ok(Expr::Literal(value)), Ok(value) => E::Literal(value),
}
} }
} else {
E::BinaryOp(Box::new(lhs), Box::new(rhs), op) E::BinaryOp(Box::new(lhs), Box::new(rhs), op)
}
}, },
E::FnCall(ident, values) => { E::FnCall(ident, values) => {
E::FnCall(ident, values E::FnCall(ident, values
@ -200,10 +253,16 @@ pub fn optimize(expr: Expr) -> Result<Expr> {
E::And(lhs, rhs) => { E::And(lhs, rhs) => {
let lhs = optimize(*lhs)?; let lhs = optimize(*lhs)?;
let rhs = optimize(*rhs)?; let rhs = optimize(*rhs)?;
if let (E::Literal(l), r) = (lhs.clone(), rhs.clone()) { if let (E::Literal(l), r) = (lhs.clone().data, rhs.clone().data) {
match !!l.clone() { match !!l.clone() {
true => r, true => {
false => E::Literal(l), pos = rhs.pos;
r
},
false => {
pos = lhs.pos;
E::Literal(l)
},
} }
} else { } else {
E::And(Box::new(lhs), Box::new(rhs)) E::And(Box::new(lhs), Box::new(rhs))
@ -212,10 +271,16 @@ pub fn optimize(expr: Expr) -> Result<Expr> {
E::Or(lhs, rhs) => { E::Or(lhs, rhs) => {
let lhs = optimize(*lhs)?; let lhs = optimize(*lhs)?;
let rhs = optimize(*rhs)?; let rhs = optimize(*rhs)?;
if let (E::Literal(l), r) = (lhs.clone(), rhs.clone()) { if let (E::Literal(l), r) = (lhs.clone().data, rhs.clone().data) {
match !l.clone() { match !l.clone() {
true => r, true => {
false => E::Literal(l), pos = rhs.pos;
r
},
false => {
pos = lhs.pos;
E::Literal(l)
},
} }
} else { } else {
E::And(Box::new(lhs), Box::new(rhs)) E::And(Box::new(lhs), Box::new(rhs))
@ -230,10 +295,10 @@ pub fn optimize(expr: Expr) -> Result<Expr> {
.into_iter() .into_iter()
.enumerate() .enumerate()
.filter(|(i, e)| { .filter(|(i, e)| {
if let E::Literal(_) = e { if let E::Literal(_) = e.data {
return i + 1 == len return i + 1 == len
} }
E::NoOp != *e E::NoOp != e.data
}) })
.map(|e| e.1) .map(|e| e.1)
.collect(); .collect();
@ -247,39 +312,60 @@ pub fn optimize(expr: Expr) -> Result<Expr> {
let cond = optimize(*cond)?; let cond = optimize(*cond)?;
let block = optimize(*block)?; let block = optimize(*block)?;
let else_block = else_block.map(|e| optimize(*e)).transpose()?; let else_block = else_block.map(|e| optimize(*e)).transpose()?;
if let E::Literal(lit) = cond { if let E::Literal(lit) = cond.data {
if !!lit { if !!lit {
return Ok(block) pos = block.pos;
} block.data
return Ok(else_block.unwrap_or(E::NoOp)) } else if let Some(else_block) = else_block {
pos = else_block.pos;
else_block.data
} else {
E::NoOp
} }
} else {
E::If(Box::new(cond), Box::new(block), else_block.map(|e| Box::new(e))) E::If(Box::new(cond), Box::new(block), else_block.map(|e| Box::new(e)))
}
}, },
E::While(cond, block) => { E::While(cond, block) => {
let cond = optimize(*cond)?; let cond = optimize(*cond)?;
let block = optimize(*block)?; let block = optimize(*block)?;
if let E::Literal(lit) = cond { if let E::Literal(lit) = cond.data {
if !!lit { if !!lit {
return Ok(E::Loop(Box::new(block))) E::Loop(Box::new(block))
} } else {
return Ok(E::NoOp) E::NoOp
} }
} else {
E::While(Box::new(cond), Box::new(block)) E::While(Box::new(cond), Box::new(block))
}
}, },
E::For(name, cond, block) => {
let cond = optimize(*cond)?;
let block = optimize(*block)?;
E::For(name, Box::new(cond), Box::new(block))
}
E::DoWhile(block, cond) => { E::DoWhile(block, cond) => {
let cond = optimize(*cond)?; let cond = optimize(*cond)?;
let block = optimize(*block)?; let block = optimize(*block)?;
if let E::Literal(lit) = cond.clone() { if let E::Literal(lit) = &cond.data {
if !!lit { if !!lit.clone() {
return Ok(E::Loop(Box::new(block))) E::Loop(Box::new(block))
} } else {
}
E::DoWhile(Box::new(block), Box::new(cond)) E::DoWhile(Box::new(block), Box::new(cond))
} }
} else {
E::DoWhile(Box::new(block), Box::new(cond))
}
}
E::Loop(block) => { E::Loop(block) => {
let block = Box::new(optimize(*block)?); let block = Box::new(optimize(*block)?);
E::Loop(block) E::Loop(block)
}, },
E::Try(expr, err, catch) => {
let expr = Box::new(optimize(*expr)?);
let catch = Box::new(optimize(*catch)?);
E::Try(expr, err, catch)
},
E::Function(ident, params, stmt, varadic) => { E::Function(ident, params, stmt, varadic) => {
let stmt = Box::new(optimize(*stmt)?); let stmt = Box::new(optimize(*stmt)?);
E::Function(ident, params, stmt, varadic) E::Function(ident, params, stmt, varadic)
@ -297,44 +383,53 @@ pub fn optimize(expr: Expr) -> Result<Expr> {
E::Assign(lhs, rhs) E::Assign(lhs, rhs)
}, },
E::Return(expr) => { E::Return(expr) => {
E::Return(Box::new(optimize(*expr)?)) let expr = Box::new(optimize(*expr)?);
E::Return(expr)
}, },
_ => expr E::Pipeline(lhs, rhs) => {
}) let lhs = Box::new(optimize(*lhs)?);
let rhs = Box::new(optimize(*rhs)?);
E::Pipeline(lhs, rhs)
}
data => data
};
expr.data = data;
expr.pos = pos;
Ok(expr)
} }
impl From<Token> for UnaryOp { impl From<TokenData> for UnaryOp {
fn from(value: Token) -> Self { fn from(value: TokenData) -> Self {
use Token::*; use TokenData as T;
match value { match value {
Subtract => Self::Negate, T::Subtract => Self::Negate,
Not => Self::Not, T::Not => Self::Not,
_ => panic!("aaaaa") _ => panic!("aaaaa")
} }
} }
} }
impl From<Token> for BinaryOp { impl From<TokenData> for BinaryOp {
fn from(value: Token) -> Self { fn from(value: TokenData) -> Self {
use Token::*; use TokenData as T;
match value { match value {
Equal => Self::Equals, T::Equal => Self::Equals,
NotEqual => Self::NotEquals, T::NotEqual => Self::NotEquals,
GreaterEqual => Self::GreaterEquals, T::GreaterEqual => Self::GreaterEquals,
LessEqual => Self::LessEquals, T::LessEqual => Self::LessEquals,
GreaterThan => Self::GreaterThan, T::GreaterThan => Self::GreaterThan,
LessThan => Self::LessThan, T::LessThan => Self::LessThan,
BitwiseShiftLeft => Self::BitwiseShiftLeft, T::BitwiseShiftLeft => Self::BitwiseShiftLeft,
BitwiseShiftRight => Self::BitwiseShiftRight, T::BitwiseShiftRight => Self::BitwiseShiftRight,
BitwiseAnd => Self::BitwiseAnd, T::BitwiseAnd => Self::BitwiseAnd,
BitwiseOr => Self::BitwiseOr, T::BitwiseOr => Self::BitwiseOr,
BitwiseXor => Self::BitwiseXor, T::BitwiseXor => Self::BitwiseXor,
Add => Self::Add, T::Add => Self::Add,
Subtract => Self::Subtract, T::Subtract => Self::Subtract,
Multiply => Self::Multiply, T::Multiply => Self::Multiply,
Divide => Self::Divide, T::Divide => Self::Divide,
Modulo => Self::Modulo, T::Modulo => Self::Modulo,
Power => Self::Power, T::Power => Self::Power,
_ => panic!("aaaaa") _ => panic!("aaaaa")
} }
} }
@ -342,11 +437,11 @@ impl From<Token> for BinaryOp {
impl Expr { impl Expr {
pub fn is_assignable(&self) -> bool { pub fn is_assignable(&self) -> bool {
use Expr::*; use ExprData as E;
match self { match self.data {
Ident(_) => true, E::Ident(_) => true,
Index(_, _) => true, E::Index(_, _) => true,
FieldAccess(_, _) => true, E::FieldAccess(_, _) => true,
_ => false, _ => false,
} }
} }

View file

@ -1,17 +1,19 @@
use crate::{value::Value, ast::{UnaryOp, BinaryOp}, vm::Vm, Result}; use crate::{value::Value, ast::{UnaryOp, BinaryOp}, vm::{Vm, StackFrame}, Result, lex::Position};
use std::{fmt::{Debug, Display}, rc::Rc}; use std::{fmt::{Debug, Display}, rc::Rc};
#[derive(Clone)] #[derive(Clone, Default)]
pub struct Chunk { pub struct Chunk {
pub constants: Vec<Value>, pub constants: Vec<Value>,
pub code: Vec<Instruction> pub code: Vec<Instruction>,
pub pos: Vec<Position>,
} }
impl Chunk { impl Chunk {
pub fn new() -> Self { pub fn new() -> Self {
Self { Self {
constants: Vec::new(), constants: Vec::new(),
code: Vec::new() code: Vec::new(),
pos: Vec::new(),
} }
} }
} }
@ -43,9 +45,10 @@ pub struct Function {
pub fun: InnerFunction pub fun: InnerFunction
} }
#[derive(Clone)]
pub enum InnerFunction { pub enum InnerFunction {
Compiled(Rc<Chunk>), Compiled(Rc<Chunk>),
Native(Box<dyn Fn(&mut Vm, Vec<Value>) -> Result<Value>>), Native(Rc<dyn Fn((&mut Vm, &mut StackFrame), Vec<Value>) -> Result<Value>>),
} }
impl Debug for Function { impl Debug for Function {
@ -98,6 +101,13 @@ pub enum Instruction {
Jump(u16), Jump(u16),
JumpTrue(u16), JumpTrue(u16),
JumpFalse(u16), JumpFalse(u16),
JumpNil(u16),
IterCreate,
IterNext,
Try(u16),
TryEnd,
Call(u8), Call(u8),
Return, Return,
@ -131,10 +141,15 @@ impl Display for Instruction {
Jump(idx) => write!(f, "jump \x1b[33m{idx}\x1b[0m"), Jump(idx) => write!(f, "jump \x1b[33m{idx}\x1b[0m"),
JumpTrue(idx) => write!(f, "jumpt \x1b[33m{idx}\x1b[0m"), JumpTrue(idx) => write!(f, "jumpt \x1b[33m{idx}\x1b[0m"),
JumpFalse(idx) => write!(f, "jumpf \x1b[33m{idx}\x1b[0m"), JumpFalse(idx) => write!(f, "jumpf \x1b[33m{idx}\x1b[0m"),
JumpNil(idx) => write!(f, "jumpn \x1b[33m{idx}\x1b[0m"),
Call(arity) => write!(f, "call \x1b[35m{arity}\x1b[0m"), Call(arity) => write!(f, "call \x1b[35m{arity}\x1b[0m"),
Return => write!(f, "return"), Return => write!(f, "return"),
IterCreate => write!(f, "iter create"),
IterNext => write!(f, "iter next"),
Field(name_idx) => write!(f, "field \x1b[33m{name_idx}\x1b[0m"), Field(name_idx) => write!(f, "field \x1b[33m{name_idx}\x1b[0m"),
StoreField(name_idx) => write!(f, "store field \x1b[33m{name_idx}\x1b[0m"), StoreField(name_idx) => write!(f, "store field \x1b[33m{name_idx}\x1b[0m"),
Try(idx) => write!(f, "try \x1b[33m{idx}\x1b[0m"),
TryEnd => write!(f, "try end"),
} }
} }
} }

View file

@ -1,9 +1,9 @@
use std::{fmt::Display, rc::Rc, cell::RefCell}; use std::{fmt::Display, rc::Rc, cell::RefCell};
use crate::{ast::Expr, chunk::{Function, Instruction, InnerFunction}, chunk::{Chunk, self}, value::Value, Result}; use crate::{ast::{Expr, ExprData, AstName}, chunk::{Function, Instruction, InnerFunction}, chunk::{Chunk, self}, value::Value, Result, lex::Position};
use Instruction as I; use Instruction as I;
use Value as V; use Value as V;
use Expr as E; use ExprData as E;
pub type NamesTable = Rc<RefCell<Vec<Rc<str>>>>; pub type NamesTable = Rc<RefCell<Vec<Rc<str>>>>;
@ -104,7 +104,7 @@ struct Local {
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum Error { pub enum InnerError {
Undefined(Rc<str>), Undefined(Rc<str>),
Redefined(Rc<str>), Redefined(Rc<str>),
InvAssign(Expr), InvAssign(Expr),
@ -113,22 +113,36 @@ pub enum Error {
NotImplemented(&'static str), NotImplemented(&'static str),
} }
#[derive(Debug, Clone)]
pub struct Error {
pos: Position,
err: InnerError,
}
impl std::error::Error for self::Error {} impl std::error::Error for self::Error {}
impl Display for self::Error { impl Display for self::Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use self::Error::*; use InnerError as E;
match self { write!(f, "parse failed at {}:{}, ", self.pos.row, self.pos.col)?;
Undefined(name) => write!(f, "value {name} is undefined"), match &self.err {
Redefined(name) => write!(f, "cannot redefine {name} in the same scope"), E::Undefined(name) => write!(f, "value {name} is undefined"),
InvAssign(expr) => write!(f, "cannot assign to {expr:?}"), E::Redefined(name) => write!(f, "cannot redefine {name} in the same scope"),
InvContinue => write!(f, "cannot continue outside a loop"), E::InvAssign(expr) => write!(f, "cannot assign to {expr:?}"),
InvBreak => write!(f, "cannot break outside a loop"), E::InvContinue => write!(f, "cannot continue outside a loop"),
NotImplemented(str) => write!(f, "{str} is not implemented yet") E::InvBreak => write!(f, "cannot break outside a loop"),
E::NotImplemented(str) => write!(f, "{str} is not implemented yet")
} }
} }
} }
fn error<T>(err: InnerError, pos: Position) -> Result<T> {
Err(self::Error {
pos,
err
}.into())
}
impl<'c> Compiler<'c> { impl<'c> Compiler<'c> {
fn child(&'c self, name: Rc<str>) -> Self { fn child(&'c self, name: Rc<str>) -> Self {
@ -156,7 +170,7 @@ impl<'c> Compiler<'c> {
cutoff = self.scopes.pop().unwrap() cutoff = self.scopes.pop().unwrap()
} }
if cutoff < self.locals.len() { if cutoff < self.locals.len() {
self.emit(Instruction::DiscardLocals((self.locals.len() - cutoff) as u16)); self.emit(Instruction::DiscardLocals((self.locals.len() - cutoff) as u16), self.last_pos());
self.locals.truncate(cutoff); self.locals.truncate(cutoff);
}; };
} }
@ -166,7 +180,7 @@ impl<'c> Compiler<'c> {
return; return;
}; };
if cutoff < self.locals.len() { if cutoff < self.locals.len() {
self.emit(Instruction::DiscardLocals((self.locals.len() - cutoff) as u16)); self.emit(Instruction::DiscardLocals((self.locals.len() - cutoff) as u16), self.last_pos());
self.locals.truncate(cutoff); self.locals.truncate(cutoff);
}; };
} }
@ -182,19 +196,19 @@ impl<'c> Compiler<'c> {
c c
} }
fn create_local_checked(&mut self, name: Rc<str>) -> Result<()> { fn create_local_checked(&mut self, name: Rc<str>, pos: Position) -> Result<()> {
if let Some(local) = self.find_local(&name) { if let Some(local) = self.find_local(&name) {
if local.scope == self.scopes.len() { if local.scope == self.scopes.len() {
return Err(Error::Redefined(name).into()) return error(InnerError::Redefined(name), pos)
} }
}; };
self.create_local(name); self.create_local(name);
Ok(()) Ok(())
} }
fn create_global_checked(&mut self, name: Rc<str>) -> Result<usize> { fn create_global_checked(&mut self, name: Rc<str>, pos: Position) -> Result<usize> {
if let Some(_) = self.find_global(&name) { if let Some(_) = self.find_global(&name) {
return Err(Error::Redefined(name).into()) return error(InnerError::Redefined(name).into(), pos)
} }
Ok(self.create_global(name)) Ok(self.create_global(name))
} }
@ -227,29 +241,29 @@ impl<'c> Compiler<'c> {
idx idx
} }
fn emit_const(&mut self, val: Value) { fn emit_const(&mut self, val: Value, pos: Position) {
// TODO: find constant if already exists // TODO: find constant if already exists
self.chunk.constants.push(val); self.chunk.constants.push(val);
let c = self.chunk.constants.len() - 1; let c = self.chunk.constants.len() - 1;
self.emit(Instruction::Const(c as u16)); self.emit(Instruction::Const(c as u16), pos);
} }
fn can_make_globals(&self) -> bool { fn can_make_globals(&self) -> bool {
self.repl && self.parent.is_none() && self.scopes.len() == 0 self.repl && self.parent.is_none() && self.scopes.len() == 0
} }
fn compile_value(&mut self, val: &Value) { fn compile_value(&mut self, val: &Value, pos: Position) {
match val { match val {
V::Nil => self.emit(I::Nil), V::Nil => self.emit(I::Nil, pos),
V::Bool(b) => if *b { self.emit(I::True) } else { self.emit(I::False) }, V::Bool(b) => if *b { self.emit(I::True, pos) } else { self.emit(I::False, pos) },
V::Int(i) => { V::Int(i) => {
if let Ok(i) = i16::try_from(*i) { if let Ok(i) = i16::try_from(*i) {
self.emit(I::Int(i)); self.emit(I::Int(i), pos);
} else { } else {
self.emit_const(val.clone()); self.emit_const(val.clone(), pos);
} }
}, },
_ => self.emit_const(val.clone()), _ => self.emit_const(val.clone(), pos),
} }
} }
@ -263,152 +277,193 @@ impl<'c> Compiler<'c> {
} }
fn compile_expr(&mut self, expr: &Expr) -> Result<()> { fn compile_expr(&mut self, expr: &Expr) -> Result<()> {
match expr { match &expr.data {
E::NoOp => self.emit(I::Nil), E::NoOp => self.emit(I::Nil, expr.pos),
E::If(cond, ifb, elseb) => { E::If(cond, ifb, elseb) => {
self.compile_expr(cond)?; self.compile_expr(cond)?;
let jmpidx = self.emit_temp(); let jmpidx = self.emit_temp(expr.pos);
self.compile_expr(ifb)?; self.compile_expr(ifb)?;
let jmpidx2 = self.emit_temp(expr.pos);
self.re_emit(I::JumpFalse(self.cur()), jmpidx); self.re_emit(I::JumpFalse(self.cur()), jmpidx);
if let Some(elseb) = elseb { if let Some(elseb) = elseb {
self.compile_expr(elseb)?; self.compile_expr(elseb)?;
} }
self.re_emit(I::Jump(self.cur()), jmpidx2);
}, },
E::Function(name, params, body, varadic) => { E::Function(name, params, body, varadic) => {
let chunk = self.compile_function(name.clone(), params, body)?; let chunk = self.compile_function(name.clone(), params, body)?;
let arity = params.len() - if *varadic { 1 } else { 0 };
let fun = Value::Function(Rc::new( let fun = Value::Function(Rc::new(
chunk::Function { chunk::Function {
name: name.clone(), name: name.0.clone(),
arity: params.len(), arity,
fun: InnerFunction::Compiled(chunk.into()), fun: InnerFunction::Compiled(chunk.into()),
variadic: *varadic variadic: *varadic
} }
)); ));
self.emit_const(fun); self.emit_const(fun, expr.pos);
self.emit(I::Dup); self.emit(I::Dup, expr.pos);
if self.can_make_globals() { if self.can_make_globals() {
let idx = self.create_global_checked(name.clone())?; let idx = self.create_global_checked(name.0.clone(), name.1)?;
self.emit(I::StoreGlobal(idx as u16)); self.emit(I::StoreGlobal(idx as u16), expr.pos);
} else { } else {
self.create_local_checked(name.clone())?; self.create_local_checked(name.0.clone(), name.1)?;
self.emit(I::CreateLocal); self.emit(I::CreateLocal, expr.pos);
} }
}, },
E::Lambda(params, body, varadic) => { E::Lambda(params, body, varadic) => {
let name: Rc<str> = Rc::from("<lambda>"); let name: AstName = (Rc::from("<lambda>"), expr.pos);
let chunk = self.compile_function(name.clone(), params, body)?; let chunk = self.compile_function(name.clone(), params, body)?;
let arity = params.len() - if *varadic { 1 } else { 0 };
let fun = Value::Function(Rc::new( let fun = Value::Function(Rc::new(
chunk::Function { chunk::Function {
name: name.clone(), name: name.0.clone(),
arity: params.len(), arity,
fun: InnerFunction::Compiled(chunk.into()), fun: InnerFunction::Compiled(chunk.into()),
variadic: *varadic variadic: *varadic
} }
)); ));
self.emit_const(fun); self.emit_const(fun, expr.pos);
}, },
E::Loop(expr) => { E::Loop(expr) => {
let idx = self.cur(); let idx = self.cur();
self.loop_top.push((idx as usize, self.scopes.len())); self.loop_top.push((idx as usize, self.scopes.len()));
self.compile_expr(expr)?; self.compile_expr(expr)?;
self.emit(I::Discard(1)); self.emit(I::Discard(1), expr.pos);
self.emit(I::Jump(idx)); self.emit(I::Jump(idx), expr.pos);
self.finish_loop(); self.finish_loop();
self.emit(I::Nil); self.emit(I::Nil, expr.pos);
},
E::Try(expr, err, catch) => {
let jmpidx = self.emit_temp(expr.pos);
self.compile_expr(expr)?;
self.emit(I::TryEnd, expr.pos);
let jmpidx2 = self.emit_temp(expr.pos);
self.re_emit(I::Try(self.cur()), jmpidx);
self.begin_scope();
self.create_local(err.0.clone());
self.emit(I::CreateLocal, err.1);
self.compile_expr(catch)?;
self.end_scope();
self.re_emit(I::Jump(self.cur() as u16), jmpidx2);
}, },
E::While(cond, expr) => { E::While(cond, expr) => {
let top = self.cur(); let top = self.cur();
self.compile_expr(cond)?; self.compile_expr(cond)?;
let jmpidx = self.emit_temp(); let jmpidx = self.emit_temp(expr.pos);
self.loop_top.push((top as usize, self.scopes.len())); self.loop_top.push((top as usize, self.scopes.len()));
self.compile_expr(expr)?; self.compile_expr(expr)?;
self.emit(I::Discard(1)); self.emit(I::Discard(1), expr.pos);
self.emit(I::Jump(top)); self.emit(I::Jump(top), expr.pos);
self.re_emit(I::JumpFalse(self.cur()), jmpidx); self.re_emit(I::JumpFalse(self.cur()), jmpidx);
self.finish_loop(); self.finish_loop();
self.emit(I::Nil); self.emit(I::Nil, expr.pos);
}, },
E::DoWhile(expr, cond) => { E::DoWhile(expr, cond) => {
let top = self.cur(); let top = self.cur();
self.loop_top.push((top as usize, self.scopes.len())); self.loop_top.push((top as usize, self.scopes.len()));
self.compile_expr(expr)?; self.compile_expr(expr)?;
self.emit(I::Discard(1)); self.emit(I::Discard(1), expr.pos);
self.compile_expr(cond)?; self.compile_expr(cond)?;
self.emit(I::JumpTrue(top)); self.emit(I::JumpTrue(top), expr.pos);
self.finish_loop(); self.finish_loop();
self.emit(I::Nil); self.emit(I::Nil, expr.pos);
}, },
E::For(name, cond, expr) => {
self.compile_expr(cond)?;
self.emit(I::IterCreate, cond.pos);
let top = self.cur();
self.emit(I::IterNext, cond.pos);
self.emit(I::Dup, expr.pos);
let jumpidx = self.emit_temp(expr.pos);
self.loop_top.push((top as usize, self.scopes.len()));
self.begin_scope();
self.create_local(name.0.clone());
self.emit(I::CreateLocal, name.1);
self.compile_expr(expr)?;
self.emit(I::Discard(1), expr.pos);
self.end_scope();
self.emit(I::Jump(top), expr.pos);
self.re_emit(I::JumpNil(self.cur()), jumpidx);
self.finish_loop();
self.emit(I::Discard(2), expr.pos);
self.emit(I::Nil, expr.pos);
}
E::Block(block) => { E::Block(block) => {
if block.len() == 0 {
self.emit(I::Nil, expr.pos);
return Ok(());
}
self.begin_scope(); self.begin_scope();
for (i, expr) in block.iter().enumerate() { for (i, expr) in block.iter().enumerate() {
self.compile_expr(expr)?; self.compile_expr(expr)?;
if i + 1 != block.len() { if i + 1 != block.len() {
self.emit(I::Discard(1)); self.emit(I::Discard(1), expr.pos);
} }
} }
self.end_scope(); self.end_scope();
}, },
E::Let(name, expr) => { E::Let(name, expr) => {
self.compile_expr(expr)?; self.compile_expr(expr)?;
self.emit(I::Dup); self.emit(I::Dup, expr.pos);
if self.can_make_globals() { if self.can_make_globals() {
let global = self.create_global_checked(name.clone())?; let global = self.create_global_checked(name.0.clone(), name.1)?;
self.emit(I::StoreGlobal(global as u16)); self.emit(I::StoreGlobal(global as u16), expr.pos);
} else { } else {
self.create_local_checked(name.clone())?; self.create_local_checked(name.0.clone(), name.1)?;
self.emit(I::CreateLocal); self.emit(I::CreateLocal, expr.pos);
} }
}, },
E::Continue => { E::Continue => {
let top = self.loop_top.pop(); let top = self.loop_top.pop();
if let Some((top, scope)) = top { if let Some((top, scope)) = top {
self.collapse_scopes(scope); self.collapse_scopes(scope);
self.emit(I::Jump(top as u16)); self.emit(I::Jump(top as u16), expr.pos);
} else { } else {
return Err(Error::InvContinue.into()) return error(InnerError::InvContinue, expr.pos)
} }
}, },
E::Break => { E::Break => {
let top = self.loop_top.pop(); let top = self.loop_top.pop();
if let Some((_, scope)) = top { if let Some((_, scope)) = top {
self.collapse_scopes(scope); self.collapse_scopes(scope);
let tmpidx = self.emit_temp(); let tmpidx = self.emit_temp(expr.pos);
self.loop_bot.push(tmpidx); self.loop_bot.push(tmpidx);
} else { } else {
return Err(Error::InvBreak.into()) return error(InnerError::InvBreak, expr.pos)
} }
}, },
E::Return(expr) => { E::Return(expr) => {
self.compile_expr(expr)?; self.compile_expr(expr)?;
self.emit(I::Return); self.emit(I::Return, expr.pos);
}, },
E::Literal(val) => self.compile_value(val), E::Literal(val) => self.compile_value(val, expr.pos),
E::Ident(name) => { E::Ident(name) => {
if name.as_ref() == "_" { if name.as_ref() == "_" {
self.emit(I::Nil); self.emit(I::Nil, expr.pos);
} else if let Some(local) = self.find_local(name) { } else if let Some(local) = self.find_local(name) {
self.emit(I::LoadLocal(local.idx as u16)); self.emit(I::LoadLocal(local.idx as u16), expr.pos);
} else if let Some(global) = self.find_global(name) { } else if let Some(global) = self.find_global(name) {
self.emit(I::LoadGlobal(global as u16)); self.emit(I::LoadGlobal(global as u16), expr.pos);
} else { } else {
return Err(self::Error::Undefined(name.clone()).into()) return error(InnerError::Undefined(name.clone()), expr.pos)
}; };
}, },
E::Assign(lhs, rhs) => { E::Assign(lhs, rhs) => {
self.compile_expr(rhs)?; self.compile_expr(rhs)?;
self.emit(I::Dup); self.emit(I::Dup, rhs.pos);
match lhs.as_ref() { match &lhs.data {
E::Ident(name) if name.as_ref() != "_" => { E::Ident(name) if name.as_ref() != "_" => {
if let Some(local) = self.find_local(&name) { if let Some(local) = self.find_local(&name) {
self.emit(I::StoreLocal(local.idx as u16)); self.emit(I::StoreLocal(local.idx as u16), lhs.pos);
} else if let Some(global) = self.find_global(&name) { } else if let Some(global) = self.find_global(&name) {
self.emit(I::StoreGlobal(global as u16)); self.emit(I::StoreGlobal(global as u16), lhs.pos);
} else if self.can_make_globals() { } else if self.can_make_globals() {
let global = self.create_global_checked(name.clone())?; let global = self.create_global_checked(name.clone(), lhs.pos)?;
self.emit(I::StoreGlobal(global as u16)); self.emit(I::StoreGlobal(global as u16), lhs.pos);
} else { } else {
self.create_local_checked(name.clone())?; self.create_local_checked(name.clone(), lhs.pos)?;
self.emit(I::CreateLocal); self.emit(I::CreateLocal, lhs.pos);
} }
}, },
E::Index(expr, params) => { E::Index(expr, params) => {
@ -416,89 +471,94 @@ impl<'c> Compiler<'c> {
for param in params { for param in params {
self.compile_expr(param)?; self.compile_expr(param)?;
} }
self.emit(I::StoreIndex(params.len() as u8)); self.emit(I::StoreIndex(params.len() as u8), expr.pos);
}, },
E::FieldAccess(expr, ident) => { E::FieldAccess(expr, ident) => {
self.compile_expr(expr)?; self.compile_expr(expr)?;
let name = self.get_name(ident.clone()); let name = self.get_name(ident.0.clone());
self.emit(I::StoreField(name as u16)); self.emit(I::StoreField(name as u16), expr.pos);
} }
_ => return Err(self::Error::InvAssign(*lhs.clone()).into()) _ => return error(InnerError::InvAssign(*lhs.clone()), lhs.pos)
} }
} }
E::UnaryOp(expr, op) => { E::UnaryOp(expr, op) => {
self.compile_expr(expr)?; self.compile_expr(expr)?;
self.emit(I::UnaryOp(*op)); self.emit(I::UnaryOp(*op), expr.pos);
}, },
E::BinaryOp(lhs, rhs, op) => { E::BinaryOp(lhs, rhs, op) => {
self.compile_expr(lhs)?; self.compile_expr(lhs)?;
self.compile_expr(rhs)?; self.compile_expr(rhs)?;
self.emit(I::BinaryOp(*op)); self.emit(I::BinaryOp(*op), lhs.pos);
}, },
E::Index(expr, params) => { E::Index(expr, params) => {
self.compile_expr(expr)?; self.compile_expr(expr)?;
for param in params { for param in params {
self.compile_expr(param)?; self.compile_expr(param)?;
} }
self.emit(I::Index(params.len() as u8)) self.emit(I::Index(params.len() as u8), expr.pos)
}, },
E::FnCall(fun, params) => { E::FnCall(fun, params) => {
for expr in params { for expr in params {
self.compile_expr(expr)?; self.compile_expr(expr)?;
} }
self.compile_expr(fun)?; self.compile_expr(fun)?;
self.emit(I::Call(params.len() as u8)); self.emit(I::Call(params.len() as u8), expr.pos);
}, },
E::FieldAccess(expr, field) => { E::FieldAccess(expr, field) => {
self.compile_expr(expr)?; self.compile_expr(expr)?;
let idx = self.get_name(field.clone()); let idx = self.get_name(field.0.clone());
self.emit(I::Field(idx as u16)) self.emit(I::Field(idx as u16), expr.pos)
} }
E::List(list) => { E::List(list) => {
for expr in list { for expr in list {
self.compile_expr(expr)?; self.compile_expr(expr)?;
} }
self.emit(I::NewList(list.len() as u16)); self.emit(I::NewList(list.len() as u16), expr.pos);
}, },
E::Matrix(mat) => { E::Matrix(mat) => {
for expr in &mat.2 { for expr in &mat.2 {
self.compile_expr(expr)?; self.compile_expr(expr)?;
} }
self.emit(I::NewMatrix(mat.2.len() as u16, mat.0 as u8)); self.emit(I::NewMatrix(mat.2.len() as u16, mat.0 as u8), expr.pos);
}, },
E::Table(table) => { E::Table(table) => {
for (key, value) in table { for (key, value) in table {
self.compile_expr(key)?; self.compile_expr(key)?;
self.compile_expr(value)?; self.compile_expr(value)?;
} }
self.emit(I::NewTable(table.len() as u16)); self.emit(I::NewTable(table.len() as u16), expr.pos);
}, },
E::And(lhs, rhs) => { E::And(lhs, rhs) => {
self.compile_expr(lhs)?; self.compile_expr(lhs)?;
self.emit(I::Dup); self.emit(I::Dup, lhs.pos);
let jmpidx = self.emit_temp(); let jmpidx = self.emit_temp(lhs.pos);
self.compile_expr(rhs)?; self.compile_expr(rhs)?;
self.re_emit(I::JumpFalse(self.cur()), jmpidx); self.re_emit(I::JumpFalse(self.cur()), jmpidx);
}, },
E::Or(lhs, rhs) => { E::Or(lhs, rhs) => {
self.compile_expr(lhs)?; self.compile_expr(lhs)?;
self.emit(I::Dup); self.emit(I::Dup, lhs.pos);
let jmpidx = self.emit_temp(); let jmpidx = self.emit_temp(lhs.pos);
self.compile_expr(rhs)?; self.compile_expr(rhs)?;
self.re_emit(I::JumpTrue(self.cur()), jmpidx); self.re_emit(I::JumpTrue(self.cur()), jmpidx);
}, },
E::Pipeline(lhs, rhs) => {
self.compile_expr(lhs)?;
self.compile_expr(rhs)?;
self.emit(I::Call(1), expr.pos);
}
}; };
Ok(()) Ok(())
} }
fn compile_function(&mut self, name: Rc<str>, params: &Vec<Rc<str>>, body: &Box<Expr>) -> Result<Chunk> { fn compile_function(&mut self, name: AstName, params: &Vec<AstName>, body: &Box<Expr>) -> Result<Chunk> {
let mut compiler = self.child(name); let mut compiler = self.child(name.0);
for name in params { for (name, pos) in params {
compiler.create_local(name.clone()); compiler.create_local(name.clone());
compiler.emit(I::CreateLocal); compiler.emit(I::CreateLocal, *pos);
} }
compiler.compile_expr(body)?; compiler.compile_expr(body)?;
compiler.finish()?; compiler.finish(name.1)?;
Ok(compiler.chunk) Ok(compiler.chunk)
} }
@ -506,15 +566,16 @@ impl<'c> Compiler<'c> {
self.chunk.code.len() as u16 self.chunk.code.len() as u16
} }
fn emit_temp(&mut self) -> usize { fn emit_temp(&mut self, pos: Position) -> usize {
let idx = self.chunk.code.len(); let idx = self.chunk.code.len();
self.emit(Instruction::NoOp); self.emit(Instruction::NoOp, pos);
idx idx
} }
fn emit(&mut self, ins: Instruction) { fn emit(&mut self, ins: Instruction, pos: Position) {
//println!("{}: {ins}", self.name); //println!("{}: {ins}", self.name);
self.chunk.code.push(ins); self.chunk.code.push(ins);
self.chunk.pos.push(pos);
} }
fn re_emit(&mut self, ins: Instruction, idx: usize) { fn re_emit(&mut self, ins: Instruction, idx: usize) {
@ -522,12 +583,20 @@ impl<'c> Compiler<'c> {
self.chunk.code[idx] = ins; self.chunk.code[idx] = ins;
} }
fn finish(&mut self) -> Result<()> { fn last_pos(&self) -> Position {
if let Some(pos) = self.chunk.pos.last() {
*pos
} else {
Position::default()
}
}
fn finish(&mut self, pos: Position) -> Result<()> {
let ins = match self.chunk.code.last() { let ins = match self.chunk.code.last() {
Some(ins) => ins.clone(), Some(ins) => ins.clone(),
None => { None => {
self.emit(I::Nil); self.emit(I::Nil, pos);
self.emit(I::Return); self.emit(I::Return, pos);
if self.debug { if self.debug {
println!("{}\n{}", self.name, self.chunk); println!("{}\n{}", self.name, self.chunk);
} }
@ -537,12 +606,12 @@ impl<'c> Compiler<'c> {
match ins { match ins {
I::Return => {}, I::Return => {},
_ => { _ => {
self.emit(I::Return); self.emit(I::Return, pos);
} }
}; };
if self.loop_bot.len() > 0 { if self.loop_bot.len() > 0 {
return Err(Error::InvBreak.into()) return error(InnerError::InvBreak, pos)
} }
if self.debug { if self.debug {
@ -555,12 +624,12 @@ impl<'c> Compiler<'c> {
&mut self, &mut self,
body: &Expr, body: &Expr,
) -> Result<Rc<Function>> { ) -> Result<Rc<Function>> {
if let Expr::Block(_) = body { if let ExprData::Block(_) = &body.data {
self.root_is_block = true; self.root_is_block = true;
} }
self.chunk = Chunk::new(); self.chunk = Chunk::new();
self.compile_expr(body)?; self.compile_expr(body)?;
self.finish()?; self.finish(self.last_pos())?;
let fun = Function { name: self.name.clone(), fun: InnerFunction::Compiled(self.chunk.clone().into()), arity: 0, variadic: false }; let fun = Function { name: self.name.clone(), fun: InnerFunction::Compiled(self.chunk.clone().into()), arity: 0, variadic: false };
Ok(Rc::new(fun)) Ok(Rc::new(fun))
} }

View file

@ -31,6 +31,12 @@ impl <T: Clone> Gc<T> {
} }
} }
pub fn into_inner(self) -> T {
unsafe {
self.ptr.as_ref().data.clone()
}
}
fn data(&self) -> T { fn data(&self) -> T {
unsafe { unsafe {
self.ptr.as_ref().data.clone() self.ptr.as_ref().data.clone()

View file

@ -31,7 +31,7 @@ impl From<RegexToken> for Regex {
} }
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum Token { pub enum TokenData {
//syntax //syntax
LeftParen, LeftParen,
RightParen, RightParen,
@ -46,9 +46,11 @@ pub enum Token {
ThinArrow, ThinArrow,
Comma, Comma,
Range, Range,
RangeEq,
Colon, Colon,
Backslash, Backslash,
Varadic, Varadic,
Pipe,
// math // math
Regex(RegexToken), Regex(RegexToken),
@ -113,11 +115,24 @@ pub enum Token {
Do, Do,
Loop, Loop,
Return, Return,
For,
In,
Try,
Catch,
// eof // eof
Eof, Eof,
} }
#[derive(Debug, PartialEq)]
pub struct Token {
pub data: TokenData,
pub pos: Position,
pub str: String,
pub bidx: usize,
pub blen: usize,
}
#[derive(Debug)] #[derive(Debug)]
pub enum Error { pub enum Error {
UnexpectedCharacter(char), UnexpectedCharacter(char),
@ -148,10 +163,24 @@ impl std::fmt::Display for Error {
impl std::error::Error for Error {} impl std::error::Error for Error {}
#[derive(Debug, Clone, PartialEq, Eq, Copy)]
pub struct Position {
pub row: usize,
pub col: usize,
}
impl Default for Position {
fn default() -> Self {
Self { row: 1, col: 1 }
}
}
pub struct Lexer { pub struct Lexer {
pub index: usize, pub index: usize,
len: usize, len: usize,
data: Vec<char>, data: Vec<char>,
pos: Position,
byte_len: usize,
} }
trait IsIdent { trait IsIdent {
@ -177,7 +206,13 @@ impl<T: Into<String>> From<T> for Lexer {
impl Lexer { impl Lexer {
pub fn new<T: Into<String>>(input: T) -> Self { pub fn new<T: Into<String>>(input: T) -> Self {
let data: Vec<char> = input.into().chars().collect(); let data: Vec<char> = input.into().chars().collect();
Self { index: 0, len: data.len(), data } Self {
index: 0,
len: data.len(),
data,
pos: Position::default(),
byte_len: 0
}
} }
fn peek(&self) -> char { fn peek(&self) -> char {
@ -190,6 +225,14 @@ impl Lexer {
fn next(&mut self) -> char { fn next(&mut self) -> char {
let c = self.peek(); let c = self.peek();
self.index += 1; self.index += 1;
self.byte_len += c.len_utf8();
self.pos.col += 1;
if c == '\n' {
self.pos.col = 1;
self.pos.row += 1;
}
c c
} }
@ -274,14 +317,14 @@ impl Lexer {
Ok(buf.into()) Ok(buf.into())
} }
fn lex_ident(&mut self, initial: char) -> Result<Token> { fn lex_ident(&mut self, initial: char) -> Result<TokenData> {
use Error::*; use Error as E;
use Token::*; use TokenData as T;
let mut buf = std::string::String::new(); let mut buf = std::string::String::new();
if !initial.is_initial_ident() { if !initial.is_initial_ident() {
return Err(UnexpectedCharacter(initial).into()) return Err(E::UnexpectedCharacter(initial).into())
} }
buf.push(initial); buf.push(initial);
@ -295,29 +338,33 @@ impl Lexer {
} }
Ok(match buf.as_str() { Ok(match buf.as_str() {
"if" => If, "if" => T::If,
"else" => Else, "else" => T::Else,
"while" => While, "while" => T::While,
"let" => Let, "let" => T::Let,
"fn" | "function" => Function, "fn" | "function" => T::Function,
"true" => True, "true" => T::True,
"false" => False, "false" => T::False,
"nil" => Nil, "nil" => T::Nil,
"continue" => Continue, "continue" => T::Continue,
"break" => Break, "break" => T::Break,
"do" => Do, "do" => T::Do,
"loop" => Loop, "loop" => T::Loop,
"and" => And, "and" => T::And,
"or" => Or, "or" => T::Or,
"not" => Not, "not" => T::Not,
"return" => Return, "return" => T::Return,
_ => Ident(buf.into()) "for" => T::For,
"in" => T::In,
"try" => T::Try,
"catch" => T::Catch,
_ => T::Ident(buf.into())
}) })
} }
fn lex_radix(&mut self, radix: i64, radix_char: char) -> Result<Token> { fn lex_radix(&mut self, radix: i64, radix_char: char) -> Result<TokenData> {
use Token::*; use TokenData as T;
use Error::*; use Error as E;
let mut n = 0i64; let mut n = 0i64;
let mut char_found = false; let mut char_found = false;
@ -328,21 +375,21 @@ impl Lexer {
n = n * radix + (i as i64); n = n * radix + (i as i64);
char_found = true; char_found = true;
} else if self.peek().is_ident() { } else if self.peek().is_ident() {
return Err(InvalidDigit(self.peek()).into()) return Err(E::InvalidDigit(self.peek()).into())
} else { } else {
break; break;
} }
} }
if char_found { if char_found {
Ok(Int(n)) Ok(T::Int(n))
} else { } else {
Err(InvalidNumber(format!("0{radix_char}")).into()) Err(E::InvalidNumber(format!("0{radix_char}")).into())
} }
} }
fn lex_number(&mut self, initial: char) -> Result<Token> { fn lex_number(&mut self, initial: char) -> Result<TokenData> {
use Error::*; use Error as E;
if initial == '0' { if initial == '0' {
match self.peek() { match self.peek() {
@ -361,6 +408,10 @@ impl Lexer {
let mut buf = String::new(); let mut buf = String::new();
buf.push(initial); buf.push(initial);
let mut pos = self.pos;
let mut idx = self.index;
let mut bidx = self.byte_len;
if initial != '.' { if initial != '.' {
loop { loop {
if !self.peek().is_ascii_digit() { break; } if !self.peek().is_ascii_digit() { break; }
@ -368,10 +419,22 @@ impl Lexer {
} }
if self.peek() == '.' { if self.peek() == '.' {
pos = self.pos;
idx = self.index;
bidx = self.byte_len;
buf.push(self.next()); buf.push(self.next());
} }
} }
let last: char = buf.chars().last().unwrap();
let is_range = initial != '.' && last == '.' && self.peek() == '.';
if is_range {
self.pos = pos;
self.index = idx;
self.byte_len = bidx;
buf.pop();
} else {
loop { loop {
if !self.peek().is_ascii_digit() { break; } if !self.peek().is_ascii_digit() { break; }
buf.push(self.next()); buf.push(self.next());
@ -388,93 +451,110 @@ impl Lexer {
buf.push(self.next()); buf.push(self.next());
} }
} }
}
let complex = self.peek() == 'i'; let complex = self.peek() == 'i';
if complex { if complex {
self.next(); self.next();
} }
if self.peek().is_ident() || self.peek() == '.' { if self.peek().is_ident() {
return Err(UnexpectedCharacter(self.peek()).into()) return Err(E::UnexpectedCharacter(self.peek()).into())
} }
if let Ok(int) = buf.parse::<i64>() { if let Ok(int) = buf.parse::<i64>() {
use Token::*; use TokenData as T;
if complex { if complex {
return Ok(Complex(int as f64)) return Ok(T::Complex(int as f64))
} }
return Ok(Int(int)) return Ok(T::Int(int))
} }
if let Ok(float) = buf.parse::<f64>() { if let Ok(float) = buf.parse::<f64>() {
use Token::*; use TokenData as T;
if complex { if complex {
return Ok(Complex(float)) return Ok(T::Complex(float))
} }
return Ok(Float(float)) return Ok(T::Float(float))
} }
Err(Error::InvalidNumber(buf).into()) Err(E::InvalidNumber(buf).into())
} }
fn peek_token_impl(&mut self, ignore_newlines: bool) -> Result<Token> { fn peek_token_impl(&mut self, ignore_newlines: bool) -> Result<Token> {
let idx = self.index; let idx = self.index;
let pos = self.pos;
let bidx = self.byte_len;
let token = self.next_token_impl(ignore_newlines); let token = self.next_token_impl(ignore_newlines);
self.index = idx; self.index = idx;
self.pos = pos;
self.byte_len = bidx;
token token
} }
fn next_token_impl(&mut self, ignore_newlines: bool) -> Result<Token> { fn next_token_impl(&mut self, ignore_newlines: bool) -> Result<Token> {
use Token::*; use TokenData as T;
use Error::*; use Error as E;
self.skip_whitespace(ignore_newlines); self.skip_whitespace(ignore_newlines);
let str_start = self.index;
let byte_start = self.byte_len;
let pos = self.pos;
let char = self.next(); let char = self.next();
let next = self.peek(); let next = self.peek();
if char == '\0' { if char == '\0' {
return Ok(if ignore_newlines { Eof } else { SemiColon }); let data = if ignore_newlines { T::Eof } else { T::SemiColon };
return Ok(Token {
data,
pos,
str: String::new(),
bidx: byte_start,
blen: 0,
})
} }
Ok(match char { let data = match char {
'\n' => SemiColon, '\n' => T::SemiColon,
'(' => LeftParen, '(' => T::LeftParen,
')' => RightParen, ')' => T::RightParen,
'[' => LeftBrack, '[' => T::LeftBrack,
']' => RightBrack, ']' => T::RightBrack,
'{' => LeftBrace, '{' => T::LeftBrace,
'}' => RightBrace, '}' => T::RightBrace,
':' => Colon, ':' => T::Colon,
'\\' => Backslash, '\\' => T::Backslash,
';' => SemiColon, ';' => T::SemiColon,
'+' => { '+' => {
match next { match next {
'=' => { '=' => {
self.next(); self.next();
AssignAdd T::AssignAdd
} }
_ => Add _ => T::Add
} }
}, },
'/' => { '/' => {
match next { match next {
'=' => { '=' => {
self.next(); self.next();
AssignDivide T::AssignDivide
} }
_ => Divide _ => T::Divide
} }
}, },
'%' => { '%' => {
match next { match next {
'=' => { '=' => {
self.next(); self.next();
AssignModulo T::AssignModulo
} }
_ => Modulo _ => T::Modulo
} }
}, },
',' => Comma, ',' => T::Comma,
'*' => { '*' => {
match next { match next {
'*' => { '*' => {
@ -482,25 +562,25 @@ impl Lexer {
match self.peek() { match self.peek() {
'=' => { '=' => {
self.next(); self.next();
AssignPower T::AssignPower
}, },
_ => Power _ => T::Power
} }
}, },
'=' => { '=' => {
self.next(); self.next();
AssignMultiply T::AssignMultiply
} }
_ => Multiply _ => T::Multiply
} }
}, },
'!' => { '!' => {
match next { match next {
'=' => { '=' => {
self.next(); self.next();
NotEqual T::NotEqual
} }
_ => Not _ => T::Not
} }
} }
'&' => { '&' => {
@ -510,16 +590,16 @@ impl Lexer {
match self.peek() { match self.peek() {
'=' => { '=' => {
self.next(); self.next();
AssignAnd T::AssignAnd
}, },
_ => And _ => T::And
} }
}, },
'=' => { '=' => {
self.next(); self.next();
AssignBitwiseAnd T::AssignBitwiseAnd
}, },
_ => BitwiseAnd _ => T::BitwiseAnd
} }
}, },
'|' => { '|' => {
@ -529,42 +609,46 @@ impl Lexer {
match self.peek() { match self.peek() {
'=' => { '=' => {
self.next(); self.next();
AssignOr T::AssignOr
}, },
_ => Or _ => T::Or
} }
}, },
'=' => { '=' => {
self.next(); self.next();
AssignBitwiseOr T::AssignBitwiseOr
}, },
_ => BitwiseOr '>' => {
self.next();
T::Pipe
},
_ => T::BitwiseOr
} }
}, },
'-' => { '-' => {
match next { match next {
'>' => { '>' => {
self.next(); self.next();
ThinArrow T::ThinArrow
}, },
'=' => { '=' => {
self.next(); self.next();
AssignSubtract T::AssignSubtract
}, },
_ => Subtract _ => T::Subtract
} }
}, },
'=' => { '=' => {
match next { match next {
'>' => { '>' => {
self.next(); self.next();
Arrow T::Arrow
} }
'=' => { '=' => {
self.next(); self.next();
Equal T::Equal
} }
_ => Assign _ => T::Assign
} }
}, },
'>' => { '>' => {
@ -574,16 +658,16 @@ impl Lexer {
match self.peek() { match self.peek() {
'=' => { '=' => {
self.next(); self.next();
AssignBitwiseShiftRight T::AssignBitwiseShiftRight
}, },
_ => BitwiseShiftRight _ => T::BitwiseShiftRight
} }
} }
'=' => { '=' => {
self.next(); self.next();
GreaterEqual T::GreaterEqual
} }
_ => GreaterThan _ => T::GreaterThan
} }
}, },
'<' => { '<' => {
@ -593,35 +677,35 @@ impl Lexer {
match self.peek() { match self.peek() {
'=' => { '=' => {
self.next(); self.next();
AssignBitwiseShiftLeft T::AssignBitwiseShiftLeft
}, },
_ => BitwiseShiftLeft _ => T::BitwiseShiftLeft
} }
} }
'=' => { '=' => {
self.next(); self.next();
LessEqual T::LessEqual
} }
_ => LessThan _ => T::LessThan
} }
}, },
'^' => { '^' => {
match next { match next {
'=' => { '=' => {
self.next(); self.next();
AssignBitwiseXor T::AssignBitwiseXor
}, },
_ => BitwiseXor _ => T::BitwiseXor
} }
} }
'\'' | '\"' => String(self.lex_string(char)?), '\'' | '\"' => T::String(self.lex_string(char)?),
'r' => { 'r' => {
match next { match next {
'\'' | '\"' => { '\'' | '\"' => {
self.next(); self.next();
Regex(regex::Regex::new(&self.lex_string(next)?) T::Regex(regex::Regex::new(&self.lex_string(next)?)
.map(|e| e.into()) .map(|e| e.into())
.map_err(|e| InvalidRegex(e.into()))?) .map_err(|e| E::InvalidRegex(e.into()))?)
} }
_ => { _ => {
self.lex_ident(char)? self.lex_ident(char)?
@ -634,14 +718,18 @@ impl Lexer {
match self.peek() { match self.peek() {
'.' => { '.' => {
self.next(); self.next();
Varadic T::Varadic
}, },
_ => Range '=' => {
self.next();
T::RangeEq
},
_ => T::Range
} }
} else if next.is_digit(10) { } else if next.is_digit(10) {
self.lex_number(char)? self.lex_number(char)?
} else { } else {
Access T::Access
} }
}, },
_ => { _ => {
@ -651,6 +739,18 @@ impl Lexer {
self.lex_ident(char)? self.lex_ident(char)?
} }
}, },
};
let str_end = self.index;
let byte_end = self.byte_len;
let str = self.data[str_start..str_end].to_owned().into_iter().collect();
Ok(Token {
data,
pos,
str,
bidx: byte_start,
blen: byte_end - byte_start
}) })
} }

View file

@ -1,4 +1,4 @@
use std::fmt::Display; use std::{fmt::Display, rc::Rc};
pub mod compiler; pub mod compiler;
pub mod value; pub mod value;
@ -9,8 +9,11 @@ pub mod parse;
pub mod chunk; pub mod chunk;
pub mod ast; pub mod ast;
#[derive(Debug)] pub use ::num_complex::Complex64 as Complex64;
pub struct Error(Box<ErrorInner>); pub use ::num_rational::Rational64 as Rational64;
#[derive(Debug, Clone)]
pub struct Error(Rc<ErrorInner>);
impl std::error::Error for Error {} impl std::error::Error for Error {}
@ -22,6 +25,8 @@ enum ErrorInner {
Compile(compiler::Error), Compile(compiler::Error),
Runtime(vm::Error), Runtime(vm::Error),
External(anyhow::Error), External(anyhow::Error),
Traced(Box<Error>, String),
Any(String),
} }
impl Display for crate::Error { impl Display for crate::Error {
@ -34,6 +39,8 @@ impl Display for crate::Error {
Compile(err) => write!(f, "{err}"), Compile(err) => write!(f, "{err}"),
Runtime(err) => write!(f, "{err}"), Runtime(err) => write!(f, "{err}"),
External(err) => write!(f, "{err}"), External(err) => write!(f, "{err}"),
Traced(err, trace) => write!(f, "{err}\n{trace}"),
Any(err) => write!(f, "{err}"),
} }
} }
} }
@ -42,7 +49,7 @@ macro_rules! from_error {
($struct:ty, $tuple:tt) => { ($struct:ty, $tuple:tt) => {
impl From<$struct> for crate::Error { impl From<$struct> for crate::Error {
fn from(value: $struct) -> Self { fn from(value: $struct) -> Self {
crate::Error(Box::new(ErrorInner::$tuple(value))) crate::Error(Rc::new(ErrorInner::$tuple(value)))
} }
} }
}; };
@ -54,5 +61,62 @@ from_error!(value::Error, Value);
from_error!(compiler::Error, Compile); from_error!(compiler::Error, Compile);
from_error!(vm::Error, Runtime); from_error!(vm::Error, Runtime);
from_error!(anyhow::Error, External); from_error!(anyhow::Error, External);
from_error!(String, Any);
impl From<(Error, String)> for Error {
fn from(value: (Error, String)) -> Self {
Self(Rc::new(ErrorInner::Traced(Box::new(value.0), value.1)))
}
}
#[macro_export]
macro_rules! iter {
($fn:expr) => {
$crate::value::Value::Iter(
::std::rc::Rc::new(
$crate::chunk::Function {
name: ::std::rc::Rc::from("<iterator>"),
arity: 0,
variadic: false,
fun: $crate::chunk::InnerFunction::Native(
::std::rc::Rc::new($fn
))}))
};
}
#[macro_export]
macro_rules! native {
($name:expr, $arity:expr, $varadic:expr, $fn:expr) => {
$crate::value::Value::Function(
::std::rc::Rc::new( $crate::chunk::Function {
name: std::rc::Rc::from($name),
arity: $arity,
variadic: $varadic,
fun: $crate::chunk::InnerFunction::Native(
::std::rc::Rc::new($fn)
)
})
)
}
}
#[macro_export]
macro_rules! unpack_args {
($e:expr) => {
$e.try_into().expect("bypassed arity check")
};
}
#[macro_export]
macro_rules! unpack_varargs {
($e:expr) => {{
let mut args = $e;
let $crate::value::Value::List(varargs) = args.pop().expect("bypassed arity check") else {
panic!("bypassed arity check")
};
let varargs = varargs.into_inner();
(args.try_into().expect("bypassed arity check"), varargs)
}};
}
pub type Result<T> = std::result::Result<T, crate::Error>; pub type Result<T> = std::result::Result<T, crate::Error>;

View file

@ -1,11 +1,10 @@
use std::{fmt::Display, rc::Rc}; use std::{fmt::Display, rc::Rc};
use num_complex::Complex64; use num_complex::Complex64;
use crate::{lex::{Lexer, self, Token, TokenData, Position}, ast::{Expr, BinaryOp, UnaryOp, optimize, ExprData, AstName}, value::{Value, self}, Result};
use crate::{lex::{Lexer, self, Token}, ast::{Expr, BinaryOp, UnaryOp, optimize}, value::{Value, self}, Result};
use Value as V; use Value as V;
use Expr as E; use ExprData as E;
use Token as T; use TokenData as T;
pub struct ParserBuilder { pub struct ParserBuilder {
optimize: bool optimize: bool
@ -38,8 +37,7 @@ pub struct Parser {
pub enum Error { pub enum Error {
LexerError(crate::lex::Error), LexerError(crate::lex::Error),
UnexpectedToken(Token), UnexpectedToken(Token),
ExpectedToken(Token), ExpectedToken(TokenData, Position),
ExpectedTokenName(&'static str),
MatrixInvDomain(usize, usize, usize), MatrixInvDomain(usize, usize, usize),
NotAssignable(Expr), NotAssignable(Expr),
ValueError(value::Error), ValueError(value::Error),
@ -50,9 +48,8 @@ impl Display for Error {
use Error::*; use Error::*;
match self { match self {
LexerError(err) => write!(f, "{err}"), LexerError(err) => write!(f, "{err}"),
UnexpectedToken(tok) => write!(f, "Unexpected token: '{tok:?}'"), UnexpectedToken(tok) => write!(f, "Unexpected token: '{:?}' at {}:{}", tok.data, tok.pos.row, tok.pos.col),
ExpectedToken(tok) => write!(f, "Expected token: '{tok:?}'"), ExpectedToken(tok, pos) => write!(f, "Expected token: '{tok:?}' at {}:{}", pos.row, pos.col),
ExpectedTokenName(name) => write!(f, "Expected {name} token"),
MatrixInvDomain(row, should, was) => write!(f, "In row {row} of matrix, domain was expected to be {should} but was given {was}"), MatrixInvDomain(row, should, was) => write!(f, "In row {row} of matrix, domain was expected to be {should} but was given {was}"),
NotAssignable(expr) => write!(f, "{expr:?} is not assignable"), NotAssignable(expr) => write!(f, "{expr:?} is not assignable"),
ValueError(err) => write!(f, "{err}"), ValueError(err) => write!(f, "{err}"),
@ -71,13 +68,14 @@ impl std::error::Error for Error {}
macro_rules! expr_parser { macro_rules! expr_parser {
($parser:ident, $pattern:pat, $fn:ident) => {{ ($parser:ident, $pattern:pat, $fn:ident) => {{
let mut expr = $parser.$fn()?; let mut expr = $parser.$fn()?;
let pos = expr.pos;
loop { loop {
let tok = $parser.lexer.peek_token_nl()?; let tok = $parser.lexer.peek_token_nl()?;
match tok { match tok.data {
$pattern => { $pattern => {
$parser.lexer.next_token_nl()?; $parser.lexer.next_token_nl()?;
let temp = $parser.$fn()?; let temp = $parser.$fn()?;
expr = E::BinaryOp(Box::new(expr), Box::new(temp), BinaryOp::from(tok)) expr = (E::BinaryOp(Box::new(expr), Box::new(temp), BinaryOp::from(tok.data)), pos).into()
} }
_ => break _ => break
} }
@ -90,10 +88,11 @@ macro_rules! expr_parser_reverse {
($parser:ident, $pattern:pat, $fn:ident, $cur:ident) => {{ ($parser:ident, $pattern:pat, $fn:ident, $cur:ident) => {{
let expr = $parser.$fn()?; let expr = $parser.$fn()?;
let tok = $parser.lexer.peek_token_nl()?; let tok = $parser.lexer.peek_token_nl()?;
Ok(match tok { let pos = tok.pos;
Ok(match tok.data {
$pattern => { $pattern => {
$parser.lexer.next_token_nl()?; $parser.lexer.next_token_nl()?;
E::BinaryOp(Box::new(expr), Box::new($parser.$cur()?), BinaryOp::from(tok)) (E::BinaryOp(Box::new(expr), Box::new($parser.$cur()?), BinaryOp::from(tok.data)), pos).into()
} }
_ => expr _ => expr
}) })
@ -102,19 +101,19 @@ macro_rules! expr_parser_reverse {
impl Parser { impl Parser {
fn force_token(&mut self, tok: Token) -> Result<Token> { fn force_token(&mut self, tok: TokenData) -> Result<TokenData> {
let next = self.lexer.next_token()?; let next = self.lexer.next_token()?;
if next != tok { if next.data != tok {
Err(Error::ExpectedToken(tok).into()) Err(Error::ExpectedToken(tok, next.pos).into())
} else { } else {
Ok(tok) Ok(tok)
} }
} }
fn force_token_nl(&mut self, tok: Token) -> Result<Token> { fn force_token_nl(&mut self, tok: TokenData) -> Result<TokenData> {
let next = self.lexer.next_token_nl()?; let next = self.lexer.next_token_nl()?;
if next != tok { if next.data != tok {
Err(Error::ExpectedToken(tok).into()) Err(Error::ExpectedToken(tok, next.pos).into())
} else { } else {
Ok(tok) Ok(tok)
} }
@ -124,7 +123,7 @@ impl Parser {
self.force_token(T::LeftParen)?; self.force_token(T::LeftParen)?;
let mut params = Vec::new(); let mut params = Vec::new();
loop { loop {
let expr = match self.lexer.peek_token()? { let expr = match self.lexer.peek_token()?.data {
T::RightParen => { T::RightParen => {
self.lexer.next_token()?; self.lexer.next_token()?;
break break
@ -133,7 +132,7 @@ impl Parser {
}; };
params.push(expr); params.push(expr);
let next = self.lexer.next_token()?; let next = self.lexer.next_token()?;
match next { match next.data {
T::Comma => continue, T::Comma => continue,
T::RightParen => break, T::RightParen => break,
_ => return Err(Error::UnexpectedToken(next).into()) _ => return Err(Error::UnexpectedToken(next).into())
@ -146,7 +145,7 @@ impl Parser {
self.force_token(T::LeftBrack)?; self.force_token(T::LeftBrack)?;
let mut indicies = Vec::new(); let mut indicies = Vec::new();
loop { loop {
let expr = match self.lexer.peek_token()? { let expr = match self.lexer.peek_token()?.data {
T::RightBrack => { T::RightBrack => {
self.lexer.next_token()?; self.lexer.next_token()?;
break break
@ -155,7 +154,7 @@ impl Parser {
}; };
indicies.push(expr); indicies.push(expr);
let next = self.lexer.next_token()?; let next = self.lexer.next_token()?;
match next { match next.data {
T::SemiColon => continue, T::SemiColon => continue,
T::RightBrack => break, T::RightBrack => break,
_ => return Err(Error::UnexpectedToken(next).into()) _ => return Err(Error::UnexpectedToken(next).into())
@ -167,13 +166,13 @@ impl Parser {
fn parse_matrix_part(&mut self) -> Result<Vec<Expr>> { fn parse_matrix_part(&mut self) -> Result<Vec<Expr>> {
let mut part = Vec::new(); let mut part = Vec::new();
loop { loop {
let expr = match self.lexer.peek_token()? { let expr = match self.lexer.peek_token()?.data {
T::SemiColon => break, T::SemiColon => break,
T::RightBrack => break, T::RightBrack => break,
_ => self.parse_expr()? _ => self.parse_expr()?
}; };
part.push(expr); part.push(expr);
match self.lexer.peek_token()? { match self.lexer.peek_token()?.data {
T::Comma => { T::Comma => {
self.lexer.next_token()?; self.lexer.next_token()?;
}, },
@ -184,20 +183,21 @@ impl Parser {
} }
fn parse_matrix(&mut self) -> Result<Expr> { fn parse_matrix(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::LeftBrack)?; self.force_token(T::LeftBrack)?;
let mut parts = Vec::new(); let mut parts = Vec::new();
loop { loop {
let part = self.parse_matrix_part()?; let part = self.parse_matrix_part()?;
parts.push(part); parts.push(part);
let next = self.lexer.next_token()?; let next = self.lexer.next_token()?;
match next { match next.data {
T::SemiColon => continue, T::SemiColon => continue,
T::RightBrack => break, T::RightBrack => break,
_ => return Err(Error::UnexpectedToken(next).into()), _ => return Err(Error::UnexpectedToken(next).into()),
}; };
} }
if parts.len() == 1 { if parts.len() == 1 {
Ok(E::List(parts.pop().unwrap())) Ok((E::List(parts.pop().unwrap()), pos).into())
} else { } else {
let codomain = parts.len(); let codomain = parts.len();
let domain = parts[0].len(); let domain = parts[0].len();
@ -211,31 +211,32 @@ impl Parser {
while let Some(part) = parts.pop() { while let Some(part) = parts.pop() {
data.extend(part); data.extend(part);
} }
Ok(E::Matrix((domain, codomain, data))) Ok((E::Matrix((domain, codomain, data)), pos).into())
} }
} }
fn parse_table_key(&mut self) -> Result<Expr> { fn parse_table_key(&mut self) -> Result<Expr> {
let tok = self.lexer.next_token()?; let tok = self.lexer.next_token()?;
Ok(match tok { Ok(match tok.data {
T::LeftBrack => { T::LeftBrack => {
let expr = self.parse_expr()?; let expr = self.parse_expr()?;
self.force_token(T::RightBrack)?; self.force_token(T::RightBrack)?;
expr expr
}, },
T::Ident(ident) => E::Literal(V::String(ident.to_string().into())), T::Ident(ident) => (E::Literal(V::String(ident.to_string().into())), tok.pos).into(),
T::String(string) => E::Literal(V::String(string.to_string().into())), T::String(string) => (E::Literal(V::String(string.to_string().into())), tok.pos).into(),
_ => return Err(Error::UnexpectedToken(tok).into()) _ => return Err(Error::UnexpectedToken(tok).into())
}) })
} }
fn parse_table(&mut self) -> Result<Expr> { fn parse_table(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::Colon)?; self.force_token(T::Colon)?;
self.force_token(T::LeftBrace)?; self.force_token(T::LeftBrace)?;
let mut table = Vec::new(); let mut table = Vec::new();
if self.lexer.peek_token()? == T::RightBrace { if self.lexer.peek_token()?.data == T::RightBrace {
self.lexer.next_token()?; self.lexer.next_token()?;
return Ok(E::Table(table)) return Ok((E::Table(table), pos).into())
} }
loop { loop {
let key = self.parse_table_key()?; let key = self.parse_table_key()?;
@ -243,13 +244,13 @@ impl Parser {
let value = self.parse_expr()?; let value = self.parse_expr()?;
table.push((key, value)); table.push((key, value));
let next = self.lexer.next_token()?; let next = self.lexer.next_token()?;
match next { match next.data {
T::Comma => continue, T::Comma => continue,
T::RightBrace => break, T::RightBrace => break,
_ => return Err(Error::UnexpectedToken(next).into()) _ => return Err(Error::UnexpectedToken(next).into())
} }
} }
Ok(E::Table(table)) Ok((E::Table(table), pos).into())
} }
fn parse_paren(&mut self) -> Result<Expr> { fn parse_paren(&mut self) -> Result<Expr> {
@ -259,28 +260,26 @@ impl Parser {
Ok(expr) Ok(expr)
} }
fn parse_params(&mut self) -> Result<(Vec<Rc<str>>, bool)> { fn parse_params(&mut self) -> Result<(Vec<(Rc<str>, Position)>, bool)> {
use T::*;
let tok = self.lexer.next_token()?; let tok = self.lexer.next_token()?;
match tok { match tok.data {
Ident(ident) => { T::Ident(ident) => {
let params = vec![ident]; let params = vec![(ident, tok.pos)];
if self.lexer.peek_token()? == T::Varadic { if self.lexer.peek_token()?.data == T::Varadic {
self.lexer.next_token()?; self.lexer.next_token()?;
return Ok((params, true)) return Ok((params, true))
} else { } else {
return Ok((params, false)) return Ok((params, false))
} }
} }
LeftParen => (), T::LeftParen => (),
_ => return Err(Error::UnexpectedToken(tok).into()), _ => return Err(Error::UnexpectedToken(tok).into()),
} }
let mut params = Vec::new(); let mut params = Vec::new();
let mut varadic = false; let mut varadic = false;
if self.lexer.peek_token()? == T::RightParen { if self.lexer.peek_token()?.data == T::RightParen {
self.lexer.next_token()?;
return Ok((params, varadic)); return Ok((params, varadic));
} }
@ -288,14 +287,14 @@ impl Parser {
let ident = self.parse_ident()?; let ident = self.parse_ident()?;
params.push(ident); params.push(ident);
let next = self.lexer.next_token()?; let next = self.lexer.next_token()?;
match next { match next.data {
Varadic => { T::Varadic => {
varadic = true; varadic = true;
self.force_token(T::RightParen)?; self.force_token(T::RightParen)?;
break; break;
} }
Comma => continue, T::Comma => continue,
RightParen => break, T::RightParen => break,
_ => return Err(Error::UnexpectedToken(next).into()), _ => return Err(Error::UnexpectedToken(next).into()),
} }
} }
@ -303,103 +302,135 @@ impl Parser {
Ok((params, varadic)) Ok((params, varadic))
} }
fn parse_ident(&mut self) -> Result<Rc<str>> { fn parse_ident(&mut self) -> Result<AstName> {
if let T::Ident(ident) = self.lexer.next_token()? { let next = self.lexer.next_token()?;
Ok(ident) if let T::Ident(ident) = next.data {
Ok((ident, next.pos))
} else { } else {
Err(Error::ExpectedTokenName("Ident").into()) Err(Error::UnexpectedToken(next).into())
} }
} }
fn parse_ident_nl(&mut self) -> Result<Rc<str>> { fn parse_wrapped_ident(&mut self) -> Result<AstName> {
if let T::Ident(ident) = self.lexer.next_token_nl()? { if self.lexer.peek_token()?.data == T::LeftParen {
self.lexer.next_token()?;
let ident = self.parse_ident()?;
self.force_token(T::RightParen)?;
Ok(ident) Ok(ident)
} else { } else {
Err(Error::ExpectedTokenName("Ident").into()) self.parse_ident()
}
}
fn parse_ident_nl(&mut self) -> Result<AstName> {
let next = self.lexer.next_token_nl()?;
if let T::Ident(ident) = next.data {
Ok((ident, next.pos))
} else {
Err(Error::UnexpectedToken(next).into())
} }
} }
fn parse_function(&mut self) -> Result<Expr> { fn parse_function(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::Function)?; self.force_token(T::Function)?;
let ident = self.parse_ident()?; let ident = self.parse_ident()?;
let (params, varadic) = match self.lexer.peek_token()? { let (params, varadic) = match self.lexer.peek_token()?.data {
T::LeftBrace => (vec![], false), T::LeftBrace => (vec![], false),
_ => self.parse_params()?, _ => self.parse_params()?,
}; };
let expr = self.parse_expr()?; let expr = self.parse_expr()?;
Ok(E::Function(ident, params, Box::new(expr), varadic)) Ok((E::Function(ident, params, Box::new(expr), varadic), pos).into())
} }
fn parse_lambda(&mut self) -> Result<Expr> { fn parse_lambda(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::Backslash)?; self.force_token(T::Backslash)?;
let (params, varadic) = match self.lexer.peek_token()? { let (params, varadic) = match self.lexer.peek_token()?.data {
T::Arrow => (vec![], false), T::Arrow => (vec![], false),
_ => self.parse_params()?, _ => self.parse_params()?,
}; };
self.force_token(T::Arrow)?; self.force_token(T::Arrow)?;
let expr = self.parse_expr()?; let expr = self.parse_expr()?;
Ok(E::Lambda(params, Box::new(expr), varadic)) Ok((E::Lambda(params, Box::new(expr), varadic), pos).into())
} }
fn parse_do_while(&mut self) -> Result<Expr> { fn parse_do_while(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::Do)?; self.force_token(T::Do)?;
let expr = Box::new(self.parse_expr()?); let expr = Box::new(self.parse_expr()?);
self.force_token(T::While)?; self.force_token(T::While)?;
let cond = Box::new(self.parse_expr()?); let cond = Box::new(self.parse_expr()?);
Ok(E::DoWhile(expr, cond)) Ok((E::DoWhile(expr, cond), pos).into())
} }
fn parse_while(&mut self) -> Result<Expr> { fn parse_while(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::While)?; self.force_token(T::While)?;
let cond = Box::new(self.parse_expr()?); let cond = Box::new(self.parse_expr()?);
let expr = Box::new(self.parse_expr()?); let expr = Box::new(self.parse_expr()?);
Ok(E::While(cond, expr)) Ok((E::While(cond, expr), pos).into())
} }
fn parse_loop(&mut self) -> Result<Expr> { fn parse_loop(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::Loop)?; self.force_token(T::Loop)?;
let expr = self.parse_expr()?; let expr = self.parse_expr()?;
Ok(E::Loop(Box::new(expr))) Ok((E::Loop(Box::new(expr)), pos).into())
}
fn parse_for(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::For)?;
let name = self.parse_ident()?;
self.force_token(T::In)?;
let cond = Box::new(self.parse_expr()?);
let expr = Box::new(self.parse_expr()?);
Ok((E::For(name, cond, expr), pos).into())
} }
fn parse_if(&mut self) -> Result<Expr> { fn parse_if(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::If)?; self.force_token(T::If)?;
let cond = Box::new(self.parse_expr()?); let cond = Box::new(self.parse_expr()?);
let expr = Box::new(self.parse_expr()?); let expr = Box::new(self.parse_expr()?);
if self.lexer.peek_token()? != T::Else { if self.lexer.peek_token()?.data != T::Else {
return Ok(E::If(cond, expr, None)) return Ok((E::If(cond, expr, None), pos).into())
} }
self.lexer.next_token()?; self.lexer.next_token()?;
if self.lexer.peek_token()? == T::If { if self.lexer.peek_token()?.data == T::If {
Ok(E::If(cond, expr, Some(Box::new(self.parse_if()?)))) Ok((E::If(cond, expr, Some(Box::new(self.parse_if()?))), pos).into())
} else { } else {
Ok(E::If(cond, expr, Some(Box::new(self.parse_expr()?)))) Ok((E::If(cond, expr, Some(Box::new(self.parse_expr()?))), pos).into())
} }
} }
fn parse_let(&mut self) -> Result<Expr> { fn parse_let(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::Let)?; self.force_token(T::Let)?;
let ident = self.parse_ident_nl()?; let ident = self.parse_ident_nl()?;
if self.lexer.peek_token_nl()? == T::Assign { if self.lexer.peek_token_nl()?.data == T::Assign {
self.force_token_nl(T::Assign)?; self.force_token_nl(T::Assign)?;
Ok(E::Let(ident, Box::new(self.parse_expr()?))) Ok((E::Let(ident, Box::new(self.parse_expr()?)), pos).into())
} else { } else {
Ok(E::Let(ident, Box::new(E::Literal(V::Nil)))) Ok((E::Let(ident, Box::new((E::Literal(V::Nil), pos).into())), pos).into())
} }
} }
fn parse_return(&mut self) -> Result<Expr> { fn parse_return(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::Return)?; self.force_token(T::Return)?;
Ok(E::Return(Box::new(self.parse_expr()?))) Ok((E::Return(Box::new(self.parse_expr()?)), pos).into())
} }
fn parse_block(&mut self) -> Result<Expr> { fn parse_block(&mut self) -> Result<Expr> {
let mut block = Vec::new(); let mut block = Vec::new();
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::LeftBrace)?; self.force_token(T::LeftBrace)?;
loop { loop {
let expr = match self.lexer.peek_token()? { let expr = match self.lexer.peek_token()?.data {
T::RightBrace => break, T::RightBrace => break,
T::SemiColon => { T::SemiColon => {
self.lexer.next_token()?; self.lexer.next_token()?;
@ -408,22 +439,32 @@ impl Parser {
_ => self.parse_expr()? _ => self.parse_expr()?
}; };
block.push(expr); block.push(expr);
let next = self.lexer.next_token()?; let next = self.lexer.next_token_nl()?;
match next { match next.data {
T::SemiColon => continue, T::SemiColon => continue,
T::RightBrace => break, T::RightBrace => break,
_ => return Err(Error::ExpectedToken(T::SemiColon).into()) _ => return Err(Error::ExpectedToken(T::SemiColon, next.pos).into())
} }
} }
if self.lexer.peek_token()? == T::RightBrace { if self.lexer.peek_token()?.data == T::RightBrace {
self.lexer.next_token()?; self.lexer.next_token()?;
} }
Ok(E::Block(block)) Ok((E::Block(block), pos).into())
}
fn parse_try(&mut self) -> Result<Expr> {
let pos = self.lexer.peek_token()?.pos;
self.force_token(T::Try)?;
let expr = self.parse_expr()?;
self.force_token(T::Catch)?;
let ident = self.parse_wrapped_ident()?;
let catch = self.parse_expr()?;
Ok((E::Try(Box::new(expr), ident, Box::new(catch)), pos).into())
} }
fn parse_value(&mut self) -> Result<Expr> { fn parse_value(&mut self) -> Result<Expr> {
let tok = self.lexer.next_token()?; let tok = self.lexer.next_token()?;
Ok(match tok { let data = match tok.data {
T::Nil => E::Literal(V::Nil), T::Nil => E::Literal(V::Nil),
T::Int(i) => E::Literal(V::Int(i)), T::Int(i) => E::Literal(V::Int(i)),
T::Float(f) => E::Literal(V::Float(f)), T::Float(f) => E::Literal(V::Float(f)),
@ -434,28 +475,31 @@ impl Parser {
T::False => E::Literal(V::Bool(false)), T::False => E::Literal(V::Bool(false)),
T::Ident(ident) => E::Ident(ident), T::Ident(ident) => E::Ident(ident),
_ => return Err(Error::UnexpectedToken(tok).into()), _ => return Err(Error::UnexpectedToken(tok).into()),
}) };
Ok((data, tok.pos).into())
} }
fn parse_term(&mut self) -> Result<Expr> { fn parse_term(&mut self) -> Result<Expr> {
use T::*; use T::*;
match self.lexer.peek_token()? { match self.lexer.peek_token()?.data {
Function => self.parse_function(), Function => self.parse_function(),
Backslash => self.parse_lambda(), Backslash => self.parse_lambda(),
Do => self.parse_do_while(), Do => self.parse_do_while(),
While => self.parse_while(), While => self.parse_while(),
For => self.parse_for(),
Let => self.parse_let(), Let => self.parse_let(),
LeftBrace => self.parse_block(), LeftBrace => self.parse_block(),
Return => self.parse_return(), Return => self.parse_return(),
If => self.parse_if(), If => self.parse_if(),
Loop => self.parse_loop(), Loop => self.parse_loop(),
Try => self.parse_try(),
Break => { Break => {
self.lexer.next_token()?; let next = self.lexer.next_token()?;
Ok(E::Break) Ok((E::Break, next.pos).into())
}, },
Continue => { Continue => {
self.lexer.next_token()?; let next = self.lexer.next_token()?;
Ok(E::Continue) Ok((E::Continue, next.pos).into())
}, },
LeftBrack => self.parse_matrix(), LeftBrack => self.parse_matrix(),
Colon => self.parse_table(), Colon => self.parse_table(),
@ -466,13 +510,14 @@ impl Parser {
fn parse_expr_expr_access(&mut self) -> Result<Expr> { fn parse_expr_expr_access(&mut self) -> Result<Expr> {
let mut expr = self.parse_term()?; let mut expr = self.parse_term()?;
let pos = expr.pos;
loop { loop {
let tok = self.lexer.peek_token()?; let tok = self.lexer.peek_token()?;
match tok { match tok.data {
T::Access => { T::Access => {
self.force_token(T::Access)?; self.force_token(T::Access)?;
let temp = self.parse_ident()?; let temp = self.parse_ident()?;
expr = E::FieldAccess(Box::new(expr), temp); expr = (E::FieldAccess(Box::new(expr), temp), pos).into();
}, },
_ => break _ => break
} }
@ -482,16 +527,17 @@ impl Parser {
fn parse_expr_call(&mut self) -> Result<Expr> { fn parse_expr_call(&mut self) -> Result<Expr> {
let mut expr = self.parse_expr_expr_access()?; let mut expr = self.parse_expr_expr_access()?;
let pos = expr.pos;
loop { loop {
let tok = self.lexer.peek_token()?; let tok = self.lexer.peek_token()?;
match tok { match tok.data {
T::LeftBrack => { T::LeftBrack => {
let index = self.parse_index()?; let index = self.parse_index()?;
expr = E::Index(Box::new(expr), index); expr = (E::Index(Box::new(expr), index), pos).into();
}, },
T::LeftParen => { T::LeftParen => {
let params = self.parse_fn_call()?; let params = self.parse_fn_call()?;
expr = E::FnCall(Box::new(expr), params); expr = (E::FnCall(Box::new(expr), params), pos).into();
} }
_ => break _ => break
} }
@ -501,14 +547,14 @@ impl Parser {
fn parse_expr_unary(&mut self) -> Result<Expr> { fn parse_expr_unary(&mut self) -> Result<Expr> {
let tok = self.lexer.peek_token_nl()?; let tok = self.lexer.peek_token_nl()?;
Ok(match tok { Ok(match tok.data {
T::Not => { T::Not => {
self.lexer.next_token()?; self.lexer.next_token()?;
E::UnaryOp(Box::new(self.parse_expr_unary()?), UnaryOp::Not) (E::UnaryOp(Box::new(self.parse_expr_unary()?), UnaryOp::Not), tok.pos).into()
} }
T::Subtract => { T::Subtract => {
self.lexer.next_token()?; self.lexer.next_token()?;
E::UnaryOp(Box::new(self.parse_expr_unary()?), UnaryOp::Negate) (E::UnaryOp(Box::new(self.parse_expr_unary()?), UnaryOp::Negate), tok.pos).into()
} }
_ => self.parse_expr_call()? _ => self.parse_expr_call()?
}) })
@ -559,13 +605,14 @@ impl Parser {
fn parse_expr_and(&mut self) -> Result<Expr> { fn parse_expr_and(&mut self) -> Result<Expr> {
let mut expr = self.parse_expr_compare()?; let mut expr = self.parse_expr_compare()?;
let pos = expr.pos;
loop { loop {
let tok = self.lexer.peek_token()?; let tok = self.lexer.peek_token()?;
match tok { match tok.data {
T::And => { T::And => {
self.force_token(T::And)?; self.force_token(T::And)?;
let temp = self.parse_expr_compare()?; let temp = self.parse_expr_compare()?;
expr = E::And(Box::new(expr), Box::new(temp)); expr = (E::And(Box::new(expr), Box::new(temp)), pos).into();
}, },
_ => break _ => break
} }
@ -575,13 +622,14 @@ impl Parser {
fn parse_expr_or(&mut self) -> Result<Expr> { fn parse_expr_or(&mut self) -> Result<Expr> {
let mut expr = self.parse_expr_and()?; let mut expr = self.parse_expr_and()?;
let pos = expr.pos;
loop { loop {
let tok = self.lexer.peek_token()?; let tok = self.lexer.peek_token()?;
match tok { match tok.data {
T::Or => { T::Or => {
self.force_token(T::Or)?; self.force_token(T::Or)?;
let temp = self.parse_expr_and()?; let temp = self.parse_expr_and()?;
expr = E::Or(Box::new(expr), Box::new(temp)); expr = (E::Or(Box::new(expr), Box::new(temp)), pos).into();
}, },
_ => break _ => break
} }
@ -589,75 +637,112 @@ impl Parser {
Ok(expr) Ok(expr)
} }
fn parse_expr(&mut self) -> Result<Expr> { fn parse_expr_range(&mut self) -> Result<Expr> {
use BinaryOp as B;
let expr = self.parse_expr_or()?; let expr = self.parse_expr_or()?;
let pos = expr.pos;
match self.lexer.peek_token()?.data {
T::Range => {
self.lexer.next_token()?;
let temp = self.parse_expr_or()?;
Ok((E::BinaryOp(Box::new(expr), Box::new(temp), BinaryOp::Range), pos).into())
},
T::RangeEq => {
self.lexer.next_token()?;
let temp = self.parse_expr_or()?;
Ok((E::BinaryOp(Box::new(expr), Box::new(temp), BinaryOp::RangeEq), pos).into())
},
_ => Ok(expr)
}
}
fn parse_expr_op_assign(&mut self) -> Result<Expr> {
use BinaryOp as B;
let expr = self.parse_expr_range()?;
let tok = self.lexer.peek_token_nl()?; let tok = self.lexer.peek_token_nl()?;
Ok(match tok { let pos = tok.pos;
let data: ExprData = match tok.data {
T::Assign => { T::Assign => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(self.parse_expr()?)) E::Assign(Box::new(expr.clone()),Box::new(self.parse_expr()?))
}, },
T::AssignAnd => { T::AssignAnd => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::And(Box::new(expr), Box::new(self.parse_expr()?)))) E::Assign(Box::new(expr.clone()),Box::new((E::And(Box::new(expr), Box::new(self.parse_expr()?)), pos).into()))
}, },
T::AssignOr => { T::AssignOr => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::Or(Box::new(expr), Box::new(self.parse_expr()?)))) E::Assign(Box::new(expr.clone()),Box::new((E::Or(Box::new(expr), Box::new(self.parse_expr()?)),pos).into()))
}, },
T::AssignAdd => { T::AssignAdd => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Add))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Add),pos).into()))
}, },
T::AssignSubtract => { T::AssignSubtract => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Subtract))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Subtract),pos).into()))
}, },
T::AssignMultiply => { T::AssignMultiply => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Multiply))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Multiply),pos).into()))
}, },
T::AssignDivide => { T::AssignDivide => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Divide))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Divide),pos).into()))
}, },
T::AssignModulo => { T::AssignModulo => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Modulo))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Modulo),pos).into()))
}, },
T::AssignPower => { T::AssignPower => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Power))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::Power),pos).into()))
}, },
T::AssignBitwiseAnd => { T::AssignBitwiseAnd => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseAnd))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseAnd),pos).into()))
}, },
T::AssignBitwiseOr => { T::AssignBitwiseOr => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseOr))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseOr),pos).into()))
}, },
T::AssignBitwiseXor => { T::AssignBitwiseXor => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseXor))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseXor),pos).into()))
}, },
T::AssignBitwiseShiftLeft => { T::AssignBitwiseShiftLeft => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseShiftLeft))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseShiftLeft),pos).into()))
}, },
T::AssignBitwiseShiftRight => { T::AssignBitwiseShiftRight => {
self.lexer.next_token_nl()?; self.lexer.next_token_nl()?;
E::Assign(Box::new(expr.clone()),Box::new(E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseShiftRight))) E::Assign(Box::new(expr.clone()),Box::new((E::BinaryOp(Box::new(expr), Box::new(self.parse_expr()?), B::BitwiseShiftRight),pos).into()))
}, },
_ => expr _ => expr.data
}) };
Ok((data, pos).into())
}
fn parse_expr(&mut self) -> Result<Expr> {
let mut expr = self.parse_expr_op_assign()?;
let pos = expr.pos;
loop {
let tok = self.lexer.peek_token()?;
match tok.data {
T::Pipe => {
self.force_token(T::Pipe)?;
let temp = self.parse_expr_op_assign()?;
expr = (E::Pipeline(Box::new(expr), Box::new(temp)), pos).into();
},
_ => break
}
}
Ok(expr)
} }
fn parse_root(&mut self) -> Result<Expr> { fn parse_root(&mut self) -> Result<Expr> {
let mut block = Vec::new(); let mut block = Vec::new();
loop { loop {
match self.lexer.peek_token()? { match self.lexer.peek_token()?.data {
T::Eof => break, T::Eof => break,
T::SemiColon => { T::SemiColon => {
self.lexer.next_token()?; self.lexer.next_token()?;
@ -667,13 +752,14 @@ impl Parser {
}; };
let expr = self.parse_expr()?; let expr = self.parse_expr()?;
block.push(expr); block.push(expr);
match self.lexer.next_token()? { let next = self.lexer.next_token()?;
match next.data {
T::Eof => break, T::Eof => break,
T::SemiColon => continue, T::SemiColon => continue,
_ => return Err(Error::ExpectedToken(T::SemiColon).into()) _ => return Err(Error::ExpectedToken(T::SemiColon, next.pos).into())
}; };
} }
Ok(E::Block(block)) Ok((E::Block(block), Position::default()).into())
} }
pub fn parse<T: Into<String>>(&mut self, into: T) -> Result<Expr> { pub fn parse<T: Into<String>>(&mut self, into: T) -> Result<Expr> {

View file

@ -1,5 +1,14 @@
use std::{collections::HashMap, rc::Rc, hash::Hash, fmt::{Display, Debug}, ops::{Add, Neg, Not, Sub, Div, Mul, BitOr, BitAnd, BitXor, Shl, Shr}, cmp::Ordering}; use std::{
collections::HashMap,
rc::Rc,
hash::Hash,
fmt::{Display, Debug},
ops::{Add, Neg, Not, Sub, Div, Mul, BitOr, BitAnd, BitXor, Shl, Shr},
cmp::Ordering,
cell::RefCell, fs::File
};
use crate::iter;
use num_complex::Complex64; use num_complex::Complex64;
use num_rational::Rational64; use num_rational::Rational64;
use regex::Regex; use regex::Regex;
@ -29,67 +38,29 @@ impl ValueMap {
self.0.insert(key, value); self.0.insert(key, value);
Ok(()) Ok(())
} }
pub fn len(&self) -> usize {
self.0.len()
}
} }
#[derive(Debug)] #[derive(Debug)]
pub enum Error { pub struct Error(String);
Neg(Value),
Add(Value, Value),
Subtract(Value, Value),
Multiply(Value, Value),
Divide(Value, Value),
Modulo(Value, Value),
Exponent(Value, Value),
Compare(Value, Value),
IndexOutOfBounds(i64, usize),
MatrixOutOfBounds(usize, usize, usize, usize),
MatrixIndexOutOfBounds(i64, usize, usize),
MatrixInvSlice(usize, usize),
MatrixMultiply(usize, usize),
MatrixAdd(usize, usize, usize, usize),
CannotIndex(Value),
BadIndex(Value, Value),
Concat(Value, Value),
Bitwise(Value, Value),
DivideByZero,
ZeroExpZero,
CannotHash(Value),
FieldAccess(Value),
}
impl Display for self::Error { impl Display for self::Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use self::Error::*; write!(f, "{}", self.0)
match self {
Neg(v) => write!(f, "cannot negate {v:?}"),
Add(a, b) => write!(f, "cannot add {a:?} to {b:?}"),
Subtract(a, b) => write!(f, "cannot subtract {a:?} from {b:?}"),
Multiply(a, b) => write!(f, "cannot multiply {a:?} and {b:?}"),
Divide(a, b) => write!(f, "cannot divide {a:?} and {b:?}"),
Modulo(a, b) => write!(f, "cannot modulo {a:?} and {b:?}"),
Exponent(a, b) => write!(f, "cannot compute {a:?} pow {b:?}"),
Compare(a, b) => write!(f, "cannot compare {a:?} and {b:?}"),
IndexOutOfBounds(a, b) => write!(f, "index {a} out of bounds for list of length {b}"),
MatrixOutOfBounds(a, b, c, d) => write!(f, "row col ({a},{b}) is out of bounds for matrix {c}x{d}"),
MatrixIndexOutOfBounds(i, d, c) => write!(f, "row index {i} is out of bounds for matrix {d}x{c}"),
MatrixMultiply(c, d) => write!(f, "cannot multiply a matrix with the domain of {d} and matrix with the codomain of {c}"),
MatrixAdd(a, b, c, d) => write!(f, "cannot add a {a}x{b} matrix and a {c}x{d} matrix"),
MatrixInvSlice(s, e) => write!(f, "invalid matrix slice {s}..{e}"),
BadIndex(a, b) => write!(f, "cannot index {a:?} with {b:?}"),
CannotIndex(a) => write!(f, "cannot index {a:?}"),
Concat(a, b) => write!(f, "cannot concat {a:?} and {b:?}"),
Bitwise(a, b) => write!(f, "cannot bitwise between {a:?} and {b:?}"),
DivideByZero => write!(f, "attempted to divide by zero"),
ZeroExpZero => write!(f, "cannot exponent zero with zero"),
CannotHash(v) => write!(f, "cannot hash {v:?}"),
FieldAccess(a) => write!(f, "{a:?} cannot be field accessed"),
}
} }
} }
impl std::error::Error for self::Error {} impl std::error::Error for self::Error {}
#[derive(Debug, Clone)] macro_rules! error {
($($arg:tt)*) => {
Err(self::Error(format!($($arg)*)).into())
};
}
#[derive(Clone)]
pub enum Value { pub enum Value {
Nil, Nil,
Bool(bool), Bool(bool),
@ -98,11 +69,21 @@ pub enum Value {
Ratio(Rational64), Ratio(Rational64),
Complex(Complex64), Complex(Complex64),
Regex(Rc<Regex>), Regex(Rc<Regex>),
String(Rc<String>), String(Rc<str>),
List(Gc<List>), List(Gc<List>),
Matrix(Gc<Matrix>), Matrix(Gc<Matrix>),
Table(Gc<Table>), Table(Gc<Table>),
Function(Rc<Function>), Function(Rc<Function>),
Range(Rc<(i64, i64, bool)>),
Iter(Rc<Function>),
File(Rc<RefCell<File>>),
Error(crate::Error),
}
impl From<&str> for Value {
fn from(value: &str) -> Self {
Value::String(value.into())
}
} }
impl Hash for Value { impl Hash for Value {
@ -132,6 +113,142 @@ impl Hash for Value {
} }
} }
impl Debug for Value {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use Value as V;
match self {
V::Nil => write!(f, "[Nil]"),
V::Bool(b) => write!(f, "[Bool {b}]"),
V::Int(i) => write!(f, "[Int {i}]"),
V::Float(vf) => write!(f, "[Float {vf}]"),
V::Ratio(r) => write!(f, "[Ratio {r}]"),
V::Complex(c) => write!(f, "[Complex {c}]"),
V::Regex(r) => write!(f, "[Regex /{r}/]"),
V::String(s) => write!(f, "[String '{s}']"),
V::List(l) => write!(f, "[List {}]", l.len()),
V::Matrix(m) => write!(f, "[Matirx {}x{}]", m.domain, m.codomain),
V::Table(t) => write!(f, "[Table {}]", t.0.len()),
V::Function(vf) => write!(f, "[Function {}]", vf.name),
V::Range(r) => write!(f, "[Range {:?}..{:?}]", r.0, r.1),
V::Iter(_) => write!(f, "[Iterator]"),
V::Error(_) => write!(f, "[Error]"),
V::File(_) => write!(f, "[File]"),
}
}
}
impl Display for Value {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use Value as V;
let red;
let green;
let yellow;
let blue;
let pink;
let cyan;
let clear;
if f.alternate() {
red = "\x1b[31m";
green = "\x1b[32m";
yellow = "\x1b[33m";
blue = "\x1b[34m";
pink = "\x1b[35m";
cyan = "\x1b[36m";
clear = "\x1b[0m";
} else {
red = "";
green = "";
yellow = "";
blue = "";
pink = "";
cyan = "";
clear = "";
}
match self {
V::Nil => {write!(f, "{blue}nil{clear}")?;},
V::Bool(b) => {write!(f, "{yellow}{b}{clear}")?;},
V::Int(i) => {write!(f, "{yellow}{i}{clear}")?;},
V::Float(l) => {write!(f, "{yellow}{l}{clear}")?;},
V::Ratio(r) => {write!(f, "{yellow}{r}{clear}")?;},
V::Complex(c) => {write!(f, "{yellow}{c}{clear}")?;},
V::Regex(r) => {write!(f, "/{red}{r}{clear}/")?;},
V::String(s) => {
if f.alternate() {
write!(f, "{green}'{s}'{clear}")?;
} else {
write!(f, "{s}")?;
}
}
V::List(l) => {
write!(f, "[")?;
for (i, el) in l.iter().enumerate() {
if i != 0 {
write!(f, " ")?;
}
if f.alternate() {
write!(f, "{el:#}")?;
} else {
write!(f, "{el}")?;
}
}
write!(f, "]")?;
},
V::Matrix(m) => {
write!(f, "\n")?;
for row in m.rows() {
write!(f, " ")?;
for (i, el) in row.into_iter().enumerate() {
if i != 0 {
write!(f, " ")?;
}
if f.alternate() {
write!(f, "{el:#}")?;
} else {
write!(f, "{el}")?;
}
}
write!(f, "\n")?;
}
},
V::Table(t) => {
write!(f, "{{")?;
for (i, (key, val)) in t.0.iter().enumerate() {
if i != 0 {
write!(f, ", ")?;
}
if f.alternate() {
write!(f, "{key:#} = {val:#}")?;
} else {
write!(f, "{key} = {val}")?;
}
}
write!(f, "}}")?;
},
V::Function(fun) => {
use crate::chunk::InnerFunction as F;
match fun.fun {
F::Compiled(_) => write!(f, "{cyan}[Function {}]{clear}", fun.name)?,
F::Native(_) => write!(f, "{cyan}[Builtin {}]{clear}", fun.name)?,
};
},
V::Range(r) => {
if f.alternate() {
write!(f, "{:#}..{:#}", r.0, r.1)?;
} else {
write!(f, "{}..{}", r.0, r.1)?;
}
}
V::Iter(_) => {write!(f, "{pink}[Iterator]{clear}")?;},
V::File(_) => {write!(f, "{pink}[File]{clear}")?;},
V::Error(e) => {write!(f, "{red}{e}{clear}")?;},
};
Ok(())
}
}
impl Value { impl Value {
pub fn can_hash(&self) -> Result<()> { pub fn can_hash(&self) -> Result<()> {
use Value::*; use Value::*;
@ -152,125 +269,19 @@ impl Value {
val.can_hash()?; val.can_hash()?;
} }
}, },
_ => return Err(Error::CannotHash(self.clone()).into()) _ => return error!("cannot hash {self:?}")
} }
Ok(()) Ok(())
} }
pub fn boring_print(&self) -> String { pub fn is_zero(&self) -> bool {
use Value::*; use Value as V;
match self { match self {
Nil => format!("nil"), V::Int(i) => *i == 0,
Bool(b) => format!("{b}"), V::Float(f) => *f == 0.0 || *f == -0.0,
Int(i) => format!("{i}"), V::Ratio(r) => *r.numer() == 0,
Float(l) => format!("{l}"), _ => false,
Ratio(r) => format!("{r}"),
Complex(c) => format!("{c}"),
Regex(r) => format!("/{r}/"),
String(s) => format!("{s}"),
List(l) => {
let mut str = "[".to_string();
for (i, el) in l.iter().enumerate() {
if i != 0 {
str.push_str(" ");
} }
str.push_str(&el.boring_print());
}
str.push_str("]");
str
},
Matrix(m) => {
let mut str = "\n".to_string();
for row in m.rows() {
str.push_str(" ");
for (i, v) in row.into_iter().enumerate() {
if i != 0 {
str.push(' ');
}
str.push_str(&v.boring_print());
}
str.push('\n');
}
str
},
Table(t) => {
let mut str = "{".to_string();
for (i, (key, val)) in t.0.iter().enumerate() {
if i != 0 {
str.push_str(", ");
}
str.push_str(&key.boring_print());
str.push_str(" = ");
str.push_str(&val.boring_print());
}
str.push_str("}");
str
},
Function(fun) => {
format!("{fun:?}")
}
}
}
pub fn pretty_print(&self) -> String {
use Value::*;
match self {
Nil => format!("\x1b[34m{}\x1b[0m", self.boring_print()),
Bool(_) => format!("\x1b[33m{}\x1b[0m", self.boring_print()),
Int(_) => format!("\x1b[33m{}\x1b[0m", self.boring_print()),
Float(_) => format!("\x1b[33m{}\x1b[0m", self.boring_print()),
Ratio(_) => format!("\x1b[33m{}\x1b[0m", self.boring_print()),
Complex(_) => format!("\x1b[33m{}\x1b[0m", self.boring_print()),
Regex(_) => format!("\x1b[31m{}\x1b[0m", self.boring_print()),
String(_) => format!("\x1b[32m'{}'\x1b[0m", self.boring_print()),
List(l) => {
let mut str = "[".to_string();
for (i, el) in l.iter().enumerate() {
if i != 0 {
str.push_str(" ");
}
str.push_str(&el.pretty_print());
}
str.push_str("]");
str
},
Matrix(m) => {
let mut str = "\n".to_string();
for row in m.rows() {
str.push_str(" ");
for (i, v) in row.into_iter().enumerate() {
if i != 0 {
str.push(' ');
}
str.push_str(&v.pretty_print());
}
str.push('\n');
}
str
},
Table(t) => {
let mut str = "{".to_string();
for (i, (key, val)) in t.0.iter().enumerate() {
if i != 0 {
str.push_str(", ");
}
str.push_str(&key.pretty_print());
str.push_str(" = ");
str.push_str(&val.pretty_print());
}
str.push_str("}");
str
},
Function(_) => {
format!("\x1b[36m{}\x1b[0m", self.boring_print())
},
}
}
}
impl Display for Value {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.pretty_print())
} }
} }
@ -278,6 +289,17 @@ fn ratio_to_f64(r: Rational64) -> f64 {
*r.numer() as f64 / *r.denom() as f64 *r.numer() as f64 / *r.denom() as f64
} }
impl Value {
pub fn promote_trig(self) -> Self {
use Value as V;
match self {
V::Int(i) => V::Float(i as f64),
V::Ratio(r) => V::Float(ratio_to_f64(r)),
a => a
}
}
}
fn promote(a: Value, b: Value) -> (Value, Value) { fn promote(a: Value, b: Value) -> (Value, Value) {
use Value as V; use Value as V;
match (&a, &b) { match (&a, &b) {
@ -293,9 +315,12 @@ fn promote(a: Value, b: Value) -> (Value, Value) {
(V::Float(..), V::Ratio(y)) => (a, V::Float(ratio_to_f64(*y))), (V::Float(..), V::Ratio(y)) => (a, V::Float(ratio_to_f64(*y))),
(V::Complex(..), V::Ratio(y)) => (a, V::Complex(ratio_to_f64(*y).into())), (V::Complex(..), V::Ratio(y)) => (a, V::Complex(ratio_to_f64(*y).into())),
(V::Complex(..), V::Float(y)) => (a, V::Complex((*y).into())), (V::Complex(..), V::Float(y)) => (a, V::Complex((*y).into())),
(V::List(l1), V::List(l2)) => (V::Matrix(Matrix::from_list(l1.to_vec()).into()), V::Matrix(Matrix::from_list(l2.to_vec()).into())), (V::List(l1), V::List(l2)) if l1.len() > 0 && l2.len() > 0
(_, V::List(l)) => (a, V::Matrix(Matrix::from_list(l.to_vec()).into())), => (V::Matrix(Matrix::from_list(l1.to_vec()).into()), V::Matrix(Matrix::from_list(l2.to_vec()).into())),
(V::List(l), _) => (V::Matrix(Matrix::from_list(l.to_vec()).into()), b), (_, V::List(l)) if l.len() > 0
=> (a, V::Matrix(Matrix::from_list(l.to_vec()).into())),
(V::List(l), _) if l.len() > 0
=> (V::Matrix(Matrix::from_list(l.to_vec()).into()), b),
_ => (a, b), _ => (a, b),
} }
} }
@ -310,17 +335,19 @@ impl Add for Value {
(Ratio(x), Ratio(y)) => Ok(Ratio(x + y)), (Ratio(x), Ratio(y)) => Ok(Ratio(x + y)),
(Complex(x), Complex(y)) => Ok(Complex(x + y)), (Complex(x), Complex(y)) => Ok(Complex(x + y)),
(Matrix(x), Matrix(y)) => Ok(Matrix((x + y)?.into())), (Matrix(x), Matrix(y)) => Ok(Matrix((x + y)?.into())),
(String(str), value) => Ok(String(Rc::new( (Matrix(x), r) => Ok(Matrix(x.increment(r)?.into())),
format!("{str}{}", value.boring_print()) (l, Matrix(y)) => Ok(Matrix(y.increment(l)?.into())),
(String(str), value) => Ok(String(Rc::from(
format!("{str}{value}")
))), ))),
(value, String(str)) => Ok(String(Rc::new( (value, String(str)) => Ok(String(Rc::from(
format!("{}{str}", value.boring_print()) format!("{value}{str}")
))), ))),
(List(mut l1), List(l2)) => { (List(mut l1), List(l2)) => {
l1.extend_from_slice(&l2); l1.extend_from_slice(&l2);
Ok(List(l1)) Ok(List(l1))
}, },
(l, r) => Err(Error::Add(l, r).into()) (l, r) => error!("cannot add: {l:?} + {r:?}")
} }
} }
} }
@ -335,7 +362,8 @@ impl Sub for Value {
(Ratio(x), Ratio(y)) => Ok(Ratio(x - y)), (Ratio(x), Ratio(y)) => Ok(Ratio(x - y)),
(Complex(x), Complex(y)) => Ok(Complex(x - y)), (Complex(x), Complex(y)) => Ok(Complex(x - y)),
(Matrix(x), Matrix(y)) => Ok(Matrix((x - y)?.into())), (Matrix(x), Matrix(y)) => Ok(Matrix((x - y)?.into())),
(l, r) => Err(Error::Subtract(l, r).into()) (Matrix(x), r) => Ok(Matrix(x.decrement(r)?.into())),
(l, r) => error!("cannot subtract: {l:?} - {r:?}")
} }
} }
} }
@ -352,7 +380,7 @@ impl Mul for Value {
(Matrix(x), Matrix(y)) => Ok(Matrix((x * y)?.into())), (Matrix(x), Matrix(y)) => Ok(Matrix((x * y)?.into())),
(Matrix(x), r) => Ok(Matrix(x.scale(r)?.into())), (Matrix(x), r) => Ok(Matrix(x.scale(r)?.into())),
(l, Matrix(y)) => Ok(Matrix(y.scale(l)?.into())), (l, Matrix(y)) => Ok(Matrix(y.scale(l)?.into())),
(l, r) => Err(Error::Multiply(l, r).into()) (l, r) => error!("cannot multiply: {l:?} * {r:?}")
} }
} }
} }
@ -362,12 +390,12 @@ impl Div for Value {
fn div(self, rhs: Value) -> Self::Output { fn div(self, rhs: Value) -> Self::Output {
use Value::*; use Value::*;
match promote(self, rhs) { match promote(self, rhs) {
(Int(_), Int(0)) => Err(Error::DivideByZero.into()), (Int(_), Int(0)) => error!("cannot divide by zero"),
(Int(x), Int(y)) => Ok(Ratio(Rational64::new(x, y))), (Int(x), Int(y)) => Ok(Ratio(Rational64::new(x, y))),
(Float(x), Float(y)) => Ok(Float(x / y)), (Float(x), Float(y)) => Ok(Float(x / y)),
(Ratio(x), Ratio(y)) => Ok(Ratio(x / y)), (Ratio(x), Ratio(y)) => Ok(Ratio(x / y)),
(Complex(x), Complex(y)) => Ok(Complex(x / y)), (Complex(x), Complex(y)) => Ok(Complex(x / y)),
(l, r) => Err(Error::Divide(l, r).into()) (l, r) => error!("cannot divide: {l:?} / {r:?}")
} }
} }
} }
@ -378,7 +406,7 @@ impl BitOr for Value {
use Value::*; use Value::*;
match promote(self, rhs) { match promote(self, rhs) {
(Int(x), Int(y)) => Ok(Int(x | y)), (Int(x), Int(y)) => Ok(Int(x | y)),
(l, r) => Err(Error::Bitwise(l, r).into()) (l, r) => error!("cannot bitwise or: {l:?} | {r:?}")
} }
} }
} }
@ -389,7 +417,7 @@ impl BitAnd for Value {
use Value::*; use Value::*;
match promote(self, rhs) { match promote(self, rhs) {
(Int(x), Int(y)) => Ok(Int(x & y)), (Int(x), Int(y)) => Ok(Int(x & y)),
(l, r) => Err(Error::Bitwise(l, r).into()) (l, r) => error!("cannot bitwise and: {l:?} & {r:?}")
} }
} }
} }
@ -400,7 +428,7 @@ impl BitXor for Value {
use Value::*; use Value::*;
match promote(self, rhs) { match promote(self, rhs) {
(Int(x), Int(y)) => Ok(Int(x ^ y)), (Int(x), Int(y)) => Ok(Int(x ^ y)),
(l, r) => Err(Error::Bitwise(l, r).into()) (l, r) => error!("cannot bitwise xor: {l:?} ^ {r:?}")
} }
} }
} }
@ -411,7 +439,7 @@ impl Shl for Value {
use Value::*; use Value::*;
match promote(self, rhs) { match promote(self, rhs) {
(Int(x), Int(y)) => Ok(Int(x << y)), (Int(x), Int(y)) => Ok(Int(x << y)),
(l, r) => Err(Error::Bitwise(l, r).into()) (l, r) => error!("cannot bitwise shift left: {l:?} << {r:?}")
} }
} }
} }
@ -422,14 +450,14 @@ impl Shr for Value {
use Value::*; use Value::*;
match promote(self, rhs) { match promote(self, rhs) {
(Int(x), Int(y)) => Ok(Int(x >> y)), (Int(x), Int(y)) => Ok(Int(x >> y)),
(l, r) => Err(Error::Bitwise(l, r).into()) (l, r) => error!("cannot bitwise shift right: {l:?} >> {r:?}")
} }
} }
} }
fn ipow(n: i64, d: i64, p: i64) -> Result<(i64, i64)> { fn ipow(n: i64, d: i64, p: i64) -> Result<(i64, i64)> {
Ok(match (n, d, p) { Ok(match (n, d, p) {
(0, _, 0) => return Err(Error::ZeroExpZero.into()), (0, _, 0) => return error!("cannot exponent: 0 ** 0"),
(0, _, _) => (0, 1), (0, _, _) => (0, 1),
(_, _, 0) => (1, 1), (_, _, 0) => (1, 1),
(1, 1, _) => (1, 1), (1, 1, _) => (1, 1),
@ -447,7 +475,7 @@ impl Value {
(Float(x), Float(y)) => Ok(Float(x % y)), (Float(x), Float(y)) => Ok(Float(x % y)),
(Ratio(x), Ratio(y)) => Ok(Ratio(x % y)), (Ratio(x), Ratio(y)) => Ok(Ratio(x % y)),
(Complex(x), Complex(y)) => Ok(Complex(x % y)), (Complex(x), Complex(y)) => Ok(Complex(x % y)),
(l, r) => Err(Error::Modulo(r, l).into()) (l, r) => error!("cannot modulo: {l:?} % {r:?}")
} }
} }
@ -461,7 +489,7 @@ impl Value {
(Float(x), Float(y)) => Ok(Float(x.powf(y))), (Float(x), Float(y)) => Ok(Float(x.powf(y))),
(Ratio(x), Ratio(y)) => Ok(Float(ratio_to_f64(x).powf(ratio_to_f64(y)))), (Ratio(x), Ratio(y)) => Ok(Float(ratio_to_f64(x).powf(ratio_to_f64(y)))),
(Complex(x), Complex(y)) => Ok(Complex(x.powc(y))), (Complex(x), Complex(y)) => Ok(Complex(x.powc(y))),
(l, r) => Err(Error::Exponent(l, r).into()) (l, r) => error!("cannot exponent: {l:?} ** {r:?}")
} }
} }
@ -534,7 +562,7 @@ impl PartialOrd for Value {
impl Value { impl Value {
pub fn val_cmp(&self, other: &Self) -> Result<Ordering> { pub fn val_cmp(&self, other: &Self) -> Result<Ordering> {
self.partial_cmp(other) self.partial_cmp(other)
.map_or_else(|| Err(Error::Compare(self.clone(), other.clone()).into()), Ok) .map_or_else(|| error!("cannot compare: {self:?} and {other:?}"), Ok)
} }
fn index_single(&self, index: &Value) -> Result<Self> { fn index_single(&self, index: &Value) -> Result<Self> {
@ -545,17 +573,17 @@ impl Value {
}, },
(V::List(l), V::Int(i)) => { (V::List(l), V::Int(i)) => {
if *i < 0 || *i as usize >= l.len() { if *i < 0 || *i as usize >= l.len() {
return Err(Error::IndexOutOfBounds(*i, l.len()).into()) return error!("{i} out of bounds for {self:?}")
} }
Ok(l[*i as usize].clone()) Ok(l[*i as usize].clone())
}, },
(V::Matrix(m), V::Int(i)) => { (V::Matrix(m), V::Int(i)) => {
if *i < 0 || *i as usize >= m.values.len() { if *i < 0 || *i as usize >= m.values.len() {
return Err(Error::MatrixIndexOutOfBounds(*i, m.domain, m.codomain).into()) return error!("{i} out of bounds for {self:?}")
} }
Ok(m.values[*i as usize].clone()) Ok(m.values[*i as usize].clone())
}, },
_ => return Err(self::Error::BadIndex(self.clone(), index.clone()).into()) _ => return error!("{index:?} cant index {self:?}")
} }
} }
@ -579,7 +607,7 @@ impl Value {
Ok(V::Table(ret.into())) Ok(V::Table(ret.into()))
} }
V::Matrix(m) => { V::Matrix(m) => {
let err = || Err(self::Error::BadIndex(self.clone(), V::List(indexes.clone().into())).into()); let err = || error!("{self:?} can be index by [Int] or [Int;Int]");
if indexes.len() != 2 { if indexes.len() != 2 {
return err() return err()
} }
@ -612,7 +640,7 @@ impl Value {
_ => return err() _ => return err()
} }
} }
_ => return Err(self::Error::CannotIndex(self.clone()).into()) _ => return error!("cannot index {self:?}")
} }
} }
@ -628,26 +656,26 @@ impl Value {
fn store_index_single(&mut self, index: &Value, store: Value) -> Result<()> { fn store_index_single(&mut self, index: &Value, store: Value) -> Result<()> {
use Value as V; use Value as V;
let err = self.clone(); let err = format!("{self:?}");
match (self, index) { match (self, index) {
(V::Table(t), index) => { (V::Table(t), index) => {
t.insert(index.clone(), store) t.insert(index.clone(), store)
}, },
(V::List(l), V::Int(i)) => { (V::List(l), V::Int(i)) => {
if *i < 0 || *i as usize >= l.len() { if *i < 0 || *i as usize >= l.len() {
return Err(Error::IndexOutOfBounds(*i, l.len()).into()) return error!("{i} out of bounds for {err}")
} }
l[*i as usize] = store; l[*i as usize] = store;
Ok(()) Ok(())
}, },
(V::Matrix(m), V::Int(i)) => { (V::Matrix(m), V::Int(i)) => {
if *i < 0 || *i as usize >= m.values.len() { if *i < 0 || *i as usize >= m.values.len() {
return Err(Error::MatrixIndexOutOfBounds(*i, m.domain, m.codomain).into()) return error!("{i} out of bounds for {err}")
} }
m.values[*i as usize] = store; m.values[*i as usize] = store;
Ok(()) Ok(())
}, },
_ => return Err(self::Error::BadIndex(err, index.clone()).into()) _ => return error!("{index:?} cant index {err}")
} }
} }
@ -666,7 +694,7 @@ impl Value {
} }
Ok(()) Ok(())
} }
_ => return Err(self::Error::CannotIndex(self.clone()).into()) _ => return error!("cannot index {self:?}")
} }
} }
@ -684,10 +712,10 @@ impl Value {
use Value as V; use Value as V;
match self { match self {
V::Table(t) => { V::Table(t) => {
let key = V::String(Rc::new(ident.to_string())); let key = V::String(Rc::from(ident));
Ok(t.insert(key, val)?) Ok(t.insert(key, val)?)
}, },
_ => return Err(self::Error::FieldAccess(self.clone()).into()) _ => return error!("cannot field access assign {self:?}")
} }
} }
@ -695,10 +723,10 @@ impl Value {
use Value as V; use Value as V;
match self { match self {
V::Table(t) => { V::Table(t) => {
let key = V::String(Rc::new(ident.to_string())); let key = V::String(Rc::from(ident));
Ok(t.get(&key)?.unwrap_or(&V::Nil).clone()) Ok(t.get(&key)?.unwrap_or(&V::Nil).clone())
}, },
_ => return Err(self::Error::FieldAccess(self.clone()).into()) _ => return error!("cannot field access {self:?}")
} }
} }
@ -722,6 +750,15 @@ impl Value {
LessEquals => Ok(Self::Bool(lhs <= rhs)), LessEquals => Ok(Self::Bool(lhs <= rhs)),
GreaterThan => Ok(Self::Bool(lhs > rhs)), GreaterThan => Ok(Self::Bool(lhs > rhs)),
LessThan => Ok(Self::Bool(lhs < rhs)), LessThan => Ok(Self::Bool(lhs < rhs)),
Range | RangeEq => {
let Value::Int(lhs) = lhs else {
return error!("range can only take [Int]'s")
};
let Value::Int(rhs) = rhs else {
return error!("range can only take [Int]'s")
};
Ok(Self::Range(Rc::new((lhs, rhs, op == RangeEq))))
},
} }
} }
@ -754,24 +791,75 @@ impl Not for Value {
type Output = bool; type Output = bool;
fn not(self) -> Self::Output { fn not(self) -> Self::Output {
use Value::*; use Value as V;
match self { match self {
Nil => true, V::Nil => true,
Bool(b) => !b, V::Bool(b) => !b,
Int(i) => i == 0, V::Int(i) => i == 0,
Float(f) => f == 0.0, V::Float(f) => f == 0.0,
Ratio(r) => *(r.numer()) == 0 || *(r.denom()) == 0, V::Ratio(r) => *(r.numer()) == 0 || *(r.denom()) == 0,
Complex(c) => !c.is_normal(), V::Complex(c) => !c.is_normal(),
Regex(_) => false, V::Regex(_) => false,
List(_) => false, V::List(_) => false,
Matrix(_) => false, V::Matrix(_) => false,
Table(_) => false, V::Table(_) => false,
String(s) => s.as_str() == "", V::String(s) => s.as_ref() == "",
Function(_) => false, V::Function(_) => false,
V::Iter(_) => false,
V::Range(_) => false,
V::File(_) => false,
V::Error(_) => false,
} }
} }
} }
impl Value {
pub fn into_iter_fn(self) -> Result<Rc<Function>> {
let Value::Iter(iter) = self.into_iter()? else {
return error!("bypassed iter check")
};
Ok(iter)
}
pub fn into_iter(self) -> Result<Self> {
use Value as V;
Ok(match self {
V::Iter(..) => self,
V::List(l) => {
let iter = RefCell::new(l.into_inner().into_iter());
iter!(move |_,_| {
match iter.borrow_mut().next() {
Some(v) => Ok(v),
None => Ok(V::Nil),
}
})
},
V::Range(r) => {
let r = (*r).clone();
let lhs = RefCell::new(r.0);
let rhs = r.1;
iter!(move |_,_| {
let val = *lhs.borrow();
let next = *lhs.borrow() + 1;
if (!r.2 && *lhs.borrow() < rhs) || (r.2 && *lhs.borrow() <= rhs) {
*lhs.borrow_mut() = next;
return Ok(Value::Int(val))
}
Ok(Value::Nil)
})
},
V::Function(f) => {
if f.arity > 0 || f.variadic {
return error!("iterator functions cannot be varadic or take arguments")
}
V::Iter(f)
},
val => return error!("cannot turn {val:?} into an iterator")
})
}
}
fn dot(lhs: Vec<&Value>, rhs: Vec<&Value>) -> Result<Value> { fn dot(lhs: Vec<&Value>, rhs: Vec<&Value>) -> Result<Value> {
let len = lhs.len(); let len = lhs.len();
@ -830,9 +918,9 @@ impl Matrix {
pub fn get(&self, row: usize, col: usize) -> Result<Value> { pub fn get(&self, row: usize, col: usize) -> Result<Value> {
if row >= self.codomain || col >= self.domain { if row >= self.codomain || col >= self.domain {
return Err(self::Error::MatrixOutOfBounds(row, col, self.domain, self.codomain).into()) return error!("[{};{}] out of bounds for [Matrix {}x{}]", row, col, self.domain, self.codomain)
} }
let idx = col + row * self.codomain; let idx = col + row * self.domain;
Ok(self.values[idx].clone()) Ok(self.values[idx].clone())
} }
@ -840,9 +928,9 @@ impl Matrix {
pub fn set(&mut self, row: usize, col: usize, val: Value) -> Result<()> { pub fn set(&mut self, row: usize, col: usize, val: Value) -> Result<()> {
if row >= self.codomain || col >= self.domain { if row >= self.codomain || col >= self.domain {
return Err(self::Error::MatrixOutOfBounds(row, col, self.domain, self.codomain).into()) return error!("[{};{}] out of bounds for [Matrix {}x{}]", row, col, self.domain, self.codomain)
} }
let idx = col + row * self.codomain; let idx = col + row * self.domain;
self.values[idx] = val; self.values[idx] = val;
Ok(()) Ok(())
} }
@ -863,8 +951,8 @@ impl Matrix {
// SPLCIE DOMAIN // SPLCIE DOMAIN
pub fn splice_cols(&self, col_start: usize, col_end: usize) -> Result<Self> { pub fn splice_cols(&self, col_start: usize, col_end: usize) -> Result<Self> {
if col_start <= col_end { if col_start <= col_end || col_end > self.domain {
return Err(self::Error::MatrixInvSlice(col_start, col_end).into()); return error!("[_;{}..{}] invalid for [Matrix {}x{}]", col_start, col_end, self.domain, self.codomain)
} }
let mut cols = Vec::new(); let mut cols = Vec::new();
@ -890,8 +978,8 @@ impl Matrix {
// SPLICE CODOMAIN // SPLICE CODOMAIN
pub fn splice_rows(&self, row_start: usize, row_end: usize) -> Result<Self> { pub fn splice_rows(&self, row_start: usize, row_end: usize) -> Result<Self> {
if row_start <= row_end { if row_start <= row_end || row_end > self.codomain {
return Err(self::Error::MatrixInvSlice(row_start, row_end).into()); return error!("[{}..{};_] invalid for [Matrix {}x{}]", row_start, row_end, self.domain, self.codomain)
} }
let mut rows = Vec::new(); let mut rows = Vec::new();
@ -915,12 +1003,64 @@ impl Matrix {
Ok(res) Ok(res)
} }
pub fn increment(&self, increment: Value) -> Result<Self> {
let values = self.values.iter()
.map(|v| v.clone() + increment.clone())
.collect::<Result<Vec<Value>>>()?;
Ok(Matrix::new(self.domain, self.codomain, values))
}
pub fn decrement(&self, decrement: Value) -> Result<Self> {
let values = self.values.iter()
.map(|v| v.clone() - decrement.clone())
.collect::<Result<Vec<Value>>>()?;
Ok(Matrix::new(self.domain, self.codomain, values))
}
pub fn scale(&self, scale: Value) -> Result<Self> { pub fn scale(&self, scale: Value) -> Result<Self> {
let values = self.values.iter() let values = self.values.iter()
.map(|v| v.clone() * scale.clone()) .map(|v| v.clone() * scale.clone())
.collect::<Result<Vec<Value>>>()?; .collect::<Result<Vec<Value>>>()?;
Ok(Matrix::new(self.domain, self.codomain, values)) Ok(Matrix::new(self.domain, self.codomain, values))
} }
pub fn join_right(&self, other: &Matrix) -> Result<Self> {
if self.domain != other.domain || self.codomain != other.codomain {
return error!("matrix dimensions do not match");
}
let mut r1 = self.rows();
let mut r2 = other.rows();
let mut rows = Vec::new();
loop {
let Some(r1) = r1.next() else { break; };
let Some(r2) = r2.next() else { break; };
let mut row = r1
.into_iter()
.map(|v| v.clone())
.collect::<Vec<Value>>();
row.extend(r2.into_iter().map(|v| v.clone()));
rows.push(row);
}
let values = rows
.into_iter()
.reduce(|mut a,b| {a.extend(b); a})
.unwrap();
Ok(Matrix::new(self.domain * 2, self.codomain, values))
}
pub fn join_bottom(&self, other: &Matrix) -> Result<Self> {
if self.domain != other.domain || self.codomain != other.codomain {
return error!("matrix dimensions do not match");
}
let mut values = self.values.clone();
values.extend(other.values.clone());
Ok(Matrix::new(self.domain, self.codomain * 2, values))
}
} }
impl Debug for Matrix { impl Debug for Matrix {
@ -950,7 +1090,9 @@ impl Add for Matrix {
fn add(self, rhs: Self) -> Self::Output { fn add(self, rhs: Self) -> Self::Output {
if self.domain != rhs.domain || self.codomain != rhs.codomain { if self.domain != rhs.domain || self.codomain != rhs.codomain {
return Err(self::Error::MatrixAdd(self.domain, self.codomain, rhs.domain, rhs.codomain).into()) return error!("cannot add: [Matrix {}x{}] + [Matrix {}x{}]",
self.domain, self.codomain,
rhs.domain, rhs.codomain)
} }
let mut res = Matrix::empty(self.domain, self.codomain); let mut res = Matrix::empty(self.domain, self.codomain);
for col in 0..self.domain { for col in 0..self.domain {
@ -968,7 +1110,9 @@ impl Sub for Matrix {
fn sub(self, rhs: Self) -> Self::Output { fn sub(self, rhs: Self) -> Self::Output {
if self.domain != rhs.domain || self.codomain != rhs.codomain { if self.domain != rhs.domain || self.codomain != rhs.codomain {
return Err(self::Error::MatrixAdd(self.domain, self.codomain, rhs.domain, rhs.codomain).into()) return error!("cannot sub: [Matrix {}x{}] - [Matrix {}x{}]",
self.domain, self.codomain,
rhs.domain, rhs.codomain)
} }
let mut res = Matrix::empty(self.domain, self.codomain); let mut res = Matrix::empty(self.domain, self.codomain);
for col in 0..self.domain { for col in 0..self.domain {
@ -986,7 +1130,9 @@ impl Mul for Matrix {
fn mul(self, rhs: Self) -> Self::Output { fn mul(self, rhs: Self) -> Self::Output {
if self.domain != rhs.codomain { if self.domain != rhs.codomain {
return Err(self::Error::MatrixMultiply(self.domain, rhs.codomain).into()) return error!("cannot multiply: [Matrix {}x{}] * [Matrix {}x{}]",
self.domain, self.codomain,
rhs.domain, rhs.codomain)
} }
let mut res = Self::empty(rhs.domain, self.codomain); let mut res = Self::empty(rhs.domain, self.codomain);
for (i, row) in self.rows().enumerate() { for (i, row) in self.rows().enumerate() {

View file

@ -1,12 +1,11 @@
use std::{rc::Rc, fmt::{Debug, Display}, usize, ops::{Index, IndexMut}, collections::HashMap, cell::RefCell, sync::{atomic::{AtomicUsize, Ordering}, Arc}}; use std::{rc::Rc, fmt::{Debug, Display}, usize, ops::{Index, IndexMut}, collections::HashMap, cell::RefCell, sync::{atomic::{AtomicUsize, Ordering}, Arc}};
use crate::{value::{Value, self, ValueMap, Matrix}, gc::Gc, chunk::{Function, Instruction, Chunk, InnerFunction}, Result, compiler::NamesTable}; use crate::{value::{Value, self, ValueMap, Matrix}, Result, gc::Gc, chunk::{Function, Instruction, Chunk, InnerFunction}, compiler::NamesTable, native};
#[derive(Debug)] #[derive(Debug)]
pub enum Error { pub enum Error {
ValueError(value::Error), ValueError(value::Error),
NotFunction(Value), NotFunction(Value),
InvArity(usize, usize, Rc<str>), InvArity(usize, usize, Rc<str>),
UndefinedGlobal(Rc<str>),
ExecNative, ExecNative,
} }
@ -19,7 +18,6 @@ impl Display for Error {
ValueError(err) => write!(f, "{err}"), ValueError(err) => write!(f, "{err}"),
NotFunction(v) => write!(f, "{v:?} is not a function"), NotFunction(v) => write!(f, "{v:?} is not a function"),
InvArity(wanted, had, name) => write!(f, "function {name} takes {wanted} params but was given {had}"), InvArity(wanted, had, name) => write!(f, "function {name} takes {wanted} params but was given {had}"),
UndefinedGlobal(name) => write!(f, "{name} is not defined"),
ExecNative => write!(f, "cannot execute a native function"), ExecNative => write!(f, "cannot execute a native function"),
} }
} }
@ -89,21 +87,64 @@ impl<T> Index<usize> for Stack<T> {
} }
} }
struct StackFrame { #[derive(Clone)]
pub struct StackFrame {
#[allow(dead_code)] #[allow(dead_code)]
name: Rc<str>, name: Rc<str>,
body: Rc<Chunk>, body: Rc<Chunk>,
ip: usize, ip: usize,
bp: usize, bp: usize,
lp: usize,
depth: usize,
} }
struct VmError {
err: crate::Error,
frames: Vec<StackFrame>
}
impl From<crate::Error> for VmError {
fn from(err: crate::Error) -> Self {
VmError {
err,
frames: Vec::new()
}
}
}
impl From<self::Error> for VmError {
fn from(err: self::Error) -> Self {
VmError {
err: err.into(),
frames: Vec::new()
}
}
}
type VmResult<T> = std::result::Result<T, VmError>;
impl StackFrame { impl StackFrame {
fn new(vm: &Vm, name: Rc<str>, body: Rc<Chunk>, arity: usize) -> Self { fn new(vm: &Vm, name: Rc<str>, body: Rc<Chunk>, arity: usize, depth: usize) -> Self {
Self { Self {
name, name,
body, body,
bp: vm.stack.len() - arity, bp: vm.stack.len() - arity,
lp: vm.locals.len(),
ip: 0, ip: 0,
depth
}
}
}
impl Default for StackFrame {
fn default() -> Self {
StackFrame {
name: Rc::from("<root>"),
body: Rc::new(Chunk::default()),
bp: 0,
lp: 0,
ip: 0,
depth: 0
} }
} }
} }
@ -112,10 +153,17 @@ pub enum Interupt {
KeyboardInterupt = 1 KeyboardInterupt = 1
} }
struct TryScope {
stack_len: usize,
locals_len: usize,
frame_depth: usize,
err_idx: usize,
}
pub struct Vm { pub struct Vm {
stack: Stack<Value>, stack: Stack<Value>,
locals: Stack<Value>, locals: Stack<Value>,
frames: Vec<StackFrame>, trystack: Vec<TryScope>,
globals: HashMap<u16, Value>, globals: HashMap<u16, Value>,
names: NamesTable, names: NamesTable,
global_names: NamesTable, global_names: NamesTable,
@ -132,6 +180,10 @@ impl Vm {
self.stack.pop() self.stack.pop()
} }
fn top(&mut self) -> Value {
self.stack[self.stack.len() - 1].clone()
}
pub fn names(&self) -> NamesTable { pub fn names(&self) -> NamesTable {
self.names.clone() self.names.clone()
} }
@ -148,7 +200,7 @@ impl Vm {
Self { Self {
stack: Stack::new(), stack: Stack::new(),
locals: Stack::new(), locals: Stack::new(),
frames: Vec::new(), trystack: Vec::new(),
globals: HashMap::new(), globals: HashMap::new(),
names: Rc::new(RefCell::new(Vec::new())), names: Rc::new(RefCell::new(Vec::new())),
global_names: Rc::new(RefCell::new(Vec::new())), global_names: Rc::new(RefCell::new(Vec::new())),
@ -156,10 +208,14 @@ impl Vm {
} }
} }
pub fn load_native_fn(&mut self, fun: Rc<Function>) { pub fn load_global(&mut self, value: Value, name: &str) {
let idx = self.global_names.borrow().len(); let idx = self.global_names.borrow().len();
self.global_names.borrow_mut().push(fun.name.clone()); self.global_names.borrow_mut().push(name.into());
self.globals.insert(idx as u16, Value::Function(fun)); self.globals.insert(idx as u16, value);
}
pub fn load_global_fn(&mut self, value: Rc<Function>, name: &str) {
self.load_global(Value::Function(value), name)
} }
fn init_frame(&mut self, fun: Rc<Function>) -> Result<StackFrame> { fn init_frame(&mut self, fun: Rc<Function>) -> Result<StackFrame> {
@ -170,7 +226,8 @@ impl Vm {
self, self,
fun.name.clone(), fun.name.clone(),
compiled_chunk.clone(), compiled_chunk.clone(),
fun.arity fun.arity,
0
)) ))
} }
@ -178,55 +235,46 @@ impl Vm {
self.interupt.load(Ordering::Relaxed) != 0 self.interupt.load(Ordering::Relaxed) != 0
} }
pub fn run(&mut self, fun: Rc<Function>) -> Result<Value> { fn exec_ins(&mut self, frame: &mut StackFrame, ins: Instruction) -> VmResult<Option<Value>> {
let mut frame = self.init_frame(fun)?; use Instruction as I;
self.interupt.store(0, Ordering::SeqCst);
self.stack = Stack::new();
self.locals = Stack::new();
loop {
use Instruction::*;
let ins = frame.body.code[frame.ip].clone();
frame.ip += 1;
match ins { match ins {
NoOp => {}, I::NoOp => {},
CreateLocal => self.locals.push(self.stack.pop()), I::CreateLocal => self.locals.push(self.stack.pop()),
LoadLocal(idx) => {self.stack.push(self.locals[idx as usize].clone());}, I::LoadLocal(idx) => {self.stack.push(self.locals[idx as usize].clone());},
StoreLocal(idx) => self.locals[frame.bp + idx as usize] = self.pop(), I::StoreLocal(idx) => self.locals[frame.bp + idx as usize] = self.pop(),
DiscardLocals(count) => {self.locals.truncate(self.locals.len() - count as usize)}, I::DiscardLocals(count) => {self.locals.truncate(self.locals.len() - count as usize)},
LoadGlobal(idx) => { I::LoadGlobal(idx) => {
let val = self.globals let val = self.globals
.get(&idx) .get(&idx)
.unwrap() .unwrap()
.clone(); .clone();
self.stack.push(val); self.stack.push(val);
}, },
StoreGlobal(idx) => { I::StoreGlobal(idx) => {
let val = self.pop(); let val = self.pop();
self.globals.insert(idx, val); self.globals.insert(idx, val);
}, },
Const(idx) => self.push(frame.body.constants[idx as usize].clone()), I::Const(idx) => self.push(frame.body.constants[idx as usize].clone()),
Int(i) => self.push(Value::Int(i as i64)), I::Int(i) => self.push(Value::Int(i as i64)),
True => self.push(Value::Bool(true)), I::True => self.push(Value::Bool(true)),
False => self.push(Value::Bool(false)), I::False => self.push(Value::Bool(false)),
Nil => self.push(Value::Nil), I::Nil => self.push(Value::Nil),
Dup => self.push(self.stack[self.stack.len() - 1].clone()), I::Dup => self.push(self.stack[self.stack.len() - 1].clone()),
Discard(count) => {self.stack.truncate(self.stack.len() - count as usize)}, I::Discard(count) => {self.stack.truncate(self.stack.len() - count as usize)},
UnaryOp(op) => { I::UnaryOp(op) => {
let val = self.pop(); let val = self.pop();
self.push(Value::unary_op(op, val)); self.push(Value::unary_op(op, val));
}, },
BinaryOp(op) => { I::BinaryOp(op) => {
let rhs = self.pop(); let rhs = self.pop();
let lhs = self.pop(); let lhs = self.pop();
self.push(Value::binary_op(op, lhs, rhs)?); self.push(Value::binary_op(op, lhs, rhs)?);
}, },
NewList(items) => { I::NewList(items) => {
let list = self.stack.split_off(self.stack.len() - items as usize); let list = self.stack.split_off(self.stack.len() - items as usize);
self.push(Value::List(list.inner.into())); self.push(Value::List(list.inner.into()));
}, },
NewTable(items) => { I::NewTable(items) => {
let mut table = ValueMap::new(); let mut table = ValueMap::new();
for _ in 0..items { for _ in 0..items {
let value = self.pop(); let value = self.pop();
@ -235,105 +283,204 @@ impl Vm {
} }
self.push(Value::Table(table.into())) self.push(Value::Table(table.into()))
}, },
NewMatrix(items, domain) => { I::NewMatrix(items, domain) => {
let values = self.stack.split_off(self.stack.len() - items as usize).inner; let values = self.stack.split_off(self.stack.len() - items as usize).inner;
let domain = domain as usize; let domain = domain as usize;
let codomain = values.len() / domain; let codomain = values.len() / domain;
self.push(Value::Matrix(Gc::new(Matrix::new(domain, codomain, values)))); self.push(Value::Matrix(Gc::new(Matrix::new(domain, codomain, values))));
} }
Jump(idx) => { I::Jump(idx) => {
if self.check_interupt() { if self.check_interupt() {
return Ok(Value::Nil) return Ok(Some(Value::Nil))
} }
frame.ip = idx as usize; frame.ip = idx as usize;
} }
JumpTrue(idx) => { I::JumpTrue(idx) => {
if self.check_interupt() { if self.check_interupt() {
return Ok(Value::Nil) return Ok(Some(Value::Nil))
} }
if !!self.pop() { if !!self.pop() {
frame.ip = idx as usize; frame.ip = idx as usize;
} }
}, },
JumpFalse(idx) => { I::JumpFalse(idx) => {
if self.check_interupt() { if self.check_interupt() {
return Ok(Value::Nil) return Ok(Some(Value::Nil))
} }
if !self.pop() { if !self.pop() {
frame.ip = idx as usize; frame.ip = idx as usize;
} }
}, },
Call(arity) => { I::JumpNil(idx) => {
if self.check_interupt() {
return Ok(Some(Value::Nil))
}
if self.pop() == Value::Nil {
frame.ip = idx as usize;
}
},
I::Call(arity) => {
let arity = arity as usize;
let fun = self.pop(); let fun = self.pop();
let Value::Function(fun) = fun else { let Value::Function(fun) = fun else {
return Err(Error::NotFunction(fun).into()) return Err(Error::NotFunction(fun).into())
}; };
let arity = arity as usize;
let normal_args = if fun.variadic { fun.arity - 1 } else { fun.arity }; if !fun.variadic && arity > fun.arity {
if (fun.variadic && arity < normal_args) || (!fun.variadic && arity != normal_args) { return Err(Error::InvArity(fun.arity, arity as usize, fun.name.clone()).into())
return Err(Error::InvArity(normal_args, arity as usize, fun.name.clone()).into())
} }
let mut params = self.stack.split_off(self.stack.len() - arity).inner;
if params.len() < fun.arity {
let new_arity = fun.arity - arity;
let val = native!("<partial>", new_arity, false, move |(vm, vm_frame), args| {
let mut params = params.clone();
params.extend(args);
vm.exec_fn(vm_frame, fun.clone(), params).map_err(|e| e.err)
});
self.stack.push(val);
return Ok(None);
}
if fun.variadic { if fun.variadic {
if arity == normal_args { if arity == fun.arity {
self.push(Value::List(vec![].into())); params.push(Value::List(vec![].into()));
} else if arity > normal_args { } else {
let count = arity - normal_args; let count = arity - fun.arity;
let varadic_params = self.stack.split_off(self.stack.len() - count).inner; let varadic_params = params.split_off(params.len() - count);
self.push(Value::List(varadic_params.into())); params.push(Value::List(varadic_params.into()));
} }
} }
let name = fun.name.clone();
match &fun.fun { let res = self.exec_fn(frame, fun, params)?;
InnerFunction::Compiled(body) => { self.push(res);
let new_frame = StackFrame::new(self, name, body.clone(), fun.arity);
self.frames.push(frame);
frame = new_frame;
}, },
InnerFunction::Native(native_fun) => { I::Return => {
let params = self.stack.split_off(self.stack.len() - fun.arity).inner;
let res = native_fun(self, params)?;
self.stack.push(res);
}
}
},
Return => {
if self.check_interupt() { if self.check_interupt() {
return Ok(Value::Nil) return Ok(Some(Value::Nil))
} }
let Some(prev_frame) = self.frames.pop() else {
break;
};
let ret = self.pop(); let ret = self.pop();
self.stack.truncate(frame.bp); self.stack.truncate(frame.bp);
self.locals.truncate(0); self.locals.truncate(frame.lp);
self.push(ret); return Ok(Some(ret))
frame = prev_frame;
}, },
Field(name_idx) => { I::Field(name_idx) => {
let expr = self.pop(); let expr = self.pop();
let name = self.names.borrow()[name_idx as usize].clone(); let name = self.names.borrow()[name_idx as usize].clone();
self.push(expr.field_access(&name)?); self.push(expr.field_access(&name)?);
}, },
StoreField(name_idx) => { I::StoreField(name_idx) => {
let mut expr = self.pop(); let mut expr = self.pop();
let value = self.pop(); let value = self.pop();
let name = self.names.borrow()[name_idx as usize].clone(); let name = self.names.borrow()[name_idx as usize].clone();
expr.store_field_access(&name, value)?; expr.store_field_access(&name, value)?;
}, },
Index(count) => { I::Index(count) => {
let index = self.stack.split_off(self.stack.len() - count as usize); let index = self.stack.split_off(self.stack.len() - count as usize);
let collection = self.pop(); let collection = self.pop();
let value = collection.index(&index.inner)?; let value = collection.index(&index.inner)?;
self.stack.push(value); self.stack.push(value);
}, },
StoreIndex(count) => { I::StoreIndex(count) => {
let index = self.stack.split_off(self.stack.len() - count as usize); let index = self.stack.split_off(self.stack.len() - count as usize);
let mut collection = self.pop(); let mut collection = self.pop();
let value = self.pop(); let value = self.pop();
collection.store_index(&index.inner, value)?; collection.store_index(&index.inner, value)?;
},
I::IterCreate => {
let val = self.pop().into_iter();
self.push(val?);
},
I::IterNext => {
let Value::Iter(iter) = self.top() else { panic!("bypassed iter check"); };
let val = self.exec_fn(frame, iter, vec![])?;
self.push(val);
},
I::Try(idx) => {
let scope = TryScope {
err_idx: idx as usize,
frame_depth: frame.depth,
stack_len: self.stack.len(),
locals_len: self.locals.len(),
};
self.trystack.push(scope);
},
I::TryEnd => {
self.trystack.pop().unwrap();
},
};
Ok(None)
}
fn stack_trace(&mut self, frames: Vec<StackFrame>) -> String {
let mut trace = String::from("\x1b[33m\x1b[1mStack Trace:\x1b[0m\n");
for frame in frames {
let ip = frame.ip - 1;
let pos = frame.body.pos[ip];
trace.push_str(&format!(" {} at {}:{}\n", &frame.name, pos.row, pos.col));
}
trace
}
fn exec_fn(&mut self, frame: &mut StackFrame, fun: Rc<Function>, params: Vec<Value>) -> VmResult<Value> {
let name = fun.name.clone();
let params_len = params.len();
match &fun.fun {
InnerFunction::Compiled(body) => {
for param in params {
self.stack.push(param);
}
let mut new_frame = StackFrame::new(self, name, body.clone(), params_len, frame.depth + 1);
self.exec(&mut new_frame)
},
InnerFunction::Native(native_fun) => {
Ok(native_fun((self, frame), params)?)
} }
} }
} }
Ok(self.pop())
fn exec(&mut self, frame: &mut StackFrame) -> VmResult<Value> {
loop {
let ins = frame.body.code[frame.ip].clone();
frame.ip += 1;
match self.exec_ins(frame, ins) {
Ok(Some(val)) => return Ok(val),
Ok(None) => {},
Err(err) => {
if let Some(catch) = self.trystack.pop() {
if frame.depth != catch.frame_depth {
self.trystack.push(catch);
return Err(err);
}
self.stack.truncate(catch.stack_len);
self.locals.truncate(catch.locals_len);
frame.ip = catch.err_idx;
self.stack.push(Value::Error(err.err));
} else {
let mut err = err;
err.frames.push(frame.clone());
return Err(err)
}
},
}
}
}
pub fn run_fn(&mut self, frame: &mut StackFrame, fun: Rc<Function>, params: Vec<Value>) -> Result<Value> {
self.exec_fn(frame, fun, params).map_err(|e| e.err)
}
pub fn run(&mut self, fun: Rc<Function>) -> Result<Value> {
let mut frame = self.init_frame(fun)?;
self.interupt.store(0, Ordering::SeqCst);
self.stack = Stack::new();
self.locals = Stack::new();
self.exec(&mut frame).map_err(|e| {
let trace = self.stack_trace(e.frames);
(e.err, trace).into()
})
} }
} }