rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

get rid of OssifiedOpDir, DBRef, simplify current_op/3

Browse Source
This commit is contained in:
Mark
2023-09-11 15:36:15 -06:00
parent c75f74f681
commit de440a8c92
8 changed files with 152 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
Cargo.lock generated
View File

@@ -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"

2
build/instructions_template.rs
View File

@@ -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,

26
src/arena.rs
View File

@@ -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>());
}

3
src/heap_print.rs
View File

@@ -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"));
}

9
src/lib/builtins.pl
View File

@@ -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),
'$iterate_op_db_refs'(RPriority, RSpec, ROp, OssifiedOpDir, Priority, Spec, Op)
'$get_next_op_db_ref'(Priority, Spec, Op, ListOfOps),
lists:member(op(Priority, Spec, Op), ListOfOps)
).
list_of_op_atoms(Var) :-

8
src/machine/machine_indices.rs
View File

@@ -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 {

307
src/machine/system_calls.rs
View File

@@ -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(7);
let orig_op = self.deref_register(3);
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,146 +4105,79 @@ impl Machine {
);
let op_descs = [
self.indices.op_dir.get_key_value(&(orig_op, Fixity::In)),
self.indices.op_dir.get_key_value(&(orig_op, Fixity::Pre)),
self.indices.op_dir.get_key_value(&(orig_op, Fixity::Post)),
self.indices.op_dir.get(&(orig_op, Fixity::In)),
self.indices.op_dir.get(&(orig_op, Fixity::Pre)),
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 {
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());
let op_descs = op_descs.into_iter().filter_map(|op_desc| {
op_desc.map(|op_desc| (orig_op, *op_desc))
});
if op_prec == 0 {
// 8.14.4, note 2
self.machine_st.fail = true;
return;
}
if number_of_keys == 0 {
self.machine_st.fail = true;
} else {
let num_functors = write_op_functors_to_heap(
&mut self.machine_st.heap,
op_descs,
);
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 h = iter_to_heap_list(
&mut self.machine_st.heap,
(0..num_functors).map(|i| str_loc_as_cell!(h + 4 * i)),
);
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
}
unify!(
self.machine_st,
heap_loc_as_cell!(h),
self.machine_st.registers[4]
);
}
return;
} else {
let mut unossified_op_dir = OssifiedOpDir::new();
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;
unossified_op_dir.extend(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;
if other_prec == 0 {
// 8.14.4, note 2
return None;
}
if other_prec == 0 {
// 8.14.4, note 2
return None;
}
if (!orig_op.is_var() && atom_as_cell!(name) != orig_op)
|| (!spec.is_var() && other_spec != spec_num)
{
return None;
}
if (!orig_op.is_var() && atom_as_cell!(name) != orig_op)
|| (!spec.is_var() && other_spec != spec_num)
{
return None;
}
Some((key.0, *op_desc))
});
Some((*key, (other_prec as usize, other_spec as Specifier)))
},
));
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(
&mut self.machine_st.heap,
(0..num_functors).map(|i| str_loc_as_cell!(h + 4 * i)),
);
match ossified_op_dir.iter().next() {
Some(((op_atom, _), (op_prec, op_spec))) => {
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));
self.machine_st.bind(
ossified_op_dir_var,
typed_arena_ptr_as_cell!(ossified_op_dir),
);
}
None => {
self.machine_st.fail = true;
return;
}
unify!(
self.machine_st,
heap_loc_as_cell!(h),
self.machine_st.registers[4]
);
} else {
self.machine_st.fail = true;
}
} 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,51 +4189,25 @@ impl Machine {
}
};
match self
.machine_st
.get_next_db_ref(&self.indices, &DBRef::Op(op_atom, fixity, ossified_op_dir))
{
Some(DBRef::Op(op_atom, fixity, ossified_op_dir)) => {
let (prec, spec) = ossified_op_dir.get(&(op_atom, fixity)).unwrap();
match self.indices.op_dir.get(&(op_atom, fixity)).cloned() {
Some(op_desc) => {
let num_functors = write_op_functors_to_heap(
&mut self.machine_st.heap,
std::iter::once((op_atom, op_desc)),
);
let prec_var = self
.machine_st
.deref(self.machine_st.registers[5])
.as_var()
.unwrap();
let h = iter_to_heap_list(
&mut self.machine_st.heap,
(0..num_functors).map(|i| str_loc_as_cell!(h + 4 * i)),
);
let spec_var = self
.machine_st
.deref(self.machine_st.registers[6])
.as_var()
.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));
unify!(
self.machine_st,
heap_loc_as_cell!(h),
self.machine_st.registers[4]
);
}
Some(DBRef::NamedPred(..)) | None => {
_ => {
self.machine_st.fail = true;
}
}

7
src/macros.rs
View File

@@ -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))