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

add occurs_check flag (#309)

Browse Source
This commit is contained in:
Mark Thom
2021-02-28 10:41:32 -07:00
parent 8e6a89b279
commit a367812348
6 changed files with 210 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/clause_types.rs
View File

@@ -304,6 +304,9 @@ pub enum SystemClauseType {
UnsetEnv, UnsetEnv,
CharsBase64, CharsBase64,
DevourWhitespace, DevourWhitespace,
IsSTOEnabled,
SetSTOAsUnify,
SetNSTOAsUnify,
} }
impl SystemClauseType { impl SystemClauseType {
@@ -585,6 +588,9 @@ impl SystemClauseType {
&SystemClauseType::CharsBase64 => clause_name!("$chars_base64"), &SystemClauseType::CharsBase64 => clause_name!("$chars_base64"),
&SystemClauseType::LoadLibraryAsStream => clause_name!("$load_library_as_stream"), &SystemClauseType::LoadLibraryAsStream => clause_name!("$load_library_as_stream"),
&SystemClauseType::DevourWhitespace => clause_name!("$devour_whitespace"), &SystemClauseType::DevourWhitespace => clause_name!("$devour_whitespace"),
&SystemClauseType::IsSTOEnabled => clause_name!("$is_sto_enabled"),
&SystemClauseType::SetSTOAsUnify => clause_name!("$set_sto_as_unify"),
&SystemClauseType::SetNSTOAsUnify => clause_name!("$set_nsto_as_unify"),
} }
} }
@@ -830,6 +836,9 @@ impl SystemClauseType {
("$devour_whitespace", 1) => { ("$devour_whitespace", 1) => {
Some(SystemClauseType::DevourWhitespace) Some(SystemClauseType::DevourWhitespace)
} }
("$is_sto_enabled", 1) => Some(SystemClauseType::IsSTOEnabled),
("$set_sto_as_unify", 0) => Some(SystemClauseType::SetSTOAsUnify),
("$set_nsto_as_unify", 0) => Some(SystemClauseType::SetNSTOAsUnify),
_ => None, _ => None,
} }
} }

8
src/lib/builtins.pl
View File

@@ -133,6 +133,10 @@ current_prolog_flag(Flag, Value) :- Flag == double_quotes, !, '$get_double_quote
current_prolog_flag(double_quotes, Value) :- '$get_double_quotes'(Value). current_prolog_flag(double_quotes, Value) :- '$get_double_quotes'(Value).
current_prolog_flag(Flag, _) :- Flag == max_integer, !, '$fail'. current_prolog_flag(Flag, _) :- Flag == max_integer, !, '$fail'.
current_prolog_flag(Flag, _) :- Flag == min_integer, !, '$fail'. current_prolog_flag(Flag, _) :- Flag == min_integer, !, '$fail'.
current_prolog_flag(Flag, OccursCheckEnabled) :-
Flag == occurs_check,
!,
'$is_sto_enabled'(OccursCheckEnabled).
current_prolog_flag(Flag, _) :- current_prolog_flag(Flag, _) :-
atom(Flag), atom(Flag),
throw(error(domain_error(prolog_flag, Flag), current_prolog_flag/2)). % 8.17.2.3 b throw(error(domain_error(prolog_flag, Flag), current_prolog_flag/2)). % 8.17.2.3 b
@@ -163,6 +167,10 @@ set_prolog_flag(double_quotes, atom) :-
!, '$set_double_quotes'(atom). % 7.11.2.5, list of char codes (UTF8). !, '$set_double_quotes'(atom). % 7.11.2.5, list of char codes (UTF8).
set_prolog_flag(double_quotes, codes) :- set_prolog_flag(double_quotes, codes) :-
!, '$set_double_quotes'(codes). !, '$set_double_quotes'(codes).
set_prolog_flag(occurs_check, true) :-
!, '$set_sto_as_unify'.
set_prolog_flag(occurs_check, false) :-
!, '$set_nsto_as_unify'.
set_prolog_flag(double_quotes, Value) :- set_prolog_flag(double_quotes, Value) :-
throw(error(domain_error(flag_value, double_quotes + Value), throw(error(domain_error(flag_value, double_quotes + Value),
set_prolog_flag/2)). % 8.17.1.3 e set_prolog_flag/2)). % 8.17.1.3 e

20
src/machine/loader.rs
View File

