Compare commits
5 commits
09e9e063ae
...
f54f630b38
Author | SHA1 | Date | |
---|---|---|---|
f54f630b38 | |||
a6282c00eb | |||
e23d8257d0 | |||
d7c06d423e | |||
ebc5f720bf |
6 changed files with 608 additions and 217 deletions
42
src/expr.rs
42
src/expr.rs
|
@ -12,6 +12,10 @@ pub enum Statement {
|
||||||
var_id: String,
|
var_id: String,
|
||||||
val_expr: LTExpr
|
val_expr: LTExpr
|
||||||
},
|
},
|
||||||
|
LetAssign {
|
||||||
|
var_id: String,
|
||||||
|
val_expr: LTExpr,
|
||||||
|
},
|
||||||
WhileLoop {
|
WhileLoop {
|
||||||
condition: LTExpr,
|
condition: LTExpr,
|
||||||
body: Vec<Statement>
|
body: Vec<Statement>
|
||||||
|
@ -23,11 +27,11 @@ pub enum Statement {
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub enum LTExpr {
|
pub enum LTExpr {
|
||||||
Literal {
|
Literal {
|
||||||
typ: laddertypes::TypeTerm,
|
typ: Option< laddertypes::TypeTerm >,
|
||||||
val: tisc::VM_Word
|
val: tisc::VM_Word
|
||||||
},
|
},
|
||||||
Symbol {
|
Symbol {
|
||||||
typ: laddertypes::TypeTerm,
|
typ: Option< laddertypes::TypeTerm >,
|
||||||
symbol: String,
|
symbol: String,
|
||||||
},
|
},
|
||||||
Application {
|
Application {
|
||||||
|
@ -35,13 +39,7 @@ pub enum LTExpr {
|
||||||
body: Vec<LTExpr>
|
body: Vec<LTExpr>
|
||||||
},
|
},
|
||||||
Abstraction {
|
Abstraction {
|
||||||
arg_id: String,
|
args: Vec<(String, Option<laddertypes::TypeTerm>)>,
|
||||||
arg_type: laddertypes::TypeTerm,
|
|
||||||
val_expr: Box<LTExpr>
|
|
||||||
},
|
|
||||||
Let {
|
|
||||||
name: String,
|
|
||||||
val: Box<LTExpr>,
|
|
||||||
body: Box<LTExpr>
|
body: Box<LTExpr>
|
||||||
},
|
},
|
||||||
Branch {
|
Branch {
|
||||||
|
@ -55,33 +53,27 @@ pub enum LTExpr {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl LTExpr {
|
impl LTExpr {
|
||||||
pub fn symbol(typectx: &Arc<RwLock<laddertypes::TypeDict>>, str: &str) -> Self {
|
pub fn symbol(str: &str) -> Self {
|
||||||
LTExpr::Symbol {
|
LTExpr::Symbol {
|
||||||
typ: typectx.write().unwrap().parse("<Ref memory::Word>~Symbol~<Seq Char>").expect("parse typeterm"),
|
typ: None,//typectx.write().unwrap().parse("<Ref memory::Word>~Symbol~<Seq Char>").expect("parse typeterm"),
|
||||||
symbol: String::from(str)
|
symbol: String::from(str)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn lit_uint(typectx: &Arc<RwLock<laddertypes::TypeDict>>, val: u64) -> Self {
|
pub fn lit_uint(val: u64) -> Self {
|
||||||
LTExpr::Literal {
|
LTExpr::Literal {
|
||||||
typ: typectx.write().unwrap().parse("ℤ_2^64~machine::UInt64~machine::Word").expect("parse typeterm"),
|
typ: None,//typectx.write().unwrap().parse("ℤ_2^64~machine::UInt64~machine::Word").expect("parse typeterm"),
|
||||||
val: val as tisc::VM_Word
|
val: val as tisc::VM_Word
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn abstraction(typectx: &Arc<RwLock<laddertypes::TypeDict>>, arg_id: &str, arg_typ: &str, val_expr: LTExpr) -> LTExpr {
|
pub fn abstraction(args: Vec<(&str, &str)>, val_expr: LTExpr) -> LTExpr {
|
||||||
LTExpr::Abstraction {
|
LTExpr::Abstraction {
|
||||||
arg_id: String::from(arg_id),
|
args: args.into_iter().map(|(arg_name, arg_type)|
|
||||||
arg_type: typectx.write().unwrap().parse(arg_typ).expect("parse typeterm"),
|
( arg_name.into(), None )
|
||||||
val_expr: Box::new(val_expr)
|
//typectx.write().unwrap().parse(t).expect("parse typeterm")
|
||||||
}
|
).collect(),
|
||||||
}
|
body: Box::new(val_expr)
|
||||||
|
|
||||||
pub fn let_expr(typectx: &Arc<RwLock<laddertypes::TypeDict>>, name: &str, val: LTExpr, body: LTExpr) -> Self {
|
|
||||||
LTExpr::Let {
|
|
||||||
name: String::from(name),
|
|
||||||
val: Box::new(val),
|
|
||||||
body: Box::new(body)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
186
src/lexer.rs
Normal file
186
src/lexer.rs
Normal file
|
@ -0,0 +1,186 @@
|
||||||
|
|
||||||
|
#[derive(PartialEq, Eq, Clone, Debug)]
|
||||||
|
pub enum LTIRToken {
|
||||||
|
Symbol( String ),
|
||||||
|
Char( char ),
|
||||||
|
Num( i64 ),
|
||||||
|
|
||||||
|
// SingleQuote(String),
|
||||||
|
// DoubleQuote(String),
|
||||||
|
// TripleQuote(String),
|
||||||
|
|
||||||
|
Lambda,
|
||||||
|
AssignType,
|
||||||
|
AssignValue,
|
||||||
|
|
||||||
|
ExprOpen,
|
||||||
|
ExprClose,
|
||||||
|
|
||||||
|
BlockOpen,
|
||||||
|
BlockClose,
|
||||||
|
StatementSep,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(PartialEq, Eq, Clone, Debug)]
|
||||||
|
pub enum LexError {
|
||||||
|
InvalidDigit,
|
||||||
|
InvalidChar
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(PartialEq, Eq, Clone, Debug)]
|
||||||
|
pub enum LexerState {
|
||||||
|
Any,
|
||||||
|
Sym( String ),
|
||||||
|
Num( i64 ),
|
||||||
|
Char( Option<char> )
|
||||||
|
}
|
||||||
|
|
||||||
|
impl LexerState {
|
||||||
|
fn into_token(self) -> Option< LTIRToken > {
|
||||||
|
match self {
|
||||||
|
LexerState::Any => None,
|
||||||
|
LexerState::Sym(s) => Some(LTIRToken::Symbol(s)),
|
||||||
|
LexerState::Num(n) => Some(LTIRToken::Num(n)),
|
||||||
|
LexerState::Char(c) => Some(LTIRToken::Char(c?))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
pub struct LTIRLexer<It>
|
||||||
|
where It: std::iter::Iterator<Item = char>
|
||||||
|
{
|
||||||
|
chars: std::iter::Peekable<It>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<It> LTIRLexer<It>
|
||||||
|
where It: Iterator<Item = char>
|
||||||
|
{
|
||||||
|
pub fn into_inner(self) -> std::iter::Peekable<It> {
|
||||||
|
self.chars
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<It> From<It> for LTIRLexer<It>
|
||||||
|
where It: Iterator<Item = char>
|
||||||
|
{
|
||||||
|
fn from(chars: It) -> Self {
|
||||||
|
LTIRLexer {
|
||||||
|
chars: chars.peekable()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<It> Iterator for LTIRLexer<It>
|
||||||
|
where It: Iterator<Item = char>
|
||||||
|
{
|
||||||
|
type Item = Result<LTIRToken, LexError>;
|
||||||
|
|
||||||
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
|
let mut state = LexerState::Any;
|
||||||
|
|
||||||
|
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::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(); return Some(Ok(LTIRToken::AssignType)); },
|
||||||
|
'=' => { 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() );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
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));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
_ => {
|
||||||
|
|
||||||
|
if c.is_whitespace()
|
||||||
|
|| *c == '(' || *c == ')'
|
||||||
|
|| *c == '{' || *c == '}'
|
||||||
|
|| *c == ';' || *c == '=' || *c == ':'
|
||||||
|
{
|
||||||
|
// finish the current token
|
||||||
|
|
||||||
|
if let Some(token) = state.clone().into_token() {
|
||||||
|
return Some(Ok(token));
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// append to the current token
|
||||||
|
|
||||||
|
let c = self.chars.next().unwrap();
|
||||||
|
|
||||||
|
match &mut state {
|
||||||
|
LexerState::Sym(s) => {
|
||||||
|
s.push(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
LexerState::Num(n) => {
|
||||||
|
if let Some(d) = c.to_digit(10) {
|
||||||
|
*n = (*n) * 10 + d as i64;
|
||||||
|
} else {
|
||||||
|
return Some(Err(LexError::InvalidDigit));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if let Some(token) = state.into_token() {
|
||||||
|
Some(Ok(token))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
186
src/main.rs
186
src/main.rs
|
@ -8,6 +8,8 @@ mod expr;
|
||||||
mod symbols;
|
mod symbols;
|
||||||
mod procedure_compiler;
|
mod procedure_compiler;
|
||||||
mod runtime;
|
mod runtime;
|
||||||
|
mod lexer;
|
||||||
|
mod parser;
|
||||||
|
|
||||||
use crate::{
|
use crate::{
|
||||||
expr::{LTExpr, Statement},
|
expr::{LTExpr, Statement},
|
||||||
|
@ -15,6 +17,18 @@ use crate::{
|
||||||
procedure_compiler::ProcedureCompiler
|
procedure_compiler::ProcedureCompiler
|
||||||
};
|
};
|
||||||
|
|
||||||
|
fn compile(scope: &Arc<RwLock<Scope>>, name: &str, source: &str) -> Vec< tisc::assembler::AssemblyWord > {
|
||||||
|
ProcedureCompiler::new(scope)
|
||||||
|
.compile(
|
||||||
|
&parser::parse_expr(
|
||||||
|
&mut lexer::LTIRLexer::from(
|
||||||
|
source.chars().peekable()
|
||||||
|
).peekable()
|
||||||
|
).expect("syntax error")
|
||||||
|
)
|
||||||
|
.into_asm(&name.into())
|
||||||
|
}
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
// create virtual machine with 4096 words of memory
|
// create virtual machine with 4096 words of memory
|
||||||
let mut vm = tisc::VM::new(0x1000);
|
let mut vm = tisc::VM::new(0x1000);
|
||||||
|
@ -22,7 +36,6 @@ fn main() {
|
||||||
let mut linker = tisc::Linker::new();
|
let mut linker = tisc::Linker::new();
|
||||||
let root_scope = crate::runtime::init_runtime(&mut linker);
|
let root_scope = crate::runtime::init_runtime(&mut linker);
|
||||||
let main_scope = Scope::with_parent(&root_scope);
|
let main_scope = Scope::with_parent(&root_scope);
|
||||||
|
|
||||||
let typectx = main_scope.read().unwrap().typectx.clone();
|
let typectx = main_scope.read().unwrap().typectx.clone();
|
||||||
|
|
||||||
/* define type of the symbol
|
/* define type of the symbol
|
||||||
|
@ -37,137 +50,62 @@ fn main() {
|
||||||
);
|
);
|
||||||
|
|
||||||
main_scope.write().unwrap()
|
main_scope.write().unwrap()
|
||||||
.declare_proc_parse(
|
.declare_static_parse(
|
||||||
"print-nullterm",
|
"pfxstr",
|
||||||
vec![],
|
"<Seq Char
|
||||||
vec![
|
~Ascii
|
||||||
"<Ref <Seq Char~Ascii~machine::Word>~<NullTerminatedSeq machine::Word>>
|
~machine::Word>
|
||||||
~machine::Address
|
~<LengthPrefixedSeq machine::Word>"
|
||||||
~machine::Word"
|
|
||||||
],
|
|
||||||
vec![]);
|
|
||||||
|
|
||||||
/* link assembly-program to symbol
|
|
||||||
*/
|
|
||||||
linker.add_procedure(
|
|
||||||
"main",
|
|
||||||
ProcedureCompiler::new(&main_scope)
|
|
||||||
.compile(
|
|
||||||
<Expr::block(vec![
|
|
||||||
Statement::Expr(
|
|
||||||
LTExpr::application(
|
|
||||||
LTExpr::abstraction(
|
|
||||||
&typectx,
|
|
||||||
"c",
|
|
||||||
"Char",
|
|
||||||
LTExpr::block(vec![
|
|
||||||
Statement::Expr(LTExpr::application(
|
|
||||||
LTExpr::symbol(&typectx, "emit"),
|
|
||||||
vec![
|
|
||||||
LTExpr::symbol(&typectx, "c")
|
|
||||||
]
|
|
||||||
)),
|
|
||||||
Statement::Assignment{
|
|
||||||
var_id: "c".into(),
|
|
||||||
val_expr: LTExpr::application(
|
|
||||||
LTExpr::symbol(&typectx, "i+"),
|
|
||||||
vec![
|
|
||||||
LTExpr::symbol(&typectx, "c"),
|
|
||||||
LTExpr::lit_uint(&typectx, 1)
|
|
||||||
]
|
|
||||||
)
|
|
||||||
},
|
|
||||||
Statement::Expr(LTExpr::application(
|
|
||||||
LTExpr::symbol(&typectx, "emit"),
|
|
||||||
vec![
|
|
||||||
LTExpr::symbol(&typectx, "c")
|
|
||||||
]
|
|
||||||
))
|
|
||||||
])
|
|
||||||
),
|
|
||||||
vec![
|
|
||||||
LTExpr::lit_uint(&typectx, 42)
|
|
||||||
]
|
|
||||||
)),
|
|
||||||
Statement::Expr(
|
|
||||||
LTExpr::application(
|
|
||||||
LTExpr::symbol(&typectx, "emit"),
|
|
||||||
vec![
|
|
||||||
LTExpr::lit_uint(&typectx, 10)
|
|
||||||
]
|
|
||||||
))
|
|
||||||
])
|
|
||||||
)
|
|
||||||
.into_asm()
|
|
||||||
.build()
|
|
||||||
);
|
);
|
||||||
|
|
||||||
|
/* link assembly-program to symbols
|
||||||
|
*/
|
||||||
|
linker.add_procedure("main", compile(&main_scope,
|
||||||
|
"main",
|
||||||
|
"{
|
||||||
|
let print-nullterm = λstr {
|
||||||
|
while (@ str) {
|
||||||
|
emit (@ str);
|
||||||
|
! str (i+ str 1);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let print-lenprefix = λstr {
|
||||||
|
let len = (@ str);
|
||||||
|
! str (i+ str 1);
|
||||||
|
let end = (i+ str len);
|
||||||
|
while (i- str end) {
|
||||||
|
emit (@ str);
|
||||||
|
! str (i+ str 1);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let hello = λ{
|
||||||
|
print-nullterm hello-string;
|
||||||
|
print-lenprefix pfxstr;
|
||||||
|
};
|
||||||
|
|
||||||
|
hello;
|
||||||
|
|
||||||
|
let isquare = λx (i* x x);
|
||||||
|
let magnitude2 = λx y {
|
||||||
|
i+ (isquare x) (isquare y);
|
||||||
|
};
|
||||||
|
magnitude2 8 16;
|
||||||
|
|
||||||
|
emit '\n';
|
||||||
|
emit (i+ '0' (isquare 3));
|
||||||
|
emit '\n';
|
||||||
|
}"));
|
||||||
|
|
||||||
linker.add_static("hello-string",
|
linker.add_static("hello-string",
|
||||||
"Hallo Welt!\n\0"
|
"Hallo Welt!\n\0"
|
||||||
.chars()
|
.chars()
|
||||||
.map(|c| (c as u8) as tisc::VM_Word)
|
.map(|c| (c as u8) as tisc::VM_Word)
|
||||||
.collect());
|
.collect());
|
||||||
|
|
||||||
linker.add_procedure(
|
linker.add_static("pfxstr",
|
||||||
"print-nullterm",
|
vec![ 3, 'a' as tisc::VM_Word, 'b' as tisc::VM_Word, 'c' as tisc::VM_Word, 'd' as tisc::VM_Word ]
|
||||||
tisc::Assembler::new()
|
|
||||||
.while_loop(
|
|
||||||
tisc::Assembler::new()
|
|
||||||
.inst( tisc::VM_Instruction::Dup )
|
|
||||||
.inst( tisc::VM_Instruction::Fetch )
|
|
||||||
.inst( tisc::VM_Instruction::Dup ),
|
|
||||||
|
|
||||||
tisc::Assembler::new()
|
|
||||||
.inst( tisc::VM_Instruction::Emit )
|
|
||||||
.lit( 1 )
|
|
||||||
.inst( tisc::VM_Instruction::Add )
|
|
||||||
)
|
|
||||||
.inst( tisc::VM_Instruction::Drop )
|
|
||||||
.inst( tisc::VM_Instruction::Drop )
|
|
||||||
.build()
|
|
||||||
);
|
|
||||||
|
|
||||||
main_scope.write().unwrap().declare_proc_parse(
|
|
||||||
"print-lenprefix",
|
|
||||||
vec![],
|
|
||||||
vec![
|
|
||||||
"<Ref <Seq Char~Ascii~machine::Word>~<LengthPrefixedSeq machine::Word>>
|
|
||||||
~machine::Address
|
|
||||||
~machine::Word"
|
|
||||||
],
|
|
||||||
vec![]);
|
|
||||||
|
|
||||||
linker.add_procedure(
|
|
||||||
"print-lenprefix",
|
|
||||||
tisc::Assembler::new()
|
|
||||||
// calculate stop address
|
|
||||||
.inst( tisc::VM_Instruction::Dup )
|
|
||||||
.inst( tisc::VM_Instruction::Dup )
|
|
||||||
.inst( tisc::VM_Instruction::Fetch )
|
|
||||||
.lit(1)
|
|
||||||
.inst( tisc::VM_Instruction::Add )
|
|
||||||
.inst( tisc::VM_Instruction::Add )
|
|
||||||
.inst( tisc::VM_Instruction::Swap )
|
|
||||||
|
|
||||||
// emit until address == start address
|
|
||||||
.while_loop(
|
|
||||||
tisc::Assembler::new()
|
|
||||||
.lit( 2 )
|
|
||||||
.inst( tisc::VM_Instruction::Pick )
|
|
||||||
.lit( 2 )
|
|
||||||
.inst( tisc::VM_Instruction::Pick )
|
|
||||||
.call("i-"),
|
|
||||||
|
|
||||||
tisc::Assembler::new()
|
|
||||||
.inst( tisc::VM_Instruction::Dup )
|
|
||||||
.inst( tisc::VM_Instruction::Fetch )
|
|
||||||
.inst( tisc::VM_Instruction::Emit )
|
|
||||||
.lit( 1 )
|
|
||||||
.inst( tisc::VM_Instruction::Add )
|
|
||||||
)
|
|
||||||
.inst( tisc::VM_Instruction::Drop )
|
|
||||||
.inst( tisc::VM_Instruction::Drop )
|
|
||||||
.build()
|
|
||||||
);
|
);
|
||||||
|
|
||||||
let main_addr = linker.get_link_addr(&"main".into()).expect("'main' not linked");
|
let main_addr = linker.get_link_addr(&"main".into()).expect("'main' not linked");
|
||||||
|
|
255
src/parser.rs
Normal file
255
src/parser.rs
Normal file
|
@ -0,0 +1,255 @@
|
||||||
|
use {
|
||||||
|
std::iter::Peekable,
|
||||||
|
crate::{
|
||||||
|
lexer::{LTIRLexer, LTIRToken, LexError},
|
||||||
|
expr::{LTExpr, Statement}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub enum ParseError {
|
||||||
|
LexError(LexError),
|
||||||
|
UnexpectedClose,
|
||||||
|
UnexpectedEnd,
|
||||||
|
UnexpectedToken
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn parse_expect<It>(
|
||||||
|
tokens: &mut Peekable<LTIRLexer<It>>,
|
||||||
|
expected_token: LTIRToken
|
||||||
|
) -> Result< (), ParseError >
|
||||||
|
where It: Iterator<Item = char>
|
||||||
|
{
|
||||||
|
match tokens.next() {
|
||||||
|
Some(Ok(t)) => {
|
||||||
|
if t == expected_token {
|
||||||
|
Ok(())
|
||||||
|
} else {
|
||||||
|
Err(ParseError::UnexpectedToken)
|
||||||
|
}
|
||||||
|
},
|
||||||
|
Some(Err(err)) => Err(ParseError::LexError(err)),
|
||||||
|
None => Err(ParseError::UnexpectedEnd)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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),
|
||||||
|
Some(Ok(_)) => Err(ParseError::UnexpectedToken),
|
||||||
|
Some(Err(err)) => Err(ParseError::LexError(err)),
|
||||||
|
None => Err(ParseError::UnexpectedEnd),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn parse_statement<It>(
|
||||||
|
tokens: &mut Peekable<LTIRLexer<It>>
|
||||||
|
) -> Result< crate::expr::Statement, ParseError >
|
||||||
|
where It: Iterator<Item = char>
|
||||||
|
{
|
||||||
|
if let Some(peektok) = tokens.peek() {
|
||||||
|
match peektok {
|
||||||
|
Ok(LTIRToken::Symbol(sym)) => {
|
||||||
|
match sym.as_str() {
|
||||||
|
"!" => {
|
||||||
|
tokens.next();
|
||||||
|
// todo accept address-expression instead of symbol
|
||||||
|
let name = parse_symbol(tokens)?;
|
||||||
|
let val_expr = parse_expr(tokens)?;
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
|
||||||
|
|
||||||
|
Ok(Statement::Assignment {
|
||||||
|
var_id: name,
|
||||||
|
val_expr
|
||||||
|
})
|
||||||
|
}
|
||||||
|
"let" => {
|
||||||
|
tokens.next();
|
||||||
|
let name = parse_symbol(tokens)?;
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::AssignValue);
|
||||||
|
let val_expr = parse_expr(tokens)?;
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
|
||||||
|
|
||||||
|
Ok(Statement::LetAssign {
|
||||||
|
var_id: name,
|
||||||
|
val_expr
|
||||||
|
})
|
||||||
|
}
|
||||||
|
"while" => {
|
||||||
|
tokens.next();
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::ExprOpen)?;
|
||||||
|
let cond = parse_expr(tokens)?;
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
|
||||||
|
Ok(Statement::WhileLoop {
|
||||||
|
condition: cond,
|
||||||
|
body: parse_block(tokens)?
|
||||||
|
})
|
||||||
|
}
|
||||||
|
"return" => {
|
||||||
|
tokens.next();
|
||||||
|
let expr = parse_expr(tokens)?;
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
|
||||||
|
Ok(Statement::Return(parse_expr(tokens)?))
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
let expr = parse_expr(tokens)?;
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
|
||||||
|
Ok(Statement::Expr(expr))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(_) => {
|
||||||
|
let expr = parse_expr(tokens)?;
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
|
||||||
|
Ok(Statement::Expr(expr))
|
||||||
|
},
|
||||||
|
Err(err) => Err(ParseError::LexError(err.clone()))
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Err(ParseError::UnexpectedEnd)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn parse_block<It>(
|
||||||
|
tokens: &mut Peekable<LTIRLexer<It>>
|
||||||
|
) -> Result< Vec<Statement>, ParseError >
|
||||||
|
where It: Iterator<Item = char>
|
||||||
|
{
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::BlockOpen)?;
|
||||||
|
|
||||||
|
let mut statements = Vec::new();
|
||||||
|
while let Some(peektok) = tokens.peek() {
|
||||||
|
match peektok {
|
||||||
|
Ok(LTIRToken::BlockClose) => {
|
||||||
|
tokens.next();
|
||||||
|
return Ok(statements)
|
||||||
|
}
|
||||||
|
Ok(_) => { statements.push( parse_statement(tokens)? ); }
|
||||||
|
Err(err) => { return Err(ParseError::LexError(err.clone())); }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Err(ParseError::UnexpectedEnd)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn parse_atom<It>(
|
||||||
|
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)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn parse_expr<It>(
|
||||||
|
tokens: &mut Peekable<LTIRLexer<It>>
|
||||||
|
) -> Result< crate::expr::LTExpr, ParseError >
|
||||||
|
where It: Iterator<Item = char>
|
||||||
|
{
|
||||||
|
let mut children = Vec::new();
|
||||||
|
|
||||||
|
while let Some(tok) = tokens.peek() {
|
||||||
|
match tok {
|
||||||
|
Ok(LTIRToken::Lambda) => {
|
||||||
|
if children.len() == 0 {
|
||||||
|
tokens.next();
|
||||||
|
|
||||||
|
let mut args = Vec::new();
|
||||||
|
while let Some(Ok(LTIRToken::Symbol(_))) = tokens.peek() {
|
||||||
|
args.push((parse_symbol(tokens)?, None));
|
||||||
|
}
|
||||||
|
let body = parse_expr(tokens)?;
|
||||||
|
|
||||||
|
return Ok(LTExpr::Abstraction{
|
||||||
|
args,
|
||||||
|
body: Box::new(body)
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
return Err(ParseError::UnexpectedToken);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(LTIRToken::ExprOpen) => {
|
||||||
|
tokens.next();
|
||||||
|
while let Some(peektok) = tokens.peek() {
|
||||||
|
match peektok {
|
||||||
|
Ok(LTIRToken::ExprClose) => {
|
||||||
|
tokens.next();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
children.push(parse_expr(tokens)?);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
Ok(LTIRToken::ExprClose) => { break; }
|
||||||
|
Ok(LTIRToken::BlockOpen) => { children.push( LTExpr::block(parse_block(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(tokens)?;
|
||||||
|
let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
|
||||||
|
let if_expr = LTExpr::block(parse_block(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(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())); }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if children.len() > 0 {
|
||||||
|
let head = children.remove(0);
|
||||||
|
Ok(LTExpr::Application {
|
||||||
|
head: Box::new(head),
|
||||||
|
body: children
|
||||||
|
})
|
||||||
|
} else {
|
||||||
|
Err(ParseError::UnexpectedEnd)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
|
@ -4,6 +4,10 @@ use {
|
||||||
sync::{Arc, RwLock},
|
sync::{Arc, RwLock},
|
||||||
ops::Deref,
|
ops::Deref,
|
||||||
},
|
},
|
||||||
|
tisc::{
|
||||||
|
assembler::AssemblyWord,
|
||||||
|
linker::LinkAddr
|
||||||
|
},
|
||||||
crate::{
|
crate::{
|
||||||
expr::{LTExpr, Statement},
|
expr::{LTExpr, Statement},
|
||||||
symbols::{Scope, SymbolDef}
|
symbols::{Scope, SymbolDef}
|
||||||
|
@ -27,14 +31,41 @@ impl ProcedureCompiler {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn into_asm(self) -> tisc::Assembler {
|
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 data_frame_size = self.symbols.read().unwrap().get_frame_size() as i64;
|
||||||
tisc::Assembler::new()
|
|
||||||
|
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 mut entry = tisc::Assembler::new();
|
||||||
|
if data_frame_size > 0 {
|
||||||
|
entry = entry
|
||||||
.lit(data_frame_size)
|
.lit(data_frame_size)
|
||||||
.call("data-frame-alloc")
|
.call("data-frame-alloc");
|
||||||
.join(self.asm)
|
}
|
||||||
|
entry = entry
|
||||||
|
.call_symbol( LinkAddr::Relative{ symbol: "__subroutines__".into(), offset: body_addr });
|
||||||
|
|
||||||
|
if data_frame_size > 0 {
|
||||||
|
entry = entry
|
||||||
.lit(data_frame_size)
|
.lit(data_frame_size)
|
||||||
.call("data-frame-drop")
|
.call("data-frame-drop");
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut superlink = tisc::Linker::new();
|
||||||
|
superlink.add_procedure("", entry.build());
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
bytecode
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn verify(&self) {
|
pub fn verify(&self) {
|
||||||
|
@ -45,6 +76,7 @@ impl ProcedureCompiler {
|
||||||
match statement {
|
match statement {
|
||||||
Statement::Assignment{ var_id, val_expr } => {
|
Statement::Assignment{ var_id, val_expr } => {
|
||||||
self = self.compile(val_expr);
|
self = self.compile(val_expr);
|
||||||
|
|
||||||
match self.symbols.read().unwrap().get(var_id) {
|
match self.symbols.read().unwrap().get(var_id) {
|
||||||
Some(SymbolDef::FrameRef{ typ, stack_ref }) => {
|
Some(SymbolDef::FrameRef{ typ, stack_ref }) => {
|
||||||
self.asm = self.asm
|
self.asm = self.asm
|
||||||
|
@ -66,6 +98,39 @@ impl ProcedureCompiler {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
Statement::LetAssign{ 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()
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Statement::WhileLoop { condition, body } => {
|
Statement::WhileLoop { condition, body } => {
|
||||||
let asm = self.asm;
|
let asm = self.asm;
|
||||||
|
|
||||||
|
@ -111,7 +176,7 @@ impl ProcedureCompiler {
|
||||||
eprintln!("undefined symbol '{}'!", symbol);
|
eprintln!("undefined symbol '{}'!", symbol);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
},
|
}
|
||||||
LTExpr::Literal { typ, val } => {
|
LTExpr::Literal { typ, val } => {
|
||||||
self.asm = self.asm.lit( *val );
|
self.asm = self.asm.lit( *val );
|
||||||
}
|
}
|
||||||
|
@ -120,35 +185,22 @@ impl ProcedureCompiler {
|
||||||
self = self.compile(arg);
|
self = self.compile(arg);
|
||||||
}
|
}
|
||||||
self = self.compile(head);
|
self = self.compile(head);
|
||||||
},
|
|
||||||
LTExpr::Let { name, val, body } => {
|
|
||||||
self.symbols.write().unwrap()
|
|
||||||
.declare_var(
|
|
||||||
name.clone(),
|
|
||||||
laddertypes::TypeTerm::unit()
|
|
||||||
);
|
|
||||||
|
|
||||||
self = self.compile_statement(
|
|
||||||
&Statement::Assignment {
|
|
||||||
var_id: name.clone(),
|
|
||||||
val_expr: val.deref().clone()
|
|
||||||
}
|
}
|
||||||
);
|
LTExpr::Abstraction { args, body } => {
|
||||||
self = self.compile(&body.deref().clone());
|
for (arg_name, arg_type) in args.iter() {
|
||||||
},
|
|
||||||
LTExpr::Abstraction { arg_id: arg_name, arg_type, val_expr } => {
|
|
||||||
let id = self.symbols
|
let id = self.symbols
|
||||||
.write().unwrap()
|
.write().unwrap()
|
||||||
.declare_var(
|
.declare_var(
|
||||||
arg_name.clone(),
|
arg_name.clone(),
|
||||||
laddertypes::TypeTerm::unit());
|
arg_type.clone().unwrap_or(
|
||||||
|
laddertypes::TypeTerm::unit())
|
||||||
|
);
|
||||||
self.asm = self.asm
|
self.asm = self.asm
|
||||||
.lit( id )
|
.lit( id )
|
||||||
.call("data-frame-set");
|
.call("data-frame-set");
|
||||||
|
}
|
||||||
self = self.compile(val_expr);
|
self = self.compile(body);
|
||||||
},
|
}
|
||||||
LTExpr::Branch { condition, if_expr, else_expr } => {
|
LTExpr::Branch { condition, if_expr, else_expr } => {
|
||||||
self = self.compile(condition);
|
self = self.compile(condition);
|
||||||
|
|
||||||
|
|
|
@ -193,38 +193,6 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
|
||||||
.build()
|
.build()
|
||||||
);
|
);
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* let isquare = λx.(i* x x);
|
|
||||||
*/
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"isquare",
|
|
||||||
vec![],
|
|
||||||
vec![ "ℤ_2^64~machine::UInt64~machine::Word" ],
|
|
||||||
vec![ "ℤ_2^64~machine::UInt64~machine::Word" ]);
|
|
||||||
|
|
||||||
linker.add_procedure(
|
|
||||||
"isquare",
|
|
||||||
ProcedureCompiler::new(&symbols)
|
|
||||||
.compile(
|
|
||||||
<Expr::abstraction(
|
|
||||||
&typectx,
|
|
||||||
"x",
|
|
||||||
"ℤ_2^64~machine::UInt64~machine::Word",
|
|
||||||
|
|
||||||
LTExpr::application(
|
|
||||||
LTExpr::symbol(&typectx, "i*"),
|
|
||||||
vec![
|
|
||||||
LTExpr::symbol(&typectx, "x"),
|
|
||||||
LTExpr::symbol(&typectx, "x")
|
|
||||||
]
|
|
||||||
)
|
|
||||||
)
|
|
||||||
)
|
|
||||||
.into_asm()
|
|
||||||
.build()
|
|
||||||
);
|
|
||||||
|
|
||||||
symbols.write().unwrap().declare_static_parse(
|
symbols.write().unwrap().declare_static_parse(
|
||||||
"data-frame-ptr",
|
"data-frame-ptr",
|
||||||
"<MutRef <Seq machine::Word>>~machine::Address~machine::Word"
|
"<MutRef <Seq machine::Word>>~machine::Address~machine::Word"
|
||||||
|
|
Loading…
Reference in a new issue