properly demarcate ops in dbrefs

diff --git a/Cargo.toml b/Cargo.toml
index 32288857b7878cb0b36c104163050bf4e7f17eb8..6414320c3f9521dd5782710c08e626f2fb9b2d19 100644 (file)
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "scryer-prolog"
-version = "0.8.25"
+version = "0.8.26"
 authors = ["Mark Thom <[email protected]>"]
 repository = "https://github.com/mthom/scryer-prolog"
 description = "A modern Prolog implementation written mostly in Rust."
@@ -14,7 +14,7 @@ cfg-if = "0.1.7"
 downcast = "0.10.0"
 num = "0.2"
 ordered-float = "0.5.0"
-prolog_parser = "0.8.5"
+prolog_parser = "0.8.6"
 readline_rs_compat = { version = "0.1.7", optional = true }
 ref_thread_local = "0.0.0"
 

diff --git a/src/prolog/machine/machine_indices.rs b/src/prolog/machine/machine_indices.rs
index d9e6941161eab29645dfb70957e6aa633dc0a6b2..0ca9fa80aa9b3630fa3e13ef7e8bf497a6cb81a3 100644 (file)
--- a/src/prolog/machine/machine_indices.rs
+++ b/src/prolog/machine/machine_indices.rs
@@ -14,8 +14,8 @@ use std::rc::Rc;
 
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub enum DBRef {
-    BuiltInPred(ClauseName, usize),
-    NamedPred(ClauseName, usize)
+    BuiltInPred(ClauseName, usize, Option<(usize, Specifier)>),
+    NamedPred(ClauseName, usize, Option<(usize, Specifier)>)
 }
 
 #[derive(Clone, PartialEq, Eq, Hash)]
@@ -409,7 +409,7 @@ pub struct IndexStore {
     pub(super) op_dir: OpDir,    
 }
 
