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

eliminate generation of dynamic clauses when compiling term expansion clauses

Browse Source
This commit is contained in:
Mark Thom
2019-03-09 17:36:27 -07:00
parent 0d41b27abb
commit b1d061f76b
2 changed files with 29 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -224,23 +224,23 @@ fn compile_into_module<R: Read>(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<R: Read>(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<R: Read>(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<R: Read>(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);

23
src/prolog/machine/toplevel.rs
View File

@@ -393,14 +393,17 @@ impl RelationWorker {
queue: VecDeque::new() }
}
fn setup_fact(&mut self, term: Term) -> Result<Term, ParserError>
fn setup_fact(&mut self, term: Term, assume_dyn: bool) -> Result<Term, ParserError>
{
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<Box<Term>>,
blocks_cuts: bool)
blocks_cuts: bool, assume_dyn: bool)
-> Result<Rule, ParserError>
{
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))))
}
}