Fresh start
This commit is contained in:
parent
ef387fc051
commit
e4d211b075
GPG key ID:
6B10F3EAF14F4C77
3 changed files with 4 additions and 479 deletions
328
src/executor.rs
328
src/executor.rs
|
|
@ -1,328 +0,0 @@
|
|||
use std::collections::HashMap;
|
||||
|
||||
use crate::{OpCode, LispValue};
|
||||
|
||||
pub struct LispState {
|
||||
table: HashMap<String, LispValue>,
|
||||
}
|
||||
|
||||
fn add_function<T: Into<String> + Clone>(table: &mut HashMap<String, LispValue>, name: T, func: fn(Vec<LispValue>) -> Vec<LispValue>) {
|
||||
table.insert(name.clone().into(), LispValue::RustFunction(name.into(), func));
|
||||
}
|
||||
|
||||
impl LispState {
|
||||
pub fn new() -> LispState {
|
||||
let mut table = HashMap::new();
|
||||
|
||||
add_function(&mut table, "print", |x| {
|
||||
let mut strings = Vec::new();
|
||||
for val in x {
|
||||
strings.push(val.to_string());
|
||||
}
|
||||
|
||||
let str = strings.join(" ");
|
||||
println!("{}", str);
|
||||
|
||||
vec![LispValue::Nil]
|
||||
});
|
||||
|
||||
add_function(&mut table, "concat", |x| {
|
||||
let mut strings = Vec::new();
|
||||
for val in x {
|
||||
strings.push(val.to_string());
|
||||
}
|
||||
|
||||
let str = strings.concat();
|
||||
vec![LispValue::String(str)]
|
||||
});
|
||||
|
||||
add_function(&mut table, "add", |x| {
|
||||
if x.len() < 1 {
|
||||
return vec![LispValue::Nil]
|
||||
} else if x.len() == 1 {
|
||||
return vec![x[0].clone()];
|
||||
}
|
||||
|
||||
let mut t = "int";
|
||||
for v in &x {
|
||||
match v {
|
||||
LispValue::Float(_) => t = "float",
|
||||
LispValue::Integer(_) => (),
|
||||
_ => return vec![LispValue::Nil]
|
||||
}
|
||||
}
|
||||
|
||||
match t {
|
||||
"int" => {
|
||||
let mut sum = 0;
|
||||
for v in &x {
|
||||
if let LispValue::Integer(n) = v {
|
||||
sum += n;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Integer(sum)];
|
||||
},
|
||||
"float" => {
|
||||
let mut sum = 0.0 as f32;
|
||||
for v in &x {
|
||||
if let LispValue::Float(n) = v {
|
||||
sum += n;
|
||||
} else if let LispValue::Integer(n) = v{
|
||||
sum += *n as f32;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Float(sum)];
|
||||
},
|
||||
_ => unreachable!()
|
||||
}
|
||||
});
|
||||
|
||||
add_function(&mut table, "sub", |x| {
|
||||
if x.len() < 1 {
|
||||
return vec![LispValue::Nil]
|
||||
} else if x.len() == 1 {
|
||||
return vec![x[0].clone()];
|
||||
}
|
||||
|
||||
let mut t = "int";
|
||||
for v in &x {
|
||||
match v {
|
||||
LispValue::Float(_) => t = "float",
|
||||
LispValue::Integer(_) => (),
|
||||
_ => return vec![LispValue::Nil]
|
||||
}
|
||||
}
|
||||
|
||||
match t {
|
||||
"int" => {
|
||||
if let LispValue::Integer(n) = x[0] {
|
||||
let mut sum = n;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Integer(n) = &x[i] {
|
||||
sum -= n;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Integer(sum)];
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
},
|
||||
"float" => {
|
||||
if let LispValue::Float(n) = x[0] {
|
||||
let mut sum = n;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Float(n) = &x[i] {
|
||||
sum -= *n;
|
||||
} else if let LispValue::Integer(n) = &x[i] {
|
||||
sum -= *n as f32;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Float(sum)];
|
||||
} else if let LispValue::Integer(n) = x[0] {
|
||||
let mut sum = n as f32;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Float(n) = &x[i] {
|
||||
sum -= *n;
|
||||
} else if let LispValue::Integer(n) = &x[i] {
|
||||
sum -= *n as f32;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Float(sum)];
|
||||
} {
|
||||
unreachable!()
|
||||
}
|
||||
},
|
||||
_ => unreachable!()
|
||||
}
|
||||
});
|
||||
|
||||
add_function(&mut table, "mul", |x| {
|
||||
if x.len() < 1 {
|
||||
return vec![LispValue::Nil]
|
||||
} else if x.len() == 1 {
|
||||
return vec![x[0].clone()];
|
||||
}
|
||||
|
||||
let mut t = "int";
|
||||
for v in &x {
|
||||
match v {
|
||||
LispValue::Float(_) => t = "float",
|
||||
LispValue::Integer(_) => (),
|
||||
_ => return vec![LispValue::Nil]
|
||||
}
|
||||
}
|
||||
|
||||
match t {
|
||||
"int" => {
|
||||
if let LispValue::Integer(n) = x[0] {
|
||||
let mut sum = n;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Integer(n) = &x[i] {
|
||||
sum *= n;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Integer(sum)];
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
},
|
||||
"float" => {
|
||||
if let LispValue::Float(n) = x[0] {
|
||||
let mut product = n;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Float(n) = &x[i] {
|
||||
product *= *n;
|
||||
} else if let LispValue::Integer(n) = &x[i] {
|
||||
product *= *n as f32;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Float(product)];
|
||||
} else if let LispValue::Integer(n) = x[0] {
|
||||
let mut product = n as f32;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Float(n) = &x[i] {
|
||||
product *= *n;
|
||||
} else if let LispValue::Integer(n) = &x[i] {
|
||||
product *= *n as f32;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Float(product)];
|
||||
} {
|
||||
unreachable!()
|
||||
}
|
||||
},
|
||||
_ => unreachable!()
|
||||
}
|
||||
});
|
||||
|
||||
add_function(&mut table, "div", |x| {
|
||||
if x.len() < 1 {
|
||||
return vec![LispValue::Nil]
|
||||
} else if x.len() == 1 {
|
||||
return vec![x[0].clone()];
|
||||
}
|
||||
|
||||
let mut t = "int";
|
||||
for v in &x {
|
||||
match v {
|
||||
LispValue::Float(_) => t = "float",
|
||||
LispValue::Integer(_) => (),
|
||||
_ => return vec![LispValue::Nil]
|
||||
}
|
||||
}
|
||||
|
||||
match t {
|
||||
"int" => {
|
||||
if let LispValue::Integer(n) = x[0] {
|
||||
let mut sum = n;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Integer(n) = &x[i] {
|
||||
sum /= n;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Integer(sum)];
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
},
|
||||
"float" => {
|
||||
if let LispValue::Float(n) = x[0] {
|
||||
let mut product = n;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Float(n) = &x[i] {
|
||||
product /= *n;
|
||||
} else if let LispValue::Integer(n) = &x[i] {
|
||||
product /= *n as f32;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Float(product)];
|
||||
} else if let LispValue::Integer(n) = x[0] {
|
||||
let mut product = n as f32;
|
||||
for i in 1..x.len() {
|
||||
if let LispValue::Float(n) = &x[i] {
|
||||
product /= *n;
|
||||
} else if let LispValue::Integer(n) = &x[i] {
|
||||
product /= *n as f32;
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
return vec![LispValue::Float(product)];
|
||||
} {
|
||||
unreachable!()
|
||||
}
|
||||
},
|
||||
_ => unreachable!()
|
||||
}
|
||||
});
|
||||
|
||||
LispState {
|
||||
table
|
||||
}
|
||||
}
|
||||
|
||||
fn do_call(&self, opcode: &OpCode) -> Vec<LispValue> {
|
||||
if let OpCode::Call(func, args) = opcode {
|
||||
let f = self.table.get(func).unwrap();
|
||||
|
||||
let mut args: Vec<LispValue> = args.clone();
|
||||
for i in 0..args.len() {
|
||||
let arg = &args[i];
|
||||
if let LispValue::Eval(OpCode::Exp(opcodes)) = arg {
|
||||
if opcodes.len() < 1 {
|
||||
args[i] = LispValue::Nil;
|
||||
continue;
|
||||
}
|
||||
|
||||
let call_opcode = opcodes.last().unwrap();
|
||||
let mut res = self.do_call(call_opcode);
|
||||
args.remove(i);
|
||||
for j in 0..res.len() {
|
||||
args.insert(i + j, res.remove(0));
|
||||
}
|
||||
}
|
||||
}
|
||||
if let LispValue::RustFunction(_, f) = f {
|
||||
return f(args.to_vec());
|
||||
} else {
|
||||
todo!();
|
||||
}
|
||||
|
||||
} else {
|
||||
panic!("Bad OpCode: expected OpCode::Call")
|
||||
}
|
||||
}
|
||||
|
||||
pub fn execute(&self, instructions: Vec<OpCode>) {
|
||||
for op in instructions {
|
||||
match op {
|
||||
OpCode::Call(func, args) => {
|
||||
self.do_call(&OpCode::Call(func, args));
|
||||
},
|
||||
OpCode::Exp(ins) => {
|
||||
self.execute(ins);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
151
src/parser.rs
151
src/parser.rs
|
|
@ -1,151 +0,0 @@
|
|||
use std::fmt;
|
||||
|
||||
use crate::Token;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum LispValue {
|
||||
Nil,
|
||||
String(String),
|
||||
Integer(i32),
|
||||
Float(f32),
|
||||
LispFunction(String, Vec<OpCode>),
|
||||
RustFunction(String, fn(Vec<LispValue>) -> Vec<LispValue>),
|
||||
Ref(String),
|
||||
Eval(OpCode)
|
||||
}
|
||||
|
||||
impl fmt::Display for LispValue {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
LispValue::Nil => write!(f, "nil"),
|
||||
LispValue::String(str) => write!(f, "{}", str),
|
||||
LispValue::LispFunction(name, _) => write!(f, "<'{}': Lisp Function>", name),
|
||||
LispValue::RustFunction(name, _) => write!(f, "<'{}': Rust Function>", name),
|
||||
LispValue::Integer(num) => write!(f, "{}", num),
|
||||
LispValue::Float(num) => write!(f, "{}", num),
|
||||
LispValue::Ref(name) => write!(f, "<'{}': Reference>", name),
|
||||
_ => todo!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&str> for LispValue {
|
||||
fn from(value: &str) -> Self {
|
||||
LispValue::String(value.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
impl From<String> for LispValue {
|
||||
fn from(value: String) -> Self {
|
||||
LispValue::String(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<i32> for LispValue {
|
||||
fn from(value: i32) -> Self {
|
||||
LispValue::Integer(value)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum OpCode {
|
||||
Call(String, Vec<LispValue>),
|
||||
Exp(Vec<OpCode>)
|
||||
}
|
||||
|
||||
// TODO: Handle failure
|
||||
fn read_exp(open_paren_idx: usize, tokens: &Vec<Token>) -> Option<(Vec<Token>, usize)> /* Option<tokens, close_paren_idx> */ {
|
||||
let mut tkns = Vec::new();
|
||||
let mut depth = 0;
|
||||
|
||||
for i in open_paren_idx..tokens.len() {
|
||||
match &tokens[i] {
|
||||
Token::OpenParen => {
|
||||
if depth != 0 {
|
||||
tkns.push(Token::OpenParen);
|
||||
}
|
||||
depth += 1;
|
||||
}
|
||||
Token::CloseParen => {
|
||||
depth -= 1;
|
||||
if depth == 0 {
|
||||
return Some((tkns, i));
|
||||
} else {
|
||||
tkns.push(Token::CloseParen)
|
||||
}
|
||||
}
|
||||
token => {
|
||||
tkns.push(token.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
|
||||
fn parse_exp(tokens: Vec<Token>) -> Vec<OpCode> {
|
||||
let mut opcodes = Vec::new();
|
||||
|
||||
if tokens.len() < 1 {
|
||||
return opcodes;
|
||||
}
|
||||
|
||||
if let Token::Identifier(name) = &tokens[0] {
|
||||
let mut args = Vec::new();
|
||||
|
||||
let mut i = 1;
|
||||
while i < tokens.len() {
|
||||
let tkn = &tokens[i];
|
||||
match tkn {
|
||||
Token::OpenParen => {
|
||||
let (tkns, close_paren_idx) = read_exp(i, &tokens).unwrap();
|
||||
args.push(LispValue::Eval(OpCode::Exp(parse_exp(tkns))));
|
||||
i = close_paren_idx;
|
||||
},
|
||||
Token::Identifier(name) => {
|
||||
args.push(LispValue::Ref(name.to_owned()));
|
||||
},
|
||||
Token::Integer(num) => {
|
||||
args.push(LispValue::Integer(*num));
|
||||
},
|
||||
Token::Float(num) => {
|
||||
args.push(LispValue::Float(*num));
|
||||
},
|
||||
Token::String(str) => {
|
||||
args.push(LispValue::String(str.to_owned()));
|
||||
},
|
||||
Token::CloseParen => {
|
||||
panic!("Unexpected closing parenthesis");
|
||||
},
|
||||
}
|
||||
|
||||
i += 1;
|
||||
}
|
||||
|
||||
opcodes.push(OpCode::Call(name.to_owned(), args))
|
||||
}
|
||||
|
||||
opcodes
|
||||
}
|
||||
|
||||
pub fn parse(tokens: Vec<Token>) -> Vec<OpCode> {
|
||||
let mut opcodes = Vec::new();
|
||||
|
||||
let mut i = 0;
|
||||
while i < tokens.len() {
|
||||
match &tokens[i] {
|
||||
Token::OpenParen => {
|
||||
let (tkns, close_paren_idx) = read_exp(i, &tokens).unwrap();
|
||||
opcodes.push(OpCode::Exp(parse_exp(tkns)));
|
||||
i = close_paren_idx;
|
||||
}
|
||||
tkn => {
|
||||
// TODO: Include more error data
|
||||
panic!("Unexpected token {:?}", tkn);
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
|
||||
opcodes
|
||||
}
|
||||
|
|
@ -4,6 +4,8 @@ use std::fmt;
|
|||
pub enum Token {
|
||||
OpenParen,
|
||||
CloseParen,
|
||||
Quote,
|
||||
Unquote,
|
||||
Identifier(String),
|
||||
String(String),
|
||||
Integer(i32),
|
||||
|
|
@ -164,6 +166,8 @@ impl Tokenizer {
|
|||
self.reading_string = true;
|
||||
self.storage.clear();
|
||||
},
|
||||
'\'' => tokens.push(Token::Quote),
|
||||
',' => tokens.push(Token::Unquote),
|
||||
c => {
|
||||
if c.is_alphabetic() {
|
||||
self.reading_identifier = true;
|
||||
|
|
|
|||
Reference in a new issue