correct for issue #145

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "scryer-prolog"
-version = "0.8.85"
+version = "0.8.86"
 authors = ["Mark Thom <markjordanthom@gmail.com>"]
 repository = "https://github.com/mthom/scryer-prolog"
 description = "A modern Prolog implementation written mostly in Rust."

src/prolog/arithmetic.rs

@@ -132,7 +132,7 @@ impl<'a> ArithmeticEvaluator<'a>
             "+" => Ok(ArithmeticInstruction::Plus(a1, t)),
             "cos" => Ok(ArithmeticInstruction::Cos(a1, t)),
             "sin" => Ok(ArithmeticInstruction::Sin(a1, t)),
-            "tan" => Ok(ArithmeticInstruction::Tan(a1, t)),            
+            "tan" => Ok(ArithmeticInstruction::Tan(a1, t)),
             "log" => Ok(ArithmeticInstruction::Log(a1, t)),
             "exp" => Ok(ArithmeticInstruction::Exp(a1, t)),
             "sqrt" => Ok(ArithmeticInstruction::Sqrt(a1, t)),
@@ -288,8 +288,8 @@ pub fn rnd_i<'a>(n: &'a Number) -> RefOrOwned<'a, Integer> {
         &Number::Rational(ref r) => {
             let r_ref = r.fract_floor_ref();
             let (mut fract, mut floor) = (Rational::new(), Integer::new());
-            
+
-            (&mut fract, &mut floor).assign(r_ref);            
+            (&mut fract, &mut floor).assign(r_ref);
             RefOrOwned::Owned(floor)
         }
     }
@@ -329,7 +329,7 @@ fn classify_float<Round>(f: f64, round: Round) -> Result<f64, EvalError>
         },
         FpCategory::Nan => Err(EvalError::Undefined),
         _ => Ok(round(&Number::Float(OrderedFloat(f))))
-    }    
+    }
 }
 
 fn float_i_to_f(n: &Integer) -> Result<f64, EvalError> {
@@ -408,13 +408,13 @@ impl Mul<Number> for Number {
             (Number::Integer(n1), Number::Integer(n2)) =>
                 Ok(Number::Integer(n1 * n2)), // mul_i
             (Number::Integer(n1), Number::Float(OrderedFloat(n2)))
-                | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) =>
+          | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) =>
                 Ok(Number::Float(mul_f(float_i_to_f(&n1)?, n2)?)),
             (Number::Integer(n1), Number::Rational(n2))
-                | (Number::Rational(n2), Number::Integer(n1)) =>
+          | (Number::Rational(n2), Number::Integer(n1)) =>
                 Ok(Number::Rational(Rational::from(n1) * n2)),
             (Number::Rational(n1), Number::Float(OrderedFloat(n2)))
-                | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) =>
+          | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) =>
                 Ok(Number::Float(mul_f(float_r_to_f(&n1)?, n2)?)),
             (Number::Float(OrderedFloat(f1)), Number::Float(OrderedFloat(f2))) =>
                 Ok(Number::Float(mul_f(f1, f2)?)),
@@ -504,16 +504,15 @@ impl Ord for Number {
 // Computes n ^ power. Ignores the sign of power.
 pub fn binary_pow(mut n: Integer, power: Integer) -> Integer
 {
-    let one = Integer::from(1);    
     let mut power = power.abs();
 
     if power == 0 {
-        return one;
+        return Integer::from(1);
     }
 
     let mut oddand = Integer::from(1);
 
-    while power > one {
+    while power > 1 {
         if power.is_odd() {
             oddand *= &n;
         }

src/prolog/machine/machine_state.rs

@@ -797,6 +797,7 @@ pub(crate) trait CallPolicy: Any {
                     } else {
                         let h = machine_st.heap.h;
                         let stub = MachineError::functor_stub(clause_name!("call"), arity + 1);
+
                         return Err(machine_st.error_form(MachineError::existence_error(h, name, arity),
                                                          stub));
                     }

src/prolog/machine/mod.rs

@@ -238,7 +238,7 @@ impl Machine {
         wam.compile_libraries();
         wam.compile_special_forms();
         wam.compile_top_level();
-
+        
         wam
     }
 

src/prolog/machine/system_calls.rs

@@ -275,9 +275,14 @@ impl MachineState {
                     },
                     None =>
                         match indices.code_dir.iter().next() {
-                            Some(((ref name, arity), _)) => {
+                            Some(((ref name, arity), idx)) => {
                                 let a2 = self[temp_v!(2)].clone();
 
+                                if idx.is_undefined() {
+                                    self.fail = true;
+                                    return;
+                                }
+                                
                                 if let Some(r) = a2.as_var() {
                                     let spec = get_clause_spec(name.clone(), *arity,
                                                                composite_op!(&indices.op_dir));
@@ -296,9 +301,14 @@ impl MachineState {
                 let key = (name.clone(), arity);
 
                 match indices.code_dir.range(key ..).skip(1).next() {
-                    Some(((name, arity), _)) => {
+                    Some(((name, arity), idx)) => {
                         let a2 = self[temp_v!(2)].clone();
 
+                        if idx.is_undefined() {
+                            self.fail = true;
+                            return;
+                        }
+                        
                         if let Some(r) = a2.as_var() {
                             let spec = get_clause_spec(name.clone(), *arity,
                                                        composite_op!(&indices.op_dir));
@@ -990,8 +1000,6 @@ impl MachineState {
                     Addr::DBRef(db_ref) =>
                         match db_ref {
                             DBRef::Op(priority, spec, name, _, shared_op_desc) => {
-
-
                                 let prec = self[temp_v!(2)].clone();
                                 let specifier = self[temp_v!(3)].clone();
                                 let op = self[temp_v!(4)].clone();