prepare for changes to relocation scheme

src/prolog/ast.rs

@@ -147,6 +147,8 @@ pub type CodeDir = HashMap<PredicateKey, CodeIndex>;
 
 pub type TermDir = HashMap<PredicateKey, Predicate>;
 
+pub type ModuleDir = HashMap<ClauseName, Module>;
+
 pub type PredicateKey = (ClauseName, usize); // name, arity.
 
 pub struct ModuleDecl {
@@ -974,6 +976,18 @@ impl ClauseType {
         }
     }
 
+    /*
+    pub fn lookup(wam: &Machine, name: ClauseName, arity: usize, fixity: Option<Fixity>) -> Self {
+        match ClauseType::from(name, arity, fixity) {
+            ClauseType::Named(name, default_idx) => {
+                
+            },
+            ClauseType::Op(name, fixity, default_idx) => {
+            },
+            ct => ct
+        }
+    }
+    */    
     pub fn from(name: ClauseName, arity: usize, fixity: Option<Fixity>) -> Self {
         InlinedClauseType::from(name.as_str(), arity)
             .map(ClauseType::Inlined)

src/prolog/machine/mod.rs

@@ -20,6 +20,7 @@ use std::rc::Rc;
 pub struct MachineCodeIndex<'a> {
     pub code_dir: &'a mut CodeDir,
     pub op_dir: &'a mut OpDir,
+//  pub modules: &'a ModuleDir // &'a HashMap<ClauseName, Module>
 }
 
 pub struct Machine {
@@ -30,7 +31,7 @@ pub struct Machine {
     pub(super) code_dir: CodeDir,
     pub(super) op_dir: OpDir,
     term_dir: TermDir,
-    modules: HashMap<ClauseName, Module>,
+    modules: ModuleDir, // HashMap<ClauseName, Module>,
     cached_query: Option<Code>
 }
 

src/prolog/toplevel.rs

@@ -570,27 +570,21 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
         TopLevelWorker { parser: Parser::new(inner, atom_tbl), indices }
     }
 
-    fn add_predicate(&mut self, name: ClauseName, mod_name: ClauseName, tl: TopLevel)
+    fn add_name(&mut self, pred: &PredicateClause, mod_name: ClauseName) -> Option<ClauseName> {
-                     -> Vec<PredicateClause>
+        pred.name().and_then(move |name| {
-    {
-        let add_name = move |arity| {
             let idx = CodeIndex(Rc::new(RefCell::new((IndexPtr::Undefined, mod_name))));
-            self.indices.code_dir.insert((name, arity), idx);
+            self.indices.code_dir.insert((name.clone(), pred.arity()), idx);
-        };
             
+            Some(name)
+        })
+    }
+
+    fn add_predicate(&mut self, tl: TopLevel) -> Vec<PredicateClause>
+    {
         match tl {
-            TopLevel::Rule(rule) => {
+            TopLevel::Rule(rule) => vec![PredicateClause::Rule(rule)],
-                add_name(rule.head.1.len());
+            TopLevel::Fact(fact) => vec![PredicateClause::Fact(fact)],
-                vec![PredicateClause::Rule(rule)]
+            TopLevel::Predicate(preds) => preds.0,
-            },
-            TopLevel::Fact(fact) => {
-                add_name(fact.arity());
-                vec![PredicateClause::Fact(fact)]
-            },
-            TopLevel::Predicate(preds) => {
-                add_name(preds.0.len());
-                preds.0
-            },
             _ => vec![]
         }
     }
@@ -606,10 +600,11 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
             self.parser.reset(); // empty the parser stack of token descriptions.
             let term = self.parser.read_term(&self.indices.op_dir)?;
 
-            let mut new_rel_worker = RelationWorker::new();
+            let mut new_rel_worker = RelationWorker::new(); //wam, mod_name.clone());
             let tl = new_rel_worker.try_term_to_tl(term, true)?;
 
-            if !is_consistent(&tl, &preds) {
+            if !is_consistent(&tl, &preds) {  // if is_consistent returns false, preds is non-empty.
+                preds.first().map(|pred| self.add_name(pred, mod_name.clone()));
                 results.push(deque_to_packet(append_preds(&mut preds), rel_worker.parse_queue()?));
             }
 
@@ -631,9 +626,10 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
                 TopLevel::Declaration(decl) => {
                     results.push(TopLevelPacket::Decl(TopLevel::Declaration(decl), vec![]));
                 },
-                tl => match tl.name() {
+                tl => if tl.name().is_some() {
-                    Some(name) => preds.extend(self.add_predicate(name, mod_name.clone(), tl)),
+                    preds.extend(self.add_predicate(tl))
-                    _ => return Err(SessionError::NamelessEntry)
+                } else {
+                    return Err(SessionError::NamelessEntry)
                 }
             };
         }
@@ -647,7 +643,7 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
 
     pub fn parse_code(&mut self) -> Result<TopLevelPacket, ParserError>
     {
-        let mut rel_worker = RelationWorker::new();
+        let mut rel_worker = RelationWorker::new(); //wam, clause_name!("user"));
 
         let terms   = self.parser.read(self.indices.op_dir)?;
         let mut tls = rel_worker.try_terms_to_tls(terms, true)?;
@@ -656,6 +652,13 @@ impl<'a, R: Read> TopLevelWorker<'a, R> {
         let tl = merge_clauses(&mut tls)?;
 
         if tls.is_empty() {
+            /*
+            match tl.name() {
+                Some(name) => self.add_name(name, tl.arity(), clause_name!("user")),
+                _ => {}
+            };
+             */
+
             Ok(deque_to_packet(tl, results))
         } else {
             Err(ParserError::InconsistentEntry)