rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "allow paths in use_module(library(..)) (#604)"

Browse Source 
This reverts commit cfd15f4e02.
This commit is contained in:
notoria
2020-07-01 10:07:26 +02:00
parent e05c34d1ee
commit 1eb42654e0
4 changed files with 59 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/machine/compile.rs
View File

@@ -600,44 +600,30 @@ fn load_library(
name: ClauseName,
suppress_warnings: bool,
) -> Result<ClauseName, SessionError> {
let mut lib_path = current_dir();
match LIBRARIES.borrow().get(name.as_str()) {
Some(code) => {
let mut lib_path = current_dir();
lib_path.pop();
lib_path.push("lib");
lib_path.pop();
lib_path.push("lib");
let (stream, listing_src) =
match LIBRARIES.borrow().get(name.as_str()) {
Some(code) => {
let listing_src = ListingSource::from_file_and_path(name, lib_path);
(Stream::from(*code), listing_src)
}
None => {
// assume that name is a path.
lib_path.push(name.as_str());
lib_path.set_extension("pl");
let listing_src = ListingSource::from_file_and_path(name, lib_path);
let file =
match File::open(&lib_path) {
Ok(file) => {
file
}
Err(_) => {
let err = ExistenceError::ModuleSource(ModuleSource::Library(name));
return Err(SessionError::ExistenceError(err));
}
};
load_module(
wam,
Stream::from(*code),
suppress_warnings,
&listing_src,
)
}
None => {
let err = ExistenceError::ModuleSource(ModuleSource::Library(
name.clone()
));
let listing_src = ListingSource::from_file_and_path(name.clone(), lib_path);
(Stream::from_file_as_input(name, file), listing_src)
}
};
load_module(
wam,
stream,
suppress_warnings,
&listing_src,
)
Err(SessionError::ExistenceError(err))
}
}
}
impl ListingCompiler {

68
src/machine/mod.rs
View File

@@ -666,27 +666,21 @@ impl Machine {
Ok(exports)
}
fn use_module(&mut self, to_src: impl Fn(ClauseName) -> ModuleSource)
fn use_module<ToSource>(&mut self, to_src: ToSource)
where ToSource: Fn(ClauseName) -> ModuleSource
{
// the term expander will overwrite the cached query, so save it here.
let cached_query = mem::replace(&mut self.code_repo.cached_query, vec![]);
let module_spec = self.machine_st[temp_v!(1)].clone();
let (name, is_path) = {
let name = {
let addr = self.machine_st.store(self.machine_st.deref(module_spec));
match self.machine_st.heap.index_addr(&addr).as_ref() {
HeapCellValue::Atom(name, _) =>
(name.clone(), name.as_str().contains('/')),
name.clone(),
HeapCellValue::Addr(Addr::Char(c)) =>
(clause_name!(c.to_string(), self.indices.atom_tbl), false),
HeapCellValue::Addr(addr @ Addr::PStrLocation(..)) => {
let mut heap_pstr_iter = self.machine_st.heap_pstr_iter(*addr);
let filename = heap_pstr_iter.to_string();
let is_path = filename.contains('/');
(clause_name!(filename, self.indices.atom_tbl), is_path)
}
clause_name!(c.to_string(), self.indices.atom_tbl),
_ =>
unreachable!(),
}
@@ -694,18 +688,14 @@ impl Machine {
let load_result = match to_src(name) {
ModuleSource::Library(name) =>
if is_path {
load_library(self, name, false)
} else {
if let Some(module) = self.indices.take_module(name.clone()) {
self.indices.remove_module(clause_name!("user"), &module);
self.indices.modules.insert(name.clone(), module);
if let Some(module) = self.indices.take_module(name.clone()) {
self.indices.remove_module(clause_name!("user"), &module);
self.indices.modules.insert(name.clone(), module);
Ok(name)
} else {
load_library(self, name, false)
}
}
Ok(name)
} else {
load_library(self, name, false)
},
ModuleSource::File(name) =>
load_module_from_file(self, PathBuf::from(name.as_str()), false)
};
@@ -727,27 +717,21 @@ impl Machine {
}
}
fn use_qualified_module(&mut self, to_src: impl Fn(ClauseName) -> ModuleSource)
fn use_qualified_module<ToSource>(&mut self, to_src: ToSource)
where ToSource: Fn(ClauseName) -> ModuleSource
{
// the term expander will overwrite the cached query, so save it here.
let cached_query = mem::replace(&mut self.code_repo.cached_query, vec![]);
let module_spec = self.machine_st[temp_v!(1)].clone();
let (name, is_path) = {
let name = {
let addr = self.machine_st.store(self.machine_st.deref(module_spec));
match self.machine_st.heap.index_addr(&addr).as_ref() {
HeapCellValue::Atom(name, _) =>
(name.clone(), name.as_str().contains('/')),
name.clone(),
HeapCellValue::Addr(Addr::Char(c)) =>
(clause_name!(c.to_string(), self.indices.atom_tbl), false),
HeapCellValue::Addr(addr @ Addr::PStrLocation(..)) => {
let mut heap_pstr_iter = self.machine_st.heap_pstr_iter(*addr);
let filename = heap_pstr_iter.to_string();
let is_path = filename.contains('/');
(clause_name!(filename, self.indices.atom_tbl), is_path)
}
clause_name!(c.to_string(), self.indices.atom_tbl),
_ =>
unreachable!(),
}
@@ -763,18 +747,14 @@ impl Machine {
let load_result = match to_src(name) {
ModuleSource::Library(name) =>
if is_path {
load_library(self, name, false)
} else {
if let Some(module) = self.indices.take_module(name.clone()) {
self.indices.remove_module(clause_name!("user"), &module);
self.indices.modules.insert(name.clone(), module);
if let Some(module) = self.indices.take_module(name.clone()) {
self.indices.remove_module(clause_name!("user"), &module);
self.indices.modules.insert(name.clone(), module);
Ok(name)
} else {
load_library(self, name, false)
}
},
Ok(name)
} else {
load_library(self, name, false)
},
ModuleSource::File(name) =>
load_module_from_file(self, PathBuf::from(name.as_str()), false)
};

43
src/machine/toplevel.rs
View File

@@ -340,39 +340,16 @@ fn setup_module_decl(
}
}
fn read_library_path(term: Term, atom_tbl: TabledData<Atom>) -> Option<ClauseName> {
match term {
Term::Constant(_, Constant::Atom(atom, _)) => {
Some(atom.defrock_brackets())
}
_ => {
let mut atoms = vec![];
for term in unfold_by_str(term, "/") {
match term {
Term::Constant(_, Constant::Atom(atom, _)) => {
atoms.push(atom.as_str().to_owned());
}
_ => {
return None;
}
}
}
Some(clause_name!(atoms.join("/"), atom_tbl))
}
}
}
fn setup_use_module_decl(
mut terms: Vec<Box<Term>>,
atom_tbl: TabledData<Atom>,
) -> Result<ModuleSource, ParserError> {
fn setup_use_module_decl(mut terms: Vec<Box<Term>>) -> Result<ModuleSource, ParserError> {
match *terms.pop().unwrap() {
Term::Clause(_, ref name, ref mut terms, None)
if name.as_str() == "library" && terms.len() == 1 =>
{
read_library_path(*terms.pop().unwrap(), atom_tbl)
terms
.pop()
.unwrap()
.to_constant()
.and_then(|c| c.to_atom())
.map(|c| ModuleSource::Library(c))
.ok_or(ParserError::InvalidUseModuleDecl)
}
@@ -419,7 +396,11 @@ fn setup_qualified_import(
Term::Clause(_, ref name, ref mut terms, None)
if name.as_str() == "library" && terms.len() == 1 =>
{
read_library_path(*terms.pop().unwrap(), atom_tbl.clone())
terms
.pop()
.unwrap()
.to_constant()
.and_then(|c| c.to_atom())
.map(|c| ModuleSource::Library(c))
.ok_or(ParserError::InvalidUseModuleDecl)
}
@@ -704,7 +685,7 @@ fn setup_declaration<'a, 'b, 'c>(
}
}
("use_module", 1) => {
Ok(Declaration::UseModule(setup_use_module_decl(terms, indices.atom_tbl())?))
Ok(Declaration::UseModule(setup_use_module_decl(terms)?))
}
("use_module", 2) => {
let (name, exports) = setup_qualified_import(terms, indices.atom_tbl())?;