DeCarabas/oden
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[fine] Many more import-related shuffles

Browse source
This commit is contained in:
John Doty 2024-02-15 06:12:18 -08:00
parent 994268abb6
commit a3ae4339cf
8 changed files with 159 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

123
fine/src/lib.rs
View file

@ -1,8 +1,8 @@
use std::{collections::HashMap, fs, rc::Rc};
use std::{collections::HashMap, fs, path::PathBuf, rc::Rc};
use compiler::compile;
use parser::parse;
use semantics::{check, Error, Semantics};
use semantics::{check, Error, ImportRecord, Semantics};
use vm::{eval, Context};
pub mod compiler;
@ -17,51 +17,69 @@ pub enum ModuleSource {
#[derive(Debug)]
pub enum ModuleLoadError {
IO(std::io::Error),
IO(String, std::io::Error),
}
pub trait ModuleLoader {
fn normalize_module_name(&self, name: String) -> String;
fn normalize_module_name(&self, source: &str, name: String) -> String;
fn load_module(&self, name: &String) -> Result<ModuleSource, ModuleLoadError>;
}
pub struct StandardModuleLoader {}
pub struct StandardModuleLoader {
base_path: PathBuf,
}
impl StandardModuleLoader {
pub fn new(base_path: PathBuf) -> Self {
StandardModuleLoader { base_path }
}
}
impl ModuleLoader for StandardModuleLoader {
fn normalize_module_name(&self, name: String) -> String {
match std::fs::canonicalize(&name) {
fn normalize_module_name(&self, source: &str, name: String) -> String {
let p = self.base_path.join(source).join(name.clone());
let result = match std::fs::canonicalize(&p) {
Ok(p) => match p.into_os_string().into_string() {
Ok(s) => s,
Err(_) => name,
Err(_e) => {
eprintln!("ERROR INTO OS STRING: {}", _e.to_string_lossy());
name.clone()
}
},
Err(_) => name,
}
Err(_e) => {
eprintln!("ERROR CANONICAL {}: {_e}", p.display());
name.clone()
}
};
eprintln!("**** {source} {name} => {result}");
result
}
fn load_module(&self, name: &String) -> Result<ModuleSource, ModuleLoadError> {
match fs::read_to_string(name) {
Ok(c) => Ok(ModuleSource::SourceText(c)),
Err(e) => Err(ModuleLoadError::IO(e)),
Err(e) => Err(ModuleLoadError::IO(name.clone(), e)),
}
}
}
pub struct Module {
module: Rc<compiler::Module>,
id: u64,
semantics: Rc<Semantics>,
}
impl Module {
pub fn semantics(&self) -> Rc<Semantics> {
self.semantics.clone()
pub fn id(&self) -> u64 {
self.id
}
pub fn compiled(&self) -> Rc<compiler::Module> {
self.module.clone()
pub fn semantics(&self) -> Rc<Semantics> {
self.semantics.clone()
}
}
pub struct Runtime {
next_module_id: u64,
modules: HashMap<String, Rc<Module>>,
loader: Box<dyn ModuleLoader>,
}
@ -69,6 +87,7 @@ pub struct Runtime {
impl Runtime {
pub fn new(loader: Box<dyn ModuleLoader>) -> Self {
Runtime {
next_module_id: 0,
modules: HashMap::new(),
loader,
}
@ -77,55 +96,72 @@ impl Runtime {
pub fn load_module(&mut self, name: &str) -> Result<(Vec<Error>, Rc<Module>), ModuleLoadError> {
let mut init_pending = HashMap::new();
let mut names = Vec::new();
let name = self.loader.normalize_module_name(name.to_string());
let name = self.loader.normalize_module_name("", name.to_string());
names.push(name.clone());
let mut id_assign = self.next_module_id;
while let Some(name) = names.pop() {
if self.modules.contains_key(&name) {
if self.modules.contains_key(&name) || init_pending.contains_key(&name) {
// Either already loaded or pending load.
continue;
}
if !init_pending.contains_key(&name) {
let loaded = self.loader.load_module(&name)?;
match loaded {
ModuleSource::SourceText(source) => {
let source: Rc<str> = source.into();
let (tree, lines) = parse(&source);
let semantics = Rc::new(Semantics::new(source, tree, lines));
let mut normalized = Vec::new();
for import in semantics.imports() {
let import = self.loader.normalize_module_name(import);
names.push(import.clone());
normalized.push(import);
}
// TODO: Errors here are bad! Remember, run everything!
match self.loader.load_module(&name)? {
ModuleSource::SourceText(source) => {
let source: Rc<str> = source.into();
let (tree, lines) = parse(&source);
let semantics = Rc::new(Semantics::new(source, tree, lines));
init_pending.insert(name, (normalized, semantics));
let mut normalized_imports = Vec::new();
for import in semantics.imports() {
let normalized = self.loader.normalize_module_name(&name, import.clone());
names.push(normalized.clone());
normalized_imports.push((import, normalized));
}
init_pending.insert(name, (id_assign, normalized_imports, semantics));
id_assign += 1;
}
}
}
for (_, (imports, semantics)) in init_pending.iter() {
for (_, (_, imports, semantics)) in init_pending.iter() {
let mut import_table = HashMap::new();
for import in imports.iter() {
let target = if let Some(module) = self.modules.get(&*import) {
Rc::downgrade(&module.semantics)
for (import, normalized) in imports.iter() {
// NOTE: We look up the load(ed|ing) module here by normalized name, because that's how
// we track it...
let target = if let Some(module) = self.modules.get(&*normalized) {
ImportRecord {
name: normalized.clone(),
module_id: module.id(),
semantics: Rc::downgrade(&module.semantics),
}
} else {
Rc::downgrade(&init_pending.get(&*import).unwrap().1)
let (module_id, _, semantics) = init_pending.get(&*normalized).unwrap();
ImportRecord {
name: normalized.clone(),
module_id: *module_id,
semantics: Rc::downgrade(semantics),
}
};
// ...but we set it into the import table here with the name
// that the source code used, for more better binding.
import_table.insert(import.clone(), target);
}
semantics.set_imports(import_table);
}
let mut errors = Vec::new();
for (name, (_, semantics)) in init_pending.into_iter() {
for (name, (id, _, semantics)) in init_pending.into_iter() {
check(&semantics);
errors.append(&mut semantics.snapshot_errors());
let module = compile(&semantics);
self.modules
.insert(name, Rc::new(Module { semantics, module }));
self.modules.insert(name, Rc::new(Module { id, semantics }));
}
self.next_module_id = id_assign;
let result = self.modules.get(&name).unwrap().clone();
Ok((errors, result))
@ -133,7 +169,7 @@ impl Runtime {
}
pub fn process_file(file: &str) {
let mut runtime = Runtime::new(Box::new(StandardModuleLoader {}));
let mut runtime = Runtime::new(Box::new(StandardModuleLoader::new(PathBuf::from("."))));
let (errors, module) = match runtime.load_module(file) {
Ok(r) => r,
@ -152,7 +188,8 @@ pub fn process_file(file: &str) {
}
// shrug
let module = module.module.clone();
let semantics = module.semantics();
let module = compile(&semantics);
let main_function = module.functions[module.init].clone();
let mut context = Context::new(module.clone());