diff --git a/src/expr.rs b/src/expr.rs
index e75811d..ed2f174 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1,16 +1,13 @@
-
-use {
- std::{
- boxed::Box,
- sync::{Arc, RwLock}
- }
+use std::{
+ boxed::Box,
+ sync::{Arc, RwLock},
};
#[derive(Clone, Debug)]
pub enum Statement {
Assignment {
var_id: String,
- val_expr: LTExpr
+ val_expr: LTExpr,
},
LetAssign {
typ: Option<TypeTag>,
@@ -19,10 +16,10 @@ pub enum Statement {
},
WhileLoop {
condition: LTExpr,
- body: Vec<Statement>
+ body: Vec<Statement>,
},
Return(LTExpr),
- Expr(LTExpr)
+ Expr(LTExpr),
}
#[derive(Clone, Debug)]
@@ -30,17 +27,17 @@ pub enum TypeError {
ParseError(laddertypes::parser::ParseError),
Mismatch {
expected: laddertypes::TypeTerm,
- received: laddertypes::TypeTerm
- }
+ received: laddertypes::TypeTerm,
+ },
}
-pub type TypeTag = Result< laddertypes::TypeTerm, TypeError >;
+pub type TypeTag = Result<laddertypes::TypeTerm, TypeError>;
#[derive(Clone, Debug)]
pub enum LTExpr {
Literal {
typ: Option<TypeTag>,
- val: tisc::VM_Word
+ val: tisc::VM_Word,
},
Symbol {
typ: Option<TypeTag>,
@@ -49,59 +46,59 @@ pub enum LTExpr {
Application {
typ: Option<TypeTag>,
head: Box<LTExpr>,
- body: Vec<LTExpr>
+ body: Vec<LTExpr>,
},
Abstraction {
args: Vec<(String, Option<TypeTag>)>,
- body: Box<LTExpr>
+ body: Box<LTExpr>,
},
Branch {
condition: Box<LTExpr>,
if_expr: Box<LTExpr>,
- else_expr: Box<LTExpr>
+ else_expr: Box<LTExpr>,
},
Block {
- statements: Vec<Statement>
- }
+ statements: Vec<Statement>,
+ },
}
impl LTExpr {
pub fn symbol(str: &str) -> Self {
LTExpr::Symbol {
- typ: None,//typectx.write().unwrap().parse("<Ref memory::Word>~Symbol~<Seq Char>").expect("parse typeterm"),
- symbol: String::from(str)
+ typ: None, //typectx.write().unwrap().parse("<Ref memory::Word>~Symbol~<Seq Char>").expect("parse typeterm"),
+ symbol: String::from(str),
}
}
pub fn lit_uint(val: u64) -> Self {
LTExpr::Literal {
- typ: None,//typectx.write().unwrap().parse("ℤ_2^64~machine::UInt64~machine::Word").expect("parse typeterm"),
- val: val as tisc::VM_Word
+ typ: None, //typectx.write().unwrap().parse("ℤ_2^64~machine::UInt64~machine::Word").expect("parse typeterm"),
+ val: val as tisc::VM_Word,
}
}
pub fn abstraction(args: Vec<(&str, &str)>, body: LTExpr) -> LTExpr {
LTExpr::Abstraction {
- args: args.into_iter().map(|(arg_name, arg_type)|
- ( arg_name.into(), None )
- //typectx.write().unwrap().parse(t).expect("parse typeterm")
- ).collect(),
- body: Box::new(body)
+ args: args
+ .into_iter()
+ .map(
+ |(arg_name, arg_type)| (arg_name.into(), None), //typectx.write().unwrap().parse(t).expect("parse typeterm")
+ )
+ .collect(),
+ body: Box::new(body),
}
}
pub fn application(head: LTExpr, body: Vec<LTExpr>) -> Self {
LTExpr::Application {
typ: None,
- head: Box::new( head ),
- body: body
+ head: Box::new(head),
+ body: body,
}
}
pub fn block(body: Vec<Statement>) -> Self {
- LTExpr::Block {
- statements: body
- }
+ LTExpr::Block { statements: body }
}
}
@@ -109,7 +106,7 @@ impl Statement {
pub fn while_loop(cond: LTExpr, body: Vec<Statement>) -> Self {
Statement::WhileLoop {
condition: cond,
- body
+ body,
}
}
}
@@ -156,4 +153,3 @@ impl LTExpr {
}
}
*/
-
diff --git a/src/lexer.rs b/src/lexer.rs
index 07e1699..41a00f6 100644
--- a/src/lexer.rs
+++ b/src/lexer.rs
@@ -1,17 +1,15 @@
-
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum LTIRToken {
- Symbol( String ),
- Char( char ),
- Num( i64 ),
+ Symbol(String),
+ Char(char),
+ Num(i64),
// SingleQuote(String),
// DoubleQuote(String),
// TripleQuote(String),
-
Lambda,
LambdaBody,
- AssignType( String ),
+ AssignType(String),
AssignValue,
ExprOpen,
@@ -25,39 +23,40 @@ pub enum LTIRToken {
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum LexError {
InvalidDigit,
- InvalidChar
+ InvalidChar,
}
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum LexerState {
Any,
- TypeTerm( String ),
- Sym( String ),
- Num( i64 ),
- Char( Option<char> )
+ TypeTerm(String),
+ Sym(String),
+ Num(i64),
+ Char(Option<char>),
}
impl LexerState {
- fn into_token(self) -> Option< LTIRToken > {
+ fn into_token(self) -> Option<LTIRToken> {
match self {
LexerState::Any => None,
LexerState::TypeTerm(s) => Some(LTIRToken::AssignType(s)),
LexerState::Sym(s) => Some(LTIRToken::Symbol(s)),
LexerState::Num(n) => Some(LTIRToken::Num(n)),
- LexerState::Char(c) => Some(LTIRToken::Char(c?))
+ LexerState::Char(c) => Some(LTIRToken::Char(c?)),
}
}
}
-
pub struct LTIRLexer<It>
-where It: std::iter::Iterator<Item = char>
+where
+ It: std::iter::Iterator<Item = char>,
{
chars: std::iter::Peekable<It>,
}
impl<It> LTIRLexer<It>
-where It: Iterator<Item = char>
+where
+ It: Iterator<Item = char>,
{
pub fn into_inner(self) -> std::iter::Peekable<It> {
self.chars
@@ -65,17 +64,19 @@ where It: Iterator<Item = char>
}
impl<It> From<It> for LTIRLexer<It>
-where It: Iterator<Item = char>
+where
+ It: Iterator<Item = char>,
{
fn from(chars: It) -> Self {
LTIRLexer {
- chars: chars.peekable()
+ chars: chars.peekable(),
}
}
}
impl<It> Iterator for LTIRLexer<It>
-where It: Iterator<Item = char>
+where
+ It: Iterator<Item = char>,
{
type Item = Result<LTIRToken, LexError>;
@@ -84,60 +85,81 @@ where It: Iterator<Item = char>
while let Some(c) = self.chars.peek() {
match &mut state {
-
// determine token type
- LexerState::Any => {
- match c {
- 'λ' => { self.chars.next(); return Some(Ok(LTIRToken::Lambda)); },
- '.' => { self.chars.next(); return Some(Ok(LTIRToken::LambdaBody)); },
- '(' => { self.chars.next(); return Some(Ok(LTIRToken::ExprOpen)); },
- ')' => { self.chars.next(); return Some(Ok(LTIRToken::ExprClose)); },
- '{' => { self.chars.next(); return Some(Ok(LTIRToken::BlockOpen)); },
- '}' => { self.chars.next(); return Some(Ok(LTIRToken::BlockClose)); },
- ':' => {
+ LexerState::Any => match c {
+ 'λ' => {
+ self.chars.next();
+ return Some(Ok(LTIRToken::Lambda));
+ }
+ '.' => {
+ self.chars.next();
+ return Some(Ok(LTIRToken::LambdaBody));
+ }
+ '(' => {
+ self.chars.next();
+ return Some(Ok(LTIRToken::ExprOpen));
+ }
+ ')' => {
+ self.chars.next();
+ return Some(Ok(LTIRToken::ExprClose));
+ }
+ '{' => {
+ self.chars.next();
+ return Some(Ok(LTIRToken::BlockOpen));
+ }
+ '}' => {
+ self.chars.next();
+ return Some(Ok(LTIRToken::BlockClose));
+ }
+ ':' => {
+ self.chars.next();
+ state = LexerState::TypeTerm(String::new());
+ }
+ '=' => {
+ self.chars.next();
+ return Some(Ok(LTIRToken::AssignValue));
+ }
+ ';' => {
+ self.chars.next();
+ return Some(Ok(LTIRToken::StatementSep));
+ }
+ '\'' => {
+ self.chars.next();
+ state = LexerState::Char(None);
+ }
+ c => {
+ if c.is_whitespace() {
self.chars.next();
- state = LexerState::TypeTerm(String::new());
- },
- '=' => { self.chars.next(); return Some(Ok(LTIRToken::AssignValue)); },
- ';' => { self.chars.next(); return Some(Ok(LTIRToken::StatementSep)); },
- '\'' => { self.chars.next(); state = LexerState::Char(None); },
- c => {
- if c.is_whitespace() {
- self.chars.next();
- } else if c.is_digit(10) {
- state = LexerState::Num( 0 );
- } else {
- state = LexerState::Sym( String::new() );
- }
+ } else if c.is_digit(10) {
+ state = LexerState::Num(0);
+ } else {
+ state = LexerState::Sym(String::new());
}
}
- }
+ },
LexerState::Char(val) => {
- *val = Some(
- match self.chars.next() {
- Some('\\') => {
- match self.chars.next() {
- Some('0') => '\0',
- Some('n') => '\n',
- Some('t') => '\t',
- Some(c) => c,
- None => {
- return Some(Err(LexError::InvalidChar));
- }
- }
- }
+ *val = Some(match self.chars.next() {
+ Some('\\') => match self.chars.next() {
+ Some('0') => '\0',
+ Some('n') => '\n',
+ Some('t') => '\t',
Some(c) => c,
None => {
return Some(Err(LexError::InvalidChar));
}
- });
+ },
+ Some(c) => c,
+ None => {
+ return Some(Err(LexError::InvalidChar));
+ }
+ });
match self.chars.next() {
Some('\'') => {
if let Some(token) = state.clone().into_token() {
return Some(Ok(token));
- }
+ }
}
_ => {
return Some(Err(LexError::InvalidChar));
@@ -148,7 +170,7 @@ where It: Iterator<Item = char>
LexerState::TypeTerm(s) => {
if *c == '=' || *c == '.' {
if let Some(token) = state.clone().into_token() {
- return Some(Ok(token))
+ return Some(Ok(token));
}
} else {
if let Some(c) = self.chars.next() {
@@ -158,12 +180,15 @@ where It: Iterator<Item = char>
}
_ => {
-
if c.is_whitespace()
- || *c == '(' || *c == ')'
- || *c == '{' || *c == '}'
- || *c == ';' || *c == '='
- || *c == ':' || *c == '.'
+ || *c == '('
+ || *c == ')'
+ || *c == '{'
+ || *c == '}'
+ || *c == ';'
+ || *c == '='
+ || *c == ':'
+ || *c == '.'
{
// finish the current token
@@ -215,7 +240,8 @@ mod tests {
λx:ℝ
.λy:ℝ
.sqrt (+ (* x x) (* y y));
- ".chars()
+ "
+ .chars(),
);
for token in lexer {
@@ -223,5 +249,3 @@ mod tests {
}
}
}
-
-
diff --git a/src/main.rs b/src/main.rs
index 12c3fc9..c14e719 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,31 +1,34 @@
use {
- std::{boxed::{Box}, ops::Deref},
std::collections::HashMap,
std::sync::{Arc, RwLock},
+ std::{boxed::Box, ops::Deref},
};
mod expr;
-mod symbols;
-mod procedure_compiler;
-mod runtime;
mod lexer;
mod parser;
+mod procedure_compiler;
+mod runtime;
+mod symbols;
use crate::{
expr::{LTExpr, Statement},
- symbols::{Scope},
- procedure_compiler::ProcedureCompiler
+ procedure_compiler::ProcedureCompiler,
+ symbols::Scope,
};
-fn compile(scope: &Arc<RwLock<Scope>>, name: &str, source: &str) -> Vec< tisc::assembler::AssemblyWord > {
+fn compile(
+ scope: &Arc<RwLock<Scope>>,
+ name: &str,
+ source: &str,
+) -> Vec<tisc::assembler::AssemblyWord> {
ProcedureCompiler::new(scope)
.compile(
&parser::parse_expr(
&scope.read().unwrap().typectx,
- &mut lexer::LTIRLexer::from(
- source.chars().peekable()
- ).peekable()
- ).expect("syntax error")
+ &mut lexer::LTIRLexer::from(source.chars().peekable()).peekable(),
+ )
+ .expect("syntax error"),
)
.into_asm(&name.into())
}
@@ -41,29 +44,30 @@ fn main() {
/* define type of the symbol
*/
- main_scope.write().unwrap()
- .declare_static_parse(
- "hello-string",
- "<Seq Char
+ main_scope.write().unwrap().declare_static_parse(
+ "hello-string",
+ "<Seq Char
~Ascii
~machine::Word>
- ~<NullTerminatedSeq machine::Word>"
- );
+ ~<NullTerminatedSeq machine::Word>",
+ );
- main_scope.write().unwrap()
- .declare_static_parse(
- "pfxstr",
- "<Seq Char
+ main_scope.write().unwrap().declare_static_parse(
+ "pfxstr",
+ "<Seq Char
~Ascii
~machine::Word>
- ~<LengthPrefixedSeq machine::Word>"
- );
+ ~<LengthPrefixedSeq machine::Word>",
+ );
/* link assembly-program to symbols
*/
- linker.add_procedure("main", compile(&main_scope,
+ linker.add_procedure(
"main",
- "{
+ compile(
+ &main_scope,
+ "main",
+ "{
let print-nullterm =
λ str : <Ref <Seq Char~Ascii~machine::Word>>
~ <Ref <NullTerminatedArray machine::Word>>
@@ -137,23 +141,37 @@ fn main() {
};
hello;
- }"
- ));
+ }",
+ ),
+ );
- linker.add_static("hello-string",
+ linker.add_static(
+ "hello-string",
"Hallo Welt!\n\0"
.chars()
.map(|c| (c as u8) as tisc::VM_Word)
- .collect());
-
- linker.add_static("pfxstr",
- vec![ 3, 'a' as tisc::VM_Word, 'b' as tisc::VM_Word, 'c' as tisc::VM_Word, 'd' as tisc::VM_Word ]
+ .collect(),
);
- let main_addr = linker.get_link_addr(&"main".into()).expect("'main' not linked");
- vm.load( linker.link_total().expect("could not link") );
- vm.execute( main_addr );
+ linker.add_static(
+ "pfxstr",
+ vec![
+ 3,
+ 'a' as tisc::VM_Word,
+ 'b' as tisc::VM_Word,
+ 'c' as tisc::VM_Word,
+ 'd' as tisc::VM_Word,
+ ],
+ );
- eprintln!("\n====\nVM execution finished\ndatastack = {:?}\n====", vm.data_stack);
+ let main_addr = linker
+ .get_link_addr(&"main".into())
+ .expect("'main' not linked");
+ vm.load(linker.link_total().expect("could not link"));
+ vm.execute(main_addr);
+
+ eprintln!(
+ "\n====\nVM execution finished\ndatastack = {:?}\n====",
+ vm.data_stack
+ );
}
-
diff --git a/src/parser.rs b/src/parser.rs
index 921a745..eb0daab 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1,12 +1,12 @@
use {
+ crate::{
+ expr::{LTExpr, Statement, TypeError, TypeTag},
+ lexer::{LTIRLexer, LTIRToken, LexError},
+ },
std::{
iter::Peekable,
- sync::{Arc, RwLock}
+ sync::{Arc, RwLock},
},
- crate::{
- lexer::{LTIRLexer, LTIRToken, LexError},
- expr::{LTExpr, Statement, TypeTag, TypeError}
- }
};
#[derive(Clone, Debug)]
@@ -14,14 +14,15 @@ pub enum ParseError {
LexError(LexError),
UnexpectedClose,
UnexpectedEnd,
- UnexpectedToken
+ UnexpectedToken,
}
pub fn parse_expect<It>(
tokens: &mut Peekable<LTIRLexer<It>>,
- expected_token: LTIRToken
-) -> Result< (), ParseError >
-where It: Iterator<Item = char>
+ expected_token: LTIRToken,
+) -> Result<(), ParseError>
+where
+ It: Iterator<Item = char>,
{
match tokens.next() {
Some(Ok(t)) => {
@@ -30,16 +31,15 @@ where It: Iterator<Item = char>
} else {
Err(ParseError::UnexpectedToken)
}
- },
+ }
Some(Err(err)) => Err(ParseError::LexError(err)),
- None => Err(ParseError::UnexpectedEnd)
+ None => Err(ParseError::UnexpectedEnd),
}
}
-pub fn parse_symbol<It>(
- tokens: &mut Peekable<LTIRLexer<It>>
-) -> Result< String, ParseError >
-where It: Iterator<Item = char>
+pub fn parse_symbol<It>(tokens: &mut Peekable<LTIRLexer<It>>) -> Result<String, ParseError>
+where
+ It: Iterator<Item = char>,
{
match tokens.next() {
Some(Ok(LTIRToken::Symbol(name))) => Ok(name),
@@ -51,24 +51,21 @@ where It: Iterator<Item = char>
pub fn parse_type_tag<It>(
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
- tokens: &mut Peekable<LTIRLexer<It>>
+ tokens: &mut Peekable<LTIRLexer<It>>,
) -> Option<TypeTag>
-where It: Iterator<Item = char>
+where
+ It: Iterator<Item = char>,
{
if let Some(peektok) = tokens.peek().clone() {
match peektok.clone() {
Ok(LTIRToken::AssignType(typeterm_str)) => {
tokens.next();
match typectx.write().unwrap().parse(typeterm_str.as_str()) {
- Ok(typeterm) => {
- Some(Ok(typeterm))
- }
- Err(parse_error) => {
- Some(Err(TypeError::ParseError(parse_error)))
- }
+ Ok(typeterm) => Some(Ok(typeterm)),
+ Err(parse_error) => Some(Err(TypeError::ParseError(parse_error))),
}
}
- _ => None
+ _ => None,
}
} else {
None
@@ -77,9 +74,10 @@ where It: Iterator<Item = char>
pub fn parse_statement<It>(
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
- tokens: &mut Peekable<LTIRLexer<It>>
-) -> Result< crate::expr::Statement, ParseError >
-where It: Iterator<Item = char>
+ tokens: &mut Peekable<LTIRLexer<It>>,
+) -> Result<crate::expr::Statement, ParseError>
+where
+ It: Iterator<Item = char>,
{
if let Some(peektok) = tokens.peek() {
match peektok {
@@ -94,7 +92,7 @@ where It: Iterator<Item = char>
Ok(Statement::Assignment {
var_id: name,
- val_expr
+ val_expr,
})
}
"let" => {
@@ -104,11 +102,11 @@ where It: Iterator<Item = char>
let _ = parse_expect(tokens, LTIRToken::AssignValue);
let val_expr = parse_expr(typectx, tokens)?;
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
-
+
Ok(Statement::LetAssign {
typ,
var_id: name,
- val_expr
+ val_expr,
})
}
"while" => {
@@ -118,7 +116,7 @@ where It: Iterator<Item = char>
let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
Ok(Statement::WhileLoop {
condition: cond,
- body: parse_block(typectx, tokens)?
+ body: parse_block(typectx, tokens)?,
})
}
"return" => {
@@ -138,8 +136,8 @@ where It: Iterator<Item = char>
let expr = parse_expr(typectx, tokens)?;
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
Ok(Statement::Expr(expr))
- },
- Err(err) => Err(ParseError::LexError(err.clone()))
+ }
+ Err(err) => Err(ParseError::LexError(err.clone())),
}
} else {
Err(ParseError::UnexpectedEnd)
@@ -148,9 +146,10 @@ where It: Iterator<Item = char>
pub fn parse_block<It>(
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
- tokens: &mut Peekable<LTIRLexer<It>>
-) -> Result< Vec<Statement>, ParseError >
-where It: Iterator<Item = char>
+ tokens: &mut Peekable<LTIRLexer<It>>,
+) -> Result<Vec<Statement>, ParseError>
+where
+ It: Iterator<Item = char>,
{
let _ = parse_expect(tokens, LTIRToken::BlockOpen)?;
@@ -159,10 +158,14 @@ where It: Iterator<Item = char>
match peektok {
Ok(LTIRToken::BlockClose) => {
tokens.next();
- return Ok(statements)
+ return Ok(statements);
+ }
+ Ok(_) => {
+ statements.push(parse_statement(typectx, tokens)?);
+ }
+ Err(err) => {
+ return Err(ParseError::LexError(err.clone()));
}
- Ok(_) => { statements.push( parse_statement(typectx, tokens)? ); }
- Err(err) => { return Err(ParseError::LexError(err.clone())); }
}
}
@@ -170,37 +173,27 @@ where It: Iterator<Item = char>
}
pub fn parse_atom<It>(
- tokens: &mut Peekable<LTIRLexer<It>>
-) -> Result< crate::expr::LTExpr, ParseError >
-where It: Iterator<Item = char>
+ tokens: &mut Peekable<LTIRLexer<It>>,
+) -> Result<crate::expr::LTExpr, ParseError>
+where
+ It: Iterator<Item = char>,
{
match tokens.next() {
- Some(Ok(LTIRToken::Symbol(sym))) => {
- Ok(LTExpr::symbol(sym.as_str()))
- }
- Some(Ok(LTIRToken::Char(c))) => {
- Ok(LTExpr::lit_uint(c as u64))
- }
- Some(Ok(LTIRToken::Num(n))) => {
- Ok(LTExpr::lit_uint(n as u64))
- }
- Some(Ok(_)) => {
- Err(ParseError::UnexpectedToken)
- }
- Some(Err(err)) => {
- Err(ParseError::LexError(err))
- }
- None => {
- Err(ParseError::UnexpectedEnd)
- }
+ Some(Ok(LTIRToken::Symbol(sym))) => Ok(LTExpr::symbol(sym.as_str())),
+ Some(Ok(LTIRToken::Char(c))) => Ok(LTExpr::lit_uint(c as u64)),
+ Some(Ok(LTIRToken::Num(n))) => Ok(LTExpr::lit_uint(n as u64)),
+ Some(Ok(_)) => Err(ParseError::UnexpectedToken),
+ Some(Err(err)) => Err(ParseError::LexError(err)),
+ None => Err(ParseError::UnexpectedEnd),
}
}
pub fn parse_expr<It>(
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
- tokens: &mut Peekable<LTIRLexer<It>>
-) -> Result< crate::expr::LTExpr, ParseError >
-where It: Iterator<Item = char>
+ tokens: &mut Peekable<LTIRLexer<It>>,
+) -> Result<crate::expr::LTExpr, ParseError>
+where
+ It: Iterator<Item = char>,
{
let mut children = Vec::new();
@@ -212,18 +205,15 @@ where It: Iterator<Item = char>
let mut args = Vec::new();
while let Some(Ok(LTIRToken::Symbol(_))) = tokens.peek() {
- args.push((
- parse_symbol(tokens)?,
- parse_type_tag(typectx, tokens)
- ));
+ args.push((parse_symbol(tokens)?, parse_type_tag(typectx, tokens)));
}
let _ = parse_expect(tokens, LTIRToken::LambdaBody);
let body = parse_expr(typectx, tokens)?;
- return Ok(LTExpr::Abstraction{
+ return Ok(LTExpr::Abstraction {
args,
- body: Box::new(body)
+ body: Box::new(body),
});
} else {
return Err(ParseError::UnexpectedToken);
@@ -241,45 +231,53 @@ where It: Iterator<Item = char>
}
children.push(parse_expr(typectx, tokens)?);
}
- },
- Ok(LTIRToken::ExprClose) => { break; }
- Ok(LTIRToken::BlockOpen) => {
- children.push( LTExpr::block(parse_block(typectx, tokens)?));
}
- Ok(LTIRToken::BlockClose) => { break; }
- Ok(LTIRToken::StatementSep) => { break; }
- Ok(LTIRToken::Symbol(name)) => {
- match name.as_str() {
- "if" => {
- tokens.next();
- let _ = parse_expect(tokens, LTIRToken::ExprOpen)?;
- let cond = parse_expr(typectx, tokens)?;
- let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
- let if_expr = LTExpr::block(parse_block(typectx, tokens)?);
- let mut else_expr = LTExpr::block(vec![]);
+ Ok(LTIRToken::ExprClose) => {
+ break;
+ }
+ Ok(LTIRToken::BlockOpen) => {
+ children.push(LTExpr::block(parse_block(typectx, tokens)?));
+ }
+ Ok(LTIRToken::BlockClose) => {
+ break;
+ }
+ Ok(LTIRToken::StatementSep) => {
+ break;
+ }
+ Ok(LTIRToken::Symbol(name)) => match name.as_str() {
+ "if" => {
+ tokens.next();
+ let _ = parse_expect(tokens, LTIRToken::ExprOpen)?;
+ let cond = parse_expr(typectx, tokens)?;
+ let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
+ let if_expr = LTExpr::block(parse_block(typectx, tokens)?);
+ let mut else_expr = LTExpr::block(vec![]);
- if let Some(peektok) = tokens.peek() {
- if let Ok(LTIRToken::Symbol(name)) = peektok {
- if name == "else" {
- tokens.next();
- else_expr = parse_expr(typectx, tokens)?;
- }
+ if let Some(peektok) = tokens.peek() {
+ if let Ok(LTIRToken::Symbol(name)) = peektok {
+ if name == "else" {
+ tokens.next();
+ else_expr = parse_expr(typectx, tokens)?;
}
}
+ }
- children.push(LTExpr::Branch{
- condition: Box::new(cond),
- if_expr: Box::new(if_expr),
- else_expr: Box::new(else_expr)
- });
- }
- name => {
- children.push(parse_atom(tokens)?);
- }
+ children.push(LTExpr::Branch {
+ condition: Box::new(cond),
+ if_expr: Box::new(if_expr),
+ else_expr: Box::new(else_expr),
+ });
}
+ name => {
+ children.push(parse_atom(tokens)?);
+ }
+ },
+ Ok(atom) => {
+ children.push(parse_atom(tokens)?);
+ }
+ Err(err) => {
+ return Err(ParseError::LexError(err.clone()));
}
- Ok(atom) => { children.push(parse_atom(tokens)?); }
- Err(err) => { return Err(ParseError::LexError(err.clone())); }
}
}
@@ -288,10 +286,9 @@ where It: Iterator<Item = char>
Ok(LTExpr::Application {
typ: None,
head: Box::new(head),
- body: children
+ body: children,
})
} else {
Err(ParseError::UnexpectedEnd)
}
}
-
diff --git a/src/procedure_compiler.rs b/src/procedure_compiler.rs
index 00f44f4..ba3d422 100644
--- a/src/procedure_compiler.rs
+++ b/src/procedure_compiler.rs
@@ -1,17 +1,13 @@
-
use {
- std::{
- sync::{Arc, RwLock},
- ops::Deref,
- },
- tisc::{
- assembler::AssemblyWord,
- linker::LinkAddr
- },
crate::{
expr::{LTExpr, Statement},
- symbols::{Scope, SymbolDef}
- }
+ symbols::{Scope, SymbolDef},
+ },
+ std::{
+ ops::Deref,
+ sync::{Arc, RwLock},
+ },
+ tisc::{assembler::AssemblyWord, linker::LinkAddr},
};
pub struct ProcedureCompiler {
@@ -31,27 +27,31 @@ impl ProcedureCompiler {
}
}
- pub fn into_asm(mut self, proc_symbol: &String) -> Vec< tisc::assembler::AssemblyWord > {
+ pub fn into_asm(mut self, proc_symbol: &String) -> Vec<tisc::assembler::AssemblyWord> {
let data_frame_size = self.symbols.read().unwrap().get_frame_size() as i64;
let body = self.asm.build();
self.linker.add_procedure("__procedure_body__", body);
- let body_addr = self.linker.get_link_addr(&"__procedure_body__".into()).unwrap();
- let subroutines = self.linker.link_relative(&"__subroutines__".into()).expect("link error");
+ let body_addr = self
+ .linker
+ .get_link_addr(&"__procedure_body__".into())
+ .unwrap();
+ let subroutines = self
+ .linker
+ .link_relative(&"__subroutines__".into())
+ .expect("link error");
let mut entry = tisc::Assembler::new();
if data_frame_size > 0 {
- entry = entry
- .lit(data_frame_size)
- .call("data-frame-alloc");
+ entry = entry.lit(data_frame_size).call("data-frame-alloc");
}
- entry = entry
- .call_symbol( LinkAddr::Relative{ symbol: "__subroutines__".into(), offset: body_addr });
+ entry = entry.call_symbol(LinkAddr::Relative {
+ symbol: "__subroutines__".into(),
+ offset: body_addr,
+ });
if data_frame_size > 0 {
- entry = entry
- .lit(data_frame_size)
- .call("data-frame-drop");
+ entry = entry.lit(data_frame_size).call("data-frame-drop");
}
let mut superlink = tisc::Linker::new();
@@ -59,12 +59,12 @@ impl ProcedureCompiler {
superlink.add_procedure("__subroutines__", subroutines);
let bytecode = superlink.link_relative(proc_symbol).expect("link error");
-/*
- eprintln!("\n\n{}:", proc_symbol);
- for (i,w) in tisc::assembler::disassemble(&bytecode).iter().enumerate() {
- eprintln!("{}:\t\t{}", i, w);
- }
-*/
+ /*
+ eprintln!("\n\n{}:", proc_symbol);
+ for (i,w) in tisc::assembler::disassemble(&bytecode).iter().enumerate() {
+ eprintln!("{}:\t\t{}", i, w);
+ }
+ */
bytecode
}
@@ -74,84 +74,82 @@ impl ProcedureCompiler {
pub fn compile_statement(mut self, statement: &Statement) -> Self {
match statement {
- Statement::Assignment{ var_id, val_expr } => {
+ Statement::Assignment { var_id, val_expr } => {
self = self.compile(val_expr);
match self.symbols.read().unwrap().get(var_id) {
- Some(SymbolDef::FrameRef{ typ, stack_ref }) => {
- self.asm = self.asm
- .lit(stack_ref)
- .call("data-frame-set");
+ Some(SymbolDef::FrameRef { typ, stack_ref }) => {
+ self.asm = self.asm.lit(stack_ref).call("data-frame-set");
}
- Some(SymbolDef::StaticRef{ typ, link_addr }) => {
- self.asm = self.asm
- .static_ref( var_id.as_str() )
- .inst( tisc::VM_Instruction::Store );
+ Some(SymbolDef::StaticRef { typ, link_addr }) => {
+ self.asm = self
+ .asm
+ .static_ref(var_id.as_str())
+ .inst(tisc::VM_Instruction::Store);
}
- Some(SymbolDef::Procedure{ in_types, out_types, link_addr }) => {
- self.asm = self.asm
- .call( var_id.as_str() )
- .inst( tisc::VM_Instruction::Store );
+ Some(SymbolDef::Procedure {
+ in_types,
+ out_types,
+ link_addr,
+ }) => {
+ self.asm = self
+ .asm
+ .call(var_id.as_str())
+ .inst(tisc::VM_Instruction::Store);
}
None => {
eprintln!("cannot assign undefined symbol '{}'!", var_id);
}
}
}
- Statement::LetAssign{ typ, var_id, val_expr } => {
- match val_expr {
- LTExpr::Abstraction { args:_, body:_ } => {
- self.symbols.write().unwrap()
- .declare_proc(
- var_id.clone(),
- vec![],vec![]
- );
- let lambda_procedure =
- ProcedureCompiler::new(&self.symbols)
- .compile( val_expr )
- .into_asm( var_id );
+ Statement::LetAssign {
+ typ,
+ var_id,
+ val_expr,
+ } => match val_expr {
+ LTExpr::Abstraction { args: _, body: _ } => {
+ self.symbols
+ .write()
+ .unwrap()
+ .declare_proc(var_id.clone(), vec![], vec![]);
+ let lambda_procedure = ProcedureCompiler::new(&self.symbols)
+ .compile(val_expr)
+ .into_asm(var_id);
- self.linker.add_procedure(
- var_id,
- lambda_procedure
- );
- }
- _ => {
- self.symbols.write().unwrap()
- .declare_var(
- var_id.clone(),
- laddertypes::TypeTerm::unit()
- );
- self = self.compile_statement(
- &Statement::Assignment {
- var_id: var_id.clone(),
- val_expr: val_expr.clone()
- }
- );
- }
+ self.linker.add_procedure(var_id, lambda_procedure);
}
- }
+ _ => {
+ self.symbols
+ .write()
+ .unwrap()
+ .declare_var(var_id.clone(), laddertypes::TypeTerm::unit());
+ self = self.compile_statement(&Statement::Assignment {
+ var_id: var_id.clone(),
+ val_expr: val_expr.clone(),
+ });
+ }
+ },
Statement::WhileLoop { condition, body } => {
let asm = self.asm;
self.asm = tisc::Assembler::new();
- self = self.compile( condition );
+ self = self.compile(condition);
let cond_asm = self.asm;
self.asm = tisc::Assembler::new();
for statement in body.into_iter() {
- self = self.compile_statement( statement );
+ self = self.compile_statement(statement);
}
let body_asm = self.asm;
self.asm = asm;
self.asm = self.asm.while_loop(cond_asm, body_asm);
}
- Statement::Expr( expr ) => {
- self = self.compile( expr );
+ Statement::Expr(expr) => {
+ self = self.compile(expr);
}
- Statement::Return( expr ) => {
- self = self.compile( expr );
+ Statement::Return(expr) => {
+ self = self.compile(expr);
}
}
self
@@ -159,26 +157,26 @@ impl ProcedureCompiler {
pub fn compile(mut self, expr: <Expr) -> Self {
match expr {
- LTExpr::Symbol { typ, symbol } => {
- match self.symbols.read().unwrap().get(symbol) {
- Some(SymbolDef::FrameRef{ typ, stack_ref }) => {
- self.asm = self.asm
- .lit( stack_ref )
- .call("data-frame-get");
- }
- Some(SymbolDef::StaticRef{ typ, link_addr }) => {
- self.asm = self.asm.static_ref( symbol.as_str() );
- }
- Some(SymbolDef::Procedure{ in_types, out_types, link_addr }) => {
- self.asm = self.asm.call( symbol.as_str() );
- }
- None => {
- eprintln!("undefined symbol '{}'!", symbol);
- }
+ LTExpr::Symbol { typ, symbol } => match self.symbols.read().unwrap().get(symbol) {
+ Some(SymbolDef::FrameRef { typ, stack_ref }) => {
+ self.asm = self.asm.lit(stack_ref).call("data-frame-get");
}
- }
+ Some(SymbolDef::StaticRef { typ, link_addr }) => {
+ self.asm = self.asm.static_ref(symbol.as_str());
+ }
+ Some(SymbolDef::Procedure {
+ in_types,
+ out_types,
+ link_addr,
+ }) => {
+ self.asm = self.asm.call(symbol.as_str());
+ }
+ None => {
+ eprintln!("undefined symbol '{}'!", symbol);
+ }
+ },
LTExpr::Literal { typ, val } => {
- self.asm = self.asm.lit( *val );
+ self.asm = self.asm.lit(*val);
}
LTExpr::Application { typ, head, body } => {
for arg in body.iter().rev() {
@@ -189,33 +187,34 @@ impl ProcedureCompiler {
LTExpr::Abstraction { args, body } => {
for (arg_name, arg_type) in args.iter() {
if let Some(Ok(typeterm)) = arg_type {
- let id = self.symbols
- .write().unwrap()
- .declare_var(
- arg_name.clone(),
- typeterm.clone()
- );
- self.asm = self.asm
- .lit( id )
- .call("data-frame-set");
+ let id = self
+ .symbols
+ .write()
+ .unwrap()
+ .declare_var(arg_name.clone(), typeterm.clone());
+ self.asm = self.asm.lit(id).call("data-frame-set");
} else {
eprintln!("invalid type {:?} for argument {}", arg_type, arg_name);
}
}
self = self.compile(body);
}
- LTExpr::Branch { condition, if_expr, else_expr } => {
+ LTExpr::Branch {
+ condition,
+ if_expr,
+ else_expr,
+ } => {
self = self.compile(condition);
let asm = self.asm;
self.asm = tisc::Assembler::new();
- self = self.compile( if_expr );
+ self = self.compile(if_expr);
let if_asm = self.asm;
self.asm = tisc::Assembler::new();
- self = self.compile( else_expr );
+ self = self.compile(else_expr);
let else_asm = self.asm;
self.asm = asm;
- self.asm = self.asm.branch( if_asm, else_asm );
+ self.asm = self.asm.branch(if_asm, else_asm);
}
LTExpr::Block { statements } => {
for s in statements.iter() {
@@ -226,4 +225,3 @@ impl ProcedureCompiler {
self
}
}
-
diff --git a/src/runtime.rs b/src/runtime.rs
index 3554ecd..97a13f1 100644
--- a/src/runtime.rs
+++ b/src/runtime.rs
@@ -1,14 +1,10 @@
use {
+ crate::{expr::LTExpr, procedure_compiler::ProcedureCompiler, symbols::Scope},
std::sync::{Arc, RwLock},
- crate::{
- expr::LTExpr,
- symbols::Scope,
- procedure_compiler::ProcedureCompiler
- },
- tisc::linker::Linker
+ tisc::linker::Linker,
};
-pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
+pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
let symbols = Scope::new();
let typectx = symbols.read().unwrap().typectx.clone();
@@ -17,26 +13,33 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
*/
symbols.write().unwrap().declare_proc_parse(
"dup",
- vec![ "T" ],
- vec![ "T~machine::Word" ],
- vec![ "T~machine::Word",
- "T~machine::Word" ]
+ vec!["T"],
+ vec!["T~machine::Word"],
+ vec!["T~machine::Word", "T~machine::Word"],
);
- linker.add_procedure("dup", tisc::Assembler::new().inst( tisc::VM_Instruction::Dup ).build());
-
+ linker.add_procedure(
+ "dup",
+ tisc::Assembler::new()
+ .inst(tisc::VM_Instruction::Dup)
+ .build(),
+ );
/* Put a single Ascii character on stdout
*/
symbols.write().unwrap().declare_proc_parse(
"emit",
vec![],
- vec![ "Char~Ascii~machine::Word" ],
- vec![]
+ vec!["Char~Ascii~machine::Word"],
+ vec![],
);
- linker.add_procedure("emit", tisc::Assembler::new().inst( tisc::VM_Instruction::Emit ).build());
-
+ linker.add_procedure(
+ "emit",
+ tisc::Assembler::new()
+ .inst(tisc::VM_Instruction::Emit)
+ .build(),
+ );
/* The top two items must be native u64 integers,
* which are replaced by their sum.
@@ -46,45 +49,49 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
symbols.write().unwrap().declare_proc_parse(
"i+",
vec![],
- vec![ "ℤ_2^64~machine::UInt64~machine::Word",
- "ℤ_2^64~machine::UInt64~machine::Word" ],
- vec![ "ℤ_2^64~machine::UInt64~machine::Word" ]
+ vec![
+ "ℤ_2^64~machine::UInt64~machine::Word",
+ "ℤ_2^64~machine::UInt64~machine::Word",
+ ],
+ vec!["ℤ_2^64~machine::UInt64~machine::Word"],
);
linker.add_procedure(
"i+",
tisc::Assembler::new()
- .inst( tisc::VM_Instruction::Add )
- .build()
+ .inst(tisc::VM_Instruction::Add)
+ .build(),
);
-
/* Floating-point Additionu
*/
symbols.write().unwrap().declare_proc_parse(
"f+",
vec![],
- vec![ "ℝ~machine::f64~machine::Word",
- "ℝ~machine::f64~machine::Word" ],
- vec![ "ℝ~machine::f64~machine::Word" ]
+ vec![
+ "ℝ~machine::f64~machine::Word",
+ "ℝ~machine::f64~machine::Word",
+ ],
+ vec!["ℝ~machine::f64~machine::Word"],
);
linker.add_procedure(
"f+",
tisc::Assembler::new()
- .inst( tisc::VM_Instruction::Addf )
- .build()
+ .inst(tisc::VM_Instruction::Addf)
+ .build(),
);
-
/* Integer Subtraction
*/
symbols.write().unwrap().declare_proc_parse(
"i-",
vec![],
- vec![ "ℤ_2^64~machine::UInt64~machine::Word",
- "ℤ_2^64~machine::UInt64~machine::Word" ],
- vec![ "ℤ_2^64~machine::UInt64~machine::Word" ]
+ vec![
+ "ℤ_2^64~machine::UInt64~machine::Word",
+ "ℤ_2^64~machine::UInt64~machine::Word",
+ ],
+ vec!["ℤ_2^64~machine::UInt64~machine::Word"],
);
linker.add_procedure(
"i-",
@@ -94,40 +101,40 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
.lit(1)
.inst(tisc::VM_Instruction::Add)
.inst(tisc::VM_Instruction::Add)
- .build()
+ .build(),
);
-
/* Fetch memory address
*/
- symbols.write().unwrap().declare_proc_parse("@",
+ symbols.write().unwrap().declare_proc_parse(
+ "@",
vec![],
- vec![ "<MutRef T~machine::Word>~machine::Address~machine::Word" ],
- vec![ "T~machine::Word" ]
+ vec!["<MutRef T~machine::Word>~machine::Address~machine::Word"],
+ vec!["T~machine::Word"],
);
linker.add_procedure(
"@",
tisc::Assembler::new()
- .inst( tisc::VM_Instruction::Fetch )
- .build()
+ .inst(tisc::VM_Instruction::Fetch)
+ .build(),
);
-
/* Store to memory
*/
- symbols.write().unwrap().declare_proc_parse("!",
+ symbols.write().unwrap().declare_proc_parse(
+ "!",
vec![],
vec![
"<MutRef T~machine::Word>~machine::Address~machine::Word",
- "T~machine::Word"
+ "T~machine::Word",
],
- vec![]
+ vec![],
);
linker.add_procedure(
"!",
tisc::Assembler::new()
- .inst( tisc::VM_Instruction::Store )
- .build()
+ .inst(tisc::VM_Instruction::Store)
+ .build(),
);
/*
@@ -143,133 +150,126 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
symbols.write().unwrap().declare_proc_parse(
"i*",
vec![],
- vec![ "ℤ_2^64~machine::UInt64~machine::Word",
- "ℤ_2^64~machine::UInt64~machine::Word" ],
- vec![ "ℤ_2^64~machine::UInt64~machine::Word" ]);
+ vec![
+ "ℤ_2^64~machine::UInt64~machine::Word",
+ "ℤ_2^64~machine::UInt64~machine::Word",
+ ],
+ vec!["ℤ_2^64~machine::UInt64~machine::Word"],
+ );
linker.add_procedure(
"i*",
tisc::Assembler::new()
.lit(0) // [ a b ] -- [ a b sum ]
-
.while_loop(
// condition
tisc::Assembler::new()
// [ a b sum ] -- [ a b sum b ]
- .lit( 2 )
- .inst( tisc::VM_Instruction::Pick ),
-
+ .lit(2)
+ .inst(tisc::VM_Instruction::Pick),
// body
tisc::Assembler::new()
// [ a b sum ] -- [ a b sum a ]
- .lit( 3 )
- .inst( tisc::VM_Instruction::Pick )
-
+ .lit(3)
+ .inst(tisc::VM_Instruction::Pick)
// [ a b sum a -- a b (sum+a) ]
- .inst( tisc::VM_Instruction::Add )
-
+ .inst(tisc::VM_Instruction::Add)
// [ a b sum -- a sum b ]
- .inst( tisc::VM_Instruction::Swap )
-
+ .inst(tisc::VM_Instruction::Swap)
// [ a sum b -- a sum b 1 ]
- .lit( 1 )
-
+ .lit(1)
// [ a sum b -- a sum (b-1) ]
- .inst( tisc::VM_Instruction::Swap )
- .call( "i-" )
-
+ .inst(tisc::VM_Instruction::Swap)
+ .call("i-")
// [ a sum b -- a b sum ]
- .inst( tisc::VM_Instruction::Swap )
+ .inst(tisc::VM_Instruction::Swap),
)
-
// [ a b sum -- a sum b ]
- .lit(2).inst(tisc::VM_Instruction::Roll)
+ .lit(2)
+ .inst(tisc::VM_Instruction::Roll)
// [ a sum b -- a sum ]
.inst(tisc::VM_Instruction::Drop)
-
// [ a sum -- sum a ]
- .lit(2).inst(tisc::VM_Instruction::Roll)
+ .lit(2)
+ .inst(tisc::VM_Instruction::Roll)
// [ sum a -- sum ]
.inst(tisc::VM_Instruction::Drop)
-
- .build()
+ .build(),
);
symbols.write().unwrap().declare_static_parse(
"data-frame-ptr",
- "<MutRef <Seq machine::Word>>~machine::Address~machine::Word"
+ "<MutRef <Seq machine::Word>>~machine::Address~machine::Word",
);
- linker.add_static("data-frame-ptr", vec![ 0x1000 ]);
+ linker.add_static("data-frame-ptr", vec![0x1000]);
symbols.write().unwrap().declare_proc_parse(
"data-frame-set",
vec!["T"],
- vec!["T~machine::Word",
- "<RefMut T~machine::Word>~LocalVariableId~machine::UInt64~machine::Word"],
- vec![]);
+ vec![
+ "T~machine::Word",
+ "<RefMut T~machine::Word>~LocalVariableId~machine::UInt64~machine::Word",
+ ],
+ vec![],
+ );
linker.add_procedure(
"data-frame-set",
tisc::Assembler::new()
.static_ref("data-frame-ptr")
- .inst( tisc::VM_Instruction::Fetch )
- .inst( tisc::VM_Instruction::Add )
- .inst( tisc::VM_Instruction::Store )
- .build()
+ .inst(tisc::VM_Instruction::Fetch)
+ .inst(tisc::VM_Instruction::Add)
+ .inst(tisc::VM_Instruction::Store)
+ .build(),
);
-
symbols.write().unwrap().declare_proc_parse(
"data-frame-get",
vec!["T"],
vec!["<Ref T~machine::Word>~DataFrameRef~machine::UInt64~machine::Word"],
- vec!["T~machine::Word"]
+ vec!["T~machine::Word"],
);
linker.add_procedure(
"data-frame-get",
tisc::Assembler::new()
.static_ref("data-frame-ptr")
- .inst( tisc::VM_Instruction::Fetch )
- .inst( tisc::VM_Instruction::Add )
- .inst( tisc::VM_Instruction::Fetch )
- .build()
+ .inst(tisc::VM_Instruction::Fetch)
+ .inst(tisc::VM_Instruction::Add)
+ .inst(tisc::VM_Instruction::Fetch)
+ .build(),
);
-
- symbols.write().unwrap().declare_proc_parse(
- "data-frame-alloc",
- vec![],
- vec![],
- vec![]);
+ symbols
+ .write()
+ .unwrap()
+ .declare_proc_parse("data-frame-alloc", vec![], vec![], vec![]);
linker.add_procedure(
"data-frame-alloc",
tisc::Assembler::new()
.static_ref("data-frame-ptr")
- .inst( tisc::VM_Instruction::Fetch )
+ .inst(tisc::VM_Instruction::Fetch)
.call("i-")
.static_ref("data-frame-ptr")
- .inst( tisc::VM_Instruction::Store )
- .build()
+ .inst(tisc::VM_Instruction::Store)
+ .build(),
);
- symbols.write().unwrap().declare_proc_parse(
- "data-frame-drop",
- vec![],
- vec![],
- vec![]);
+ symbols
+ .write()
+ .unwrap()
+ .declare_proc_parse("data-frame-drop", vec![], vec![], vec![]);
linker.add_procedure(
"data-frame-drop",
tisc::Assembler::new()
.static_ref("data-frame-ptr")
- .inst( tisc::VM_Instruction::Fetch )
+ .inst(tisc::VM_Instruction::Fetch)
.call("i+")
.static_ref("data-frame-ptr")
- .inst( tisc::VM_Instruction::Store )
- .build()
+ .inst(tisc::VM_Instruction::Store)
+ .build(),
);
symbols
}
-
diff --git a/src/symbols.rs b/src/symbols.rs
index 34a2669..673643f 100644
--- a/src/symbols.rs
+++ b/src/symbols.rs
@@ -1,9 +1,9 @@
use {
+ crate::expr::LTExpr,
std::{
collections::HashMap,
sync::{Arc, RwLock},
},
- crate::expr::LTExpr
};
#[derive(Clone, Debug)]
@@ -14,27 +14,36 @@ pub enum SymbolDef {
},
StaticRef {
typ: laddertypes::TypeTerm,
- link_addr: Option< tisc::VM_Word >
+ link_addr: Option<tisc::VM_Word>,
},
Procedure {
- in_types: Vec< laddertypes::TypeTerm >,
- out_types: Vec< laddertypes::TypeTerm >,
- link_addr: Option< tisc::VM_Word >
- }
+ in_types: Vec<laddertypes::TypeTerm>,
+ out_types: Vec<laddertypes::TypeTerm>,
+ link_addr: Option<tisc::VM_Word>,
+ },
}
impl SymbolDef {
- pub fn get_type(&self, typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>) -> laddertypes::TypeTerm {
+ pub fn get_type(
+ &self,
+ typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
+ ) -> laddertypes::TypeTerm {
match self {
- SymbolDef::FrameRef { typ, stack_ref:_ } => typ.clone(),
- SymbolDef::StaticRef { typ, link_addr:_ } => typ.clone(),
- SymbolDef::Procedure { in_types, out_types, link_addr: _ } => {
- laddertypes::TypeTerm::App(vec![
- typectx.write().unwrap().parse("Fn").expect("parse typeterm"),
- laddertypes::TypeTerm::App( in_types.clone() ),
- laddertypes::TypeTerm::App( out_types.clone() )
- ])
- }
+ SymbolDef::FrameRef { typ, stack_ref: _ } => typ.clone(),
+ SymbolDef::StaticRef { typ, link_addr: _ } => typ.clone(),
+ SymbolDef::Procedure {
+ in_types,
+ out_types,
+ link_addr: _,
+ } => laddertypes::TypeTerm::App(vec![
+ typectx
+ .write()
+ .unwrap()
+ .parse("Fn")
+ .expect("parse typeterm"),
+ laddertypes::TypeTerm::App(in_types.clone()),
+ laddertypes::TypeTerm::App(out_types.clone()),
+ ]),
}
}
}
@@ -44,7 +53,7 @@ impl SymbolDef {
pub struct Scope {
/* definition of runtime symbols
*/
- symbols: HashMap< String, SymbolDef >,
+ symbols: HashMap<String, SymbolDef>,
/* type symbols
*/
@@ -57,17 +66,17 @@ pub struct Scope {
/* parent scope whose all
* symbols are inherited
- */
- parent: Option< Arc<RwLock<Scope>> >
+ */
+ parent: Option<Arc<RwLock<Scope>>>,
}
impl Scope {
pub fn new() -> Arc<RwLock<Self>> {
Arc::new(RwLock::new(Scope {
symbols: HashMap::new(),
- typectx: Arc::new(RwLock::new( laddertypes::dict::TypeDict::new() )),
+ typectx: Arc::new(RwLock::new(laddertypes::dict::TypeDict::new())),
frame_size: 0,
- parent: None
+ parent: None,
}))
}
@@ -90,17 +99,16 @@ impl Scope {
}
pub fn get(&self, name: &str) -> Option<SymbolDef> {
- match self.symbols.get(name) {
+ match self.symbols.get(name) {
Some(def) => Some(def.clone()),
None => {
if let Some(parent) = self.parent.as_ref() {
- match parent.read().unwrap().get( name ) {
- Some(SymbolDef::FrameRef {
- typ, stack_ref
- }) => Some(SymbolDef::FrameRef {
- typ: typ.clone(), stack_ref: stack_ref + self.get_frame_size() as i64
+ match parent.read().unwrap().get(name) {
+ Some(SymbolDef::FrameRef { typ, stack_ref }) => Some(SymbolDef::FrameRef {
+ typ: typ.clone(),
+ stack_ref: stack_ref + self.get_frame_size() as i64,
}),
- x => x.clone()
+ x => x.clone(),
}
} else {
None
@@ -108,27 +116,28 @@ impl Scope {
}
}
}
-/*
- pub fn get_link_addr(&self, name: &str) -> Option<tisc::VM_Word> {
- match self.get(name) {
- Some(SymbolDef::Procedure{ in_types:_, out_types:_, link_addr }) => {
- link_addr
+ /*
+ pub fn get_link_addr(&self, name: &str) -> Option<tisc::VM_Word> {
+ match self.get(name) {
+ Some(SymbolDef::Procedure{ in_types:_, out_types:_, link_addr }) => {
+ link_addr
+ }
+ Some(SymbolDef::StaticRef { typ:_, link_addr }) => {
+ link_addr
+ }
+ Some(SymbolDef::FrameRef { typ:_, stack_ref:_ }) => None,
+ None => None
}
- Some(SymbolDef::StaticRef { typ:_, link_addr }) => {
- link_addr
- }
- Some(SymbolDef::FrameRef { typ:_, stack_ref:_ }) => None,
- None => None
}
- }
-*/
+ */
//<><><><><><>
- pub fn declare_proc_parse(&mut self,
+ pub fn declare_proc_parse(
+ &mut self,
name: &str,
type_vars: Vec<&str>,
in_types: Vec<&str>,
- out_types: Vec<&str>
+ out_types: Vec<&str>,
) {
for v in type_vars {
self.typectx.write().unwrap().add_varname(v.into());
@@ -136,70 +145,86 @@ impl Scope {
self.declare_proc(
String::from(name),
- in_types.into_iter().map(|t| self.typectx.write().unwrap().parse(t).expect("parse typeterm")).collect(),
- out_types.into_iter().map(|t| self.typectx.write().unwrap().parse(t).expect("parse typeterm")).collect()
+ in_types
+ .into_iter()
+ .map(|t| {
+ self.typectx
+ .write()
+ .unwrap()
+ .parse(t)
+ .expect("parse typeterm")
+ })
+ .collect(),
+ out_types
+ .into_iter()
+ .map(|t| {
+ self.typectx
+ .write()
+ .unwrap()
+ .parse(t)
+ .expect("parse typeterm")
+ })
+ .collect(),
);
}
- pub fn declare_proc(&mut self,
+ pub fn declare_proc(
+ &mut self,
name: String,
- in_types: Vec< laddertypes::TypeTerm >,
- out_types: Vec< laddertypes::TypeTerm >
+ in_types: Vec<laddertypes::TypeTerm>,
+ out_types: Vec<laddertypes::TypeTerm>,
) {
- self.symbols.insert(name, SymbolDef::Procedure {
- link_addr: None,//LinkAddr::Relative{ name, offset: 0 },
- in_types,
- out_types
- });
+ self.symbols.insert(
+ name,
+ SymbolDef::Procedure {
+ link_addr: None, //LinkAddr::Relative{ name, offset: 0 },
+ in_types,
+ out_types,
+ },
+ );
}
//<><><><><>
- pub fn declare_var_parse(&mut self,
- name: &str,
- typ: &str
- ) {
- let typ = self.typectx.write().unwrap().parse(typ).expect("parse typeterm");
- self.declare_var(
- String::from(name),
- typ
- );
+ pub fn declare_var_parse(&mut self, name: &str, typ: &str) {
+ let typ = self
+ .typectx
+ .write()
+ .unwrap()
+ .parse(typ)
+ .expect("parse typeterm");
+ self.declare_var(String::from(name), typ);
}
pub fn declare_var(&mut self, name: String, typ: laddertypes::TypeTerm) -> tisc::VM_Word {
let stack_ref = self.frame_size as tisc::VM_Word;
self.frame_size += 1;
- self.symbols.insert(name, SymbolDef::FrameRef {
- typ,
- stack_ref
- });
+ self.symbols
+ .insert(name, SymbolDef::FrameRef { typ, stack_ref });
stack_ref
}
//<><><><><><>
- pub fn declare_static_parse(
- &mut self,
- name: &str,
- typ: &str
- ) {
- let typ = self.typectx
- .write().unwrap()
- .parse(typ).expect("parse typeterm");
+ pub fn declare_static_parse(&mut self, name: &str, typ: &str) {
+ let typ = self
+ .typectx
+ .write()
+ .unwrap()
+ .parse(typ)
+ .expect("parse typeterm");
self.declare_static(String::from(name), typ);
}
- pub fn declare_static(
- &mut self,
- name: String,
- typ: laddertypes::TypeTerm
- ) {
- self.symbols.insert(name, SymbolDef::StaticRef {
- typ,
- link_addr: None
- });
+ pub fn declare_static(&mut self, name: String, typ: laddertypes::TypeTerm) {
+ self.symbols.insert(
+ name,
+ SymbolDef::StaticRef {
+ typ,
+ link_addr: None,
+ },
+ );
}
}
-