-impl IndexStore {
+impl IndexStore {    
     pub fn predicate_exists(&self, name: ClauseName, module: ClauseName, arity: usize,
                             op_spec: Option<(usize, Specifier)>)
                             -> bool

diff --git a/src/prolog/machine/system_calls.rs b/src/prolog/machine/system_calls.rs
index 873b34ec63e116575bcda7a1129fcc815da83bf2..0901cd1f39a389cbdd27e2b19aa401414519ebf4 100644 (file)
--- a/src/prolog/machine/system_calls.rs
+++ b/src/prolog/machine/system_calls.rs
@@ -1,4 +1,5 @@
 use prolog_parser::ast::*;
+use prolog_parser::parser::get_clause_spec;
 
 use prolog::clause_types::*;
 use prolog::heap_iter::*;
@@ -215,9 +216,9 @@ impl MachineState {
         }
     }
 
-    fn get_next_db_ref(&mut self, db_ref: &DBRef, code_dir: &CodeDir) {
+    fn get_next_db_ref(&mut self, indices: &IndexStore, db_ref: &DBRef) {
         match db_ref {
-            &DBRef::BuiltInPred(ref name, arity) => {
+            &DBRef::BuiltInPred(ref name, arity, _) => {
                 let key = (name.as_str(), arity);
 
                 match CLAUSE_TYPE_FORMS.borrow().range(&key ..).skip(1).next() {
@@ -225,18 +226,20 @@ impl MachineState {
                         let a2 = self[temp_v!(2)].clone();
 
                         if let Some(r) = a2.as_var() {
-                            self.bind(r, Addr::DBRef(DBRef::BuiltInPred(ct.name(), *arity)));
+                            self.bind(r, Addr::DBRef(DBRef::BuiltInPred(ct.name(), *arity, ct.spec())));
                         } else {
                             self.fail = true;
                         }
                     },
-                    None => 
-                        match code_dir.iter().next() {
+                    None =>
+                        match indices.code_dir.iter().next() {
                             Some(((ref name, arity), _)) => {
                                 let a2 = self[temp_v!(2)].clone();
 
                                 if let Some(r) = a2.as_var() {
-                                    self.bind(r, Addr::DBRef(DBRef::NamedPred(name.clone(), *arity)));
+                                    let spec = get_clause_spec(name.clone(), *arity,
+                                                               composite_op!(&indices.op_dir));
+                                    self.bind(r, Addr::DBRef(DBRef::NamedPred(name.clone(), *arity, spec)));
                                 } else {
                                     self.fail = true;
                                 }
@@ -247,15 +250,17 @@ impl MachineState {
                         }
                 }
             },
-            &DBRef::NamedPred(ref name, arity) => {
+            &DBRef::NamedPred(ref name, arity, _) => {
                 let key = (name.clone(), arity);
 
-                match code_dir.range(key ..).skip(1).next() {
+                match indices.code_dir.range(key ..).skip(1).next() {
                     Some(((name, arity), _)) => {
                         let a2 = self[temp_v!(2)].clone();
 
                         if let Some(r) = a2.as_var() {
-                            self.bind(r, Addr::DBRef(DBRef::NamedPred(name.clone(), *arity)));
+                            let spec = get_clause_spec(name.clone(), *arity,
+                                                       composite_op!(&indices.op_dir));
+                            self.bind(r, Addr::DBRef(DBRef::NamedPred(name.clone(), *arity, spec)));
                         } else {
                             self.fail = true;
                         }
@@ -524,7 +529,7 @@ impl MachineState {
                   | addr @ Addr::AttrVar(_) =>
                       match CLAUSE_TYPE_FORMS.borrow().iter().next() {
                           Some(((_, arity), ct)) => {
-                              let db_ref = DBRef::BuiltInPred(ct.name(), *arity);
+                              let db_ref = DBRef::BuiltInPred(ct.name(), *arity, ct.spec());
                               let r = addr.as_var().unwrap();
 
                               self.bind(r, Addr::DBRef(db_ref));
@@ -535,7 +540,7 @@ impl MachineState {
                           }
                       },
                     Addr::DBRef(ref db_ref) =>
-                      self.get_next_db_ref(db_ref, &indices.code_dir),
+                      self.get_next_db_ref(&indices, db_ref),
                     _ => {
                       self.fail = true;
                     }
@@ -547,13 +552,13 @@ impl MachineState {
                 match self.store(self.deref(a1)) {
                     Addr::DBRef(db_ref) =>
                         match db_ref {
-                            DBRef::BuiltInPred(name, arity) | DBRef::NamedPred(name, arity) => {
+                            DBRef::BuiltInPred(name, arity, spec) | DBRef::NamedPred(name, arity, spec) => {
                                 let a2 = self[temp_v!(2)].clone();
                                 let a3 = self[temp_v!(3)].clone();
 
                                 let arity = Number::Integer(Rc::new(BigInt::from_usize(arity).unwrap()));
 
-                                self.unify(a2, Addr::Con(Constant::Atom(name, None)));
+                                self.unify(a2, Addr::Con(Constant::Atom(name, spec)));
 
                                 if !self.fail {
                                     self.unify(a3, Addr::Con(Constant::Number(arity)));

diff --git a/src/prolog/write.rs b/src/prolog/write.rs
index a81da29792db435f2e667cc333588a353843eb73..d635dcab9b04093f280913c8985c2b1bae117bc2 100644 (file)
--- a/src/prolog/write.rs
+++ b/src/prolog/write.rs
@@ -162,8 +162,8 @@ impl fmt::Display for HeapCellValue {
 impl fmt::Display for DBRef {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            &DBRef::BuiltInPred(ref name, arity) => write!(f, "db_ref:builtin:{}/{}", name, arity),
-            &DBRef::NamedPred(ref name, arity) =>   write!(f, "db_ref:named:{}/{}", name, arity)
+            &DBRef::BuiltInPred(ref name, arity, _) => write!(f, "db_ref:builtin:{}/{}", name, arity),
+            &DBRef::NamedPred(ref name, arity, _) =>   write!(f, "db_ref:named:{}/{}", name, arity)
         }
     }
 }