Compare commits
No commits in common. "2b7d974851f763431a70fe7b59728c94cfabddf7" and "c9102655312f5d9824fcf9a6b2f090b46b1bb93d" have entirely different histories.
2b7d974851
...
c910265531
4 changed files with 279 additions and 513 deletions
110
src/lexer.rs
110
src/lexer.rs
|
@ -52,7 +52,6 @@ where
|
||||||
It: std::iter::Iterator<Item = char>,
|
It: std::iter::Iterator<Item = char>,
|
||||||
{
|
{
|
||||||
chars: std::iter::Peekable<It>,
|
chars: std::iter::Peekable<It>,
|
||||||
position: usize
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<It> LTIRLexer<It>
|
impl<It> LTIRLexer<It>
|
||||||
|
@ -71,23 +70,6 @@ where
|
||||||
fn from(chars: It) -> Self {
|
fn from(chars: It) -> Self {
|
||||||
LTIRLexer {
|
LTIRLexer {
|
||||||
chars: chars.peekable(),
|
chars: chars.peekable(),
|
||||||
position: 0,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub struct InputRegionTag {
|
|
||||||
begin: usize,
|
|
||||||
end: usize
|
|
||||||
}
|
|
||||||
|
|
||||||
impl InputRegionTag {
|
|
||||||
pub fn max( a: InputRegionTag, b: InputRegionTag ) -> InputRegionTag {
|
|
||||||
InputRegionTag {
|
|
||||||
begin: usize::min( a.begin, b.begin ),
|
|
||||||
end: usize::max( a.end, b.end )
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -96,14 +78,10 @@ impl<It> Iterator for LTIRLexer<It>
|
||||||
where
|
where
|
||||||
It: Iterator<Item = char>,
|
It: Iterator<Item = char>,
|
||||||
{
|
{
|
||||||
type Item = (InputRegionTag, Result<LTIRToken, LexError>);
|
type Item = Result<LTIRToken, LexError>;
|
||||||
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
let mut state = LexerState::Any;
|
let mut state = LexerState::Any;
|
||||||
let mut region = InputRegionTag{
|
|
||||||
begin: self.position,
|
|
||||||
end: self.position
|
|
||||||
};
|
|
||||||
|
|
||||||
while let Some(c) = self.chars.peek() {
|
while let Some(c) = self.chars.peek() {
|
||||||
match &mut state {
|
match &mut state {
|
||||||
|
@ -111,70 +89,47 @@ where
|
||||||
LexerState::Any => match c {
|
LexerState::Any => match c {
|
||||||
'λ' => {
|
'λ' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
return Some(Ok(LTIRToken::Lambda));
|
||||||
region.end += 1;
|
|
||||||
return Some((region, Ok(LTIRToken::Lambda)));
|
|
||||||
}
|
}
|
||||||
'.' | '↦' => {
|
'.' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
return Some(Ok(LTIRToken::LambdaBody));
|
||||||
region.end += 1;
|
|
||||||
return Some((region, Ok(LTIRToken::LambdaBody)));
|
|
||||||
}
|
}
|
||||||
'(' => {
|
'(' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
return Some(Ok(LTIRToken::ExprOpen));
|
||||||
region.end += 1;
|
|
||||||
return Some((region, Ok(LTIRToken::ExprOpen)));
|
|
||||||
}
|
}
|
||||||
')' => {
|
')' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
return Some(Ok(LTIRToken::ExprClose));
|
||||||
region.end += 1;
|
|
||||||
return Some((region, Ok(LTIRToken::ExprClose)));
|
|
||||||
}
|
}
|
||||||
'{' => {
|
'{' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
return Some(Ok(LTIRToken::BlockOpen));
|
||||||
region.end += 1;
|
|
||||||
return Some((region, Ok(LTIRToken::BlockOpen)));
|
|
||||||
}
|
}
|
||||||
'}' => {
|
'}' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
return Some(Ok(LTIRToken::BlockClose));
|
||||||
region.end += 1;
|
|
||||||
return Some((region, Ok(LTIRToken::BlockClose)));
|
|
||||||
}
|
}
|
||||||
':' => {
|
':' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
|
||||||
region.end += 1;
|
|
||||||
state = LexerState::TypeTerm(String::new());
|
state = LexerState::TypeTerm(String::new());
|
||||||
}
|
}
|
||||||
'=' => {
|
'=' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
return Some(Ok(LTIRToken::AssignValue));
|
||||||
region.end += 1;
|
|
||||||
return Some((region, Ok(LTIRToken::AssignValue)));
|
|
||||||
}
|
}
|
||||||
';' => {
|
';' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
return Some(Ok(LTIRToken::StatementSep));
|
||||||
region.end += 1;
|
|
||||||
return Some((region, Ok(LTIRToken::StatementSep)));
|
|
||||||
}
|
}
|
||||||
'\'' => {
|
'\'' => {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
|
||||||
region.end += 1;
|
|
||||||
state = LexerState::Char(None);
|
state = LexerState::Char(None);
|
||||||
}
|
}
|
||||||
c => {
|
c => {
|
||||||
if c.is_whitespace() {
|
if c.is_whitespace() {
|
||||||
self.chars.next();
|
self.chars.next();
|
||||||
self.position += 1;
|
|
||||||
region.begin += 1;
|
|
||||||
region.end += 1;
|
|
||||||
} else if c.is_digit(10) {
|
} else if c.is_digit(10) {
|
||||||
state = LexerState::Num(0);
|
state = LexerState::Num(0);
|
||||||
} else {
|
} else {
|
||||||
|
@ -184,49 +139,41 @@ where
|
||||||
},
|
},
|
||||||
|
|
||||||
LexerState::Char(val) => {
|
LexerState::Char(val) => {
|
||||||
self.position += 2;
|
|
||||||
region.end += 2;
|
|
||||||
*val = Some(match self.chars.next() {
|
*val = Some(match self.chars.next() {
|
||||||
Some('\\') => {
|
Some('\\') => match self.chars.next() {
|
||||||
self.position += 1;
|
Some('0') => '\0',
|
||||||
region.end += 1;
|
Some('n') => '\n',
|
||||||
match self.chars.next() {
|
Some('t') => '\t',
|
||||||
Some('0') => '\0',
|
Some(c) => c,
|
||||||
Some('n') => '\n',
|
None => {
|
||||||
Some('t') => '\t',
|
return Some(Err(LexError::InvalidChar));
|
||||||
Some(c) => c,
|
|
||||||
None => {
|
|
||||||
return Some((region, Err(LexError::InvalidChar)));
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
Some(c) => c,
|
Some(c) => c,
|
||||||
None => {
|
None => {
|
||||||
return Some((region, Err(LexError::InvalidChar)));
|
return Some(Err(LexError::InvalidChar));
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
match self.chars.next() {
|
match self.chars.next() {
|
||||||
Some('\'') => {
|
Some('\'') => {
|
||||||
if let Some(token) = state.clone().into_token() {
|
if let Some(token) = state.clone().into_token() {
|
||||||
return Some((region, Ok(token)));
|
return Some(Ok(token));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
return Some((region, Err(LexError::InvalidChar)));
|
return Some(Err(LexError::InvalidChar));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
LexerState::TypeTerm(s) => {
|
LexerState::TypeTerm(s) => {
|
||||||
if *c == '=' || *c == '.' || *c == '↦' || *c == ';' {
|
if *c == '=' || *c == '.' {
|
||||||
if let Some(token) = state.clone().into_token() {
|
if let Some(token) = state.clone().into_token() {
|
||||||
return Some((region, Ok(token)));
|
return Some(Ok(token));
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
if let Some(c) = self.chars.next() {
|
if let Some(c) = self.chars.next() {
|
||||||
self.position += 1;
|
|
||||||
region.end += 1;
|
|
||||||
s.push(c);
|
s.push(c);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -242,19 +189,16 @@ where
|
||||||
|| *c == '='
|
|| *c == '='
|
||||||
|| *c == ':'
|
|| *c == ':'
|
||||||
|| *c == '.'
|
|| *c == '.'
|
||||||
|| *c == '↦'
|
|
||||||
{
|
{
|
||||||
// finish the current token
|
// finish the current token
|
||||||
|
|
||||||
if let Some(token) = state.clone().into_token() {
|
if let Some(token) = state.clone().into_token() {
|
||||||
return Some((region, Ok(token)));
|
return Some(Ok(token));
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
// append to the current token
|
// append to the current token
|
||||||
|
|
||||||
let c = self.chars.next().unwrap();
|
let c = self.chars.next().unwrap();
|
||||||
self.position += 1;
|
|
||||||
region.end += 1;
|
|
||||||
|
|
||||||
match &mut state {
|
match &mut state {
|
||||||
LexerState::Sym(s) => {
|
LexerState::Sym(s) => {
|
||||||
|
@ -265,7 +209,7 @@ where
|
||||||
if let Some(d) = c.to_digit(10) {
|
if let Some(d) = c.to_digit(10) {
|
||||||
*n = (*n) * 10 + d as i64;
|
*n = (*n) * 10 + d as i64;
|
||||||
} else {
|
} else {
|
||||||
return Some((region, Err(LexError::InvalidDigit)));
|
return Some(Err(LexError::InvalidDigit));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -277,7 +221,7 @@ where
|
||||||
}
|
}
|
||||||
|
|
||||||
if let Some(token) = state.into_token() {
|
if let Some(token) = state.into_token() {
|
||||||
Some((region, Ok(token)))
|
Some(Ok(token))
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
}
|
}
|
||||||
|
@ -300,8 +244,8 @@ mod tests {
|
||||||
.chars(),
|
.chars(),
|
||||||
);
|
);
|
||||||
|
|
||||||
for (range, token) in lexer {
|
for token in lexer {
|
||||||
eprintln!("[{:?}] {:?}", range, token);
|
eprintln!("token = {:?}", token);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
169
src/main.rs
169
src/main.rs
|
@ -42,6 +42,24 @@ fn main() {
|
||||||
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
|
||||||
|
*/
|
||||||
|
main_scope.write().unwrap().declare_static_parse(
|
||||||
|
"hello-string",
|
||||||
|
"<Seq Char
|
||||||
|
~Ascii
|
||||||
|
~machine::Word>
|
||||||
|
~<NullTerminatedSeq machine::Word>",
|
||||||
|
);
|
||||||
|
|
||||||
|
main_scope.write().unwrap().declare_static_parse(
|
||||||
|
"pfxstr",
|
||||||
|
"<Seq Char
|
||||||
|
~Ascii
|
||||||
|
~machine::Word>
|
||||||
|
~<LengthPrefixedSeq machine::Word>",
|
||||||
|
);
|
||||||
|
|
||||||
/* link assembly-program to symbols
|
/* link assembly-program to symbols
|
||||||
*/
|
*/
|
||||||
linker.add_procedure(
|
linker.add_procedure(
|
||||||
|
@ -50,79 +68,102 @@ fn main() {
|
||||||
&main_scope,
|
&main_scope,
|
||||||
"main",
|
"main",
|
||||||
"{
|
"{
|
||||||
let print-nullterm =
|
let print-nullterm =
|
||||||
λ{} : < Seq Char~Ascii~machine::Word >
|
λ str : <Ref <Seq Char~Ascii~machine::Word>>
|
||||||
~ < NullTerminatedArray machine::Word >
|
~ <Ref <NullTerminatedArray machine::Word>>
|
||||||
↦ {
|
~ machine::Address
|
||||||
while(dup) { emit; }
|
~ machine::Word
|
||||||
emit;
|
.
|
||||||
};
|
{
|
||||||
|
while (@ str) {
|
||||||
|
emit (@ str);
|
||||||
|
! str (i+ str 1);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
print-nullterm 'H' 'a' 'l' 'l' 'o' ' ' 'W' 'e' 'l' 't' '!' '\n' '\0';
|
let print-len =
|
||||||
|
λ len : ℤ_2^64
|
||||||
let print-uint =
|
~ machine::UInt64
|
||||||
λx : ℕ ~ ℤ_2^64 ~ machine::UInt64
|
~ machine::Word
|
||||||
↦ {
|
.
|
||||||
if( x ) {
|
λ str : <Ref <Seq Char~Ascii~machine::Word>>
|
||||||
print-nullterm {
|
~ <Ref <Array machine::Word>>
|
||||||
'\0';
|
~ machine::Address
|
||||||
while( x ) {
|
~ machine::Word
|
||||||
i+ '0' (i% x 10);
|
.
|
||||||
! x (i/ x 10);
|
{
|
||||||
}
|
let end = (i+ str len);
|
||||||
};
|
while (i- str end) {
|
||||||
} else {
|
emit (@ str);
|
||||||
emit '0';
|
! str (i+ str 1);
|
||||||
};
|
}
|
||||||
};
|
|
||||||
|
|
||||||
let int-neg = λx : ℤ~machine::Int64~machine::Word ↦ i+ (bit-neg x) 1;
|
|
||||||
let int-sign = λx : ℤ~machine::Int64~machine::Word ↦ bit-and (bit-shr x 63) 1;
|
|
||||||
|
|
||||||
let int-lte = λ{
|
|
||||||
a : ℤ~machine::Int64~machine::Word;
|
|
||||||
b : ℤ~machine::Int64~machine::Word;
|
|
||||||
} ↦ int-sign (i- a b);
|
|
||||||
|
|
||||||
let int-max = λ{
|
|
||||||
a : ℤ~machine::Int64~machine::Word;
|
|
||||||
b : ℤ~machine::Int64~machine::Word;
|
|
||||||
} ↦ if( int-lte b a ) { a; } else { b; };
|
|
||||||
|
|
||||||
let vec3i-add = λ{
|
|
||||||
{ ax:ℤ_2^64; ay:ℤ_2^64; az:ℤ_2^64; } : <Vec3 ℤ_2^64~machine::UInt64>;
|
|
||||||
{ bx:ℤ_2^64; by:ℤ_2^64; bz:ℤ_2^64; } : <Vec3 ℤ_2^64~machine::UInt64>;
|
|
||||||
} ↦ {
|
|
||||||
i+ az bz;
|
|
||||||
i+ ay by;
|
|
||||||
i+ ax bx;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
let print-vec3i =
|
let print-lenprefix =
|
||||||
λ{ x:ℤ_2^64; y:ℤ_2^64; z:ℤ_2^64; } : <Vec3 ℤ_2^64~machine::UInt64>
|
λ str : <Ref <Seq Char~Ascii~machine::Word>>
|
||||||
↦ {
|
~ <Ref <LenPrefixArray machine::Word>>
|
||||||
print-nullterm '{' 'x' '=' '\0';
|
~ <Ref <Struct
|
||||||
print-uint x;
|
<len ℤ_2^64
|
||||||
print-nullterm ';' ' ' 'y' '=' '\0';
|
~machine::UInt64
|
||||||
print-uint y;
|
~machine::Word>
|
||||||
print-nullterm ';' ' ' 'z' '=' '\0';
|
<data <Array machine::Word>>
|
||||||
print-uint z;
|
>>
|
||||||
print-nullterm '}' '\0';
|
~ machine::Address
|
||||||
};
|
~ machine::Word
|
||||||
|
.
|
||||||
|
{
|
||||||
|
let len = (@ str);
|
||||||
|
! str (i+ str 1);
|
||||||
|
print-len len str;
|
||||||
|
};
|
||||||
|
|
||||||
let red-u8
|
let hello = λ.{
|
||||||
: <Fn <> Color ~ RGB ~ <Vec3 ℝ_0,1 ~ ℤ_256 ~ machine::UInt64>>
|
print-nullterm hello-string;
|
||||||
= λ{} ↦ { 0; 0; 255; };
|
print-lenprefix pfxstr;
|
||||||
let green-u8 = λ{} ↦ { 0; 255; 0; };
|
|
||||||
let blue-u8 = λ{} ↦ { 255; 0; 0; };
|
let isquare = λx:ℤ. i* x x;
|
||||||
let yellow-u8 = λ{} ↦ { 0; 220; 220; };
|
let imagnitude2 = λx:ℤ.λy:ℤ. i+ (isquare x) (isquare y);
|
||||||
|
let factorial = λn:ℤ.
|
||||||
|
if( n ){ i* n (factorial (i- n 1)); }
|
||||||
|
else { 1; };
|
||||||
|
|
||||||
|
factorial 20;
|
||||||
|
|
||||||
|
if ( i- (imagnitude2 10 20) 500 ) {
|
||||||
|
emit '?';
|
||||||
|
} else {
|
||||||
|
emit '!';
|
||||||
|
};
|
||||||
|
|
||||||
print-vec3i (vec3i-add green-u8 blue-u8);
|
|
||||||
emit '\n';
|
emit '\n';
|
||||||
}"
|
emit (i+ '0' (isquare 3));
|
||||||
|
emit '\n';
|
||||||
|
};
|
||||||
|
|
||||||
|
hello;
|
||||||
|
}",
|
||||||
),
|
),
|
||||||
);
|
);
|
||||||
|
|
||||||
|
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,
|
||||||
|
],
|
||||||
|
);
|
||||||
|
|
||||||
let main_addr = linker
|
let main_addr = linker
|
||||||
.get_link_addr(&"main".into())
|
.get_link_addr(&"main".into())
|
||||||
.expect("'main' not linked");
|
.expect("'main' not linked");
|
||||||
|
|
265
src/parser.rs
265
src/parser.rs
|
@ -9,13 +9,12 @@ use {
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
|
|
||||||
#[derive(Clone, Debug, PartialEq)]
|
#[derive(Clone, Debug)]
|
||||||
pub enum ParseError {
|
pub enum ParseError {
|
||||||
LexError(LexError),
|
LexError(LexError),
|
||||||
UnexpectedClose,
|
UnexpectedClose,
|
||||||
UnexpectedEnd,
|
UnexpectedEnd,
|
||||||
UnexpectedToken,
|
UnexpectedToken,
|
||||||
TypeParseError(laddertypes::parser::ParseError)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn parse_expect<It>(
|
pub fn parse_expect<It>(
|
||||||
|
@ -26,151 +25,53 @@ where
|
||||||
It: Iterator<Item = char>,
|
It: Iterator<Item = char>,
|
||||||
{
|
{
|
||||||
match tokens.next() {
|
match tokens.next() {
|
||||||
Some((region, Ok(t))) => {
|
Some(Ok(t)) => {
|
||||||
if t == expected_token {
|
if t == expected_token {
|
||||||
Ok(())
|
Ok(())
|
||||||
} else {
|
} else {
|
||||||
Err(ParseError::UnexpectedToken)
|
Err(ParseError::UnexpectedToken)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Some((region, Err(err))) => Err(ParseError::LexError(err)),
|
Some(Err(err)) => Err(ParseError::LexError(err)),
|
||||||
None => Err(ParseError::UnexpectedEnd),
|
None => Err(ParseError::UnexpectedEnd),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/* parse symbol name
|
|
||||||
*/
|
|
||||||
pub fn parse_symbol<It>(tokens: &mut Peekable<LTIRLexer<It>>) -> Result<String, ParseError>
|
pub fn parse_symbol<It>(tokens: &mut Peekable<LTIRLexer<It>>) -> Result<String, ParseError>
|
||||||
where
|
where
|
||||||
It: Iterator<Item = char>,
|
It: Iterator<Item = char>,
|
||||||
{
|
{
|
||||||
match tokens.next() {
|
match tokens.next() {
|
||||||
Some((region, Ok(LTIRToken::Symbol(name)))) => Ok(name),
|
Some(Ok(LTIRToken::Symbol(name))) => Ok(name),
|
||||||
Some((region, Ok(_))) => Err(ParseError::UnexpectedToken),
|
Some(Ok(_)) => Err(ParseError::UnexpectedToken),
|
||||||
Some((region, Err(err))) => Err(ParseError::LexError(err)),
|
Some(Err(err)) => Err(ParseError::LexError(err)),
|
||||||
None => Err(ParseError::UnexpectedEnd),
|
None => Err(ParseError::UnexpectedEnd),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/* parse an optional type annotation
|
|
||||||
* `: T`
|
|
||||||
*/
|
|
||||||
pub fn parse_type_tag<It>(
|
pub fn parse_type_tag<It>(
|
||||||
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
|
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
|
||||||
tokens: &mut Peekable<LTIRLexer<It>>,
|
tokens: &mut Peekable<LTIRLexer<It>>,
|
||||||
) -> Result<Option<laddertypes::TypeTerm>, ParseError>
|
) -> Option<TypeTag>
|
||||||
where
|
where
|
||||||
It: Iterator<Item = char>,
|
It: Iterator<Item = char>,
|
||||||
{
|
{
|
||||||
if let Some((region, peektok)) = tokens.peek().clone() {
|
if let Some(peektok) = tokens.peek().clone() {
|
||||||
match peektok.clone() {
|
match peektok.clone() {
|
||||||
Ok(LTIRToken::AssignType(typeterm_str)) => {
|
Ok(LTIRToken::AssignType(typeterm_str)) => {
|
||||||
tokens.next();
|
tokens.next();
|
||||||
match typectx.write().unwrap().parse(typeterm_str.as_str()) {
|
match typectx.write().unwrap().parse(typeterm_str.as_str()) {
|
||||||
Ok(typeterm) => Ok(Some(typeterm)),
|
Ok(typeterm) => Some(Ok(typeterm)),
|
||||||
Err(parse_error) => Err(ParseError::TypeParseError(parse_error)),
|
Err(parse_error) => Some(Err(TypeError::ParseError(parse_error))),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
_ => Ok(None),
|
_ => None,
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
Ok(None)
|
None
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, Eq)]
|
|
||||||
pub enum VariableBinding {
|
|
||||||
Atomic {
|
|
||||||
symbol: String,
|
|
||||||
typtag: Option<laddertypes::TypeTerm>
|
|
||||||
},
|
|
||||||
Struct {
|
|
||||||
members: Vec< VariableBinding >,
|
|
||||||
typtag: Option<laddertypes::TypeTerm>
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl VariableBinding {
|
|
||||||
pub fn flatten(self) -> Vec<(String, Option<laddertypes::TypeTerm>)> {
|
|
||||||
match self {
|
|
||||||
VariableBinding::Atomic{ symbol, typtag } =>
|
|
||||||
vec![ (symbol, typtag) ],
|
|
||||||
VariableBinding::Struct{ members, typtag } =>
|
|
||||||
members
|
|
||||||
.into_iter()
|
|
||||||
.map(|a| a.flatten().into_iter())
|
|
||||||
.flatten()
|
|
||||||
.collect()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* parse a symbol binding of the form
|
|
||||||
* `x`
|
|
||||||
* or `x : T`
|
|
||||||
*/
|
|
||||||
pub fn parse_binding_expr<It>(
|
|
||||||
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
|
|
||||||
tokens: &mut Peekable<LTIRLexer<It>>,
|
|
||||||
) -> Result< VariableBinding, ParseError>
|
|
||||||
where It: Iterator<Item = char>
|
|
||||||
{
|
|
||||||
if let Some((region, peektok)) = tokens.peek().clone() {
|
|
||||||
match peektok {
|
|
||||||
Ok(LTIRToken::BlockOpen) => {
|
|
||||||
Ok(VariableBinding::Struct {
|
|
||||||
members: parse_binding_block(typectx, tokens)?,
|
|
||||||
typtag: parse_type_tag(typectx, tokens)?
|
|
||||||
})
|
|
||||||
}
|
|
||||||
Ok(LTIRToken::Symbol(_)) => {
|
|
||||||
Ok(VariableBinding::Atomic{
|
|
||||||
symbol: parse_symbol(tokens)?,
|
|
||||||
typtag: parse_type_tag(typectx, tokens)?
|
|
||||||
})
|
|
||||||
}
|
|
||||||
Err(err) => Err(ParseError::LexError(err.clone())),
|
|
||||||
_ => Err(ParseError::UnexpectedToken)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
Err(ParseError::UnexpectedEnd)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* parse a block of symbol bidnings
|
|
||||||
* `{ x:T; y:U; ... }`
|
|
||||||
*/
|
|
||||||
pub fn parse_binding_block<It>(
|
|
||||||
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
|
|
||||||
tokens: &mut Peekable<LTIRLexer<It>>,
|
|
||||||
) -> Result< Vec<VariableBinding>, ParseError>
|
|
||||||
where
|
|
||||||
It: Iterator<Item = char>,
|
|
||||||
{
|
|
||||||
let _ = parse_expect(tokens, LTIRToken::BlockOpen)?;
|
|
||||||
|
|
||||||
let mut bindings = Vec::new();
|
|
||||||
while let Some((region, peektok)) = tokens.peek() {
|
|
||||||
match peektok {
|
|
||||||
Ok(LTIRToken::BlockClose) => {
|
|
||||||
tokens.next();
|
|
||||||
return Ok(bindings);
|
|
||||||
}
|
|
||||||
Ok(LTIRToken::StatementSep) => {
|
|
||||||
tokens.next();
|
|
||||||
}
|
|
||||||
Ok(_) => {
|
|
||||||
bindings.push(parse_binding_expr(typectx, tokens)?);
|
|
||||||
}
|
|
||||||
Err(err) => {
|
|
||||||
return Err(ParseError::LexError(err.clone()));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Err(ParseError::UnexpectedEnd)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn parse_statement<It>(
|
pub fn parse_statement<It>(
|
||||||
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
|
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
|
||||||
tokens: &mut Peekable<LTIRLexer<It>>,
|
tokens: &mut Peekable<LTIRLexer<It>>,
|
||||||
|
@ -178,7 +79,7 @@ pub fn parse_statement<It>(
|
||||||
where
|
where
|
||||||
It: Iterator<Item = char>,
|
It: Iterator<Item = char>,
|
||||||
{
|
{
|
||||||
if let Some((region, peektok)) = tokens.peek() {
|
if let Some(peektok) = tokens.peek() {
|
||||||
match peektok {
|
match peektok {
|
||||||
Ok(LTIRToken::Symbol(sym)) => {
|
Ok(LTIRToken::Symbol(sym)) => {
|
||||||
match sym.as_str() {
|
match sym.as_str() {
|
||||||
|
@ -197,19 +98,13 @@ where
|
||||||
"let" => {
|
"let" => {
|
||||||
tokens.next();
|
tokens.next();
|
||||||
let name = parse_symbol(tokens)?;
|
let name = parse_symbol(tokens)?;
|
||||||
let typ = parse_type_tag(typectx, tokens)?;
|
let typ = parse_type_tag(typectx, tokens);
|
||||||
/* todo
|
|
||||||
let mut variable_bindings = parse_binding_expr(typectx, tokens)?;
|
|
||||||
*/
|
|
||||||
let _ = parse_expect(tokens, LTIRToken::AssignValue);
|
let _ = parse_expect(tokens, LTIRToken::AssignValue);
|
||||||
let val_expr = parse_expr(typectx, tokens)?;
|
let val_expr = parse_expr(typectx, tokens)?;
|
||||||
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
|
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
|
||||||
|
|
||||||
Ok(Statement::LetAssign {
|
Ok(Statement::LetAssign {
|
||||||
typ: match typ {
|
typ,
|
||||||
Some(t) => Some(Ok(t)),
|
|
||||||
None => None
|
|
||||||
},
|
|
||||||
var_id: name,
|
var_id: name,
|
||||||
val_expr,
|
val_expr,
|
||||||
})
|
})
|
||||||
|
@ -221,7 +116,7 @@ where
|
||||||
let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
|
let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
|
||||||
Ok(Statement::WhileLoop {
|
Ok(Statement::WhileLoop {
|
||||||
condition: cond,
|
condition: cond,
|
||||||
body: parse_statement_block(typectx, tokens)?,
|
body: parse_block(typectx, tokens)?,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
"return" => {
|
"return" => {
|
||||||
|
@ -249,7 +144,7 @@ where
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn parse_statement_block<It>(
|
pub fn parse_block<It>(
|
||||||
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
|
typectx: &Arc<RwLock<laddertypes::dict::TypeDict>>,
|
||||||
tokens: &mut Peekable<LTIRLexer<It>>,
|
tokens: &mut Peekable<LTIRLexer<It>>,
|
||||||
) -> Result<Vec<Statement>, ParseError>
|
) -> Result<Vec<Statement>, ParseError>
|
||||||
|
@ -259,7 +154,7 @@ where
|
||||||
let _ = parse_expect(tokens, LTIRToken::BlockOpen)?;
|
let _ = parse_expect(tokens, LTIRToken::BlockOpen)?;
|
||||||
|
|
||||||
let mut statements = Vec::new();
|
let mut statements = Vec::new();
|
||||||
while let Some((region, peektok)) = tokens.peek() {
|
while let Some(peektok) = tokens.peek() {
|
||||||
match peektok {
|
match peektok {
|
||||||
Ok(LTIRToken::BlockClose) => {
|
Ok(LTIRToken::BlockClose) => {
|
||||||
tokens.next();
|
tokens.next();
|
||||||
|
@ -284,11 +179,11 @@ where
|
||||||
It: Iterator<Item = char>,
|
It: Iterator<Item = char>,
|
||||||
{
|
{
|
||||||
match tokens.next() {
|
match tokens.next() {
|
||||||
Some((region, Ok(LTIRToken::Symbol(sym)))) => Ok(LTExpr::symbol(sym.as_str())),
|
Some(Ok(LTIRToken::Symbol(sym))) => Ok(LTExpr::symbol(sym.as_str())),
|
||||||
Some((region, Ok(LTIRToken::Char(c)))) => Ok(LTExpr::lit_uint(c as u64)),
|
Some(Ok(LTIRToken::Char(c))) => Ok(LTExpr::lit_uint(c as u64)),
|
||||||
Some((region, Ok(LTIRToken::Num(n)))) => Ok(LTExpr::lit_uint(n as u64)),
|
Some(Ok(LTIRToken::Num(n))) => Ok(LTExpr::lit_uint(n as u64)),
|
||||||
Some((region, Ok(_))) => Err(ParseError::UnexpectedToken),
|
Some(Ok(_)) => Err(ParseError::UnexpectedToken),
|
||||||
Some((region, Err(err))) => Err(ParseError::LexError(err)),
|
Some(Err(err)) => Err(ParseError::LexError(err)),
|
||||||
None => Err(ParseError::UnexpectedEnd),
|
None => Err(ParseError::UnexpectedEnd),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -302,18 +197,22 @@ where
|
||||||
{
|
{
|
||||||
let mut children = Vec::new();
|
let mut children = Vec::new();
|
||||||
|
|
||||||
while let Some((region, tok)) = tokens.peek() {
|
while let Some(tok) = tokens.peek() {
|
||||||
match tok {
|
match tok {
|
||||||
Ok(LTIRToken::Lambda) => {
|
Ok(LTIRToken::Lambda) => {
|
||||||
if children.len() == 0 {
|
if children.len() == 0 {
|
||||||
tokens.next();
|
tokens.next();
|
||||||
|
|
||||||
let mut variable_bindings = parse_binding_expr(typectx, tokens)?;
|
let mut args = Vec::new();
|
||||||
|
while let Some(Ok(LTIRToken::Symbol(_))) = tokens.peek() {
|
||||||
|
args.push((parse_symbol(tokens)?, parse_type_tag(typectx, tokens)));
|
||||||
|
}
|
||||||
|
|
||||||
let _ = parse_expect(tokens, LTIRToken::LambdaBody);
|
let _ = parse_expect(tokens, LTIRToken::LambdaBody);
|
||||||
let body = parse_expr(typectx, tokens)?;
|
let body = parse_expr(typectx, tokens)?;
|
||||||
|
|
||||||
return Ok(LTExpr::Abstraction {
|
return Ok(LTExpr::Abstraction {
|
||||||
args: variable_bindings.flatten().into_iter().map(|(s,t)| (s,t.map(|t|Ok(t))) ).collect(),
|
args,
|
||||||
body: Box::new(body),
|
body: Box::new(body),
|
||||||
});
|
});
|
||||||
} else {
|
} else {
|
||||||
|
@ -322,7 +221,7 @@ where
|
||||||
}
|
}
|
||||||
Ok(LTIRToken::ExprOpen) => {
|
Ok(LTIRToken::ExprOpen) => {
|
||||||
tokens.next();
|
tokens.next();
|
||||||
while let Some((region, peektok)) = tokens.peek() {
|
while let Some(peektok) = tokens.peek() {
|
||||||
match peektok {
|
match peektok {
|
||||||
Ok(LTIRToken::ExprClose) => {
|
Ok(LTIRToken::ExprClose) => {
|
||||||
tokens.next();
|
tokens.next();
|
||||||
|
@ -337,7 +236,7 @@ where
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
Ok(LTIRToken::BlockOpen) => {
|
Ok(LTIRToken::BlockOpen) => {
|
||||||
children.push(LTExpr::block(parse_statement_block(typectx, tokens)?));
|
children.push(LTExpr::block(parse_block(typectx, tokens)?));
|
||||||
}
|
}
|
||||||
Ok(LTIRToken::BlockClose) => {
|
Ok(LTIRToken::BlockClose) => {
|
||||||
break;
|
break;
|
||||||
|
@ -351,10 +250,10 @@ where
|
||||||
let _ = parse_expect(tokens, LTIRToken::ExprOpen)?;
|
let _ = parse_expect(tokens, LTIRToken::ExprOpen)?;
|
||||||
let cond = parse_expr(typectx, tokens)?;
|
let cond = parse_expr(typectx, tokens)?;
|
||||||
let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
|
let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
|
||||||
let if_expr = LTExpr::block(parse_statement_block(typectx, tokens)?);
|
let if_expr = LTExpr::block(parse_block(typectx, tokens)?);
|
||||||
let mut else_expr = LTExpr::block(vec![]);
|
let mut else_expr = LTExpr::block(vec![]);
|
||||||
|
|
||||||
if let Some((region, peektok)) = tokens.peek() {
|
if let Some(peektok) = tokens.peek() {
|
||||||
if let Ok(LTIRToken::Symbol(name)) = peektok {
|
if let Ok(LTIRToken::Symbol(name)) = peektok {
|
||||||
if name == "else" {
|
if name == "else" {
|
||||||
tokens.next();
|
tokens.next();
|
||||||
|
@ -393,99 +292,3 @@ where
|
||||||
Err(ParseError::UnexpectedEnd)
|
Err(ParseError::UnexpectedEnd)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
mod tests {
|
|
||||||
use std::sync::{Arc, RwLock};
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_parse_atomic_binding() {
|
|
||||||
let mut lexer = crate::lexer::LTIRLexer::from("x".chars()).peekable();
|
|
||||||
let typectx = Arc::new(RwLock::new(laddertypes::dict::TypeDict::new()));
|
|
||||||
let bindings = crate::parser::parse_binding_expr( &typectx, &mut lexer );
|
|
||||||
|
|
||||||
assert_eq!(
|
|
||||||
bindings,
|
|
||||||
Ok(crate::parser::VariableBinding::Atomic{
|
|
||||||
symbol: "x".into(),
|
|
||||||
typtag: None
|
|
||||||
})
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_parse_typed_atomic_binding() {
|
|
||||||
let mut lexer = crate::lexer::LTIRLexer::from("x:T".chars()).peekable();
|
|
||||||
let typectx = Arc::new(RwLock::new(laddertypes::dict::TypeDict::new()));
|
|
||||||
let bindings = crate::parser::parse_binding_expr( &typectx, &mut lexer );
|
|
||||||
|
|
||||||
assert_eq!(
|
|
||||||
bindings,
|
|
||||||
Ok(crate::parser::VariableBinding::Atomic{
|
|
||||||
symbol: "x".into(),
|
|
||||||
typtag: Some(typectx.write().unwrap().parse("T").unwrap())
|
|
||||||
})
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_parse_struct_binding() {
|
|
||||||
let mut lexer = crate::lexer::LTIRLexer::from("{x y}".chars()).peekable();
|
|
||||||
let typectx = Arc::new(RwLock::new(laddertypes::dict::TypeDict::new()));
|
|
||||||
let bindings = crate::parser::parse_binding_expr( &typectx, &mut lexer );
|
|
||||||
|
|
||||||
assert_eq!(
|
|
||||||
bindings,
|
|
||||||
Ok(crate::parser::VariableBinding::Struct{
|
|
||||||
members: vec![
|
|
||||||
crate::parser::VariableBinding::Atomic{ symbol: "x".into(), typtag: None },
|
|
||||||
crate::parser::VariableBinding::Atomic{ symbol: "y".into(), typtag: None }
|
|
||||||
],
|
|
||||||
typtag: None
|
|
||||||
})
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_parse_typed_struct_binding1() {
|
|
||||||
let mut lexer = crate::lexer::LTIRLexer::from("{x y}:T".chars()).peekable();
|
|
||||||
let typectx = Arc::new(RwLock::new(laddertypes::dict::TypeDict::new()));
|
|
||||||
let bindings = crate::parser::parse_binding_expr( &typectx, &mut lexer );
|
|
||||||
|
|
||||||
assert_eq!(
|
|
||||||
bindings,
|
|
||||||
Ok(crate::parser::VariableBinding::Struct{
|
|
||||||
members: vec![
|
|
||||||
crate::parser::VariableBinding::Atomic{ symbol: "x".into(), typtag: None },
|
|
||||||
crate::parser::VariableBinding::Atomic{ symbol: "y".into(), typtag: None }
|
|
||||||
],
|
|
||||||
typtag: Some(typectx.write().unwrap().parse("T").unwrap())
|
|
||||||
})
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_parse_typed_struct_binding2() {
|
|
||||||
let mut lexer = crate::lexer::LTIRLexer::from("{x:U; y}:T".chars()).peekable();
|
|
||||||
let typectx = Arc::new(RwLock::new(laddertypes::dict::TypeDict::new()));
|
|
||||||
let bindings = crate::parser::parse_binding_expr( &typectx, &mut lexer );
|
|
||||||
|
|
||||||
let type_u = typectx.write().unwrap().parse("U").unwrap();
|
|
||||||
let type_t = typectx.write().unwrap().parse("T").unwrap();
|
|
||||||
|
|
||||||
assert_eq!(
|
|
||||||
bindings,
|
|
||||||
Ok(crate::parser::VariableBinding::Struct{
|
|
||||||
members: vec![
|
|
||||||
crate::parser::VariableBinding::Atomic{
|
|
||||||
symbol: "x".into(),
|
|
||||||
typtag: Some(type_u)
|
|
||||||
},
|
|
||||||
crate::parser::VariableBinding::Atomic{ symbol: "y".into(), typtag: None }
|
|
||||||
],
|
|
||||||
typtag: Some(type_t)
|
|
||||||
})
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
248
src/runtime.rs
248
src/runtime.rs
|
@ -18,14 +18,13 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
|
||||||
vec!["T~machine::Word", "T~machine::Word"],
|
vec!["T~machine::Word", "T~machine::Word"],
|
||||||
);
|
);
|
||||||
|
|
||||||
/* drop topmost element
|
linker.add_procedure(
|
||||||
*/
|
"dup",
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
tisc::Assembler::new()
|
||||||
"drop",
|
.inst(tisc::VM_Instruction::Dup)
|
||||||
vec!["T"],
|
.build(),
|
||||||
vec!["T~machine::Word"],
|
|
||||||
vec![],
|
|
||||||
);
|
);
|
||||||
|
|
||||||
/* Put a single Ascii character on stdout
|
/* Put a single Ascii character on stdout
|
||||||
*/
|
*/
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
symbols.write().unwrap().declare_proc_parse(
|
||||||
|
@ -34,17 +33,13 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
|
||||||
vec!["Char~Ascii~machine::Word"],
|
vec!["Char~Ascii~machine::Word"],
|
||||||
vec![],
|
vec![],
|
||||||
);
|
);
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"accept",
|
|
||||||
vec![],
|
|
||||||
vec![],
|
|
||||||
vec!["Char~Ascii~machine::Word"],
|
|
||||||
);
|
|
||||||
|
|
||||||
linker.add_procedure("dup", tisc::Assembler::new().inst(tisc::VM_Instruction::Dup).build());
|
linker.add_procedure(
|
||||||
linker.add_procedure("drop", tisc::Assembler::new().inst(tisc::VM_Instruction::Accept).build());
|
"emit",
|
||||||
linker.add_procedure("emit", tisc::Assembler::new().inst(tisc::VM_Instruction::Emit).build());
|
tisc::Assembler::new()
|
||||||
linker.add_procedure("accept", tisc::Assembler::new().inst(tisc::VM_Instruction::Accept).build());
|
.inst(tisc::VM_Instruction::Emit)
|
||||||
|
.build(),
|
||||||
|
);
|
||||||
|
|
||||||
/* The top two items must be native u64 integers,
|
/* The top two items must be native u64 integers,
|
||||||
* which are replaced by their sum.
|
* which are replaced by their sum.
|
||||||
|
@ -60,43 +55,16 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
|
||||||
],
|
],
|
||||||
vec!["ℤ_2^64~machine::UInt64~machine::Word"],
|
vec!["ℤ_2^64~machine::UInt64~machine::Word"],
|
||||||
);
|
);
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"i-",
|
linker.add_procedure(
|
||||||
vec![],
|
"i+",
|
||||||
vec![
|
tisc::Assembler::new()
|
||||||
"ℤ_2^64~machine::UInt64~machine::Word",
|
.inst(tisc::VM_Instruction::IntAdd)
|
||||||
"ℤ_2^64~machine::UInt64~machine::Word",
|
.build(),
|
||||||
],
|
|
||||||
vec!["ℤ_2^64~machine::UInt64~machine::Word"],
|
|
||||||
);
|
|
||||||
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"],
|
|
||||||
);
|
|
||||||
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"],
|
|
||||||
);
|
|
||||||
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"],
|
|
||||||
);
|
);
|
||||||
|
|
||||||
|
/* Floating-point Addition
|
||||||
|
*/
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
symbols.write().unwrap().declare_proc_parse(
|
||||||
"f+",
|
"f+",
|
||||||
vec![],
|
vec![],
|
||||||
|
@ -107,93 +75,35 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
|
||||||
vec!["ℝ~machine::f64~machine::Word"],
|
vec!["ℝ~machine::f64~machine::Word"],
|
||||||
);
|
);
|
||||||
|
|
||||||
|
linker.add_procedure(
|
||||||
|
"f+",
|
||||||
|
tisc::Assembler::new()
|
||||||
|
.inst(tisc::VM_Instruction::FltAdd)
|
||||||
|
.build(),
|
||||||
|
);
|
||||||
|
|
||||||
|
/* Integer Subtraction
|
||||||
|
*/
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
symbols.write().unwrap().declare_proc_parse(
|
||||||
"f-",
|
"i-",
|
||||||
vec![],
|
vec![],
|
||||||
vec![
|
vec![
|
||||||
"ℝ~machine::f64~machine::Word",
|
"ℤ_2^64~machine::UInt64~machine::Word",
|
||||||
"ℝ~machine::f64~machine::Word",
|
"ℤ_2^64~machine::UInt64~machine::Word",
|
||||||
],
|
],
|
||||||
vec!["ℝ~machine::f64~machine::Word"],
|
vec!["ℤ_2^64~machine::UInt64~machine::Word"],
|
||||||
);
|
);
|
||||||
|
linker.add_procedure(
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
"i-",
|
||||||
"f*",
|
tisc::Assembler::new()
|
||||||
vec![],
|
.inst(tisc::VM_Instruction::Swap)
|
||||||
vec![
|
.inst(tisc::VM_Instruction::BitNeg)
|
||||||
"ℝ~machine::f64~machine::Word",
|
.lit(1)
|
||||||
"ℝ~machine::f64~machine::Word",
|
.inst(tisc::VM_Instruction::IntAdd)
|
||||||
],
|
.inst(tisc::VM_Instruction::IntAdd)
|
||||||
vec!["ℝ~machine::f64~machine::Word"],
|
.build(),
|
||||||
);
|
);
|
||||||
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"f/",
|
|
||||||
vec![],
|
|
||||||
vec![
|
|
||||||
"ℝ~machine::f64~machine::Word",
|
|
||||||
"ℝ~machine::f64~machine::Word",
|
|
||||||
],
|
|
||||||
vec!["ℝ~machine::f64~machine::Word"],
|
|
||||||
);
|
|
||||||
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"f%",
|
|
||||||
vec![],
|
|
||||||
vec![
|
|
||||||
"ℝ~machine::f64~machine::Word",
|
|
||||||
"ℝ~machine::f64~machine::Word",
|
|
||||||
],
|
|
||||||
vec!["ℝ~machine::f64~machine::Word"],
|
|
||||||
);
|
|
||||||
|
|
||||||
linker.add_procedure("i+", tisc::Assembler::new().inst(tisc::VM_Instruction::IntAdd).build());
|
|
||||||
linker.add_procedure("i-", tisc::Assembler::new().inst(tisc::VM_Instruction::IntSub).build());
|
|
||||||
linker.add_procedure("i*", tisc::Assembler::new().inst(tisc::VM_Instruction::IntMul).build());
|
|
||||||
linker.add_procedure("i/", tisc::Assembler::new().inst(tisc::VM_Instruction::IntDiv).build());
|
|
||||||
linker.add_procedure("i%", tisc::Assembler::new().inst(tisc::VM_Instruction::IntRem).build());
|
|
||||||
|
|
||||||
linker.add_procedure("f+", tisc::Assembler::new().inst(tisc::VM_Instruction::FltAdd).build());
|
|
||||||
linker.add_procedure("f-", tisc::Assembler::new().inst(tisc::VM_Instruction::FltSub).build());
|
|
||||||
linker.add_procedure("f*", tisc::Assembler::new().inst(tisc::VM_Instruction::FltMul).build());
|
|
||||||
linker.add_procedure("f/", tisc::Assembler::new().inst(tisc::VM_Instruction::FltDiv).build());
|
|
||||||
linker.add_procedure("f%", tisc::Assembler::new().inst(tisc::VM_Instruction::FltRem).build());
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"bit-neg",
|
|
||||||
vec![], vec!["machine::Word", "machine::Word"], vec!["machine::Word"],
|
|
||||||
);
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"bit-and",
|
|
||||||
vec![], vec!["machine::Word", "machine::Word"], vec!["machine::Word"],
|
|
||||||
);
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"bit-or",
|
|
||||||
vec![], vec!["machine::Word", "machine::Word"], vec!["machine::Word"],
|
|
||||||
);
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"bit-xor",
|
|
||||||
vec![], vec!["machine::Word", "machine::Word"], vec!["machine::Word"],
|
|
||||||
);
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"bit-shl",
|
|
||||||
vec![], vec!["machine::Word", "machine::Word"], vec!["machine::Word"],
|
|
||||||
);
|
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
|
||||||
"bit-shr",
|
|
||||||
vec![], vec!["machine::Word", "machine::Word"], vec!["machine::Word"],
|
|
||||||
);
|
|
||||||
|
|
||||||
linker.add_procedure("bit-neg", tisc::Assembler::new().inst(tisc::VM_Instruction::BitNeg).build());
|
|
||||||
linker.add_procedure("bit-and", tisc::Assembler::new().inst(tisc::VM_Instruction::BitAnd).build());
|
|
||||||
linker.add_procedure("bit-or", tisc::Assembler::new().inst(tisc::VM_Instruction::BitOr).build());
|
|
||||||
linker.add_procedure("bit-xor", tisc::Assembler::new().inst(tisc::VM_Instruction::BitXor).build());
|
|
||||||
linker.add_procedure("bit-shl", tisc::Assembler::new().inst(tisc::VM_Instruction::BitShl).build());
|
|
||||||
linker.add_procedure("bit-shr", tisc::Assembler::new().inst(tisc::VM_Instruction::BitShr).build());
|
|
||||||
|
|
||||||
|
|
||||||
/* Fetch memory address
|
/* Fetch memory address
|
||||||
*/
|
*/
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
symbols.write().unwrap().declare_proc_parse(
|
||||||
|
@ -202,6 +112,13 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
|
||||||
vec!["<MutRef T~machine::Word>~machine::Address~machine::Word"],
|
vec!["<MutRef T~machine::Word>~machine::Address~machine::Word"],
|
||||||
vec!["T~machine::Word"],
|
vec!["T~machine::Word"],
|
||||||
);
|
);
|
||||||
|
linker.add_procedure(
|
||||||
|
"@",
|
||||||
|
tisc::Assembler::new()
|
||||||
|
.inst(tisc::VM_Instruction::Fetch)
|
||||||
|
.build(),
|
||||||
|
);
|
||||||
|
|
||||||
/* Store to memory
|
/* Store to memory
|
||||||
*/
|
*/
|
||||||
symbols.write().unwrap().declare_proc_parse(
|
symbols.write().unwrap().declare_proc_parse(
|
||||||
|
@ -213,11 +130,72 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
|
||||||
],
|
],
|
||||||
vec![],
|
vec![],
|
||||||
);
|
);
|
||||||
|
linker.add_procedure(
|
||||||
|
"!",
|
||||||
|
tisc::Assembler::new()
|
||||||
|
.inst(tisc::VM_Instruction::Store)
|
||||||
|
.build(),
|
||||||
|
);
|
||||||
|
|
||||||
linker.add_procedure("@", tisc::Assembler::new().inst(tisc::VM_Instruction::Fetch).build());
|
/*
|
||||||
linker.add_procedure("!", tisc::Assembler::new().inst(tisc::VM_Instruction::Store).build());
|
* let muli = λa.λb.{
|
||||||
|
* let mut sum = 0;
|
||||||
|
* while( b != 0 ) {
|
||||||
|
* sum := (addi sum a);
|
||||||
|
* b := (subi b 1);
|
||||||
|
* }
|
||||||
|
* sum
|
||||||
|
* };
|
||||||
|
*/
|
||||||
|
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"],
|
||||||
|
);
|
||||||
|
|
||||||
|
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),
|
||||||
|
// body
|
||||||
|
tisc::Assembler::new()
|
||||||
|
// [ a b sum ] -- [ a b sum a ]
|
||||||
|
.lit(3)
|
||||||
|
.inst(tisc::VM_Instruction::Pick)
|
||||||
|
// [ a b sum a -- a b (sum+a) ]
|
||||||
|
.inst(tisc::VM_Instruction::IntAdd)
|
||||||
|
// [ a b sum -- a sum b ]
|
||||||
|
.inst(tisc::VM_Instruction::Swap)
|
||||||
|
// [ a sum b -- a sum b 1 ]
|
||||||
|
.lit(1)
|
||||||
|
// [ a sum b -- a sum (b-1) ]
|
||||||
|
.inst(tisc::VM_Instruction::Swap)
|
||||||
|
.call("i-")
|
||||||
|
// [ a sum b -- a b sum ]
|
||||||
|
.inst(tisc::VM_Instruction::Swap),
|
||||||
|
)
|
||||||
|
// [ a b sum -- a sum b ]
|
||||||
|
.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)
|
||||||
|
// [ sum a -- sum ]
|
||||||
|
.inst(tisc::VM_Instruction::Drop)
|
||||||
|
.build(),
|
||||||
|
);
|
||||||
|
|
||||||
symbols.write().unwrap().declare_static_parse(
|
symbols.write().unwrap().declare_static_parse(
|
||||||
"data-frame-ptr",
|
"data-frame-ptr",
|
||||||
|
|
Loading…
Reference in a new issue