slight tweaks.

src/prolog/and_stack.rs

@@ -32,6 +32,7 @@ impl AndStack {
         self.0.push(Frame::new(global_index, e, cp, n));
     }
 
+    #[allow(dead_code)]
     pub fn top(&self) -> Option<&Frame> {
         self.0.last()
     }
@@ -45,6 +46,7 @@ impl AndStack {
     }
 
     // drop the last n frames.
+    #[allow(dead_code)]
     pub fn drop_frames(&mut self, n: usize) {
         let len = self.0.len();
         self.0.truncate(len - n);

src/prolog/ast.rs

@@ -344,6 +344,14 @@ pub type Heap = Vec<HeapCellValue>;
 pub type Registers = Vec<Addr>;
 
 impl Term {
+    pub fn is_clause(&self) -> bool {
+        if let &Term::Clause(_, _, _) = self {
+            true
+        } else {
+            false
+        }
+    }        
+    
     pub fn subterms(&self) -> usize {
         match self {
             &Term::Clause(_, _, ref terms) => terms.len(),
@@ -354,7 +362,6 @@ impl Term {
     pub fn name(&self) -> Option<&Atom> {
         match self {
             &Term::Constant(_, Constant::Atom(ref atom))
-            | &Term::Var(_, ref atom)
             | &Term::Clause(_, ref atom, _) => Some(atom),
             _ => None
         }

src/prolog/codegen.rs

@@ -704,14 +704,18 @@ impl<'a> CodeGenerator<'a> {
         self.marker.advance(term);
         self.update_var_count(term.breadth_first_iter());
 
-        let mut compiled_fact = self.compile_target(term, false);
-        Self::mark_unsafe_fact_vars(&mut compiled_fact, self.vars());
-
-        let mut compiled_fact = vec![Line::Fact(compiled_fact)];
+        let mut code = Vec::new();
+        
+        if term.is_clause() {
+            let mut compiled_fact = self.compile_target(term, false);            
+            Self::mark_unsafe_fact_vars(&mut compiled_fact, self.vars());
+            code.push(Line::Fact(compiled_fact));
+        }
+        
         let proceed = Line::Control(ControlInstruction::Proceed);
 
-        compiled_fact.push(proceed);
-        compiled_fact
+        code.push(proceed);
+        code
     }
 
     fn compile_internal_query(&mut self, term: &'a Term, index: usize) -> Code
@@ -719,20 +723,32 @@ impl<'a> CodeGenerator<'a> {
         self.marker.advance(term);
         self.update_var_count(term.breadth_first_iter());
 
-        let mut compiled_query = vec![Line::Query(self.compile_target(term, false))];
-        Self::add_conditional_call(&mut compiled_query, term, index);
+        let mut code = Vec::new();
 
-        compiled_query
+        if term.is_clause() {                
+            let compiled_query = Line::Query(self.compile_target(term, false));
+            code.push(compiled_query);
+        }
+        
+        Self::add_conditional_call(&mut code, term, index);
+
+        code
     }
 
     pub fn compile_query(&mut self, term: &'a Term) -> Code {
         self.marker.advance(term);
         self.update_var_count(term.breadth_first_iter());
 
-        let mut compiled_query = vec![Line::Query(self.compile_target(term, true))];
-        Self::add_conditional_call(&mut compiled_query, term, 0);
+        let mut code = Vec::new();
 
-        compiled_query
+        if term.is_clause() {                
+            let compiled_query = Line::Query(self.compile_target(term, false));
+            code.push(compiled_query);
+        }
+        
+        Self::add_conditional_call(&mut code, term, 0);
+
+        code
     }
 
     pub fn compile_predicate(&mut self, clauses: &'a Vec<PredicateClause>) -> Code

src/prolog/io.rs

@@ -218,7 +218,7 @@ pub fn eval(wam: &mut Machine, buffer: &str) -> EvalResult
     match &result {
         &Ok(TopLevel::Predicate(ref clauses)) => {
             if is_consistent(clauses) {
-                let compiled_pred = cg.compile_predicate(clauses);
+                let compiled_pred = cg.compile_predicate(clauses);                
                 wam.add_predicate(clauses, compiled_pred);
 
                 EvalResult::EntrySuccess
@@ -231,17 +231,17 @@ Each predicate must have the same name and arity.";
             }
         },
         &Ok(TopLevel::Fact(ref fact)) => {
-            let compiled_fact = cg.compile_fact(&fact);
+            let compiled_fact = cg.compile_fact(&fact);            
             wam.add_fact(fact, compiled_fact);
             EvalResult::EntrySuccess
         },
         &Ok(TopLevel::Rule(ref rule)) => {
-            let compiled_rule = cg.compile_rule(&rule);
+            let compiled_rule = cg.compile_rule(&rule);            
             wam.add_rule(rule, compiled_rule);
             EvalResult::EntrySuccess
         },
         &Ok(TopLevel::Query(ref query)) => {
-            let compiled_query = cg.compile_query(&query);
+            let compiled_query = cg.compile_query(&query);            
             wam.run_query(compiled_query, &cg)
         },
         &Err(_) => {

src/prolog/machine.rs

@@ -81,24 +81,22 @@ impl Machine {
     }
 
     pub fn add_fact(&mut self, fact: &Term, mut code: Code) {
-        if fact.name().is_some() {
-            let p = self.code.len();
-            let name  = fact.name().unwrap().clone();
+        if let Some(name) = fact.name() {
+            let p = self.code.len();            
             let arity = fact.arity();
 
             self.code.append(&mut code);
-            self.code_dir.insert((name, arity), p);
+            self.code_dir.insert((name.clone(), arity), p);
         }
     }
 
     pub fn add_rule(&mut self, rule: &Rule, mut code: Code) {
-        if rule.head.0.name().is_some() {
+        if let Some(name) = rule.head.0.name() {
             let p = self.code.len();
-            let name  = rule.head.0.name().unwrap().clone();
             let arity = rule.head.0.arity();
 
             self.code.append(&mut code);
-            self.code_dir.insert((name, arity), p);
+            self.code_dir.insert((name.clone(), arity), p);
         }
     }
 

src/prolog/or_stack.rs

@@ -69,7 +69,7 @@ impl OrStack {
     pub fn clear(&mut self) {
         self.0.clear()
     }
-
+    
     pub fn top(&self) -> Option<&Frame> {
         self.0.last()
     }