@@ -1631,8 +1631,7 @@ impl Machine {
.push(HeapCellValue::Atom(path_atom, None)), .push(HeapCellValue::Atom(path_atom, None)),
); );
self.machine_st self.machine_st.unify(path_addr, self.machine_st[temp_v!(1)]);
.unify(path_addr, self.machine_st[temp_v!(1)]);
} else { } else {
self.machine_st.fail = true; self.machine_st.fail = true;
} }
@@ -1652,9 +1651,7 @@ impl Machine {
.push(HeapCellValue::Atom(file_name_atom, None)), .push(HeapCellValue::Atom(file_name_atom, None)),
); );
self.machine_st self.machine_st.unify(file_name_addr, self.machine_st[temp_v!(1)]);
.unify(file_name_addr, self.machine_st[temp_v!(1)]);
return; return;
} }
_ => { _ => {
@@ -1680,8 +1677,7 @@ impl Machine {
.push(HeapCellValue::Atom(directory_atom, None)), .push(HeapCellValue::Atom(directory_atom, None)),
); );
self.machine_st self.machine_st.unify(directory_addr, self.machine_st[temp_v!(1)]);
.unify(directory_addr, self.machine_st[temp_v!(1)]);
return; return;
} }
} }
@@ -1697,8 +1693,7 @@ impl Machine {
.push(HeapCellValue::Atom(load_context.module.clone(), None)), .push(HeapCellValue::Atom(load_context.module.clone(), None)),
); );
self.machine_st self.machine_st.unify(module_name_addr, self.machine_st[temp_v!(1)]);
.unify(module_name_addr, self.machine_st[temp_v!(1)]);
} else { } else {
self.machine_st.fail = true; self.machine_st.fail = true;
} }
@@ -1712,8 +1707,7 @@ impl Machine {
.push(HeapCellValue::Stream(load_context.stream.clone())), .push(HeapCellValue::Stream(load_context.stream.clone())),
); );
self.machine_st self.machine_st.unify(stream_addr, self.machine_st[temp_v!(1)]);
.unify(stream_addr, self.machine_st[temp_v!(1)]);
} else { } else {
self.machine_st.fail = true; self.machine_st.fail = true;
} }
@@ -2064,8 +2058,8 @@ impl Machine {
self.machine_st self.machine_st
.heap .heap
.push(HeapCellValue::Addr(Addr::HeapCell(list_loc))); .push(HeapCellValue::Addr(Addr::HeapCell(list_loc)));
self.machine_st
.unify(Addr::HeapCell(heap_loc), self.machine_st[temp_v!(4)]); self.machine_st.unify(Addr::HeapCell(heap_loc), self.machine_st[temp_v!(4)]);
} }
None => { None => {
self.machine_st.fail = true; self.machine_st.fail = true;

61
src/machine/machine_state.rs
View File

@@ -275,7 +275,7 @@ pub enum FirstOrNext {
Next, Next,
} }
#[derive(Debug)] // #[derive(Debug)]
pub struct MachineState { pub struct MachineState {
pub(crate) atom_tbl: TabledData<Atom>, pub(crate) atom_tbl: TabledData<Atom>,
pub(super) s: HeapPtr, pub(super) s: HeapPtr,
@@ -299,11 +299,48 @@ pub struct MachineState {
pub(super) lifted_heap: Heap, pub(super) lifted_heap: Heap,
pub(super) interms: Vec<Number>, // intermediate numbers. pub(super) interms: Vec<Number>, // intermediate numbers.
pub(super) last_call: bool, pub(super) last_call: bool,
pub(crate) heap_locs: HeapVarDict,
pub(crate) flags: MachineFlags, pub(crate) flags: MachineFlags,
pub(crate) cc: usize, pub(crate) cc: usize,
pub(crate) global_clock: usize, pub(crate) global_clock: usize,
pub(crate) dynamic_mode: FirstOrNext, pub(crate) dynamic_mode: FirstOrNext,
pub(crate) unify_fn: fn(&mut MachineState, Addr, Addr),
}
impl fmt::Debug for MachineState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("MachineState")
.field("atom_tbl", &self.atom_tbl)
.field("s", &self.s)
.field("p", &self.p)
.field("b", &self.b)
.field("b0", &self.b0)
.field("e", &self.e)
.field("num_of_args", &self.num_of_args)
.field("cp", &self.cp)
.field("attr_var_init", &self.attr_var_init)
.field("fail", &self.fail)
.field("heap", &self.heap)
.field("mode", &self.mode)
.field("stack", &self.stack)
.field("registers", &self.registers)
.field("trail", &self.trail)
.field("tr", &self.tr)
.field("hb", &self.hb)
.field("block", &self.block)
.field("ball", &self.ball)
.field("lifted_heap", &self.lifted_heap)
.field("interms", &self.interms)
.field("last_call", &self.last_call)
.field("flags", &self.flags)
.field("cc", &self.cc)
.field("global_clock", &self.global_clock)
.field("dynamic_mode", &self.dynamic_mode)
.field("unify_fn",
if self.unify_fn as usize == MachineState::unify as usize
{ &"MachineState::unify" }
else { &"MachineState::unify_with_occurs_check" })
.finish()
}
} }
impl MachineState { impl MachineState {
@@ -354,7 +391,7 @@ impl MachineState {
match self.read(stream.clone(), self.atom_tbl.clone(), &indices.op_dir) { match self.read(stream.clone(), self.atom_tbl.clone(), &indices.op_dir) {
Ok(term_write_result) => { Ok(term_write_result) => {
let term = self[temp_v!(2)]; let term = self[temp_v!(2)];
self.unify(Addr::HeapCell(term_write_result.heap_loc), term); (self.unify_fn)(self, Addr::HeapCell(term_write_result.heap_loc), term);
if self.fail { if self.fail {
return Ok(()); return Ok(());
@@ -398,7 +435,7 @@ impl MachineState {
let singletons_offset = let singletons_offset =
Addr::HeapCell(self.heap.to_list(singleton_var_list.into_iter())); Addr::HeapCell(self.heap.to_list(singleton_var_list.into_iter()));
self.unify(singletons_offset, singleton_addr); (self.unify_fn)(self, singletons_offset, singleton_addr);
if self.fail { if self.fail {
return Ok(()); return Ok(());
@@ -407,7 +444,7 @@ impl MachineState {
let vars_addr = self[temp_v!(4)]; let vars_addr = self[temp_v!(4)];
let vars_offset = Addr::HeapCell(self.heap.to_list(var_list.into_iter())); let vars_offset = Addr::HeapCell(self.heap.to_list(var_list.into_iter()));
self.unify(vars_offset, vars_addr); (self.unify_fn)(self, vars_offset, vars_addr);
if self.fail { if self.fail {
return Ok(()); return Ok(());
@@ -417,7 +454,7 @@ impl MachineState {
let var_names_offset = let var_names_offset =
Addr::HeapCell(self.heap.to_list(list_of_var_eqs.into_iter())); Addr::HeapCell(self.heap.to_list(list_of_var_eqs.into_iter()));
return Ok(self.unify(var_names_offset, var_names_addr)); return Ok((self.unify_fn)(self, var_names_offset, var_names_addr));
} }
Err(err) => { Err(err) => {
if let ParserError::UnexpectedEOF = err { if let ParserError::UnexpectedEOF = err {
@@ -1027,7 +1064,7 @@ pub(crate) trait CallPolicy: Any + fmt::Debug {
let h = machine_st.heap.h(); let h = machine_st.heap.h();
machine_st.heap.push(atom); machine_st.heap.push(atom);
machine_st.unify(a1, Addr::Con(h)); (machine_st.unify_fn)(machine_st, a1, Addr::Con(h));
return_from_clause!(machine_st.last_call, machine_st) return_from_clause!(machine_st.last_call, machine_st)
} }
@@ -1049,7 +1086,7 @@ pub(crate) trait CallPolicy: Any + fmt::Debug {
) { ) {
Ok(offset) => { Ok(offset) => {
let addr = machine_st[temp_v!(1)]; let addr = machine_st[temp_v!(1)];
machine_st.unify(addr, Addr::HeapCell(offset.heap_loc)); (machine_st.unify_fn)(machine_st, addr, Addr::HeapCell(offset.heap_loc));
} }
Err(ParserError::UnexpectedEOF) => { Err(ParserError::UnexpectedEOF) => {
let addr = machine_st[temp_v!(1)]; let addr = machine_st[temp_v!(1)];
@@ -1057,7 +1094,7 @@ pub(crate) trait CallPolicy: Any + fmt::Debug {
let atom = machine_st.heap.to_unifiable(HeapCellValue::Atom(eof, None)); let atom = machine_st.heap.to_unifiable(HeapCellValue::Atom(eof, None));
machine_st.unify(addr, atom); (machine_st.unify_fn)(machine_st, addr, atom);
} }
Err(e) => { Err(e) => {
let h = machine_st.heap.h(); let h = machine_st.heap.h();
@@ -1121,7 +1158,7 @@ pub(crate) trait CallPolicy: Any + fmt::Debug {
let heap_addr = Addr::HeapCell(machine_st.heap.to_list(list.into_iter())); let heap_addr = Addr::HeapCell(machine_st.heap.to_list(list.into_iter()));
let r2 = machine_st[temp_v!(2)]; let r2 = machine_st[temp_v!(2)];
machine_st.unify(r2, heap_addr); (machine_st.unify_fn)(machine_st, r2, heap_addr);
return_from_clause!(machine_st.last_call, machine_st) return_from_clause!(machine_st.last_call, machine_st)
} }
@@ -1147,7 +1184,7 @@ pub(crate) trait CallPolicy: Any + fmt::Debug {
let heap_addr = Addr::HeapCell(machine_st.heap.to_list(key_pairs)); let heap_addr = Addr::HeapCell(machine_st.heap.to_list(key_pairs));
let r2 = machine_st[temp_v!(2)]; let r2 = machine_st[temp_v!(2)];
machine_st.unify(r2, heap_addr); (machine_st.unify_fn)(machine_st, r2, heap_addr);
return_from_clause!(machine_st.last_call, machine_st) return_from_clause!(machine_st.last_call, machine_st)
} }
@@ -1156,7 +1193,7 @@ pub(crate) trait CallPolicy: Any + fmt::Debug {
let n2 = machine_st.get_number(at)?; let n2 = machine_st.get_number(at)?;
let n2 = machine_st.heap.put_constant(n2.into()); let n2 = machine_st.heap.put_constant(n2.into());
machine_st.unify(a1, n2); (machine_st.unify_fn)(machine_st, a1, n2);
return_from_clause!(machine_st.last_call, machine_st) return_from_clause!(machine_st.last_call, machine_st)
} }

30
src/machine/machine_state_impl.rs
View File

@@ -52,11 +52,11 @@ impl MachineState {
lifted_heap: Heap::new(), lifted_heap: Heap::new(),
interms: vec![Number::default(); 256], interms: vec![Number::default(); 256],
last_call: false, last_call: false,
heap_locs: HeapVarDict::new(),
flags: MachineFlags::default(), flags: MachineFlags::default(),
cc: 0, cc: 0,
global_clock: 0, global_clock: 0,
dynamic_mode: FirstOrNext::First, dynamic_mode: FirstOrNext::First,
unify_fn: MachineState::unify,
} }
} }
@@ -770,7 +770,7 @@ impl MachineState {
self.heap.put_complete_string(&string[prefix_len..]) self.heap.put_complete_string(&string[prefix_len..])
}; };
self.unify(Addr::Lis(l), pstr_addr); (self.unify_fn)(self, Addr::Lis(l), pstr_addr);
} }
_ => { _ => {
self.fail = true; self.fail = true;
@@ -839,7 +839,7 @@ impl MachineState {
} }
Addr::Lis(l) => { Addr::Lis(l) => {
let addr = self.heap.put_constant(c.clone()); let addr = self.heap.put_constant(c.clone());
self.unify(Addr::Lis(l), addr); (self.unify_fn)(self, Addr::Lis(l), addr);
} }
Addr::PStrLocation(h, n) => { Addr::PStrLocation(h, n) => {
if let Constant::String(ref s2) = c { if let Constant::String(ref s2) = c {
@@ -857,7 +857,7 @@ impl MachineState {
if let Some(r) = addr.as_var() { if let Some(r) = addr.as_var() {
self.bind(r, c); self.bind(r, c);
} else { } else {
self.unify(addr, c); (self.unify_fn)(self, addr, c);
} }
} }
}; };
@@ -1209,7 +1209,7 @@ impl MachineState {
let norm_addr = self[norm]; let norm_addr = self[norm];
let reg_addr = self.registers[arg]; let reg_addr = self.registers[arg];
self.unify(norm_addr, reg_addr); (self.unify_fn)(self, norm_addr, reg_addr);
} }
&FactInstruction::UnifyConstant(ref c) => { &FactInstruction::UnifyConstant(ref c) => {
match self.mode { match self.mode {
@@ -1247,7 +1247,7 @@ impl MachineState {
MachineMode::Read => { MachineMode::Read => {
let reg_addr = self[reg]; let reg_addr = self[reg];
self.unify(reg_addr, self.s.read(&self.heap)); (self.unify_fn)(self, reg_addr, self.s.read(&self.heap));
self.increment_s_ptr(1); self.increment_s_ptr(1);
} }
MachineMode::Write => { MachineMode::Write => {
@@ -1275,7 +1275,7 @@ impl MachineState {
MachineMode::Read => { MachineMode::Read => {
let reg_addr = self[reg]; let reg_addr = self[reg];
self.unify(reg_addr, self.s.read(&self.heap)); (self.unify_fn)(self, reg_addr, self.s.read(&self.heap));
self.increment_s_ptr(1); self.increment_s_ptr(1);
} }
MachineMode::Write => { MachineMode::Write => {
@@ -1778,7 +1778,7 @@ impl MachineState {
let a3 = self[temp_v!(3)]; let a3 = self[temp_v!(3)];
let h_a = Addr::HeapCell(o + n); let h_a = Addr::HeapCell(o + n);
self.unify(a3, h_a); (self.unify_fn)(self, a3, h_a);
} }
_ => { _ => {
self.fail = true; self.fail = true;
@@ -1789,7 +1789,7 @@ impl MachineState {
let a3 = self[temp_v!(3)]; let a3 = self[temp_v!(3)];
let h_a = Addr::HeapCell(l + n - 1); let h_a = Addr::HeapCell(l + n - 1);
self.unify(a3, h_a); (self.unify_fn)(self, a3, h_a);
} else { } else {
self.fail = true; self.fail = true;
} }
@@ -1812,7 +1812,7 @@ impl MachineState {
unreachable!() unreachable!()
}; };
self.unify(a3, h_a); (self.unify_fn)(self, a3, h_a);
} else { } else {
self.fail = true; self.fail = true;
} }
@@ -2396,10 +2396,10 @@ impl MachineState {
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
let a3 = self[temp_v!(3)]; let a3 = self[temp_v!(3)];
self.unify(a2, name); (self.unify_fn)(self, a2, name);
if !self.fail { if !self.fail {
self.unify(a3, Addr::Usize(arity)); (self.unify_fn)(self, a3, Addr::Usize(arity));
} }
} }
@@ -2520,7 +2520,7 @@ impl MachineState {
| Addr::Usize(_) | Addr::Usize(_)
if arity == 0 => if arity == 0 =>
{ {
self.unify(a1, name); (self.unify_fn)(self, a1, name);
} }
Addr::Con(h) => { Addr::Con(h) => {
if let HeapCellValue::Atom(name, spec) = self.heap.clone(h) { if let HeapCellValue::Atom(name, spec) = self.heap.clone(h) {
@@ -2763,7 +2763,7 @@ impl MachineState {
copy_term(CopyTerm::new(self), a1, attr_var_policy); copy_term(CopyTerm::new(self), a1, attr_var_policy);
self.unify(Addr::HeapCell(old_h), a2); (self.unify_fn)(self, Addr::HeapCell(old_h), a2);
} }
// returns true on failure. // returns true on failure.
@@ -3505,7 +3505,7 @@ impl MachineState {
let b0 = self[perm_v!(1)]; let b0 = self[perm_v!(1)];
let a = self[r]; let a = self[r];
self.unify(a, b0); (self.unify_fn)(self, a, b0);
self.p += 1; self.p += 1;
} }
&CutInstruction::Cut(r) => { &CutInstruction::Cut(r) => {

223
src/machine/system_calls.rs
View File

@@ -253,11 +253,11 @@ impl MachineState {
fn finalize_skip_max_list(&mut self, n: usize, addr: Addr) { fn finalize_skip_max_list(&mut self, n: usize, addr: Addr) {
let target_n = self[temp_v!(1)]; let target_n = self[temp_v!(1)];
self.unify(Addr::Usize(n), target_n); (self.unify_fn)(self, Addr::Usize(n), target_n);
if !self.fail { if !self.fail {
let xs = self[temp_v!(4)]; let xs = self[temp_v!(4)];
self.unify(addr, xs); (self.unify_fn)(self, addr, xs);
} }
} }
@@ -313,7 +313,7 @@ impl MachineState {
let xs0 = self[temp_v!(3)]; let xs0 = self[temp_v!(3)];
let xs = self[temp_v!(4)]; let xs = self[temp_v!(4)];
self.unify(xs0, xs); (self.unify_fn)(self, xs0, xs);
} else { } else {
self.skip_max_list_result(max_steps_n); self.skip_max_list_result(max_steps_n);
} }
@@ -323,7 +323,7 @@ impl MachineState {
let xs0 = self[temp_v!(3)]; let xs0 = self[temp_v!(3)];
let xs = self[temp_v!(4)]; let xs = self[temp_v!(4)];
self.unify(xs0, xs); (self.unify_fn)(self, xs0, xs);
} else { } else {
self.skip_max_list_result(max_steps_n); self.skip_max_list_result(max_steps_n);
} }
@@ -630,19 +630,19 @@ impl MachineState {
} }
Ok(Term::Constant(_, Constant::Rational(n))) => { Ok(Term::Constant(_, Constant::Rational(n))) => {
let addr = self.heap.put_constant(Constant::Rational(n)); let addr = self.heap.put_constant(Constant::Rational(n));
self.unify(nx, addr); (self.unify_fn)(self, nx, addr);
} }
Ok(Term::Constant(_, Constant::Float(n))) => { Ok(Term::Constant(_, Constant::Float(n))) => {
let addr = self.heap.put_constant(Constant::Float(n)); let addr = self.heap.put_constant(Constant::Float(n));
self.unify(nx, addr); (self.unify_fn)(self, nx, addr);
} }
Ok(Term::Constant(_, Constant::Integer(n))) => { Ok(Term::Constant(_, Constant::Integer(n))) => {
let addr = self.heap.put_constant(Constant::Integer(n)); let addr = self.heap.put_constant(Constant::Integer(n));
self.unify(nx, addr); (self.unify_fn)(self, nx, addr);
} }
Ok(Term::Constant(_, Constant::Fixnum(n))) => { Ok(Term::Constant(_, Constant::Fixnum(n))) => {
let addr = self.heap.put_constant(Constant::Fixnum(n)); let addr = self.heap.put_constant(Constant::Fixnum(n));
self.unify(nx, addr); (self.unify_fn)(self, nx, addr);
} }
_ => { _ => {
let err = ParserError::ParseBigInt(0, 0); let err = ParserError::ParseBigInt(0, 0);
@@ -668,7 +668,7 @@ impl MachineState {
let attr_goals = Addr::HeapCell(self.heap.to_list(attr_goals.into_iter())); let attr_goals = Addr::HeapCell(self.heap.to_list(attr_goals.into_iter()));
let target = self[temp_v!(1)]; let target = self[temp_v!(1)];
self.unify(attr_goals, target); (self.unify_fn)(self, attr_goals, target);
} }
fn call_continuation_chunk(&mut self, chunk: Addr, return_p: LocalCodePtr) -> LocalCodePtr { fn call_continuation_chunk(&mut self, chunk: Addr, return_p: LocalCodePtr) -> LocalCodePtr {
@@ -742,7 +742,7 @@ impl MachineState {
let target = self[temp_v!(n)]; let target = self[temp_v!(n)];
let addr = self[temp_v!(1)]; let addr = self[temp_v!(1)];
self.unify(addr, target); (self.unify_fn)(self, addr, target);
return return_from_clause!(self.last_call, self); return return_from_clause!(self.last_call, self);
} }
} }
@@ -758,7 +758,7 @@ impl MachineState {
None, None,
)); ));
self.unify(self[temp_v!(1)], hostname); (self.unify_fn)(self, self[temp_v!(1)], hostname);
return return_from_clause!(self.last_call, self); return return_from_clause!(self.last_call, self);
} }
None => {} None => {}
@@ -777,7 +777,7 @@ impl MachineState {
match addr { match addr {
addr if addr.is_ref() => { addr if addr.is_ref() => {
let stream = self.heap.to_unifiable(HeapCellValue::Stream(stream)); let stream = self.heap.to_unifiable(HeapCellValue::Stream(stream));
self.unify(stream, addr); (self.unify_fn)(self, stream, addr);
} }
Addr::Stream(other_stream) => { Addr::Stream(other_stream) => {
if let HeapCellValue::Stream(ref other_stream) = &self.heap[other_stream] { if let HeapCellValue::Stream(ref other_stream) = &self.heap[other_stream] {
@@ -802,7 +802,7 @@ impl MachineState {
match addr { match addr {
addr if addr.is_ref() => { addr if addr.is_ref() => {
let stream = self.heap.to_unifiable(HeapCellValue::Stream(stream)); let stream = self.heap.to_unifiable(HeapCellValue::Stream(stream));
self.unify(stream, addr); (self.unify_fn)(self, stream, addr);
} }
Addr::Stream(other_stream) => { Addr::Stream(other_stream) => {
if let HeapCellValue::Stream(ref other_stream) = &self.heap[other_stream] { if let HeapCellValue::Stream(ref other_stream) = &self.heap[other_stream] {
@@ -849,7 +849,7 @@ impl MachineState {
} }
let files_list = Addr::HeapCell(self.heap.to_list(files.into_iter())); let files_list = Addr::HeapCell(self.heap.to_list(files.into_iter()));
self.unify(self[temp_v!(2)], files_list); (self.unify_fn)(self, self[temp_v!(2)], files_list);
} }
&SystemClauseType::FileSize => { &SystemClauseType::FileSize => {
let file = self.heap_pstr_iter(self[temp_v!(1)]).to_string(); let file = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
@@ -857,7 +857,7 @@ impl MachineState {
let len = self.heap.to_unifiable(HeapCellValue::Integer(Rc::new(len))); let len = self.heap.to_unifiable(HeapCellValue::Integer(Rc::new(len)));
self.unify(self[temp_v!(2)], len); (self.unify_fn)(self, self[temp_v!(2)], len);
} }
&SystemClauseType::FileExists => { &SystemClauseType::FileExists => {
let file = self.heap_pstr_iter(self[temp_v!(1)]).to_string(); let file = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
@@ -880,7 +880,7 @@ impl MachineState {
let addr = self let addr = self
.heap .heap
.put_constant(Constant::Char(std::path::MAIN_SEPARATOR)); .put_constant(Constant::Char(std::path::MAIN_SEPARATOR));
self.unify(self[temp_v!(1)], addr); (self.unify_fn)(self, self[temp_v!(1)], addr);
} }
&SystemClauseType::MakeDirectory => { &SystemClauseType::MakeDirectory => {
let directory = self.heap_pstr_iter(self[temp_v!(1)]).to_string(); let directory = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
@@ -919,7 +919,7 @@ impl MachineState {
}; };
let chars = self.heap.put_complete_string(current); let chars = self.heap.put_complete_string(current);
self.unify(self[temp_v!(1)], chars); (self.unify_fn)(self, self[temp_v!(1)], chars);
let next = self.heap_pstr_iter(self[temp_v!(2)]).to_string(); let next = self.heap_pstr_iter(self[temp_v!(2)]).to_string();
@@ -952,7 +952,7 @@ impl MachineState {
} }
}; };
let chars = self.heap.put_complete_string(cs); let chars = self.heap.put_complete_string(cs);
self.unify(self[temp_v!(2)], chars); (self.unify_fn)(self, self[temp_v!(2)], chars);
} }
_ => { _ => {
self.fail = true; self.fail = true;
@@ -986,7 +986,7 @@ impl MachineState {
} }
} { } {
let chars = self.systemtime_to_timestamp(time); let chars = self.systemtime_to_timestamp(time);
self.unify(self[temp_v!(3)], chars); (self.unify_fn)(self, self[temp_v!(3)], chars);
} else { } else {
self.fail = true; self.fail = true;
return Ok(()); return Ok(());
@@ -1005,14 +1005,14 @@ impl MachineState {
let list_of_chars = Addr::HeapCell(self.heap.to_list(iter)); let list_of_chars = Addr::HeapCell(self.heap.to_list(iter));
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(a2, list_of_chars); (self.unify_fn)(self, a2, list_of_chars);
} }
Addr::Con(h) if self.heap.atom_at(h) => { Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(name, _) = self.heap.clone(h) { if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
let s = self.heap.put_complete_string(name.as_str()); let s = self.heap.put_complete_string(name.as_str());
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(s, a2); (self.unify_fn)(self, s, a2);
} else { } else {
unreachable!() unreachable!()
} }
@@ -1023,7 +1023,7 @@ impl MachineState {
let list_of_chars = Addr::HeapCell(self.heap.to_list(chars.into_iter())); let list_of_chars = Addr::HeapCell(self.heap.to_list(chars.into_iter()));
self.unify(a2, list_of_chars); (self.unify_fn)(self, a2, list_of_chars);
} }
addr if addr.is_ref() => { addr if addr.is_ref() => {
let mut iter = self.heap_pstr_iter(self[temp_v!(2)]); let mut iter = self.heap_pstr_iter(self[temp_v!(2)]);
@@ -1032,13 +1032,13 @@ impl MachineState {
match iter.focus() { match iter.focus() {
Addr::EmptyList => { Addr::EmptyList => {
if &string == "[]" { if &string == "[]" {
self.unify(addr, Addr::EmptyList); (self.unify_fn)(self, addr, Addr::EmptyList);
} else { } else {
let chars = clause_name!(string, self.atom_tbl); let chars = clause_name!(string, self.atom_tbl);
let atom = let atom =
self.heap.to_unifiable(HeapCellValue::Atom(chars, None)); self.heap.to_unifiable(HeapCellValue::Atom(chars, None));
self.unify(addr, atom); (self.unify_fn)(self, addr, atom);
} }
} }
focus => { focus => {
@@ -1071,7 +1071,7 @@ impl MachineState {
let list_of_codes = Addr::HeapCell(self.heap.to_list(iter)); let list_of_codes = Addr::HeapCell(self.heap.to_list(iter));
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(a2, list_of_codes); (self.unify_fn)(self, a2, list_of_codes);
} }
Addr::Con(h) if self.heap.atom_at(h) => { Addr::Con(h) if self.heap.atom_at(h) => {
if let HeapCellValue::Atom(name, _) = self.heap.clone(h) { if let HeapCellValue::Atom(name, _) = self.heap.clone(h) {
@@ -1081,7 +1081,7 @@ impl MachineState {
let list_of_codes = Addr::HeapCell(self.heap.to_list(iter)); let list_of_codes = Addr::HeapCell(self.heap.to_list(iter));
self.unify(a2, list_of_codes); (self.unify_fn)(self, a2, list_of_codes);
} else { } else {
unreachable!() unreachable!()
} }
@@ -1092,7 +1092,7 @@ impl MachineState {
let list_of_codes = Addr::HeapCell(self.heap.to_list(chars.into_iter())); let list_of_codes = Addr::HeapCell(self.heap.to_list(chars.into_iter()));
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(a2, list_of_codes); (self.unify_fn)(self, a2, list_of_codes);
} }
addr if addr.is_ref() => { addr if addr.is_ref() => {
let stub = MachineError::functor_stub(clause_name!("atom_codes"), 2); let stub = MachineError::functor_stub(clause_name!("atom_codes"), 2);
@@ -1180,7 +1180,7 @@ impl MachineState {
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(a2, len); (self.unify_fn)(self, a2, len);
} }
&SystemClauseType::CallContinuation => { &SystemClauseType::CallContinuation => {
let stub = MachineError::functor_stub(clause_name!("call_continuation"), 1); let stub = MachineError::functor_stub(clause_name!("call_continuation"), 1);
@@ -1244,13 +1244,13 @@ impl MachineState {
} }
let pstr = self.heap.allocate_pstr(atom.as_str()); let pstr = self.heap.allocate_pstr(atom.as_str());
self.unify(self[temp_v!(2)], pstr); (self.unify_fn)(self, self[temp_v!(2)], pstr);
if !self.fail { if !self.fail {
let h = self.heap.h(); let h = self.heap.h();
let pstr_tail = self.heap[h - 1].as_addr(h - 1); let pstr_tail = self.heap[h - 1].as_addr(h - 1);
self.unify(self[temp_v!(3)], pstr_tail); (self.unify_fn)(self, self[temp_v!(3)], pstr_tail);
} }
} }
&SystemClauseType::IsPartialString => { &SystemClauseType::IsPartialString => {
@@ -1288,14 +1288,14 @@ impl MachineState {
let tail = self.heap[h + 1].as_addr(h + 1); let tail = self.heap[h + 1].as_addr(h + 1);
let target = self[temp_v!(2)]; let target = self[temp_v!(2)];
self.unify(tail, target); (self.unify_fn)(self, tail, target);
} else { } else {
self.fail = true; self.fail = true;
return Ok(()); return Ok(());
} }
} }
Addr::Lis(h) => { Addr::Lis(h) => {
self.unify(Addr::HeapCell(h + 1), self[temp_v!(2)]); (self.unify_fn)(self, Addr::HeapCell(h + 1), self[temp_v!(2)]);
} }
Addr::EmptyList => { Addr::EmptyList => {
self.fail = true; self.fail = true;
@@ -1328,7 +1328,7 @@ impl MachineState {
if stream.at_end_of_stream() { if stream.at_end_of_stream() {
stream.set_past_end_of_stream(); stream.set_past_end_of_stream();
self.unify(self[temp_v!(2)], Addr::Fixnum(-1)); (self.unify_fn)(self, self[temp_v!(2)], Addr::Fixnum(-1));
return return_from_clause!(self.last_call, self); return return_from_clause!(self.last_call, self);
} }
@@ -1432,7 +1432,7 @@ impl MachineState {
stream.set_past_end_of_stream(); stream.set_past_end_of_stream();
self.unify(self[temp_v!(2)], end_of_file); (self.unify_fn)(self, self[temp_v!(2)], end_of_file);
return return_from_clause!(self.last_call, self); return return_from_clause!(self.last_call, self);
} }
@@ -1535,7 +1535,7 @@ impl MachineState {
stream.set_past_end_of_stream(); stream.set_past_end_of_stream();
self.unify(self[temp_v!(2)], end_of_file); (self.unify_fn)(self, self[temp_v!(2)], end_of_file);
return return_from_clause!(self.last_call, self); return return_from_clause!(self.last_call, self);
} }
@@ -1645,7 +1645,7 @@ impl MachineState {
let chars = string.trim().chars().map(|c| Addr::Char(c)); let chars = string.trim().chars().map(|c| Addr::Char(c));
let char_list = Addr::HeapCell(self.heap.to_list(chars)); let char_list = Addr::HeapCell(self.heap.to_list(chars));
self.unify(char_list, chs); (self.unify_fn)(self, char_list, chs);
} }
&SystemClauseType::NumberToCodes => { &SystemClauseType::NumberToCodes => {
let n = self[temp_v!(1)]; let n = self[temp_v!(1)];
@@ -1672,7 +1672,7 @@ impl MachineState {
let codes_list = Addr::HeapCell(self.heap.to_list(codes)); let codes_list = Addr::HeapCell(self.heap.to_list(codes));
self.unify(codes_list, chs); (self.unify_fn)(self, codes_list, chs);
} }
&SystemClauseType::CodesToNumber => { &SystemClauseType::CodesToNumber => {
let stub = MachineError::functor_stub(clause_name!("number_codes"), 2); let stub = MachineError::functor_stub(clause_name!("number_codes"), 2);
@@ -1698,7 +1698,7 @@ impl MachineState {
let a1 = self[temp_v!(1)]; let a1 = self[temp_v!(1)];
let lh_len = Addr::Usize(self.lifted_heap.h()); let lh_len = Addr::Usize(self.lifted_heap.h());
self.unify(a1, lh_len); (self.unify_fn)(self, a1, lh_len);
} }
&SystemClauseType::CharCode => { &SystemClauseType::CharCode => {
let a1 = self[temp_v!(1)]; let a1 = self[temp_v!(1)];
@@ -1717,11 +1717,11 @@ impl MachineState {
}; };
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(Addr::Fixnum(c as isize), a2); (self.unify_fn)(self, Addr::Fixnum(c as isize), a2);
} }
Addr::Char(c) => { Addr::Char(c) => {
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(Addr::Fixnum(c as isize), a2); (self.unify_fn)(self, Addr::Fixnum(c as isize), a2);
} }
addr if addr.is_ref() => { addr if addr.is_ref() => {
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
@@ -1738,7 +1738,7 @@ impl MachineState {
} }
}; };
self.unify(Addr::Char(c), addr); (self.unify_fn)(self, Addr::Char(c), addr);
} }
_ => { _ => {
unreachable!(); unreachable!();
@@ -1869,14 +1869,14 @@ impl MachineState {
Some((ref ball, ref mut loc)) => { Some((ref ball, ref mut loc)) => {
match loc { match loc {
Some(ref value_addr) => { Some(ref value_addr) => {
self.unify(addr, *value_addr); (self.unify_fn)(self, addr, *value_addr);
} }
loc @ None if !ball.stub.is_empty() => { loc @ None if !ball.stub.is_empty() => {
let h = self.heap.h(); let h = self.heap.h();
let stub = ball.copy_and_align(h); let stub = ball.copy_and_align(h);
self.heap.extend(stub.into_iter()); self.heap.extend(stub.into_iter());
self.unify(addr, Addr::HeapCell(h)); (self.unify_fn)(self, addr, Addr::HeapCell(h));
if !self.fail { if !self.fail {
*loc = Some(Addr::HeapCell(h)); *loc = Some(Addr::HeapCell(h));
@@ -2204,7 +2204,7 @@ impl MachineState {
} }
_ => { _ => {
stream.set_past_end_of_stream(); stream.set_past_end_of_stream();
self.unify(self[temp_v!(2)], Addr::Fixnum(-1)); (self.unify_fn)(self, self[temp_v!(2)], Addr::Fixnum(-1));
return return_from_clause!(self.last_call, self); return return_from_clause!(self.last_call, self);
} }
} }
@@ -2238,7 +2238,7 @@ impl MachineState {
stream.set_past_end_of_stream(); stream.set_past_end_of_stream();
self.unify(self[temp_v!(2)], end_of_file); (self.unify_fn)(self, self[temp_v!(2)], end_of_file);
return return_from_clause!(self.last_call, self); return return_from_clause!(self.last_call, self);
} }
@@ -2357,7 +2357,7 @@ impl MachineState {
} }
}; };
let string = self.heap.put_complete_string(&string); let string = self.heap.put_complete_string(&string);
self.unify(self[temp_v!(3)], string); (self.unify_fn)(self, self[temp_v!(3)], string);
} }
&SystemClauseType::GetCode => { &SystemClauseType::GetCode => {
let mut stream = let mut stream =
@@ -2387,7 +2387,7 @@ impl MachineState {
stream.set_past_end_of_stream(); stream.set_past_end_of_stream();
self.unify(self[temp_v!(2)], end_of_file); (self.unify_fn)(self, self[temp_v!(2)], end_of_file);
return return_from_clause!(self.last_call, self); return return_from_clause!(self.last_call, self);
} }
@@ -2580,7 +2580,7 @@ impl MachineState {
let a1 = self[temp_v!(1)]; let a1 = self[temp_v!(1)];
self.unify(Addr::Char(c), a1); (self.unify_fn)(self, Addr::Char(c), a1);
} }
&SystemClauseType::HeadIsDynamic => { &SystemClauseType::HeadIsDynamic => {
let module_name = atom_from!(self, self.store(self.deref(self[temp_v!(1)]))); let module_name = atom_from!(self, self.store(self.deref(self[temp_v!(1)])));
@@ -2933,10 +2933,10 @@ impl MachineState {
let atom = self.heap.to_unifiable(HeapCellValue::Atom(name, spec)); let atom = self.heap.to_unifiable(HeapCellValue::Atom(name, spec));
self.unify(a2, atom); (self.unify_fn)(self, a2, atom);
if !self.fail { if !self.fail {
self.unify(a3, Addr::Usize(arity)); (self.unify_fn)(self, a3, Addr::Usize(arity));
} }
} }
_ => { _ => {
@@ -2986,14 +2986,14 @@ impl MachineState {
.heap .heap
.to_unifiable(HeapCellValue::Atom(name, Some(shared_op_desc))); .to_unifiable(HeapCellValue::Atom(name, Some(shared_op_desc)));
self.unify(Addr::Usize(priority), prec); (self.unify_fn)(self, Addr::Usize(priority), prec);
if !self.fail { if !self.fail {
self.unify(a3, specifier); (self.unify_fn)(self, a3, specifier);
} }
if !self.fail { if !self.fail {
self.unify(a4, op); (self.unify_fn)(self, a4, op);
} }
} }
_ => { _ => {
@@ -3018,11 +3018,11 @@ impl MachineState {
let a2 = ProcessTime::now().as_duration().as_secs_f64(); let a2 = ProcessTime::now().as_duration().as_secs_f64();
let addr = self.heap.put_constant(Constant::Float(OrderedFloat(a2))); let addr = self.heap.put_constant(Constant::Float(OrderedFloat(a2)));
self.unify(a1, addr); (self.unify_fn)(self, a1, addr);
} }
&SystemClauseType::CurrentTime => { &SystemClauseType::CurrentTime => {
let str = self.systemtime_to_timestamp(SystemTime::now()); let str = self.systemtime_to_timestamp(SystemTime::now());
self.unify(self[temp_v!(1)], str); (self.unify_fn)(self, self[temp_v!(1)], str);
} }
&SystemClauseType::OpDeclaration => { &SystemClauseType::OpDeclaration => {
let priority = self[temp_v!(1)]; let priority = self[temp_v!(1)];
@@ -3176,7 +3176,7 @@ impl MachineState {
let addr = self[temp_v!(1)]; let addr = self[temp_v!(1)];
let value = Addr::Usize(self.attr_var_init.attr_var_queue.len()); let value = Addr::Usize(self.attr_var_init.attr_var_queue.len());
self.unify(addr, value); (self.unify_fn)(self, addr, value);
} }
&SystemClauseType::GetAttrVarQueueBeyond => { &SystemClauseType::GetAttrVarQueueBeyond => {
let addr = self[temp_v!(1)]; let addr = self[temp_v!(1)];
@@ -3200,7 +3200,7 @@ impl MachineState {
let var_list_addr = Addr::HeapCell(self.heap.to_list(iter)); let var_list_addr = Addr::HeapCell(self.heap.to_list(iter));
let list_addr = self[temp_v!(2)]; let list_addr = self[temp_v!(2)];
self.unify(var_list_addr, list_addr); (self.unify_fn)(self, var_list_addr, list_addr);
} }
} }
&SystemClauseType::GetContinuationChunk => { &SystemClauseType::GetContinuationChunk => {
@@ -3245,7 +3245,7 @@ impl MachineState {
self.heap.push(HeapCellValue::Addr(p_functor)); self.heap.push(HeapCellValue::Addr(p_functor));
self.heap.extend(addrs.into_iter().map(HeapCellValue::Addr)); self.heap.extend(addrs.into_iter().map(HeapCellValue::Addr));
self.unify(self[temp_v!(3)], chunk); (self.unify_fn)(self, self[temp_v!(3)], chunk);
} }
&SystemClauseType::GetLiftedHeapFromOffsetDiff => { &SystemClauseType::GetLiftedHeapFromOffsetDiff => {
let lh_offset = self[temp_v!(1)]; let lh_offset = self[temp_v!(1)];
@@ -3256,8 +3256,8 @@ impl MachineState {
let solutions = self[temp_v!(2)]; let solutions = self[temp_v!(2)];
let diff = self[temp_v!(3)]; let diff = self[temp_v!(3)];
self.unify(solutions, Addr::EmptyList); (self.unify_fn)(self, solutions, Addr::EmptyList);
self.unify(diff, Addr::EmptyList); (self.unify_fn)(self, diff, Addr::EmptyList);
} else { } else {
let h = self.heap.h(); let h = self.heap.h();
let mut last_index = h; let mut last_index = h;
@@ -3285,14 +3285,14 @@ impl MachineState {
addr_opt.map(|addr| { addr_opt.map(|addr| {
let diff = self[temp_v!(3)]; let diff = self[temp_v!(3)];
self.unify(diff, addr); (self.unify_fn)(self, diff, addr);
}); });
} }
self.lifted_heap.truncate(lh_offset); self.lifted_heap.truncate(lh_offset);
let solutions = self[temp_v!(2)]; let solutions = self[temp_v!(2)];
self.unify(Addr::HeapCell(h), solutions); (self.unify_fn)(self, Addr::HeapCell(h), solutions);
} }
} }
_ => { _ => {
@@ -3307,7 +3307,7 @@ impl MachineState {
Addr::Usize(lh_offset) => { Addr::Usize(lh_offset) => {
if lh_offset >= self.lifted_heap.h() { if lh_offset >= self.lifted_heap.h() {
let solutions = self[temp_v!(2)]; let solutions = self[temp_v!(2)];
self.unify(solutions, Addr::EmptyList); (self.unify_fn)(self, solutions, Addr::EmptyList);
} else { } else {
let h = self.heap.h(); let h = self.heap.h();
@@ -3325,7 +3325,7 @@ impl MachineState {
self.lifted_heap.truncate(lh_offset); self.lifted_heap.truncate(lh_offset);
let solutions = self[temp_v!(2)]; let solutions = self[temp_v!(2)];
self.unify(Addr::HeapCell(h), solutions); (self.unify_fn)(self, Addr::HeapCell(h), solutions);
} }
} }
_ => { _ => {
@@ -3342,21 +3342,21 @@ impl MachineState {
.heap .heap
.to_unifiable(HeapCellValue::Atom(clause_name!("chars"), None)); .to_unifiable(HeapCellValue::Atom(clause_name!("chars"), None));
self.unify(a1, atom); (self.unify_fn)(self, a1, atom);
} }
DoubleQuotes::Atom => { DoubleQuotes::Atom => {
let atom = self let atom = self
.heap .heap
.to_unifiable(HeapCellValue::Atom(clause_name!("atom"), None)); .to_unifiable(HeapCellValue::Atom(clause_name!("atom"), None));
self.unify(a1, atom); (self.unify_fn)(self, a1, atom);
} }
DoubleQuotes::Codes => { DoubleQuotes::Codes => {
let atom = self let atom = self
.heap .heap
.to_unifiable(HeapCellValue::Atom(clause_name!("codes"), None)); .to_unifiable(HeapCellValue::Atom(clause_name!("codes"), None));
self.unify(a1, atom); (self.unify_fn)(self, a1, atom);
} }
} }
} }
@@ -3460,7 +3460,7 @@ impl MachineState {
.to_unifiable(HeapCellValue::Integer(Rc::new(count))); .to_unifiable(HeapCellValue::Integer(Rc::new(count)));
let a3 = self[temp_v!(3)]; let a3 = self[temp_v!(3)];
self.unify(a3, count); (self.unify_fn)(self, a3, count);
} }
None => { None => {
panic!( panic!(
@@ -3645,7 +3645,7 @@ impl MachineState {
let a2 = self[temp_v!(2)]; let a2 = self[temp_v!(2)];
self.unify(a2, count); (self.unify_fn)(self, a2, count);
} }
_ => { _ => {
panic!("remove_inference_counter: expected Usize in A1."); panic!("remove_inference_counter: expected Usize in A1.");
@@ -3795,13 +3795,13 @@ impl MachineState {
.heap .heap
.to_unifiable(HeapCellValue::Atom(clause_name!("!"), None)); .to_unifiable(HeapCellValue::Atom(clause_name!("!"), None));
self.unify(a1, a2); (self.unify_fn)(self, a1, a2);
} else { } else {
let a2 = self let a2 = self
.heap .heap
.to_unifiable(HeapCellValue::Atom(clause_name!("true"), None)); .to_unifiable(HeapCellValue::Atom(clause_name!("true"), None));
self.unify(a1, a2); (self.unify_fn)(self, a1, a2);
} }
} }
_ => { _ => {
@@ -3860,13 +3860,13 @@ impl MachineState {
let a1 = self[temp_v!(1)]; let a1 = self[temp_v!(1)];
let a2 = Addr::Usize(self.b); let a2 = Addr::Usize(self.b);
self.unify(a1, a2); (self.unify_fn)(self, a1, a2);
} }
&SystemClauseType::GetCutPoint => { &SystemClauseType::GetCutPoint => {
let a1 = self[temp_v!(1)]; let a1 = self[temp_v!(1)];
let a2 = Addr::CutPoint(self.b0); let a2 = Addr::CutPoint(self.b0);
self.unify(a1, a2); (self.unify_fn)(self, a1, a2);
} }
&SystemClauseType::InstallNewBlock => { &SystemClauseType::InstallNewBlock => {
self.install_new_block(temp_v!(1)); self.install_new_block(temp_v!(1));
@@ -3891,10 +3891,10 @@ impl MachineState {
let p = cp.as_functor(&mut self.heap); let p = cp.as_functor(&mut self.heap);
self.unify(self[temp_v!(2)], e); (self.unify_fn)(self, self[temp_v!(2)], e);
if !self.fail { if !self.fail {
self.unify(self[temp_v!(3)], p); (self.unify_fn)(self, self[temp_v!(3)], p);
} }
} else { } else {
unreachable!() unreachable!()
@@ -3918,10 +3918,10 @@ impl MachineState {
let e = Addr::Usize(e); let e = Addr::Usize(e);
self.unify(self[temp_v!(2)], e); (self.unify_fn)(self, self[temp_v!(2)], e);
if !self.fail { if !self.fail {
self.unify(self[temp_v!(3)], p); (self.unify_fn)(self, self[temp_v!(3)], p);
} }
} }
_ => { _ => {
@@ -4288,7 +4288,7 @@ impl MachineState {
self.bind(addr.as_var().unwrap(), tcp_listener); self.bind(addr.as_var().unwrap(), tcp_listener);
if had_zero_port { if had_zero_port {
self.unify(self[temp_v!(2)], Addr::Usize(port)); (self.unify_fn)(self, self[temp_v!(2)], Addr::Usize(port));
} }
} }
&SystemClauseType::SocketServerAccept => { &SystemClauseType::SocketServerAccept => {
@@ -4510,7 +4510,7 @@ impl MachineState {
}; };
let property = self.heap.to_unifiable(property); let property = self.heap.to_unifiable(property);
self.unify(self[temp_v!(3)], property); (self.unify_fn)(self, self[temp_v!(3)], property);
} }
&SystemClauseType::StoreGlobalVar => { &SystemClauseType::StoreGlobalVar => {
let key = match self.store(self.deref(self[temp_v!(1)])) { let key = match self.store(self.deref(self[temp_v!(1)])) {
@@ -4580,7 +4580,7 @@ impl MachineState {
let seen_vars = self.attr_vars_of_term(self[temp_v!(1)]); let seen_vars = self.attr_vars_of_term(self[temp_v!(1)]);
let outcome = Addr::HeapCell(self.heap.to_list(seen_vars.into_iter())); let outcome = Addr::HeapCell(self.heap.to_list(seen_vars.into_iter()));
self.unify(self[temp_v!(2)], outcome); (self.unify_fn)(self, self[temp_v!(2)], outcome);
} }
&SystemClauseType::TermVariables => { &SystemClauseType::TermVariables => {
let a1 = self[temp_v!(1)]; let a1 = self[temp_v!(1)];
@@ -4595,7 +4595,7 @@ impl MachineState {
} }
let outcome = Addr::HeapCell(self.heap.to_list(seen_vars.into_iter())); let outcome = Addr::HeapCell(self.heap.to_list(seen_vars.into_iter()));
self.unify(self[temp_v!(2)], outcome); (self.unify_fn)(self, self[temp_v!(2)], outcome);
} }
&SystemClauseType::TruncateLiftedHeapTo => { &SystemClauseType::TruncateLiftedHeapTo => {
match self.store(self.deref(self[temp_v!(1)])) { match self.store(self.deref(self[temp_v!(1)])) {
@@ -4732,7 +4732,7 @@ impl MachineState {
let listing = Addr::HeapCell(self.heap.to_list(functor_list.into_iter())); let listing = Addr::HeapCell(self.heap.to_list(functor_list.into_iter()));
let listing_var = self[temp_v!(4)]; let listing_var = self[temp_v!(4)];
self.unify(listing, listing_var); (self.unify_fn)(self, listing, listing_var);
} }
&SystemClauseType::WriteTerm => { &SystemClauseType::WriteTerm => {
let mut stream = let mut stream =
@@ -4819,7 +4819,7 @@ impl MachineState {
let buffer = git_version!(cargo_prefix = "cargo:", fallback = "unknown"); let buffer = git_version!(cargo_prefix = "cargo:", fallback = "unknown");
let chars = buffer.chars().map(|c| Addr::Char(c)); let chars = buffer.chars().map(|c| Addr::Char(c));
let result = Addr::HeapCell(self.heap.to_list(chars)); let result = Addr::HeapCell(self.heap.to_list(chars));
self.unify(version, result); (self.unify_fn)(self, version, result);
} }
&SystemClauseType::CryptoRandomByte => { &SystemClauseType::CryptoRandomByte => {
let arg = self[temp_v!(1)]; let arg = self[temp_v!(1)];
@@ -4840,7 +4840,7 @@ impl MachineState {
.heap .heap
.to_unifiable(HeapCellValue::Integer(Rc::new(Integer::from(bytes[0])))); .to_unifiable(HeapCellValue::Integer(Rc::new(Integer::from(bytes[0]))));
self.unify(arg, byte); (self.unify_fn)(self, arg, byte);
} }
&SystemClauseType::CryptoDataHash => { &SystemClauseType::CryptoDataHash => {
let encoding = self.atom_argument_to_string(2); let encoding = self.atom_argument_to_string(2);
@@ -4963,7 +4963,7 @@ impl MachineState {
} }
}; };
self.unify(self[temp_v!(3)], ints_list); (self.unify_fn)(self, self[temp_v!(3)], ints_list);
} }
&SystemClauseType::CryptoDataHKDF => { &SystemClauseType::CryptoDataHKDF => {
let encoding = self.atom_argument_to_string(2); let encoding = self.atom_argument_to_string(2);
@@ -5023,7 +5023,7 @@ impl MachineState {
) )
}; };
self.unify(self[temp_v!(7)], ints_list); (self.unify_fn)(self, self[temp_v!(7)], ints_list);
} }
&SystemClauseType::CryptoPasswordHash => { &SystemClauseType::CryptoPasswordHash => {
let stub1 = MachineError::functor_stub(clause_name!("crypto_password_hash"), 3); let stub1 = MachineError::functor_stub(clause_name!("crypto_password_hash"), 3);
@@ -5066,7 +5066,7 @@ impl MachineState {
) )
}; };
self.unify(self[temp_v!(4)], ints_list); (self.unify_fn)(self, self[temp_v!(4)], ints_list);
} }
&SystemClauseType::CryptoDataEncrypt => { &SystemClauseType::CryptoDataEncrypt => {
let encoding = self.atom_argument_to_string(3); let encoding = self.atom_argument_to_string(3);
@@ -5107,8 +5107,8 @@ impl MachineState {
self.heap.put_complete_string(&buffer) self.heap.put_complete_string(&buffer)
}; };
self.unify(self[temp_v!(6)], tag_list); (self.unify_fn)(self, self[temp_v!(6)], tag_list);
self.unify(self[temp_v!(7)], complete_string); (self.unify_fn)(self, self[temp_v!(7)], complete_string);
} }
&SystemClauseType::CryptoDataDecrypt => { &SystemClauseType::CryptoDataDecrypt => {
let data = self.string_encoding_bytes(1, "octet"); let data = self.string_encoding_bytes(1, "octet");
@@ -5152,7 +5152,7 @@ impl MachineState {
self.heap.put_complete_string(&buffer) self.heap.put_complete_string(&buffer)
}; };
self.unify(self[temp_v!(6)], complete_string); (self.unify_fn)(self, self[temp_v!(6)], complete_string);
} }
&SystemClauseType::CryptoCurveScalarMult => { &SystemClauseType::CryptoCurveScalarMult => {
let curve = self.atom_argument_to_string(1); let curve = self.atom_argument_to_string(1);
@@ -5196,8 +5196,8 @@ impl MachineState {
.heap .heap
.put_complete_string(&ry.to_dec_str().unwrap().to_string()); .put_complete_string(&ry.to_dec_str().unwrap().to_string());
self.unify(self[temp_v!(4)], sx); (self.unify_fn)(self, self[temp_v!(4)], sx);
self.unify(self[temp_v!(5)], sy); (self.unify_fn)(self, self[temp_v!(5)], sy);
} }
&SystemClauseType::Ed25519NewKeyPair => { &SystemClauseType::Ed25519NewKeyPair => {
let pkcs8_bytes = signature::Ed25519KeyPair::generate_pkcs8(rng()).unwrap(); let pkcs8_bytes = signature::Ed25519KeyPair::generate_pkcs8(rng()).unwrap();
@@ -5206,7 +5206,7 @@ impl MachineState {
self.heap.put_complete_string(&buffer) self.heap.put_complete_string(&buffer)
}; };
self.unify(self[temp_v!(1)], complete_string); (self.unify_fn)(self, self[temp_v!(1)], complete_string);
} }
&SystemClauseType::Ed25519KeyPairPublicKey => { &SystemClauseType::Ed25519KeyPairPublicKey => {
let bytes = self.string_encoding_bytes(1, "octet"); let bytes = self.string_encoding_bytes(1, "octet");
@@ -5226,7 +5226,7 @@ impl MachineState {
self.heap.put_complete_string(&buffer) self.heap.put_complete_string(&buffer)
}; };
self.unify(self[temp_v!(2)], complete_string); (self.unify_fn)(self, self[temp_v!(2)], complete_string);
} }
&SystemClauseType::Ed25519Sign => { &SystemClauseType::Ed25519Sign => {
let key = self.string_encoding_bytes(1, "octet"); let key = self.string_encoding_bytes(1, "octet");
@@ -5251,7 +5251,7 @@ impl MachineState {
), ),
); );
self.unify(self[temp_v!(4)], sig_list); (self.unify_fn)(self, self[temp_v!(4)], sig_list);
} }
&SystemClauseType::Ed25519Verify => { &SystemClauseType::Ed25519Verify => {
let key = self.string_encoding_bytes(1, "octet"); let key = self.string_encoding_bytes(1, "octet");
@@ -5282,21 +5282,21 @@ impl MachineState {
let string = String::from_iter(result[..].iter().map(|b| *b as char)); let string = String::from_iter(result[..].iter().map(|b| *b as char));
let cstr = self.heap.put_complete_string(&string); let cstr = self.heap.put_complete_string(&string);
self.unify(self[temp_v!(3)], cstr); (self.unify_fn)(self, self[temp_v!(3)], cstr);
} }
&SystemClauseType::LoadHTML => { &SystemClauseType::LoadHTML => {
let string = self.heap_pstr_iter(self[temp_v!(1)]).to_string(); let string = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
let doc = select::document::Document::from_read(string.as_bytes()).unwrap(); let doc = select::document::Document::from_read(string.as_bytes()).unwrap();
let result = self.html_node_to_term(indices, doc.nth(0).unwrap()); let result = self.html_node_to_term(indices, doc.nth(0).unwrap());
self.unify(self[temp_v!(2)], result); (self.unify_fn)(self, self[temp_v!(2)], result);
} }
&SystemClauseType::LoadXML => { &SystemClauseType::LoadXML => {
let string = self.heap_pstr_iter(self[temp_v!(1)]).to_string(); let string = self.heap_pstr_iter(self[temp_v!(1)]).to_string();
match roxmltree::Document::parse(&string) { match roxmltree::Document::parse(&string) {
Ok(doc) => { Ok(doc) => {
let result = self.xml_node_to_term(indices, doc.root_element()); let result = self.xml_node_to_term(indices, doc.root_element());
self.unify(self[temp_v!(2)], result); (self.unify_fn)(self, self[temp_v!(2)], result);
} }
_ => { _ => {
self.fail = true; self.fail = true;
@@ -5309,7 +5309,7 @@ impl MachineState {
match env::var(key) { match env::var(key) {
Ok(value) => { Ok(value) => {
let cstr = self.heap.put_complete_string(&value); let cstr = self.heap.put_complete_string(&value);
self.unify(self[temp_v!(2)], cstr); (self.unify_fn)(self, self[temp_v!(2)], cstr);
} }
_ => { _ => {
self.fail = true; self.fail = true;
@@ -5352,7 +5352,7 @@ impl MachineState {
Ok(bs) => { Ok(bs) => {
let string = String::from_iter(bs.iter().map(|b| *b as char)); let string = String::from_iter(bs.iter().map(|b| *b as char));
let cstr = self.heap.put_complete_string(&string); let cstr = self.heap.put_complete_string(&string);
self.unify(self[temp_v!(1)], cstr); (self.unify_fn)(self, self[temp_v!(1)], cstr);
} }
_ => { _ => {
self.fail = true; self.fail = true;
@@ -5379,7 +5379,7 @@ impl MachineState {
let b64 = base64::encode_config(bytes, config); let b64 = base64::encode_config(bytes, config);
let cstr = self.heap.put_complete_string(&b64); let cstr = self.heap.put_complete_string(&b64);
self.unify(self[temp_v!(2)], cstr); (self.unify_fn)(self, self[temp_v!(2)], cstr);
} }
} }
&SystemClauseType::LoadLibraryAsStream => { &SystemClauseType::LoadLibraryAsStream => {
@@ -5433,6 +5433,27 @@ impl MachineState {
} }
} }
} }
&SystemClauseType::IsSTOEnabled => {
if self.unify_fn as usize == MachineState::unify_with_occurs_check as usize {
let value = self.heap.to_unifiable(
HeapCellValue::Atom(clause_name!("true"), None),
);
(self.unify_fn)(self, self[temp_v!(1)], value);
} else {
let value = self.heap.to_unifiable(
HeapCellValue::Atom(clause_name!("false"), None),
);
(self.unify_fn)(self, self[temp_v!(1)], value);
}
}
&SystemClauseType::SetSTOAsUnify => {
self.unify_fn = MachineState::unify_with_occurs_check;
}
&SystemClauseType::SetNSTOAsUnify => {
self.unify_fn = MachineState::unify;
}
}; };
return_from_clause!(self.last_call, self) return_from_clause!(self.last_call, self)