From: Mark Thom Date: Fri, 8 Mar 2019 03:27:55 +0000 (-0700) Subject: correct mismanagement of dynamic database across modules X-Git-Tag: v0.8.110~199 X-Git-Url: https://git.sagredo.dev/?a=commitdiff_plain;h=72f759da407af65c618d961af6a7f3f94ff14971;p=scryer-prolog.git correct mismanagement of dynamic database across modules --- diff --git a/src/prolog/machine/compile.rs b/src/prolog/machine/compile.rs index 6c8fcee3..5d6fbdc3 100644 --- a/src/prolog/machine/compile.rs +++ b/src/prolog/machine/compile.rs @@ -159,11 +159,12 @@ pub fn compile_term(wam: &mut Machine, packet: TopLevelPacket) -> EvalSession } pub(super) -fn compile_into_module(wam: &mut Machine, src: R, name: ClauseName, arity: usize) +fn compile_into_module(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(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(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(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)); diff --git a/src/prolog/machine/dynamic_database.rs b/src/prolog/machine/dynamic_database.rs index 296a5906..512066f5 100644 --- a/src/prolog/machine/dynamic_database.rs +++ b/src/prolog/machine/dynamic_database.rs @@ -20,8 +20,18 @@ impl Machine { fn compile_into_machine(&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); diff --git a/src/prolog/machine/mod.rs b/src/prolog/machine/mod.rs index e1b704a5..fd92cee7 100644 --- a/src/prolog/machine/mod.rs +++ b/src/prolog/machine/mod.rs @@ -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) { diff --git a/src/prolog/machine/modules.rs b/src/prolog/machine/modules.rs index 31e13cd9..03e86899 100644 --- a/src/prolog/machine/modules.rs +++ b/src/prolog/machine/modules.rs @@ -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: &mut User, submodule: &Module, exports: Ok(()) } -pub fn use_module(user: &mut User, submodule: &Module) -> Result<(), SessionError> +pub fn use_module(user: &mut User, submodule: &Module) + -> Result<(), SessionError> { for (name, arity) in submodule.module_decl.exports.iter().cloned() { if !user.import_decl(name, arity, submodule) {