syntaxAlchemist/lt-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Compare commits

base: syntaxAlchemist:dev2
Branches Tags
syntaxAlchemist:dev
syntaxAlchemist:dev2
syntaxAlchemist:topic-lib-structure
..
compare: syntaxAlchemist:dev
Branches Tags
syntaxAlchemist:dev2
syntaxAlchemist:dev
syntaxAlchemist:topic-lib-structure

No commits in common. "dev2" and "dev" have entirely different histories.
dev2 ... dev

12 changed files with 224 additions and 431 deletions
Show stats Expand all files Collapse all files

3
Cargo.toml
View file

@ -2,6 +2,5 @@
members = [
"lib-ltcore",
"ltcc",
"ltvm",
"ltobjdump",
"ltvm"
]

1
lib-ltcore/Cargo.toml
View file

@ -7,5 +7,4 @@ edition = "2021"
laddertypes = { path = "../../lib-laddertypes", features = ["pretty"] }
tisc = { path = "../../lib-tisc" }
serde = { version = "1.0", features = ["derive"] }
iterate-text = "0.0.1"
tiny-ansi = "0.1.0"

3
lib-ltcore/src/expr.rs
View file

@ -12,9 +12,6 @@ use {
#[derive(Clone, Debug)]
pub enum Statement {
Import {
path: String,
},
Assignment {
name_region: InputRegionTag,
var_id: String,

22
lib-ltcore/src/parser.rs
View file

@ -225,28 +225,6 @@ where It: Iterator<Item = (InputRegionTag, Result<LTIRToken, LexError>)>
val_expr,
})
}
"import" => {
let region = region.clone();
tokens.next();
let tok = tokens.next();
if let Some((path_region, path_token)) = tok {
match path_token {
Ok(LTIRToken::DoubleQuote(path_str)) => {
let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
Ok(Statement::Import {
path: path_str
})
}
_ => {
Err((path_region, ParseError::UnexpectedToken))
}
}
} else {
Err((region, ParseError::UnexpectedEnd))
}
}
"return" => {
tokens.next();
let expr = parse_expr(super_scope, tokens)?;

206
lib-ltcore/src/procedure_compiler.rs
View file

@ -20,12 +20,7 @@ pub struct ProcedureCompiler {
proc_symbol: String,
scope: Arc<RwLock<Scope>>,
asm: tisc::Assembler,
subroutine_count: u32,
frame_size: u32,
in_types: Vec< laddertypes::TypeTerm >,
out_types: Vec< laddertypes::TypeTerm >,
subroutines: Vec<tisc::assembler::AssemblyWord>,
pub linker: tisc::Linker,
pub diagnostics: Vec<( InputRegionTag, String )>
}
@ -35,36 +30,48 @@ impl ProcedureCompiler {
ProcedureCompiler {
proc_symbol,
scope,
subroutine_count: 0,
frame_size: 0,
in_types: vec![],
out_types: vec![],
subroutines: Vec::new(),
asm: tisc::Assembler::new(),
linker: tisc::Linker::new(),
diagnostics: Vec::new()
}
}
pub fn make_subroutine_symbol(&mut self) -> String {
let id = self.subroutine_count;
self.subroutine_count += 1;
format!("__{}_sub_{}__", self.proc_symbol, id)
/*
pub fn export_symbols(&self) -> Vec<(String, SymbolDef)> {
let mut scope = self.scope.write().unwrap();
scope.update_link_addresses(&self.proc_symbol, &self.linker);
scope.export()
}
pub fn get_bytecode(mut self) -> (
*/
pub fn get_bytecode(mut self, ret: bool) -> (
Vec<(String, SymbolDef)>,
Vec<tisc::assembler::AssemblyWord>
) {
if self.frame_size > 0 {
let frame_size = self.scope.read().unwrap().get_frame_size();
if frame_size > 0 {
let alloc_asm = tisc::Assembler::new()
.lit(self.frame_size as tisc::VM_Word).call("data-frame-alloc");
.lit(frame_size as tisc::VM_Word).call("data-frame-alloc");
let drop_asm = tisc::Assembler::new()
.lit(self.frame_size as tisc::VM_Word).call("data-frame-drop");
.lit(frame_size as tisc::VM_Word).call("data-frame-drop");
self.asm = alloc_asm.join( self.asm ).join( drop_asm );
}
self.linker.add_procedure_front( &self.proc_symbol, self.asm.build() );
let main_section = self.asm.build();
//self.linker.add_procedure( &self.proc_symbol, main_section );
// ^--- this would insert the asm section at the end,
// we however need it an the beginning of the bytecode
// insert section at front
self.linker.next_addr += main_section.len() as i64;
for (name,section) in self.linker.symbols.iter_mut() {
section.addr += main_section.len() as i64;
}
self.linker.symbols.insert(
self.proc_symbol.clone(),
tisc::linker::Section { addr: 0, data: main_section }
);
// replace all symbol definitions from subroutines
// with relative LinkAddr`s
@ -73,28 +80,22 @@ impl ProcedureCompiler {
&self.linker
);
let code =
self.linker.link_relative(&self.proc_symbol).expect("link error");
let mut export_symbols = self.scope.read().unwrap().export();
(
export_symbols,
code
self.scope.read().unwrap().export(),
self.linker.link_relative( &self.proc_symbol ).expect("link error")
)
}
pub fn compile_statement(mut self, statement: &Statement) -> Self {
pub fn compile_statement(mut self, statement: &Statement, enable_export: bool) -> Self {
match statement {
Statement::Import { path } => {
}
Statement::Assignment { name_region, var_id, val_expr } => {
self = self.compile_expr(val_expr, true);
self = self.compile_expr(val_expr);
match self.scope.read().unwrap().get(var_id) {
Some(SymbolDef::FrameRef { typ, stack_ref }) => {
self.asm = self.asm.lit(stack_ref).call("data-frame-set");
}
Some(SymbolDef::StaticRef { typ, link_addr, export }) => {
Some(SymbolDef::StaticRef { typ, link_addr }) => {
self.asm = self
.asm
.static_ref(var_id.as_str())
@ -126,20 +127,35 @@ impl ProcedureCompiler {
} => {
let val_type = self.scope.read().unwrap()
.get(var_id).unwrap()
.get_type(&mut self.scope.clone())
.sugar(&mut self.scope.clone());
.get_type(&mut self.scope.clone());
let val_type = val_type.sugar(&mut self.scope.clone());
match val_type {
laddertypes::SugaredTypeTerm::Func(mut f_types) => {
let mut c =
ProcedureCompiler::new(
var_id.clone(), self.scope.clone()
).compile_expr( val_expr, true );
let mut c = ProcedureCompiler::new(
var_id.clone(),
self.scope.clone()
);
c = c.compile_expr( val_expr );
self.diagnostics.append(&mut c.diagnostics);
let (symbols,code) = c.get_bytecode();
let (symbols,code) = c.get_bytecode( true );
eprintln!("LET assign compiled {}", var_id);
for (i,l) in tisc::assembler::disassemble( &code ).iter().enumerate() {
eprintln!("{}+{} ... {}", var_id, i, l);
}
self.linker.add_procedure(var_id, code);
/*
let out_types = vec![ f_types.pop().unwrap().desugar(&mut self.scope.clone()) ];
let in_types = f_types.into_iter().map(|t| t.desugar(&mut self.scope.clone())).collect();
self.scope.write().unwrap().declare_proc(
var_id.clone(),
in_types,
out_types,
true
);
*/
}
_ => {
@ -147,34 +163,27 @@ impl ProcedureCompiler {
name_region: *name_region,
var_id: var_id.clone(),
val_expr: val_expr.clone(),
});
self.frame_size += 1;
}, false);
}
}
}
Statement::Expr(expr) => {
self = self.compile_expr(expr, true);
self = self.compile_expr(expr);
}
Statement::Return(expr) => {
self = self.compile_expr(expr, true);
self = self.compile_expr(expr);
}
}
self
}
pub fn compile_expr(mut self, expr: &LTExpr, call: bool) -> Self {
/*
self.out_types.push(
expr.infer_type( &self.scope ).expect("type error")
);
*/
pub fn compile_expr(mut self, expr: &LTExpr) -> Self {
match expr {
LTExpr::Symbol { region, typ, symbol } => match self.scope.read().unwrap().get(symbol) {
Some(SymbolDef::FrameRef { typ, stack_ref }) => {
self.asm = self.asm.lit(stack_ref).call("data-frame-get");
}
Some(SymbolDef::StaticRef { typ, link_addr, export }) => {
Some(SymbolDef::StaticRef { typ, link_addr }) => {
self.asm = self.asm.static_ref(symbol.as_str());
}
Some(SymbolDef::Procedure {
@ -183,11 +192,7 @@ impl ProcedureCompiler {
link_addr,
export
}) => {
if call {
self.asm = self.asm.call_symbol(link_addr);
} else {
self.asm = self.asm.ref_symbol( link_addr );
}
self.asm = self.asm.call_symbol(link_addr);
}
None => {
self.diagnostics.push(
@ -205,10 +210,10 @@ impl ProcedureCompiler {
self.asm = self.asm.lit(*val);
}
LTExpr::Ascend { region, typ, expr } => {
self = self.compile_expr(expr, call);
self = self.compile_expr(expr);
}
LTExpr::Descend { region, typ, expr } => {
self = self.compile_expr(expr, call);
self = self.compile_expr(expr);
}
LTExpr::Branch {
region,
@ -216,14 +221,14 @@ impl ProcedureCompiler {
if_expr,
else_expr,
} => {
self = self.compile_expr(condition, true);
self = self.compile_expr(condition);
let asm = self.asm;
self.asm = tisc::Assembler::new();
self = self.compile_expr(if_expr, true);
self = self.compile_expr(if_expr);
let if_asm = self.asm;
self.asm = tisc::Assembler::new();
self = self.compile_expr(else_expr, true);
self = self.compile_expr(else_expr);
let else_asm = self.asm;
self.asm = asm;
self.asm = self.asm.branch(if_asm, else_asm);
@ -232,34 +237,34 @@ impl ProcedureCompiler {
let asm = self.asm;
self.asm = tisc::Assembler::new();
self = self.compile_expr(condition, true);
self = self.compile_expr(condition);
let cond_asm = self.asm;
self.asm = tisc::Assembler::new();
self = self.compile_expr(body, true);
self = self.compile_expr(body);
let body_asm = self.asm;
self.asm = asm;
self.asm = self.asm.while_loop(cond_asm, body_asm);
}
LTExpr::Application { region, typ, head, body } => {
LTExpr::Application { region, typ, head, body } => {
for arg in body.iter().rev() {
self = self.compile_expr(arg, false);
self = self.compile_expr(arg);
}
self = self.compile_expr(head, true);
self = self.compile_expr(head);
}
LTExpr::Abstraction { region, scope, args, body } => {
let abs_symbol = self.make_subroutine_symbol();
let mut abs_compiler = ProcedureCompiler::new(abs_symbol.clone(), scope.clone());
let mut abs_compiler = ProcedureCompiler::new("__abs__".into(), scope.clone());
for (region, arg_name, arg_type) in args.iter() {
match scope.read().unwrap().get(arg_name) {
Some(SymbolDef::FrameRef{ typ, stack_ref }) => {
eprintln!("Arg {} stack ref = {}", arg_name, stack_ref);
// TODO: aknowledge actual size of arguments
// let arg_size = typ.get_size()
let arg_size = 1;
abs_compiler.frame_size += 1;
for i in 0..arg_size {
abs_compiler.asm = abs_compiler.asm
.lit(stack_ref + i)
@ -275,23 +280,50 @@ impl ProcedureCompiler {
}
}
abs_compiler = abs_compiler.compile_expr( body, true );
let (abs_export_symbols, mut abs_code) = abs_compiler.get_bytecode();
self.scope.write().unwrap().import( abs_export_symbols );
self.linker.add_procedure( &abs_symbol, abs_code );
self.asm = self.asm.call( &abs_symbol );
}
LTExpr::ExportBlock{ region, scope, statements }
| LTExpr::Block { region, scope, statements } => {
let block_symbol = self.make_subroutine_symbol();
let mut block_compiler = ProcedureCompiler::new( block_symbol.clone(), scope.clone() );
for stmnt in statements.iter() {
block_compiler = block_compiler.compile_statement( stmnt );
abs_compiler = abs_compiler.compile_expr( body );
let (abs_symbols, mut abs_code) = abs_compiler.get_bytecode( false );
for (s,def) in abs_symbols.iter() {
eprintln!("{} = {:?}", s, def);
}
let (block_export_symbols, mut block_code) = block_compiler.get_bytecode();
self.scope.write().unwrap().import( block_export_symbols );
self.linker.add_procedure( &block_symbol, block_code.clone() );
self.asm = self.asm.call( &block_symbol );
for (i, l) in tisc::assembler::disassemble(&abs_code).into_iter().enumerate() {
eprintln!("__abs__+{} .. {}", i, l);
}
self.asm.words.append( &mut abs_code );
/*
self.linker.add_procedure(
"__abs__".into(),
abs_code
);*/
}
LTExpr::Block { region, scope, statements } => {
let mut block_compiler = ProcedureCompiler::new(
"__block__".into(),
scope.clone()
);
for stmnt in statements.iter() {
block_compiler = block_compiler.compile_statement( stmnt, true );
}
let (block_symbols, mut block_code) = block_compiler.get_bytecode( true );
eprintln!("BLOCK compiler:");
for (s,def) in block_symbols.iter() {
eprintln!("{} = {:?}", s, def);
}
for (i,l) in tisc::assembler::disassemble( &block_code ).into_iter().enumerate() {
eprintln!("block+{} .. {}", i, l);
}
self.linker.
self.scope.write().unwrap().import(
block_symbols
);
self.asm.words.append(&mut block_code);
}
LTExpr::ExportBlock{ region, scope, statements } => {
}
}
self

45
lib-ltcore/src/symbols.rs
View file

@ -20,7 +20,6 @@ pub enum SymbolDef {
StaticRef {
typ: laddertypes::TypeTerm,
link_addr: Option<tisc::VM_Word>,
export: bool
},
Procedure {
in_types: Vec<laddertypes::TypeTerm>,
@ -37,7 +36,7 @@ impl SymbolDef {
) -> laddertypes::TypeTerm {
match self {
SymbolDef::FrameRef { typ, stack_ref: _ } => typ.clone(),
SymbolDef::StaticRef { typ, link_addr: _, export: _ } => typ.clone(),
SymbolDef::StaticRef { typ, link_addr: _ } => typ.clone(),
SymbolDef::Procedure {
in_types,
out_types,
@ -154,7 +153,6 @@ impl Scope {
.iter()
.filter(|(name, def)|
match def {
SymbolDef::StaticRef { typ:_, link_addr:_, export } => *export,
SymbolDef::Procedure { in_types:_, out_types:_, link_addr:_, export } => *export,
_ => false
}
@ -209,38 +207,25 @@ impl Scope {
linker: &tisc::Linker
) {
for (name, def) in self.symbols.iter_mut() {
match def {
SymbolDef::Procedure {
in_types:_,
out_types:_,
link_addr,
export:_
} => {
if let Some(offset) = linker.get_link_addr( name ) {
// eprintln!("update link addr {} @ {} + {}", name, base_symbol, offset);
if let Some(offset) = linker.get_link_addr( name ) {
match def {
SymbolDef::Procedure {
in_types:_,out_types:_,
link_addr,
export:_
} => {
*link_addr = LinkAddr::Relative{
symbol: base_symbol.clone(),
offset
};
} else {
match link_addr {
LinkAddr::Relative{ symbol, offset } => {
if let Some(base_symb_offset) = linker.get_link_addr( &symbol ) {
*symbol = base_symbol.clone();
*offset += base_symb_offset;
}
},
_ => {}
}
}
}
_ => {
// TODO: what about StaticRef??
},
_ => {}
}
}
}
}
//<><><><><><>
pub fn declare_proc_parse(
@ -273,7 +258,7 @@ impl Scope {
}
})
.collect(),
true
false
);
}
@ -320,17 +305,15 @@ impl Scope {
let typ = self
.parse(typ)
.expect("parse typeterm");
self.declare_static(String::from(name), typ, true);
self.declare_static(String::from(name), typ);
}
pub fn declare_static(&mut self, name: String, typ: laddertypes::TypeTerm, export: bool) {
eprintln!("add {} export {}", name, export);
pub fn declare_static(&mut self, name: String, typ: laddertypes::TypeTerm) {
self.symbols.insert(
name,
SymbolDef::StaticRef {
typ,
link_addr: None,
export
},
);
}

122
lib-ltcore/src/typing.rs
View file

@ -23,39 +23,24 @@ impl LTExpr {
Err(TypeError::Todo)
}*/
pub fn export_symbols(&self) -> Vec< (String, SymbolDef) > {
match self {
LTExpr::Block{ region, scope, statements }
| LTExpr::ExportBlock{
region,
scope,
statements
} => {
scope.read().unwrap().export()
}
_ => vec![]
}
}
pub fn infer_type(&self, super_scope: &Arc<RwLock<Scope>>) -> TypeTag
pub fn infer_type(&self, scope: &Arc<RwLock<Scope>>) -> TypeTag
{
match self {
LTExpr::WordLiteral{ region, val } => {
Ok(super_scope.write().unwrap().parse(
"machine.Int64 ~ machine.Word"
Ok(scope.write().unwrap().parse(
"ℤ_2^64 ~ machine.UInt64 ~ machine.Word"
).unwrap())
}
LTExpr::StringLiteral{ region, value } => {
Ok(super_scope.write().unwrap().parse(
Ok(scope.write().unwrap().parse(
"<Seq Char ~ Unicode ~ ℤ_2^32 ~ ℤ_2^64 ~ machine.UInt64>
~ <TermArray 0 machine.UInt64 ~ machine.Word>"
).unwrap())
}
LTExpr::Symbol { region, typ, symbol } => {
let mut s = super_scope.write().unwrap();
let mut s = scope.write().unwrap();
if let Some(sdef) = s.get(symbol) {
Ok(sdef.get_type(&mut *s))
} else {
@ -65,7 +50,7 @@ impl LTExpr {
}
LTExpr::Ascend { region, typ, expr } => {
let expr_type = expr.infer_type( super_scope )?;
let expr_type = expr.infer_type( scope )?;
let sub_type = typ.clone();
/*
@ -89,7 +74,7 @@ impl LTExpr {
}
LTExpr::Descend { region, typ, expr } => {
let expr_type = expr.infer_type(super_scope)?;
let expr_type = expr.infer_type(scope)?;
let super_type = typ.clone();
if let Ok(i) = expr_type.is_syntactic_subtype_of(&super_type) {
@ -127,11 +112,11 @@ impl LTExpr {
}
LTExpr::Application{ region, typ, head, body } => {
let mut head_type = head.infer_type(super_scope)?;
let mut head_type = head.infer_type(scope)?;
let mut args = body.into_iter();
let mut result_type = head_type;
let mut sugared_result_type = result_type.sugar(&mut *super_scope.write().unwrap());
let mut sugared_result_type = result_type.sugar(&mut *scope.write().unwrap());
let mut errors = Vec::new();
@ -141,10 +126,10 @@ impl LTExpr {
for (argi, expected_arg_type) in f_types.iter().enumerate() {
if let Some(arg) = args.next() {
let expected_arg_type = expected_arg_type.clone().desugar(&mut *super_scope.write().unwrap());
let expected_arg_type = expected_arg_type.clone().desugar(&mut *scope.write().unwrap());
// check subtype
let received_arg_type = arg.infer_type(super_scope)?;
let received_arg_type = arg.infer_type(scope)?;
if ! received_arg_type.is_syntactic_subtype_of(&expected_arg_type).is_ok() {
errors.push(TypeError{
region: arg.get_region(),
@ -166,7 +151,7 @@ impl LTExpr {
return
if errors.len() == 0 {
result_type = sugared_result_type.desugar(&mut *super_scope.write().unwrap());
result_type = sugared_result_type.desugar(&mut *scope.write().unwrap());
Ok(result_type)
} else {
Err(errors)
@ -183,7 +168,7 @@ impl LTExpr {
}
if errors.len() == 0 {
result_type = sugared_result_type.desugar(&mut *super_scope.write().unwrap());
result_type = sugared_result_type.desugar(&mut *scope.write().unwrap());
Ok(result_type)
} else {
Err(errors)
@ -191,13 +176,13 @@ impl LTExpr {
}
LTExpr::Branch { region, condition, if_expr, else_expr } => {
let received_cond_type = condition.infer_type(super_scope)?;
let expected_cond_type = super_scope.write().unwrap().parse("Bool ~ machine.Word").unwrap();
let received_cond_type = condition.infer_type(scope)?;
let expected_cond_type = scope.write().unwrap().parse("Bool ~ machine.Word").unwrap();
if received_cond_type.is_syntactic_subtype_of(&expected_cond_type).is_ok() {
let if_expr_type = if_expr.infer_type(super_scope)?;
let else_expr_type = else_expr.infer_type(super_scope)?;
let if_expr_type = if_expr.infer_type(scope)?;
let else_expr_type = else_expr.infer_type(scope)?;
if if_expr_type.is_syntactic_subtype_of(&else_expr_type).is_ok() {
Ok(else_expr_type)
@ -223,14 +208,14 @@ impl LTExpr {
}
}
LTExpr::WhileLoop { region, condition, body } => {
let received_cond_type = condition.infer_type(super_scope)?;
let expected_cond_type = super_scope.write().unwrap().parse("Bool ~ machine.Word").unwrap();
let received_cond_type = condition.infer_type(scope)?;
let expected_cond_type = scope.write().unwrap().parse("Bool ~ machine.Word").unwrap();
if received_cond_type.is_syntactic_subtype_of(&expected_cond_type).is_ok() {
let body_type = body.infer_type(super_scope)?;
let body_type = body_type.sugar(&mut super_scope.clone());
let body_type = body.infer_type(scope)?;
let body_type = body_type.sugar(&mut scope.clone());
let loop_type = laddertypes::SugaredTypeTerm::Seq(vec![ body_type ]);
Ok(loop_type.desugar(&mut super_scope.clone()))
Ok(loop_type.desugar(&mut scope.clone()))
} else {
return Err(vec![ TypeError{
region: condition.get_region(),
@ -245,14 +230,8 @@ impl LTExpr {
LTExpr::Block{ region, scope, statements } => {
let mut types = Vec::new();
let enable_export =
match self {
LTExpr::ExportBlock{ region:_, scope:_, statements:_ } => true,
_ => false
};
for s in statements {
match s.infer_type(scope, enable_export) {
match s.infer_type(scope) {
Ok(Some(t)) => {
if !t.is_empty() {
types.insert(0, t);
@ -265,11 +244,6 @@ impl LTExpr {
}
}
let export = scope.read().unwrap().export();
super_scope.write().unwrap().import(
export
);
Ok(
if types.len() == 1 { types.pop().unwrap() }
else { laddertypes::SugaredTypeTerm::Struct(types) }
@ -281,47 +255,8 @@ impl LTExpr {
}
impl Statement {
pub fn infer_type(&self, scope: &Arc<RwLock<Scope>>, enable_export: bool) -> Result< Option<laddertypes::SugaredTypeTerm> , Vec<TypeError> > {
pub fn infer_type(&self, scope: &Arc<RwLock<Scope>>) -> Result< Option<laddertypes::SugaredTypeTerm> , Vec<TypeError> > {
match self {
Statement::Import { path } => {
/*
* 1. load file
* 2. parse
* 3. infer types
* 3. import symbols
*/
let iter_chars = iterate_text::file::characters::IterateFileCharacters::new(path.clone());
/* compile source file
*/
let mut lexer = crate::lexer::LTIRLexer::from( iter_chars.peekable() );
let mut program_tokens =
lexer
.filter(|tok| match tok {
(_, Ok(crate::lexer::LTIRToken::Comment(_))) => false,
_ => true
})
.peekable();
let mut scope = scope.clone();
match crate::parser::parse_expr( &mut scope, &mut program_tokens ) {
Ok( mut ast ) => {
match ast.infer_type(&scope) {
Ok(mut t) => {
}
Err(type_err) =>{
eprintln!("In {} : Type Error", path);
}
}
}
Err( parse_err ) => {
eprintln!("In {} : Parse Error", path);
}
}
Ok(None)
}
Statement::LetAssign{ name_region, typ, var_id, val_expr } => {
let typ = val_expr.infer_type( scope )?;
@ -336,17 +271,18 @@ impl Statement {
let in_types = args.into_iter().map(|t| t.desugar(&mut scope.clone())).collect();
scope.write().unwrap()
.declare_proc(
.declare_proc(
var_id.clone(),
in_types,
out_types,
enable_export
true
);
return Ok(None);
}
_ => {
let id = scope.write().unwrap().declare_var(var_id.clone(), typ);
eprintln!("TYPING declare var = {}", id);
Ok(None)
}
}
@ -355,10 +291,6 @@ impl Statement {
Statement::Expr(expr) => {
let t = expr.infer_type(scope)?;
let symb = expr.export_symbols();
// eprintln!("expr statement: import symbols from expr {:?}", symb);
// scope.write().unwrap().import( symb );
if t != laddertypes::TypeTerm::App(vec![]) {
let st = t.sugar(&mut scope.clone());
Ok(Some(st))

151
ltcc/src/main.rs
View file

@ -17,19 +17,6 @@ use {
mod diagnostic;
/* TODO:
* - import function symbols (use / import statement)
* - parse float literals
* - return type annotation
* - write to address resulting from expression
* - sized objects
* - typecheck stack
*/
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
@ -45,71 +32,7 @@ fn main() {
let args = Args::parse();
let mut linker = tisc::Linker::new();
let mut runtime_linker = tisc::Linker::new();
let root_scope = ltcore::runtime::init_runtime(&mut runtime_linker);
let runtime_obj_file = tisc::linker::ObjectFile {
symbols: root_scope.read().unwrap().clone()
.export()
.into_iter()
.filter_map(|(symbol, def)| match def {
ltcore::symbols::SymbolDef::StaticRef { typ, link_addr, export } => {
if export {
if let Some(addr)= runtime_linker.get_link_addr(&symbol) {
Some((symbol, addr))
} else {
None
}
} else {
None
}
}
ltcore::symbols::SymbolDef::Procedure { in_types:_, out_types:_, link_addr, export } => {
if true {
match link_addr {
tisc::LinkAddr::Absolute(w) => {
// eprintln!("add symbol {} -> {}", symbol, w);
Some(( symbol, w ))
}
tisc::LinkAddr::Relative{ symbol: b, offset } => {
let addr = runtime_linker.get_link_addr(&b).unwrap_or(-1);
// eprintln!("relative symbol {} -> {}({})+{}", symbol, b, addr, offset);
Some((symbol, addr + offset))
}
}
} else {
None
}
}
_ => None
})
.collect(),
code: runtime_linker.link_partial().expect("Link error:")
.into_iter()
.map(|w| match w {
tisc::assembler::AssemblyWord::Symbol(
tisc::LinkAddr::Absolute(a)
) => {
tisc::assembler::AssemblyWord::Symbol(
tisc::LinkAddr::Relative{
symbol: "runtime.lt.o".into(),
offset: a
}
)
},
w => w
})
.collect()
};
let mut runtime_output = std::io::BufWriter::new(
std::fs::File::create("runtime.lt.o").expect("Failed to open file")
);
bincode::serialize_into( runtime_output, &runtime_obj_file );
let root_scope = ltcore::runtime::init_runtime(&mut linker);
let mut main_scope = Scope::with_parent(&root_scope);
for path in args.sources {
@ -150,13 +73,13 @@ fn main() {
eprintln!("----------------------------------");
eprintln!("{} ({} errors)", "Typecheck failed".bright_red().bold(), type_errs.len());
std::process::exit(-2);
return;
}
}
compiler = compiler.compile_expr(&ast, true);
compiler = compiler.compile_expr(&ast);
let diagnostics = compiler.diagnostics.clone();
let (exports, proc_code) = compiler.get_bytecode();
let (exports, proc_code) = compiler.get_bytecode(false);
for (region, message) in diagnostics {
crate::diagnostic::print_diagnostic(
@ -166,16 +89,28 @@ fn main() {
);
}
eprintln!("{} {}\n{}", "Compiled".green(), path.bold(), "---------------".green());
eprintln!("{} {}", "Compiled".green(), path.bold());
for (name, def) in exports.iter() {
eprintln!("export {}:", name.yellow().bold());
let mut t = def.get_type(&mut main_scope);
t = t.normalize();
t = t.param_normalize();
let mut tc = main_scope.clone();
eprintln!( "{}", t.sugar(&mut tc).pretty(&tc,0) );
}
main_scope.write().unwrap().import(
exports
);
/* link assembly-program to symbols
*/
linker.add_procedure_front(path.as_str(), proc_code);
main_scope.write().unwrap().update_link_addresses(
&path,
&linker
);
eprintln!("generated bytecode ({})", proc_code.len() );
for (i,l) in tisc::assembler::disassemble(&proc_code).iter().enumerate() {
eprintln!("{} .... {}", i,l);
}
linker.add_procedure(path.as_str(), proc_code);
}
Err( (region, parse_error) ) => {
crate::diagnostic::print_diagnostic(
@ -185,43 +120,27 @@ fn main() {
);
eprintln!("=======\nParse Error: Abort\n");
std::process::exit(-1);
}
}
}
eprintln!("write output file {}", args.output);
let obj_file = tisc::linker::ObjectFile {
symbols: Arc::into_inner(main_scope).unwrap().into_inner().unwrap()
.export()
.into_iter()
.filter_map(|(symbol, def)| match def {
ltcore::symbols::SymbolDef::StaticRef { typ, link_addr, export } => {
if export {
if let Some(addr) = linker.get_link_addr(&symbol) {
Some((symbol.clone(), addr))
} else {
None
}
} else {
None
}
}
ltcore::symbols::SymbolDef::Procedure { in_types:_, out_types:_, link_addr, export } => {
if export {
match link_addr {
tisc::LinkAddr::Absolute(w) => {
// eprintln!("add symbol {} -> {}", symbol, w);
eprintln!("add symbol {} -> {}", symbol, w);
Some(( symbol, w ))
}
tisc::LinkAddr::Relative{ symbol: b, offset } => {
if let Some(addr) = linker.get_link_addr(&b) {
// eprintln!("relative symbol {} -> {}({})+{}", symbol, b, addr, offset);
Some((symbol, addr + offset ))
} else {
None
}
let addr = linker.get_link_addr(&b).unwrap_or(-1);
eprintln!("relative symbol {} -> {}({})+{}", symbol, b, addr, offset);
Some((symbol, addr + offset ))
}
}
} else {
@ -233,22 +152,6 @@ fn main() {
.collect(),
code: linker.link_partial().expect("Link error:")
.into_iter()
.map(|w| match w {
tisc::assembler::AssemblyWord::Symbol(
tisc::LinkAddr::Absolute(a)
) => {
tisc::assembler::AssemblyWord::Symbol(
tisc::LinkAddr::Relative{
symbol: args.output.clone().into(),
offset: a
}
)
},
w => w
})
.collect()
};
let mut output = std::io::BufWriter::new(

30
ltcc/src/oldmain.rs Normal file
View file

@ -0,0 +1,30 @@
use {
std::collections::HashMap,
std::sync::{Arc, RwLock},
std::{boxed::Box, ops::Deref},
tiny_ansi::TinyAnsi
};
use crate::{
lexer::InputRegionTag,
expr::{LTExpr, Statement},
procedure_compiler::ProcedureCompiler,
symbols::Scope,
};
/* TODO:
* - import function symbols
* - Compiler error reporting
* - parse float literals
* - return type annotation
* - write to address resulting from expression
* - sized objects
* - Typecheck for LTExpr::Application
* - typecheck & inference for rest
*/
fn main() {
// create virtual machine with 4096 words of memory
let mut vm = tisc::VM::new(0x1000);
}

14
ltobjdump/Cargo.toml
View file

@ -1,14 +0,0 @@
[package]
name = "ltobjdump"
version = "0.1.0"
edition = "2021"
[dependencies]
laddertypes = { path = "../../lib-laddertypes" }
ltcore = { path = "../lib-ltcore" }
tisc = { path = "../../lib-tisc" }
clap = { version = "4.5.15", features = ["derive"] }
tiny-ansi = "0.1.0"
iterate-text = "0.0.1"
bincode = "1.3.3"

50
ltobjdump/src/main.rs
View file

@ -1,50 +0,0 @@
use {
std::io::Read,
clap::Parser,
tiny_ansi::TinyAnsi,
};
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
/// source files
sources: Vec< String >,
}
fn main() {
let args = Args::parse();
for source_path in args.sources.iter() {
let mut input = std::io::BufReader::new(
std::fs::File::open(source_path).expect("Failed to open file")
);
let obj_file : tisc::linker::ObjectFile
= bincode::deserialize_from( input ).expect("");
println!("{}\n{}", source_path.bold().yellow(), "------------".green());
println!("{}", "Symbols".bold().white());
for (name, addr) in obj_file.symbols.iter() {
println!("{} @ {}", name.bold().yellow(), format!("{:#010x}", addr).blue());
}
println!("{}\n{}", "------------".green(),
"Code".bold().white());
for (i,l) in tisc::assembler::disassemble( &obj_file.code )
.into_iter().enumerate()
{
for (name, addr) in obj_file.symbols.iter() {
if *addr == i as tisc::VM_Word {
println!("{}:", name.bold().yellow());
}
}
println!("{} {}", format!("{:#06x}",i).blue(), l.green());
}
println!("{}\n", "============".green());
}
}

8
ltvm/src/main.rs
View file

@ -25,16 +25,20 @@ fn main() {
let mut vm = tisc::VM::new( args.memsize );
let mut linker = tisc::Linker::new();
let mut symbols = std::collections::HashMap::<String, tisc::LinkAddr>::new();
for source_path in args.sources.iter() {
let mut input = std::io::BufReader::new(
std::fs::File::open(source_path).expect("Failed to open file")
);
let obj_file : tisc::linker::ObjectFile = bincode::deserialize_from( input ).expect("");
linker.import( source_path, obj_file );
linker.import( source_path, bincode::deserialize_from( input ).expect("") );
}
let entry_addr = linker.get_link_addr(&args.entry).unwrap_or(0);
/*
.expect(&format!("cant find entry symbol '{}'", args.entry));
*/
let bytecode = linker.link_total().expect("Link error:");
eprintln!("{} ({} bytes)", "Loaded bytecode.".green(), bytecode.len());