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

add support for user:goal_expansion

Browse Source
This commit is contained in:
Mark Thom
2018-12-09 00:48:28 -07:00
parent deabdafa48
commit a4406f784a
8 changed files with 228 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/prolog/machine/machine_state.rs
View File

@@ -629,13 +629,19 @@ pub(crate) trait CallPolicy: Any {
}
}
fn compile_hook(&mut self, machine_st: &mut MachineState, _: &CompileTimeHook) -> CallResult
fn compile_hook(&mut self, machine_st: &mut MachineState, hook: &CompileTimeHook) -> CallResult
{
machine_st.cp = LocalCodePtr::TopLevel(0, 0);
machine_st.num_of_args = 2;
machine_st.num_of_args = hook.arity();
machine_st.b0 = machine_st.b;
machine_st.p = CodePtr::Local(LocalCodePtr::UserTermExpansion(0));
machine_st.p = match hook {
CompileTimeHook::TermExpansion =>
CodePtr::Local(LocalCodePtr::UserTermExpansion(0)),
CompileTimeHook::GoalExpansion =>
CodePtr::Local(LocalCodePtr::UserGoalExpansion(0))
};
Ok(())
}

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

@@ -102,6 +102,7 @@ impl IndexStore {
pub struct CodeRepo {
cached_query: Option<Code>,
pub(super) goal_expanders: Code,
pub(super) term_expanders: Code,
pub(super) code: Code,
pub(super) term_dir: TermDir
@@ -112,6 +113,7 @@ impl CodeRepo {
fn new() -> Self {
CodeRepo {
cached_query: None,
goal_expanders: Code::new(),
term_expanders: Code::new(),
code: Code::new(),
term_dir: TermDir::new()
@@ -124,11 +126,17 @@ impl CodeRepo {
&Some(ref query) => query.len(),
_ => 0
}
}
}
fn lookup_instr<'a>(&'a self, last_call: bool, p: &CodePtr) -> Option<RefOrOwned<'a, Line>>
{
match p {
&CodePtr::Local(LocalCodePtr::UserGoalExpansion(p)) =>
if p < self.goal_expanders.len() {
Some(RefOrOwned::Borrowed(&self.goal_expanders[p]))
} else {
None
},
&CodePtr::Local(LocalCodePtr::UserTermExpansion(p)) =>
if p < self.term_expanders.len() {
Some(RefOrOwned::Borrowed(&self.term_expanders[p]))
@@ -190,6 +198,7 @@ impl Index<LocalCodePtr> for CodeRepo {
}
},
LocalCodePtr::DirEntry(p) => &self.code[p],
LocalCodePtr::UserGoalExpansion(p) => &self.goal_expanders[p],
LocalCodePtr::UserTermExpansion(p) => &self.term_expanders[p]
}
}
@@ -502,6 +511,8 @@ impl MachineState {
CodePtr::Local(LocalCodePtr::DirEntry(p)) if p < code_repo.code.len() => {},
CodePtr::Local(LocalCodePtr::UserTermExpansion(p)) if p < code_repo.term_expanders.len() => {},
CodePtr::Local(LocalCodePtr::UserTermExpansion(_)) => self.fail = true,
CodePtr::Local(LocalCodePtr::UserGoalExpansion(p)) if p < code_repo.goal_expanders.len() => {},
CodePtr::Local(LocalCodePtr::UserGoalExpansion(_)) => self.fail = true,
CodePtr::Local(_) => break,
_ => {}
};

176
src/prolog/machine/term_expansion.rs
View File

@@ -5,7 +5,50 @@ use prolog::instructions::HeapCellValue;
use prolog::machine::*;
use prolog::read::*;
use std::cell::Cell;
use std::collections::VecDeque;
use std::io::Read;
use std::iter::Rev;
use std::vec::IntoIter;
fn unfold_by_str_once(term: &mut Term, s: &str) -> Option<(Term, Term)>
{
if let &mut Term::Clause(_, ref name, ref mut subterms, _) = term {
if name.as_str() == s && subterms.len() == 2 {
let snd = *subterms.pop().unwrap();
let fst = *subterms.pop().unwrap();
return Some((fst, snd));
}
}
None
}
pub fn unfold_by_str(mut term: Term, s: &str) -> Vec<Term>
{
let mut terms = vec![];
while let Some((fst, snd)) = unfold_by_str_once(&mut term, s) {
terms.push(fst);
term = snd;
}
terms.push(term);
terms
}
pub fn fold_by_str<I>(terms: I, mut term: Term, sym: ClauseName) -> Term
where I: DoubleEndedIterator<Item=Term>
{
for prec in terms.rev() {
term = Term::Clause(Cell::default(), sym.clone(),
vec![Box::new(prec), Box::new(term)],
None);
}
term
}
pub struct TermStream<'a, R: Read> {
stack: Vec<Term>,
@@ -14,7 +57,7 @@ pub struct TermStream<'a, R: Read> {
pub(crate) code_repo: &'a mut CodeRepo,
parser: Parser<R>,
in_module: bool,
flags: MachineFlags
flags: MachineFlags
}
impl<'a, R: Read> TermStream<'a, R> {
@@ -49,22 +92,29 @@ impl<'a, R: Read> TermStream<'a, R> {
Ok(self.stack.is_empty() && self.parser.eof()?)
}
fn extract_from_list(&mut self, head: Box<Term>, tail: Box<Term>)
-> Result<Rev<IntoIter<Term>>, ParserError>
{
let mut terms = vec![*head];
let mut tail = *tail;
while let Term::Cons(_, head, next_tail) = tail {
terms.push(*head);
tail = *next_tail;
}
if let Term::Constant(_, Constant::EmptyList) = tail {
Ok(terms.into_iter().rev())
} else {
Err(ParserError::ExpectedTopLevelTerm)
}
}
fn enqueue_term(&mut self, term: Term) -> Result<(), ParserError> {
match term {
Term::Cons(_, head, tail) => {
let mut terms = vec![*head];
let mut tail = *tail;
while let Term::Cons(_, head, next_tail) = tail {
terms.push(*head);
tail = *next_tail;
}
if let Term::Constant(_, Constant::EmptyList) = tail {
Ok(self.stack.extend(terms.into_iter().rev()))
} else {
Err(ParserError::ExpectedTopLevelTerm)
}
let iter = self.extract_from_list(head, tail)?;
Ok(self.stack.extend(iter))
},
Term::Clause(..) | Term::Constant(_, Constant::Atom(..)) =>
Ok(self.stack.push(term)),
@@ -72,50 +122,113 @@ impl<'a, R: Read> TermStream<'a, R> {
}
}
fn parse_expansion_output(&mut self, term_string: &str, op_dir: &OpDir) -> Result<Term, ParserError> {
let mut parser = Parser::new(term_string.trim().as_bytes(), self.indices.atom_tbl.clone(), self.flags);
parser.read_term(composite_op!(self.in_module,
&self.indices.op_dir,
op_dir))
fn parse_expansion_output(&mut self, term_string: &str, op_dir: &OpDir)
-> Result<Term, ParserError>
{
let mut parser = Parser::new(term_string.trim().as_bytes(), self.indices.atom_tbl.clone(),
self.flags);
parser.read_term(composite_op!(self.in_module, &self.indices.op_dir, op_dir))
}
pub fn read_term(&mut self, machine_st: &mut MachineState, op_dir: &OpDir)
-> Result<Term, ParserError>
{
loop {
while let Some(term) = self.stack.pop() {
match machine_st.try_expand_term(self.indices, self.policies, self.code_repo, &term)
match machine_st.try_expand_term(self.indices, self.policies, self.code_repo,
&term, CompileTimeHook::TermExpansion)
{
Some(term_string) => {
let term = self.parse_expansion_output(term_string.as_str(), op_dir)?;
self.enqueue_term(term)?
},
None => return Ok(term)
None => {
let term = self.run_goal_expanders(machine_st, op_dir, term)?;
return Ok(term);
}
};
}
self.parser.reset();
let term = self.parser.read_term(composite_op!(self.in_module,
&self.indices.op_dir,
let term = self.parser.read_term(composite_op!(self.in_module, &self.indices.op_dir,
op_dir))?;
self.stack.push(term);
}
}
fn run_goal_expanders(&mut self, machine_st: &mut MachineState, op_dir: &OpDir, term: Term)
-> Result<Term, ParserError>
{
match term {
Term::Clause(cell, name, mut terms, arity) => {
let mut new_terms = {
let old_terms = if name.as_str() == ":-" && terms.len() == 2 {
let comma_term = *terms.pop().unwrap();
unfold_by_str(comma_term, ",")
} else if name.as_str() == "?-" && terms.len() == 1 {
let comma_term = *terms.pop().unwrap();
unfold_by_str(comma_term, ",")
} else {
return Ok(Term::Clause(cell, name, terms, arity));
};
self.expand_goals(machine_st, op_dir, VecDeque::from(old_terms))?
};
let initial_term = new_terms.pop().unwrap();
terms.push(Box::new(fold_by_str(new_terms.into_iter(), initial_term,
clause_name!(","))));
Ok(Term::Clause(cell, name, terms, None))
},
_ =>
Ok(term)
}
}
fn expand_goals(&mut self, machine_st: &mut MachineState, op_dir: &OpDir,
mut terms: VecDeque<Term>)
-> Result<Vec<Term>, ParserError>
{
let mut results = vec![];
while let Some(term) = terms.pop_front() {
match machine_st.try_expand_term(self.indices, self.policies, self.code_repo,
&term, CompileTimeHook::GoalExpansion)
{
Some(term_string) => {
let term = self.parse_expansion_output(term_string.as_str(), op_dir)?;
match term {
Term::Cons(_, head, tail) =>
for term in self.extract_from_list(head, tail)? {
terms.push_front(term);
},
term =>
terms.push_front(term)
};
},
None => results.push(term)
}
}
Ok(results)
}
}
impl MachineState {
fn try_expand_term(&mut self, indices: &mut IndexStore, policies: &mut MachinePolicies,
code_repo: &mut CodeRepo, term: &Term)
code_repo: &mut CodeRepo, term: &Term, hook: CompileTimeHook)
-> Option<String>
{
let term_h = write_term_to_heap(term, self);
let (term_h, var_dict) = write_term_to_heap(term, self);
let h = self.heap.h;
self[temp_v!(1)] = Addr::HeapCell(term_h);
self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h)));
self[temp_v!(2)] = Addr::HeapCell(h);
let code = vec![call_clause!(ClauseType::Hook(CompileTimeHook::TermExpansion), 2, 0, true)];
let code = vec![call_clause!(ClauseType::Hook(hook), 2, 0, true)];
code_repo.cached_query = Some(code);
self.run_query(indices, policies, code_repo, &AllocVarDict::new(), &mut HeapVarDict::new());
@@ -125,11 +238,14 @@ impl MachineState {
None
} else {
let mut output = {
let mut printer = HCPrinter::new(&self, PrinterOutputter::new());
let output = PrinterOutputter::new();
let mut printer = HCPrinter::from_heap_locs(&self, output, &var_dict);
printer.quoted = true;
printer.numbervars = true;
printer.see_all_locs();
printer.print(Addr::HeapCell(h))
};