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 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 mut compiled_fact = vec![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/machine.rs

@@ -81,24 +81,22 @@ impl Machine {
     }
 
     pub fn add_fact(&mut self, fact: &Term, mut code: Code) {
-        if fact.name().is_some() {
+        if let Some(name) = fact.name() {
             let p = self.code.len();            
-            let name  = fact.name().unwrap().clone();
             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);
         }
     }