get rid of OssifiedOpDir, DBRef, simplify current_op/3

Cargo.lock

@@ -251,6 +251,26 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "console_log"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be8aed40e4edbf4d3b4431ab260b63fdc40f5780a4766824329ea0f1eefe3c0f"
+dependencies = [
+ "log",
+ "web-sys",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.9.3"
@@ -1899,6 +1919,8 @@ dependencies = [
  "blake2 0.8.1",
  "bytes",
  "chrono",
+ "console_error_panic_hook",
+ "console_log",
  "cpu-time",
  "crossterm",
  "crrl",
@@ -1938,6 +1960,7 @@ dependencies = [
  "rustyline",
  "ryu",
  "select",
+ "serde-wasm-bindgen",
  "serial_test",
  "sha3 0.8.2",
  "smallvec",
@@ -1949,6 +1972,9 @@ dependencies = [
  "to-syn-value_derive",
  "tokio",
  "walkdir",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
@@ -1994,6 +2020,17 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-wasm-bindgen"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3b143e2833c57ab9ad3ea280d21fd34e285a42837aeb0ee301f4f41890fa00e"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "serde_derive"
 version = "1.0.188"

build/instructions_template.rs

@@ -306,7 +306,7 @@ enum SystemClauseType {
     GetBValue,
     #[strum_discriminants(strum(props(Arity = "3", Name = "$get_cont_chunk")))]
     GetContinuationChunk,
-    #[strum_discriminants(strum(props(Arity = "7", Name = "$get_next_op_db_ref")))]
+    #[strum_discriminants(strum(props(Arity = "4", Name = "$get_next_op_db_ref")))]
     GetNextOpDBRef,
     #[strum_discriminants(strum(props(Arity = "3", Name = "$lookup_db_ref")))]
     LookupDBRef,

src/arena.rs

@@ -169,7 +169,6 @@ impl F64Table {
 pub enum ArenaHeaderTag {
     Integer = 0b10,
     Rational = 0b11,
-    OssifiedOpDir = 0b0000100,
     LiveLoadState = 0b0001000,
     InactiveLoadState = 0b1011000,
     InputFileStream = 0b10000,
@@ -546,28 +545,6 @@ impl ArenaAllocated for Rational {
     }
 }
 
-impl ArenaAllocated for OssifiedOpDir {
-    type PtrToAllocated = TypedArenaPtr<OssifiedOpDir>;
-
-    #[inline]
-    fn tag() -> ArenaHeaderTag {
-        ArenaHeaderTag::OssifiedOpDir
-    }
-
-    #[inline]
-    fn size(&self) -> usize {
-        mem::size_of::<Self>()
-    }
-
-    #[inline]
-    fn copy_to_arena(self, dst: *mut Self) -> Self::PtrToAllocated {
-        unsafe {
-            ptr::write(dst, self);
-            TypedArenaPtr::new(dst as *mut Self)
-        }
-    }
-}
-
 impl ArenaAllocated for LiveLoadState {
     type PtrToAllocated = TypedArenaPtr<LiveLoadState>;
 
@@ -769,9 +746,6 @@ unsafe fn drop_slab_in_place(value: &mut AllocSlab) {
         ArenaHeaderTag::ByteStream => {
             ptr::drop_in_place(value.payload_offset::<StreamLayout<CharReader<ByteStream>>>());
         }
-        ArenaHeaderTag::OssifiedOpDir => {
-            ptr::drop_in_place(value.payload_offset::<OssifiedOpDir>());
-        }
         ArenaHeaderTag::LiveLoadState | ArenaHeaderTag::InactiveLoadState => {
             ptr::drop_in_place(value.payload_offset::<LiveLoadState>());
         }

src/heap_print.rs

@@ -1646,9 +1646,6 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                    (ArenaHeaderTag::Stream, stream) => {
                        self.print_stream(stream, max_depth);
                    }
-                   (ArenaHeaderTag::OssifiedOpDir, _op_dir) => {
-                       self.print_impromptu_atom(atom!("$ossified_op_dir"));
-                   }
                    (ArenaHeaderTag::Dropped, _value) => {
                        self.print_impromptu_atom(atom!("$dropped_value"));
                    }

src/lib/builtins.pl

@@ -1376,11 +1376,6 @@ current_predicate(Pred) :-
     ;  throw(error(type_error(predicate_indicator, Pred), current_predicate/1))
     ).
 
-'$iterate_op_db_refs'(RPriority, RSpec, ROp, _, RPriority, RSpec, ROp).
-'$iterate_op_db_refs'(RPriority, RSpec, ROp, OssifiedOpDir, Priority, Spec, Op) :-
-    '$get_next_op_db_ref'(RPriority, RSpec, ROp, OssifiedOpDir, RRPriority, RRSpec, RROp),
-    '$iterate_op_db_refs'(RRPriority, RRSpec, RROp, OssifiedOpDir, Priority, Spec, Op).
-
 can_be_op_priority(Priority) :- var(Priority).
 can_be_op_priority(Priority) :- op_priority(Priority).
 
@@ -1396,8 +1391,8 @@ current_op(Priority, Spec, Op) :-
     (  can_be_op_priority(Priority),
        can_be_op_specifier(Spec),
        error:can_be(atom, Op) ->
-       '$get_next_op_db_ref'(RPriority, RSpec, ROp, OssifiedOpDir, _, _, Op),
+       '$get_next_op_db_ref'(Priority, Spec, Op, ListOfOps),
-       '$iterate_op_db_refs'(RPriority, RSpec, ROp, OssifiedOpDir, Priority, Spec, Op)
+       lists:member(op(Priority, Spec, Op), ListOfOps)
     ).
 
 list_of_op_atoms(Var) :-

src/machine/machine_indices.rs

@@ -21,14 +21,6 @@ use crate::types::*;
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub(crate) struct OrderedOpDirKey(pub(crate) Atom, pub(crate) Fixity);
 
-pub(crate) type OssifiedOpDir = IndexMap<(Atom, Fixity), (usize, Specifier)>;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum DBRef {
-    NamedPred(Atom, usize),
-    Op(Atom, Fixity, TypedArenaPtr<OssifiedOpDir>),
-}
-
 // 7.2
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TermOrderCategory {

src/machine/system_calls.rs

@@ -872,37 +872,6 @@ impl MachineState {
         );
     }
 
-    pub(crate) fn get_next_db_ref(&self, indices: &IndexStore, db_ref: &DBRef) -> Option<DBRef> {
-        match db_ref {
-            DBRef::NamedPred(name, arity) => {
-                let key = (*name, *arity);
-
-                if let Some((last_idx, _, _)) = indices.code_dir.get_full(&key) {
-                    for idx in last_idx + 1..indices.code_dir.len() {
-                        let ((name, arity), idx) = indices.code_dir.get_index(idx).unwrap();
-
-                        if idx.is_undefined() {
-                            return None;
-                        }
-
-                        return Some(DBRef::NamedPred(*name, *arity));
-                    }
-                }
-            }
-            DBRef::Op(name, fixity, op_dir) => {
-                let key = (*name, *fixity);
-
-                if let Some((last_idx, _, _)) = op_dir.get_full(&key) {
-                    if let Some(((name, fixity), _)) = op_dir.get_index(last_idx + 1) {
-                        return Some(DBRef::Op(*name, *fixity, *op_dir));
-                    }
-                }
-            }
-        }
-
-        None
-    }
-
     pub(crate) fn parse_number_from_string(
         &mut self,
         string: &str,
@@ -4059,10 +4028,51 @@ impl Machine {
     pub(crate) fn get_next_op_db_ref(&mut self) {
         let prec = self.deref_register(1);
 
-        if let Some(prec_var) = prec.as_var() {
+        fn get_spec(op_spec: u8) -> Atom {
+            match op_spec as u32 {
+                XFX => atom!("xfx"),
+                XFY => atom!("xfy"),
+                YFX => atom!("yfx"),
+                FX => atom!("fx"),
+                FY => atom!("fy"),
+                XF => atom!("xf"),
+                YF => atom!("yf"),
+                _ => unreachable!(),
+            }
+        }
+
+        let h = self.machine_st.heap.len();
+
+        fn write_op_functors_to_heap(
+            heap: &mut Heap,
+            op_descs: impl Iterator<Item = (Atom, OpDesc)>,
+        ) -> usize {
+            let mut num_functors = 0;
+
+            for (name, op_desc) in op_descs {
+                let prec = op_desc.get_prec();
+
+                if prec == 0 {
+                    // 8.14.4, note 2
+                    continue;
+                }
+
+                let spec_atom = get_spec(op_desc.get_spec());
+
+                heap.extend(functor!(
+                    atom!("op"),
+                    [fixnum(prec), cell(atom_as_cell!(spec_atom)), cell(atom_as_cell!(name))]
+                ));
+
+                num_functors += 1;
+            }
+
+            num_functors
+        }
+
+        if prec.is_var() {
             let spec = self.deref_register(2);
-            let op = self.deref_register(3);
+            let orig_op = self.deref_register(3);
-            let orig_op = self.deref_register(7);
 
             let spec_num = if spec.get_tag() == HeapCellValueTag::Atom {
                 (match cell_as_atom!(spec) {
@@ -4078,7 +4088,7 @@ impl Machine {
                 0
             };
 
-            let unossified_op_dir = if !orig_op.is_var() {
+            let num_functors = if !orig_op.is_var() {
                 let orig_op = read_heap_cell!(orig_op,
                     (HeapCellValueTag::Atom, (name, _arity)) => {
                         name
@@ -4095,75 +4105,42 @@ impl Machine {
                 );
 
                 let op_descs = [
-                    self.indices.op_dir.get_key_value(&(orig_op, Fixity::In)),
+                    self.indices.op_dir.get(&(orig_op, Fixity::In)),
-                    self.indices.op_dir.get_key_value(&(orig_op, Fixity::Pre)),
+                    self.indices.op_dir.get(&(orig_op, Fixity::Pre)),
-                    self.indices.op_dir.get_key_value(&(orig_op, Fixity::Post)),
+                    self.indices.op_dir.get(&(orig_op, Fixity::Post)),
                 ];
 
                 let number_of_keys = op_descs[0].is_some() as usize
                     + op_descs[1].is_some() as usize
                     + op_descs[2].is_some() as usize;
 
-                match number_of_keys {
+                let op_descs = op_descs.into_iter().filter_map(|op_desc| {
-                    0 => {
+                    op_desc.map(|op_desc| (orig_op, *op_desc))
+                });
+
+                if number_of_keys == 0 {
                     self.machine_st.fail = true;
-                        return;
-                    }
-                    1 => {
-                        for op_desc in op_descs {
-                            if let Some((_, op_desc)) = op_desc {
-                                let (op_prec, op_spec) = (op_desc.get_prec(), op_desc.get_spec());
-
-                                if op_prec == 0 {
-                                    // 8.14.4, note 2
-                                    self.machine_st.fail = true;
-                                    return;
-                                }
-
-                                let op_spec = match op_spec as u32 {
-                                    XFX => atom!("xfx"),
-                                    XFY => atom!("xfy"),
-                                    YFX => atom!("yfx"),
-                                    FX => atom!("fx"),
-                                    FY => atom!("fy"),
-                                    XF => atom!("xf"),
-                                    YF => atom!("yf"),
-                                    _ => unreachable!(),
-                                };
-
-                                let op_prec = Fixnum::build_with(op_prec as i64);
-
-                                self.machine_st.unify_fixnum(op_prec, prec);
-                                self.machine_st.unify_atom(op_spec, spec);
-                            }
-                        }
-
-                        return;
-                    }
-                    _ => {
-                        let mut unossified_op_dir = OssifiedOpDir::new();
-
-                        for op_desc in op_descs {
-                            if let Some((key, op_desc)) = op_desc {
-                                let (prec, spec) = (op_desc.get_prec(), op_desc.get_spec());
-
-                                if prec == 0 {
-                                    // 8.14.4, note 2
-                                    continue;
-                                }
-
-                                unossified_op_dir.insert(*key, (prec as usize, spec as Specifier));
-                            }
-                        }
-
-                        unossified_op_dir
-                    }
-                }
                 } else {
-                let mut unossified_op_dir = OssifiedOpDir::new();
+                    let num_functors = write_op_functors_to_heap(
+                        &mut self.machine_st.heap,
+                        op_descs,
+                    );
 
-                unossified_op_dir.extend(self.indices.op_dir.iter().filter_map(
+                    let h = iter_to_heap_list(
-                    |(key, op_desc)| {
+                        &mut self.machine_st.heap,
+                        (0..num_functors).map(|i| str_loc_as_cell!(h + 4 * i)),
+                    );
+
+                    unify!(
+                        self.machine_st,
+                        heap_loc_as_cell!(h),
+                        self.machine_st.registers[4]
+                    );
+                }
+
+                return;
+            } else {
+                let op_descs = self.indices.op_dir.iter().filter_map(|(key, op_desc)| {
                     let (other_prec, other_spec) = (op_desc.get_prec(), op_desc.get_spec());
                     let name = key.0;
 
@@ -4178,63 +4155,29 @@ impl Machine {
                         return None;
                     }
 
-                        Some((*key, (other_prec as usize, other_spec as Specifier)))
+                    Some((key.0, *op_desc))
-                    },
+                });
-                ));
 
-                unossified_op_dir
+                write_op_functors_to_heap(&mut self.machine_st.heap, op_descs)
             };
 
-            let ossified_op_dir = arena_alloc!(unossified_op_dir, &mut self.machine_st.arena);
+            if num_functors > 0 {
-
+                let h = iter_to_heap_list(
-            match ossified_op_dir.iter().next() {
+                    &mut self.machine_st.heap,
-                Some(((op_atom, _), (op_prec, op_spec))) => {
+                    (0..num_functors).map(|i| str_loc_as_cell!(h + 4 * i)),
-                    let ossified_op_dir_var = self.deref_register(4).as_var().unwrap();
-
-                    let spec_atom = match *op_spec {
-                        FX => atom!("fx"),
-                        FY => atom!("fy"),
-                        XF => atom!("xf"),
-                        YF => atom!("yf"),
-                        XFX => atom!("xfx"),
-                        XFY => atom!("xfy"),
-                        YFX => atom!("yfx"),
-                        _ => {
-                            self.machine_st.fail = true;
-                            return;
-                        }
-                    };
-
-                    let spec_var = spec.as_var().unwrap();
-                    let op_var = op.as_var().unwrap();
-
-                    self.machine_st.bind(
-                        prec_var,
-                        fixnum_as_cell!(Fixnum::build_with(*op_prec as i64)),
                 );
-                    self.machine_st.bind(spec_var, atom_as_cell!(spec_atom));
+
-                    self.machine_st.bind(op_var, atom_as_cell!(op_atom));
+                unify!(
-                    self.machine_st.bind(
+                    self.machine_st,
-                        ossified_op_dir_var,
+                    heap_loc_as_cell!(h),
-                        typed_arena_ptr_as_cell!(ossified_op_dir),
+                    self.machine_st.registers[4]
                 );
-                }
+            } else {
-                None => {
                 self.machine_st.fail = true;
-                    return;
-                }
             }
         } else {
             let spec = cell_as_atom!(self.deref_register(2));
             let op_atom = cell_as_atom!(self.deref_register(3));
-            let ossified_op_dir_cell = self.deref_register(4);
-
-            if ossified_op_dir_cell.is_var() {
-                self.machine_st.fail = true;
-                return;
-            }
-
-            let ossified_op_dir = cell_as_ossified_op_dir!(ossified_op_dir_cell);
 
             let fixity = match spec {
                 atom!("xfy") | atom!("yfx") | atom!("xfx") => Fixity::In,
@@ -4246,52 +4189,26 @@ impl Machine {
                 }
             };
 
-            match self
+            match self.indices.op_dir.get(&(op_atom, fixity)).cloned() {
-                .machine_st
+                Some(op_desc) => {
-                .get_next_db_ref(&self.indices, &DBRef::Op(op_atom, fixity, ossified_op_dir))
+                    let num_functors = write_op_functors_to_heap(
-            {
+                        &mut self.machine_st.heap,
-                Some(DBRef::Op(op_atom, fixity, ossified_op_dir)) => {
+                        std::iter::once((op_atom, op_desc)),
-                    let (prec, spec) = ossified_op_dir.get(&(op_atom, fixity)).unwrap();
+                    );
 
-                    let prec_var = self
+                    let h = iter_to_heap_list(
-                        .machine_st
+                        &mut self.machine_st.heap,
-                        .deref(self.machine_st.registers[5])
+                        (0..num_functors).map(|i| str_loc_as_cell!(h + 4 * i)),
-                        .as_var()
+                    );
-                        .unwrap();
 
-                    let spec_var = self
+                    unify!(
-                        .machine_st
+                        self.machine_st,
-                        .deref(self.machine_st.registers[6])
+                        heap_loc_as_cell!(h),
-                        .as_var()
+                        self.machine_st.registers[4]
-                        .unwrap();
+                    );
-
+                }
-                    let op_var = self
-                        .machine_st
-                        .deref(self.machine_st.registers[7])
-                        .as_var()
-                        .unwrap();
-
-                    let spec_atom = match *spec {
-                        FX => atom!("fx"),
-                        FY => atom!("fy"),
-                        XF => atom!("xf"),
-                        YF => atom!("yf"),
-                        XFX => atom!("xfx"),
-                        XFY => atom!("xfy"),
-                        YFX => atom!("yfx"),
                 _ => {
                     self.machine_st.fail = true;
-                            return;
-                        }
-                    };
-
-                    self.machine_st
-                        .bind(prec_var, fixnum_as_cell!(Fixnum::build_with(*prec as i64)));
-                    self.machine_st.bind(spec_var, atom_as_cell!(spec_atom));
-                    self.machine_st.bind(op_var, atom_as_cell!(op_atom));
-                }
-                Some(DBRef::NamedPred(..)) | None => {
-                    self.machine_st.fail = true;
                 }
             }
         }

src/macros.rs

@@ -57,13 +57,6 @@ macro_rules! atom_as_cell {
     };
 }
 
-macro_rules! cell_as_ossified_op_dir {
-    ($cell:expr) => {{
-        let ptr_u64 = cell_as_untyped_arena_ptr!($cell);
-        TypedArenaPtr::new(ptr_u64.payload_offset() as *mut OssifiedOpDir)
-    }};
-}
-
 macro_rules! cell_as_string {
     ($cell:expr) => {
         PartialString::from(cell_as_atom!($cell))