dergrimm/hence
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add string support to henceforth

Browse source
This commit is contained in:
Dominic Grimm 2022-09-06 11:54:57 +02:00
parent 47529445df
commit 20dfd1244d
No known key found for this signature in database
GPG key ID: A6C051C716D2CE65
16 changed files with 824 additions and 353 deletions
Download patch file Download diff file Expand all files Collapse all files

4
henceforth/src/bin/main.rs
View file

@ -1,5 +1,6 @@
use anyhow::Result;
use clap::{Parser, Subcommand};
use hence::assembler::ToCode;
use std::fs;
use henceforth::*;
@ -56,7 +57,8 @@ fn main() -> Result<()> {
let source = fs::read_to_string(&src)?;
let tokens = lexer::lex(source)?;
let ast = parser::parse(tokens)?;
let assembly = compiler::compile(ast)?;
let ast = compiler::compile(ast)?;
let assembly = ast.to_code();
if let Some(x) = out {
fs::write(x, &assembly)?;

275
henceforth/src/lib/compiler.rs
View file

@ -1,61 +1,52 @@
use std::collections::HashMap;
use anyhow::{bail, Result};
use sailfish::TemplateOnce;
use indexmap::IndexSet;
use itertools::Itertools;
use std::collections::HashMap;
use crate::parser;
#[derive(Debug, Clone, PartialEq)]
pub enum Instruction {
Push(u16),
pub mod instruction;
pub use crate::compiler::instruction::Instruction;
Drop,
Add,
Sub,
Dot,
Call(String),
}
impl Instruction {
pub fn from_word(word: &str) -> Option<Self> {
match word {
"drop" => Some(Instruction::Drop),
"+" => Some(Instruction::Add),
"-" => Some(Instruction::Sub),
"." => Some(Instruction::Dot),
_ => None,
}
}
pub trait Compilable<T, U> {
fn compile(&self, data: &T) -> Result<U>;
}
#[derive(Debug)]
pub struct Word {
id: u16,
instructions: Vec<Instruction>,
pub id: usize,
pub instructions: Vec<Instruction>,
pub times_used: usize,
}
#[derive(Debug)]
pub struct Data {
instructions: Vec<Instruction>,
words: HashMap<String, Word>,
pub words: HashMap<String, Word>,
pub strings: IndexSet<String>,
}
impl Data {
fn new() -> Self {
pub fn new() -> Self {
Self {
instructions: vec![],
words: HashMap::new(),
strings: IndexSet::new(),
}
}
pub fn generate_instructions(&mut self, body: parser::ast::Body) -> Result<()> {
pub fn generate_instructions(&mut self, body: parser::ast::Body) -> Result<Vec<Instruction>> {
let mut instructions: Vec<Instruction> = vec![];
for node in body {
match node {
parser::ast::Node::Comment(_) => {}
parser::ast::Node::String { mode, string } => {}
parser::ast::Node::String { mode, string } => {
let id = self.strings.insert_full(string).0;
instructions.push(match mode.as_str() {
"." => Instruction::DotQuote(id),
_ => bail!("Unknown string mode: {}", mode),
});
}
parser::ast::Node::Number(x) => {
self.instructions.push(Instruction::Push(x as u16));
instructions.push(instruction::Instruction::Push(x as u16));
}
parser::ast::Node::WordDefinition {
name,
@ -68,25 +59,23 @@ impl Data {
bail!("Word already exists as user word definition: {}", name);
}
let pre_instructions = self.instructions.clone();
self.instructions.clear();
self.generate_instructions(body)?;
let instructions = self.instructions.clone();
self.instructions = pre_instructions;
let ins = self.generate_instructions(body)?;
self.words.insert(
name,
Word {
id: self.words.len() as u16,
instructions,
id: self.words.len(),
instructions: ins,
times_used: 0,
},
);
}
parser::ast::Node::Word(x) => {
if let Some(ins) = Instruction::from_word(&x) {
self.instructions.push(ins);
} else if self.words.contains_key(&x) {
self.instructions.push(Instruction::Call(x));
instructions.push(ins);
} else if let Some(w) = self.words.get_mut(&x) {
instructions.push(Instruction::Call(x));
w.times_used += 1;
} else {
bail!("Word does not exist: {}", x);
}
@ -94,20 +83,198 @@ impl Data {
}
}
Ok(())
Ok(instructions)
}
pub fn embed(&self, body: hence::parser::ast::Body) -> hence::parser::ast::Body {
let mut x = vec![
// includes
hence::parser::ast::Node::MacroCall {
name: "include".to_string(),
args: vec![hence::arg::Arg::String("$lib/core.asm".to_string())],
},
hence::parser::ast::Node::MacroCall {
name: "include".to_string(),
args: vec![hence::arg::Arg::String("$lib/std.asm".to_string())],
},
hence::parser::ast::Node::MacroCall {
name: "include".to_string(),
args: vec![hence::arg::Arg::String("$lib/main.asm".to_string())],
},
// constants
hence::parser::ast::Node::MacroCall {
name: "define".to_string(),
args: vec![
hence::arg::Arg::Variable("MEM_CALL_STACK".to_string()),
hence::arg::Arg::Variable("CORE_MEM_MEM".to_string()),
],
},
// macros
// stack_transfer_alu
hence::parser::ast::Node::MacroCall {
name: "macro".to_string(),
args: vec![hence::arg::Arg::Variable("stack_transfer_alu".to_string())],
},
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "endmacro".to_string(),
args: vec![],
},
// call_word
hence::parser::ast::Node::MacroCall {
name: "macro".to_string(),
args: vec![
hence::arg::Arg::Variable("call_word".to_string()),
hence::arg::Arg::Variable("call_word_arg_0_label".to_string()),
],
},
hence::parser::ast::Node::Call {
name: "ts".to_string(),
arg: Some(hence::arg::Arg::BinaryExpression {
left: Box::new(hence::arg::Arg::Variable("OFFSET".to_string())),
right: Box::new(hence::arg::Arg::Number(3 + 3 + 3 + 1 + 3 + 1)),
op: hence::arg::BinaryExpressionOperator::Add,
}),
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::Call {
name: "ts".to_string(),
arg: Some(hence::arg::Arg::Variable("MEM_CALL_STACK".to_string())),
},
hence::parser::ast::Node::Call {
name: "set".to_string(),
arg: None,
},
hence::parser::ast::Node::Call {
name: "ts".to_string(),
arg: Some(hence::arg::Arg::Variable(
"call_word_arg_0_label".to_string(),
)),
},
hence::parser::ast::Node::Call {
// tlr CORE_REG_PC -> tlr 0 -> tlr
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_PC".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "endmacro".to_string(),
args: vec![],
},
// return_word
hence::parser::ast::Node::MacroCall {
name: "macro".to_string(),
args: vec![hence::arg::Arg::Variable("return_word".to_string())],
},
hence::parser::ast::Node::MacroCall {
name: "std_get".to_string(),
args: vec![hence::arg::Arg::Variable("MEM_CALL_STACK".to_string())],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_PC".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "endmacro".to_string(),
args: vec![],
},
// jump_main
hence::parser::ast::Node::MacroCall {
name: "jump_main".to_string(),
args: vec![],
},
// data
hence::parser::ast::Node::Label("data".to_string()),
hence::parser::ast::Node::Label("data_strings".to_string()),
];
for (id, s) in self.strings.iter().enumerate() {
x.extend([
hence::parser::ast::Node::Label(format!("data_strings_{}", id)),
hence::parser::ast::Node::MacroCall {
name: "bytes".to_string(),
args: vec![hence::arg::Arg::String(s.to_string())],
},
hence::parser::ast::Node::Label(format!("data_strings_end_{}", id)),
]);
}
// words
x.push(hence::parser::ast::Node::Label("words".to_string()));
for (name, word) in &self
.words
.iter()
.filter(|(_, w)| w.times_used > 1)
.sorted_by(|a, b| Ord::cmp(&a.1.id, &b.1.id))
.collect::<Vec<_>>()
{
x.extend(vec![
hence::parser::ast::Node::Label(format!("words_{}", word.id)),
hence::parser::ast::Node::Comment(format!("word: \"{}\"", name)),
]);
x.extend(
word.instructions
.iter()
.map(|ins| ins.compile(self))
.collect::<Result<Vec<hence::parser::ast::Body>>>()
.unwrap()
.into_iter()
.flatten(),
);
x.push(hence::parser::ast::Node::MacroCall {
name: "return_word".to_string(),
args: vec![],
});
}
x.extend([
hence::parser::ast::Node::Label("main".to_string()),
hence::parser::ast::Node::MacroCall {
name: "main".to_string(),
args: vec![hence::arg::Arg::Variable("main".to_string())],
},
]);
x.extend(body);
x.push(hence::parser::ast::Node::MacroCall {
name: "std_stop".to_string(),
args: vec![],
});
x
}
}
#[derive(TemplateOnce)]
#[template(path = "assembly.asm")]
pub struct Template {
pub data: Data,
}
pub fn compile(ast: parser::ast::AST) -> Result<String> {
pub fn compile(ast: parser::ast::AST) -> Result<hence::parser::ast::AST> {
let mut data = Data::new();
data.generate_instructions(ast.body)?;
dbg!(&data);
let instructions = data.generate_instructions(ast.body)?;
Ok(Template { data }.render_once()?)
Ok(hence::parser::ast::AST {
body: data.embed(
instructions
.iter()
.map(|ins| ins.compile(&data))
.collect::<Result<Vec<hence::parser::ast::Body>>>()
.unwrap()
.into_iter()
.flatten()
.collect(),
),
})
}

526
henceforth/src/lib/compiler/instruction.rs Normal file
View file

@ -0,0 +1,526 @@
use anyhow::{bail, Result};
use crate::compiler;
#[derive(Debug, Clone, PartialEq)]
pub enum Instruction {
Nop,
Debug,
Quit,
Push(u16),
Drop,
Depth,
Pick,
Dup,
Swap,
Over,
Rot,
Nip,
I,
J,
Tuck,
Fetch,
FetchPrint,
Store,
PlusStore,
MinusStore,
Cells,
Allot,
Dot,
Emit,
Space,
Spaces,
Cr,
DotQuote(usize),
Count,
Not,
And,
Nand,
Or,
Nor,
Xor,
Xnor,
Lsh,
Rsh,
Compare,
Eq,
Neq,
Lt,
Leq,
Gt,
Geq,
Min,
Max,
Boolean,
Invert,
Plus,
OnePlus,
TwoPlus,
Minus,
OneMinus,
TwoMinus,
Times,
Divide,
Mod,
Call(String),
}
impl Instruction {
pub fn from_word(word: &str) -> Option<Self> {
match word.to_lowercase().as_str() {
"nop" => Some(Instruction::Nop),
"debug" => Some(Instruction::Debug),
"quit" => Some(Instruction::Quit),
"drop" => Some(Instruction::Drop),
"depth" => Some(Instruction::Depth),
"pick" => Some(Instruction::Pick),
"dup" => Some(Instruction::Dup),
"swap" => Some(Instruction::Swap),
"over" => Some(Instruction::Over),
"rot" => Some(Instruction::Rot),
"nip" => Some(Instruction::Nip),
"i" => Some(Instruction::I),
"j" => Some(Instruction::J),
"tuck" => Some(Instruction::Tuck),
"@" => Some(Instruction::Fetch),
"?" => Some(Instruction::FetchPrint),
"!" => Some(Instruction::Store),
"+!" => Some(Instruction::PlusStore),
"-!" => Some(Instruction::MinusStore),
"cells" => Some(Instruction::Cells),
"allot" => Some(Instruction::Allot),
"." => Some(Instruction::Dot),
"emit" => Some(Instruction::Emit),
"space" => Some(Instruction::Space),
"spaces" => Some(Instruction::Spaces),
"cr" => Some(Instruction::Cr),
"count" => Some(Instruction::Count),
"not" => Some(Instruction::Not),
"and" => Some(Instruction::And),
"nand" => Some(Instruction::Nand),
"or" => Some(Instruction::Or),
"nor" => Some(Instruction::Nor),
"xor" => Some(Instruction::Xor),
"xnor" => Some(Instruction::Xnor),
"lshift" => Some(Instruction::Lsh),
"rshift" => Some(Instruction::Rsh),
"compare" => Some(Instruction::Compare),
"=" => Some(Instruction::Eq),
"!=" => Some(Instruction::Neq),
"<" => Some(Instruction::Lt),
"<=" => Some(Instruction::Leq),
">" => Some(Instruction::Gt),
">=" => Some(Instruction::Geq),
"min" => Some(Instruction::Min),
"max" => Some(Instruction::Max),
"boolean" => Some(Instruction::Boolean),
"invert" => Some(Instruction::Invert),
"+" => Some(Instruction::Plus),
"1+" => Some(Instruction::OnePlus),
"2+" => Some(Instruction::TwoPlus),
"-" => Some(Instruction::Minus),
"1-" => Some(Instruction::OneMinus),
"2-" => Some(Instruction::TwoMinus),
"*" => Some(Instruction::Times),
"/" => Some(Instruction::Divide),
"mod" => Some(Instruction::Mod),
_ => None,
}
}
}
impl compiler::Compilable<compiler::Data, hence::parser::ast::Body> for Instruction {
fn compile(&self, data: &compiler::Data) -> Result<hence::parser::ast::Body> {
match self {
Instruction::Nop => Ok(vec![hence::parser::ast::Node::Call {
name: "nop".to_string(),
arg: None,
}]),
Instruction::Debug => Ok(vec![hence::parser::ast::Node::Call {
name: "dbg".to_string(),
arg: None,
}]),
Instruction::Quit => Ok(vec![hence::parser::ast::Node::MacroCall {
name: "std_stop".to_string(),
args: vec![],
}]),
Instruction::Push(x) => Ok(vec![hence::parser::ast::Node::Call {
name: "push".to_string(),
arg: Some(hence::arg::Arg::Number(*x)),
}]),
Instruction::Drop => Ok(vec![hence::parser::ast::Node::Call {
name: "pop".to_string(),
arg: None,
}]),
Instruction::Depth => Ok(vec![
hence::parser::ast::Node::Call {
name: "tsr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_SP".to_string())),
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::Pick => Ok(vec![]),
Instruction::Dup => Ok(vec![
hence::parser::ast::Node::Call {
name: "tss".to_string(),
arg: None,
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::Swap => Ok(vec![
// hence::parser::ast::Node::Call {
// name: "ld".to_string(),
// arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
// },
// hence::parser::ast::Node::Call {
// name: "ld".to_string(),
// arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
// },
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
},
hence::parser::ast::Node::Call {
name: "tsr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
hence::parser::ast::Node::Call {
name: "tsr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::Over => Ok(vec![]),
Instruction::Rot => Ok(vec![]),
Instruction::Nip => Ok(vec![]),
Instruction::I => Ok(vec![]),
Instruction::J => Ok(vec![]),
Instruction::Tuck => Ok(vec![]),
Instruction::Fetch => Ok(vec![]),
Instruction::FetchPrint => Ok(vec![]),
Instruction::Store => Ok(vec![]),
Instruction::PlusStore => Ok(vec![]),
Instruction::MinusStore => Ok(vec![]),
Instruction::Cells => Ok(vec![]),
Instruction::Allot => Ok(vec![]),
Instruction::Dot => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_set".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_MEM_OUT".to_string())],
},
]),
Instruction::Emit => Ok(vec![]),
Instruction::Space => Ok(vec![]),
Instruction::Spaces => Ok(vec![]),
Instruction::Cr => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "std_rset".to_string(),
args: vec![
hence::arg::Arg::Variable("CORE_REG_A".to_string()),
hence::arg::Arg::Number(0x0a),
],
},
hence::parser::ast::Node::MacroCall {
name: "std_set".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_MEM_CHR".to_string())],
},
]),
Instruction::DotQuote(x) => {
let loop_label = format!("loop_strings_{}", x);
let data_label = format!("data_strings_{}", x);
let data_end_label = format!("data_strings_end_{}", x);
Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "std_rset".to_string(),
args: vec![
hence::arg::Arg::Variable("CORE_REG_B".to_string()),
hence::arg::Arg::Variable(data_label),
],
},
hence::parser::ast::Node::Label(loop_label.clone()),
hence::parser::ast::Node::Call {
name: "tsr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
},
hence::parser::ast::Node::Call {
name: "get".to_string(),
arg: None,
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_set".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_MEM_CHR".to_string())],
},
hence::parser::ast::Node::MacroCall {
name: "std_rset".to_string(),
args: vec![
hence::arg::Arg::Variable("CORE_REG_A".to_string()),
hence::arg::Arg::Number(1),
],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_ADD".to_string())],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_B".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_rset".to_string(),
args: vec![
hence::arg::Arg::Variable("CORE_REG_A".to_string()),
hence::arg::Arg::Variable(data_end_label),
],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_GT".to_string())],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_cond_jump".to_string(),
args: vec![hence::arg::Arg::Variable(loop_label)],
},
])
}
Instruction::Count => Ok(vec![]),
Instruction::Not => Ok(vec![]),
Instruction::And => Ok(vec![]),
Instruction::Nand => Ok(vec![]),
Instruction::Or => Ok(vec![]),
Instruction::Nor => Ok(vec![]),
Instruction::Xor => Ok(vec![]),
Instruction::Xnor => Ok(vec![]),
Instruction::Lsh => Ok(vec![]),
Instruction::Rsh => Ok(vec![]),
Instruction::Compare => Ok(vec![]),
Instruction::Eq => Ok(vec![]),
Instruction::Neq => Ok(vec![]),
Instruction::Lt => Ok(vec![]),
Instruction::Leq => Ok(vec![]),
Instruction::Gt => Ok(vec![]),
Instruction::Geq => Ok(vec![]),
Instruction::Min => Ok(vec![]),
Instruction::Max => Ok(vec![]),
Instruction::Boolean => Ok(vec![]),
Instruction::Invert => Ok(vec![]),
Instruction::Plus => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "stack_transfer_alu".to_string(),
args: vec![],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_ADD".to_string())],
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::OnePlus => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_rset".to_string(),
args: vec![
hence::arg::Arg::Variable("CORE_REG_B".to_string()),
hence::arg::Arg::Number(1),
],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_ADD".to_string())],
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::TwoPlus => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_rset".to_string(),
args: vec![
hence::arg::Arg::Variable("CORE_REG_B".to_string()),
hence::arg::Arg::Number(2),
],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_ADD".to_string())],
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::Minus => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "stack_transfer_alu".to_string(),
args: vec![],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_SUB".to_string())],
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::OneMinus => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_rset".to_string(),
args: vec![
hence::arg::Arg::Variable("CORE_REG_B".to_string()),
hence::arg::Arg::Number(1),
],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_SUB".to_string())],
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::TwoMinus => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "std_ld".to_string(),
args: vec![],
},
hence::parser::ast::Node::Call {
name: "tlr".to_string(),
arg: Some(hence::arg::Arg::Variable("CORE_REG_A".to_string())),
},
hence::parser::ast::Node::MacroCall {
name: "std_rset".to_string(),
args: vec![
hence::arg::Arg::Variable("CORE_REG_B".to_string()),
hence::arg::Arg::Number(2),
],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_SUB".to_string())],
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::Times => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "stack_transfer_alu".to_string(),
args: vec![],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_MUL".to_string())],
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::Divide => Ok(vec![
hence::parser::ast::Node::MacroCall {
name: "stack_transfer_alu".to_string(),
args: vec![],
},
hence::parser::ast::Node::MacroCall {
name: "std_alu".to_string(),
args: vec![hence::arg::Arg::Variable("CORE_ALU_DIV".to_string())],
},
hence::parser::ast::Node::Call {
name: "tls".to_string(),
arg: None,
},
]),
Instruction::Mod => Ok(vec![]),
Instruction::Call(x) => match data.words.get(x) {
Some(w) => {
if w.times_used > 1 {
Ok(vec![hence::parser::ast::Node::MacroCall {
name: "call_word".to_string(),
args: vec![hence::arg::Arg::Variable(format!("words_{}", w.id))],
}])
} else {
Ok(w.instructions
.iter()
.map(|ins| ins.compile(data))
.collect::<Result<Vec<hence::parser::ast::Body>>>()?
.into_iter()
.flatten()
.collect())
}
}
None => bail!("Unknown word: {}", x),
},
}
}
}

46
henceforth/src/lib/parser.rs
View file

@ -1,11 +1,11 @@
use anyhow::{bail, Result};
use num_parse;
use parse_int;
use crate::lexer;
pub mod ast;
fn process_raw_stack_result(s: Option<&str>) -> Vec<String> {
pub fn parse_stack_state(s: Option<&str>) -> Vec<String> {
match s {
Some(x) if !x.trim().is_empty() => {
x.split_whitespace().map(|x| x.trim().to_string()).collect()
@ -18,8 +18,8 @@ pub fn parse_stack_result(s: String) -> ast::StackResult {
let mut splitter = s.splitn(2, "--");
ast::StackResult {
before: process_raw_stack_result(splitter.next()),
after: process_raw_stack_result(splitter.next()),
before: parse_stack_state(splitter.next()),
after: parse_stack_state(splitter.next()),
}
}
@ -38,12 +38,7 @@ pub fn parse(tokens: Vec<lexer::Token>) -> Result<ast::AST> {
lexer::Token::StringLiteral { mode, string } => {
body.push(ast::Node::String { mode, string });
}
lexer::Token::Number(x) => match num_parse::parse_int::<i32>(x.as_str()) {
Some(n) => {
body.push(ast::Node::Number(n));
}
None => bail!("Invalid number: {}", x),
},
lexer::Token::Number(x) => body.push(ast::Node::Number(parse_int::parse(&x)?)),
lexer::Token::Word(x) => match x.as_str() {
":" => {
let mut depth: usize = 1;
@ -64,7 +59,8 @@ pub fn parse(tokens: Vec<lexer::Token>) -> Result<ast::AST> {
_ => true,
})
.collect::<Vec<_>>()
.into_iter();
.into_iter()
.peekable();
if depth != 0 {
bail!("Unbalanced word definitions");
}
@ -78,16 +74,24 @@ pub fn parse(tokens: Vec<lexer::Token>) -> Result<ast::AST> {
},
None => bail!("Word definition can not be empty"),
};
let stack = match content.find(|t| {
!matches!(t, lexer::Token::Newline(_) | lexer::Token::Whitespace(_))
}) {
Some(t) => match t {
lexer::Token::ParenComment(x)
| lexer::Token::BackslashComment(x)
| lexer::Token::DoubleDashComment(x) => Some(parse_stack_result(x)),
_ => None,
},
None => None,
let stack = loop {
if let Some(t) = content.peek() {
match t {
lexer::Token::Newline(_) | lexer::Token::Whitespace(_) => {
content.next();
}
lexer::Token::ParenComment(x)
| lexer::Token::BackslashComment(x)
| lexer::Token::DoubleDashComment(x) => {
let y = x.to_string();
content.next();
break Some(parse_stack_result(y));
}
_ => break None,
}
} else {
break None;
}
};
body.push(ast::Node::WordDefinition {