restore parse_term to toplevel

src/prolog/compile.rs

@@ -271,7 +271,7 @@ fn compile_listing<'a, R: Read>(wam: &mut Machine, src: R, mut indices: MachineC
     let mut compiler = ListingCompiler::new();
     let mut toplevel_results = vec![];
 
-    while let Some(decl) = try_eval_session!(worker.consume(&wam.op_dir, &mut indices)) {
+    while let Some(decl) = try_eval_session!(worker.consume(wam, &mut indices)) {
         if decl.is_module_decl() {
             toplevel_indices.copy_and_swap(&mut indices);
             mem::swap(&mut worker.results, &mut toplevel_results);

src/prolog/instructions.rs

@@ -195,7 +195,7 @@ pub type ModuleCodeDir = HashMap<PredicateKey, ModuleCodeIndex>;
 
 pub type CodeDir = HashMap<PredicateKey, CodeIndex>;
 
-//pub type TermDir = HashMap<PredicateKey, Predicate>;
+pub type TermDir = HashMap<PredicateKey, Predicate>;
 
 pub type ModuleDir = HashMap<ClauseName, Module>;
 

src/prolog/machine/mod.rs

@@ -53,7 +53,7 @@ pub struct Machine {
     code: Code,
     pub(super) code_dir: Rc<RefCell<CodeDir>>,
     pub(super) op_dir: OpDir,
-    // term_dir: TermDir,
+//    term_dir: TermDir,
     pub(super) modules: ModuleDir,
     cached_query: Option<Code>
 }

src/prolog/term_writer.rs

@@ -1,43 +0,0 @@
-use prolog_parser::ast::*;
-
-use prolog::heap_iter::*;
-use prolog::instructions::HeapCellValue;
-use prolog::machine::machine_state::MachineState;
-
-pub fn term_write(machine_st: &'a MachineState, addr: Addr) -> Result<Term, ParserError> {
-    let pre_order_iter  = HCPreOrderIterator::new(machine_st, addr);
-    let post_order_iter = HCPostOrderIterator::new(pre_order_iter);
-    let acyclic_post_order_iter = HCAcyclicIterator::new(post_order_iter);
-
-    let mut stack = vec![];
-    
-    for value in acyclic_post_order_iter {
-        match value {
-            HeapCellValue::NamedStr(arity, name, fixity)
-                if stack.len() >= arity => {
-                    let subterms: Vec<_> = stack[stack.len() - arity ..].drain().collect();
-                    stack.push(Box::new(Term::Clause(Cell::default(), name, subterms, fixity)));
-                },
-            HeapCellValue::Addr(Addr::Con(constant)) =>
-                stack.push(Box::new(Term::Constant(Cell::default(), constant))),
-            HeapCellValue::Addr(Addr::Lis(_))
-                if stack.len() >= 2 => {
-                    let subterms: Vec<_> = stack[stack.len() - 2 ..].drain().collect();                    
-                    stack.push(Box::new(Term::Cons(Cell::default(), subterms[0], subterms[1])));
-                },
-            HeapCellValue::Addr(Addr::HeapCell(h)) =>
-                stack.push(Box::new(Term::Var(Cell::default(), Rc::new(format!("_{}", h))))),
-            HeapCellValue::Addr(Addr::StackCell(fr, sc)) =>
-                stack.push(Box::new(Term::Var(Cell::default(), Rc::new(format!("_{}_{}", sc, fr))))),
-            _ => return Err(ParserError::IncompleteReduction)
-        }
-    }
-
-    if let Some(term) = stack.pop() {
-        if stack.is_empty() {
-            return Ok(term);
-        } 
-    }
-
-    Err(ParserError::IncompleteReduction)
-}

src/prolog/toplevel.rs

@@ -669,6 +669,13 @@ impl RelationWorker {
     }
 }
 
+// used to parse queries in test. mostly.
+pub fn parse_term<R: Read>(wam: &Machine, buf: R) -> Result<Term, ParserError>
+{
+    let mut parser = Parser::new(buf, wam.atom_tbl(), wam.machine_flags());
+    parser.read_term(composite_op!(&wam.op_dir))
+}
+
 pub
 fn consume_term<'a>(static_code_dir: Rc<RefCell<CodeDir>>, term: Term,
                     mut indices: MachineCodeIndices<'a>)
@@ -710,7 +717,7 @@ impl<R: Read> TopLevelBatchWorker<R> {
     }
 
     pub
-    fn consume<'a, 'b : 'a>(&mut self, op_dir: &OpDir, indices: &'a mut MachineCodeIndices<'b>)
+    fn consume<'a, 'b : 'a>(&mut self, wam: &mut Machine, indices: &'a mut MachineCodeIndices<'b>)
                            -> Result<Option<Declaration>, SessionError>
     {
         let mut preds = vec![];
@@ -721,7 +728,7 @@ impl<R: Read> TopLevelBatchWorker<R> {
             self.parser.reset(); // empty the parser stack of token descriptions.
 
             let mut new_rel_worker = RelationWorker::new();
-            let term = self.read_term(op_dir, &indices.local.op_dir)?;          
+            let term = self.read_term(&wam.op_dir, &indices.local.op_dir)?;          
                 
             let tl = new_rel_worker.try_term_to_tl(&mut indices, term, true)?;