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

correct mismanagement of dynamic database across modules

Browse Source
This commit is contained in:
Mark Thom
2019-03-07 20:27:55 -07:00
parent 72c8807ff1
commit 72f759da40
4 changed files with 54 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
src/prolog/machine/compile.rs
View File

@@ -159,11 +159,12 @@ pub fn compile_term(wam: &mut Machine, packet: TopLevelPacket) -> EvalSession
}
pub(super)
fn compile_into_module<R: Read>(wam: &mut Machine, src: R, name: ClauseName, arity: usize)
fn compile_into_module<R: Read>(wam: &mut Machine, module_name: ClauseName, src: R,
name: ClauseName, arity: usize)
-> EvalSession
{
let mut indices = default_index_store!(wam.atom_tbl_of(&name));
try_eval_session!(setup_indices(wam, name.owning_module(), &mut indices));
try_eval_session!(setup_indices(wam, module_name.clone(), &mut indices));
let mut compiler = ListingCompiler::new(&wam.code_repo);
@@ -172,23 +173,23 @@ fn compile_into_module<R: Read>(wam: &mut Machine, src: R, name: ClauseName, ari
&mut indices.code_dir, 0));
let mut clause_code_generator = ClauseCodeGenerator::new(module_code.len());
try_eval_session!(clause_code_generator.generate_clause_code(results.dynamic_clause_map,
try_eval_session!(clause_code_generator.generate_clause_code(module_name.clone(),
results.dynamic_clause_map,
wam));
match wam.indices.modules.get_mut(&name.owning_module()) {
match wam.indices.modules.get_mut(&module_name) {
Some(module) => {
let code_dir = mem::replace(&mut indices.code_dir, CodeDir::new());
module.code_dir.extend(as_module_code_dir(code_dir));
if module.module_decl.exports.contains(&(name.clone(), arity)) {
if let Some(idx) = wam.indices.code_dir.get(&(name.clone(), arity)) {
if let Some(idx) = wam.indices.code_dir.get(&(name.clone(), arity)) {
if module.module_decl.name == idx.0.borrow().1 {
let module = module.module_decl.name.clone();
if module_code.len() > 0 {
set_code_index!(idx, IndexPtr::Index(wam.code_repo.code.len()), module);
set_code_index!(idx, IndexPtr::Index(wam.code_repo.code.len()),
module_name.clone());
} else {
set_code_index!(idx, IndexPtr::Undefined, module);
set_code_index!(idx, IndexPtr::Undefined, module_name.clone());
}
}
}
@@ -198,7 +199,7 @@ fn compile_into_module<R: Read>(wam: &mut Machine, src: R, name: ClauseName, ari
};
wam.code_repo.code.extend(module_code.into_iter());
clause_code_generator.add_clause_code(wam);
clause_code_generator.add_clause_code(module_name, wam);
EvalSession::EntrySuccess
}
@@ -223,7 +224,8 @@ impl ClauseCodeGenerator {
ClauseCodeGenerator { len_offset, code: vec![], pi_to_loc: HashMap::new() }
}
fn generate_clause_code(&mut self, dynamic_clause_map: DynamicClauseMap, wam: &Machine)
fn generate_clause_code(&mut self, module: ClauseName, dynamic_clause_map: DynamicClauseMap,
wam: &Machine)
-> Result<(), SessionError>
{
for ((name, arity), heads_and_tails) in dynamic_clause_map {
@@ -231,7 +233,7 @@ impl ClauseCodeGenerator {
continue;
}
wam.check_dynamic_clause_overwrite(name.clone(), arity)?;
wam.check_dynamic_clause_overwrite(name.clone(), arity, module.clone())?;
let predicate = Predicate(heads_and_tails.into_iter().map(|(head, tail)| {
let clause = Term::Clause(Cell::default(), clause_name!("clause"),
@@ -253,15 +255,15 @@ impl ClauseCodeGenerator {
Ok(())
}
fn add_clause_code(self, wam: &mut Machine) {
fn add_clause_code(self, module: ClauseName, wam: &mut Machine) {
wam.code_repo.code.extend(self.code.into_iter());
for ((name, arity), p) in self.pi_to_loc {
let entry = wam.indices.dynamic_code_dir.entry((name.clone(), arity))
let entry = wam.indices.dynamic_code_dir.entry((name, arity))
.or_insert(DynamicPredicateInfo::default());
entry.clauses_subsection_p = p;
entry.module_src = name.owning_module();
entry.module_src = module.clone();
}
}
}
@@ -302,10 +304,10 @@ fn add_non_module_code(wam: &mut Machine, dynamic_clause_map: DynamicClauseMap,
wam.check_toplevel_code(&indices, &dynamic_clause_map)?;
let mut clause_code_generator = ClauseCodeGenerator::new(code.len());
clause_code_generator.generate_clause_code(dynamic_clause_map, wam)?;
clause_code_generator.generate_clause_code(clause_name!("user"), dynamic_clause_map, wam)?;
add_toplevel_code(wam, code, indices);
clause_code_generator.add_clause_code(wam);
clause_code_generator.add_clause_code(clause_name!("user"), wam);
Ok(())
}
@@ -607,14 +609,17 @@ fn compile_work<R: Read>(compiler: &mut ListingCompiler, wam: &mut Machine, src:
if let Some(module) = compiler.module.take() {
let mut clause_code_generator = ClauseCodeGenerator::new(module_code.len() + toplvl_code.len());
let module_name = module.module_decl.name.clone();
try_eval_session!(wam.check_toplevel_code(&results.toplevel_indices, &results.dynamic_clause_map));
try_eval_session!(clause_code_generator.generate_clause_code(results.dynamic_clause_map, wam));
try_eval_session!(clause_code_generator.generate_clause_code(module_name.clone(),
results.dynamic_clause_map,
wam));
add_module_code(wam, module, module_code, indices);
add_toplevel_code(wam, toplvl_code, results.toplevel_indices);
clause_code_generator.add_clause_code(wam);
clause_code_generator.add_clause_code(module_name, wam);
} else {
try_eval_session!(add_non_module_code(wam, results.dynamic_clause_map, module_code,
indices));

22
src/prolog/machine/dynamic_database.rs
View File

@@ -20,8 +20,18 @@ impl Machine {
fn compile_into_machine<R: Read>(&mut self, src: R, name: ClauseName, arity: usize) -> EvalSession
{
match name.owning_module().as_str() {
"user" => compile_user_module(self, src),
_ => compile_into_module(self, src, name, arity)
"user" => match self.indices.code_dir.get(&(name.clone(), arity)).cloned() {
Some(idx) => {
let module = idx.0.borrow().1.clone();
match module.as_str() {
"user" => compile_user_module(self, src),
_ => compile_into_module(self, module, src, name, arity)
}
},
None => compile_user_module(self, src)
},
_ => compile_into_module(self, name.owning_module(), src, name, arity)
}
}
@@ -76,7 +86,7 @@ impl Machine {
{
let (name, arity) = self.get_predicate_key(name, arity);
let module_addr = self.machine_st[module].clone();
let module_name = match self.machine_st.store(self.machine_st.deref(module_addr)) {
Addr::Con(Constant::Atom(module, _)) =>
match self.indices.modules.get_mut(&module) {
@@ -91,7 +101,7 @@ impl Machine {
},
_ => unreachable!()
};
if let Some(idx) = self.indices.code_dir.get(&(name.clone(), arity)) {
if idx.module_name() == module_name {
set_code_index!(idx, IndexPtr::Undefined, clause_name!("user"));
@@ -100,7 +110,7 @@ impl Machine {
self.indices.remove_code_index((name, arity));
}
fn handle_eval_result_from_dynamic_compile(&mut self, pred_str: String, name: ClauseName,
arity: usize, src: ClauseName)
{
@@ -198,7 +208,7 @@ impl Machine {
Addr::Con(Constant::Number(Number::Integer(n))) => n.to_usize().unwrap(),
_ => unreachable!()
};
let (name, arity) = self.get_predicate_key(temp_v!(1), temp_v!(2));
self.retract_from_dynamic_predicate_impl(name, arity, index);

7
src/prolog/machine/mod.rs
View File

@@ -211,11 +211,11 @@ impl Machine {
self.machine_st.flags
}
pub fn check_dynamic_clause_overwrite(&self, name: ClauseName, arity: usize)
pub fn check_dynamic_clause_overwrite(&self, name: ClauseName, arity: usize, module: ClauseName)
-> Result<(), SessionError>
{
if let Some(info) = self.indices.dynamic_code_dir.get(&(name.clone(), arity)) {
if info.module_src != name.owning_module() {
if info.module_src != module {
let err_str = format!("{}/{}", name.as_str(), arity);
let err_str = clause_name!(err_str, self.indices.atom_tbl());
@@ -242,7 +242,8 @@ impl Machine {
};
if dynamic_clause_map.contains_key(&key) {
self.check_dynamic_clause_overwrite(key.0.clone(), key.1)?;
let module = idx.0.borrow().1.clone();
self.check_dynamic_clause_overwrite(key.0.clone(), key.1, module)?;
}
if let Some(ref existing_idx) = self.indices.code_dir.get(&key) {

17
src/prolog/machine/modules.rs
View File

@@ -114,8 +114,7 @@ pub trait SubModuleUser
}
// returns true on successful import.
fn import_decl(&mut self, name: ClauseName, arity: usize, submodule: &Module)
-> bool
fn import_decl(&mut self, name: ClauseName, arity: usize, submodule: &Module) -> bool
{
let name = name.defrock_brackets();
let mut found_op = false;
@@ -134,14 +133,17 @@ pub trait SubModuleUser
} else if arity == 2 {
insert_op_dir(Fixity::In);
}
}
}
if let Some(code_data) = submodule.code_dir.get(&(name.clone(), arity)) {
let name = name.with_table(submodule.atom_tbl.clone());
let name = name.with_table(submodule.atom_tbl.clone());
let mut atom_tbl = self.atom_tbl();
atom_tbl.borrow_mut().insert(name.to_rc());
let mut code_data = code_data.clone();
code_data.1 = submodule.module_decl.name.clone();
self.insert_dir_entry(name, arity, code_data.clone());
true
} else {
@@ -172,7 +174,8 @@ pub fn use_qualified_module<User>(user: &mut User, submodule: &Module, exports:
Ok(())
}
pub fn use_module<User: SubModuleUser>(user: &mut User, submodule: &Module) -> Result<(), SessionError>
pub fn use_module<User: SubModuleUser>(user: &mut User, submodule: &Module)
-> Result<(), SessionError>
{
for (name, arity) in submodule.module_decl.exports.iter().cloned() {
if !user.import_decl(name, arity, submodule) {