From: Mark Thom Date: Sun, 10 Mar 2019 00:36:27 +0000 (-0700) Subject: eliminate generation of dynamic clauses when compiling term expansion clauses X-Git-Tag: v0.8.110~187 X-Git-Url: https://git.sagredo.dev/?a=commitdiff_plain;h=b1d061f76b6a902c14f92d6f1439e6f44dd6cc61;p=scryer-prolog.git eliminate generation of dynamic clauses when compiling term expansion clauses --- diff --git a/src/prolog/machine/compile.rs b/src/prolog/machine/compile.rs index 5d5e0fc1..9761b6ee 100644 --- a/src/prolog/machine/compile.rs +++ b/src/prolog/machine/compile.rs @@ -224,23 +224,23 @@ fn compile_into_module(wam: &mut Machine, module_name: ClauseName, src: match compile_into_module_impl(wam, &mut compiler, module_name, src, indices) { Ok(()) => EvalSession::EntrySuccess, Err(e) => { - compiler.drop_expansions(wam.machine_flags(), &mut wam.code_repo); + compiler.drop_expansions(wam.machine_flags(), &mut wam.code_repo); EvalSession::from(e) } } } - + fn compile_into_module_impl(wam: &mut Machine, compiler: &mut ListingCompiler, module_name: ClauseName, src: R, mut indices: IndexStore) -> Result<(), SessionError> -{ +{ setup_module_expansions(wam, module_name.clone()); let flags = wam.machine_flags(); - + wam.code_repo.compile_hook(CompileTimeHook::TermExpansion, flags)?; wam.code_repo.compile_hook(CompileTimeHook::GoalExpansion, flags)?; - + let results = compiler.gather_items(wam, src, &mut indices)?; let module_code = compiler.generate_code(results.worker_results, wam, &mut indices.code_dir, 0)?; @@ -249,7 +249,7 @@ fn compile_into_module_impl(wam: &mut Machine, compiler: &mut ListingCo clause_code_generator.generate_clause_code(results.dynamic_clause_map, wam)?; update_module_indices(wam, module_name, indices); - + wam.code_repo.code.extend(module_code.into_iter()); clause_code_generator.add_clause_code(wam); @@ -341,10 +341,12 @@ fn add_module_code(wam: &mut Machine, mut module: Module, code: Code, mut indice module.code_dir.extend(code_dir); module.op_dir.extend(op_dir.into_iter()); - - for (name, arity) in module.code_dir.keys().cloned() { - wam.indices.dynamic_code_dir.remove(&(name.owning_module(), name, arity)); - } + + for (name, arity) in indices.code_dir.keys().cloned() { + if name.owning_module() == module.module_decl.name { + wam.indices.dynamic_code_dir.remove(&(name.owning_module(), name, arity)); + } + } wam.add_module(module, code); } @@ -357,7 +359,7 @@ fn add_non_module_code(wam: &mut Machine, dynamic_clause_map: DynamicClauseMap, let mut clause_code_generator = ClauseCodeGenerator::new(code.len()); clause_code_generator.generate_clause_code(dynamic_clause_map, wam)?; - + add_toplevel_code(wam, code, indices); clause_code_generator.add_clause_code(wam); @@ -508,7 +510,7 @@ impl ListingCompiler { if let Some(ref mut module) = &mut self.module { module.add_module_expansion_record(hook, clause.clone(), queue.clone()); } - + (module_preds.0).0.push(clause); module_preds.1.extend(queue.into_iter()); @@ -669,7 +671,7 @@ fn compile_work(compiler: &mut ListingCompiler, wam: &mut Machine, src: try_eval_session!(wam.check_toplevel_code(&results.toplevel_indices)); try_eval_session!(clause_code_generator.generate_clause_code(results.dynamic_clause_map, wam)); - + add_module_code(wam, module, module_code, indices); add_toplevel_code(wam, toplvl_code, results.toplevel_indices); diff --git a/src/prolog/machine/toplevel.rs b/src/prolog/machine/toplevel.rs index ac33c593..1be84c37 100644 --- a/src/prolog/machine/toplevel.rs +++ b/src/prolog/machine/toplevel.rs @@ -393,14 +393,17 @@ impl RelationWorker { queue: VecDeque::new() } } - fn setup_fact(&mut self, term: Term) -> Result + fn setup_fact(&mut self, term: Term, assume_dyn: bool) -> Result { match term { Term::Clause(..) | Term::Constant(_, Constant::Atom(..)) => { let tail = Term::Constant(Cell::default(), Constant::Atom(clause_name!("true"), None)); - self.dynamic_clauses.push((term.clone(), tail)); + if assume_dyn { + self.dynamic_clauses.push((term.clone(), tail)); + } + Ok(term) }, _ => @@ -630,10 +633,10 @@ impl RelationWorker { match flatten_hook(term) { Term::Clause(r, name, terms, _) => if name == hook.name() && terms.len() == hook.arity() { - let term = self.setup_fact(Term::Clause(r, name, terms, None))?; + let term = self.setup_fact(Term::Clause(r, name, terms, None), false)?; Ok((hook, PredicateClause::Fact(term), VecDeque::from(vec![]))) } else if name.as_str() == ":-" && terms.len() == 2 { - let rule = self.setup_rule(indices, terms, true)?; + let rule = self.setup_rule(indices, terms, true, false)?; let results_queue = self.parse_queue(indices)?; Ok((hook, PredicateClause::Rule(rule), results_queue)) @@ -645,7 +648,7 @@ impl RelationWorker { } fn setup_rule(&mut self, indices: &mut CompositeIndices, mut terms: Vec>, - blocks_cuts: bool) + blocks_cuts: bool, assume_dyn: bool) -> Result { let post_head_terms: Vec<_> = terms.drain(1 ..).collect(); @@ -653,7 +656,9 @@ impl RelationWorker { let head = *terms.first().cloned().unwrap(); let tail = *post_head_terms.first().cloned().unwrap(); - self.dynamic_clauses.push((head, tail)); + if assume_dyn { + self.dynamic_clauses.push((head, tail)); + } let mut query_terms = self.setup_query(indices, post_head_terms, blocks_cuts)?; let clauses = query_terms.drain(1 ..).collect(); @@ -681,15 +686,15 @@ impl RelationWorker { } else if name.as_str() == "?-" { Ok(TopLevel::Query(try!(self.setup_query(indices, terms, blocks_cuts)))) } else if name.as_str() == ":-" && terms.len() > 1 { - Ok(TopLevel::Rule(try!(self.setup_rule(indices, terms, blocks_cuts)))) + Ok(TopLevel::Rule(try!(self.setup_rule(indices, terms, blocks_cuts, true)))) } else if name.as_str() == ":-" && terms.len() == 1 { let term = *terms.pop().unwrap(); Ok(TopLevel::Declaration(try!(setup_declaration(term)))) } else { let term = Term::Clause(r, name, terms, fixity); - Ok(TopLevel::Fact(try!(self.setup_fact(term)))) + Ok(TopLevel::Fact(try!(self.setup_fact(term, true)))) }, - term => Ok(TopLevel::Fact(try!(self.setup_fact(term)))) + term => Ok(TopLevel::Fact(try!(self.setup_fact(term, true)))) } }