rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f340f9ac9415154de913cc03f50079a4ac07f013
scryer-prolog/src/machine/machine_state_impl.rs
Mark Thom bc613eeff9 fix number not recognizing floats
2022-01-06 21:44:41 -07:00

4200 lines
158 KiB
Rust
Raw Blame History

use crate::arena::*;
use crate::atom_table::*;
use crate::types::*;
use crate::clause_types::*;
use crate::forms::*;
use crate::heap_iter::*;
use crate::instructions::*;
use crate::machine::arithmetic_ops::*;
use crate::machine::attributed_variables::*;
use crate::machine::code_repo::CodeRepo;
use crate::machine::copier::*;
use crate::machine::heap::*;
use crate::machine::machine_errors::*;
use crate::machine::machine_indices::*;
use crate::machine::machine_state::*;
use crate::machine::partial_string::*;
use crate::machine::stack::*;
use crate::machine::streams::*;
use crate::machine::INTERRUPT;
use crate::parser::ast::*;
use crate::parser::rug::{Integer, Rational};
use crate::try_numeric_result;
use ordered_float::*;
use indexmap::IndexSet;
use std::cmp::Ordering;
use std::convert::TryFrom;
impl MachineState {
pub(crate) fn new() -> Self {
MachineState {
arena: Arena::new(),
atom_tbl: AtomTable::new(),
pdl: Vec::with_capacity(1024),
s: HeapPtr::default(),
p: CodePtr::default(),
b: 0,
b0: 0,
e: 0,
num_of_args: 0,
cp: LocalCodePtr::default(),
attr_var_init: AttrVarInitializer::new(0),
fail: false,
heap: Heap::with_capacity(256 * 256),
mode: MachineMode::Write,
stack: Stack::new(),
registers: [heap_loc_as_cell!(0); MAX_ARITY + 1], // self.registers[0] is never used.
trail: vec![],
tr: 0,
hb: 0,
block: 0,
ball: Ball::new(),
lifted_heap: Heap::new(),
interms: vec![Number::default(); 256],
last_call: false,
flags: MachineFlags::default(),
cc: 0,
global_clock: 0,
dynamic_mode: FirstOrNext::First,
unify_fn: MachineState::unify,
bind_fn: MachineState::bind,
}
}
#[inline]
pub(crate) fn store(&self, value: HeapCellValue) -> HeapCellValue {
read_heap_cell!(value,
(HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
self.heap[h]
}
(HeapCellValueTag::StackVar, s) => {
self.stack[s]
}
_ => {
value
}
)
}
pub fn deref(&self, mut addr: HeapCellValue) -> HeapCellValue {
loop {
let value = self.store(addr);
if value.is_var() && value != addr {
addr = value;
continue;
}
return addr;
}
}
pub fn trail(&mut self, r: TrailRef) {
match r {
TrailRef::Ref(r) => {
let h = r.get_value() as usize;
match r.get_tag() {
RefTag::HeapCell => {
if h < self.hb {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedHeapVar,
h as u64,
));
self.tr += 1;
}
}
RefTag::StackCell => {
if h < self.b {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedStackVar,
h as u64,
));
self.tr += 1;
}
}
RefTag::AttrVar => {
if h < self.hb {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedAttrVar,
h as u64,
));
self.tr += 1;
}
}
}
}
TrailRef::AttrVarHeapLink(h) => {
if h < self.hb {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedAttrVarHeapLink,
h as u64,
));
self.tr += 1;
}
}
TrailRef::AttrVarListLink(h, l) => {
if h < self.hb {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedAttrVarListLink,
h as u64,
));
self.trail.push(TrailEntry::from_bytes(
list_loc_as_cell!(l).into_bytes()
));
self.tr += 2;
}
}
TrailRef::BlackboardEntry(key_atom) => {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedBlackboardEntry,
key_atom.index as u64,
));
self.tr += 1;
}
TrailRef::BlackboardOffset(key_atom, value_cell) => {
self.trail.push(TrailEntry::build_with(
TrailEntryTag::TrailedBlackboardOffset,
key_atom.index as u64,
));
self.trail.push(TrailEntry::from_bytes(
value_cell.into_bytes(),
));
self.tr += 2;
}
}
}
pub fn allocate(&mut self, num_cells: usize) {
let e = self.stack.allocate_and_frame(num_cells);
let and_frame = self.stack.index_and_frame_mut(e);
and_frame.prelude.e = self.e;
and_frame.prelude.cp = self.cp;
self.e = e;
self.p += 1;
}
pub fn bind(&mut self, r1: Ref, a2: HeapCellValue) {
let t1 = self.store(r1.as_heap_cell_value());
let t2 = self.store(a2);
if t1.is_var() && (!t2.is_var() || a2 < r1) {
match r1.get_tag() {
RefTag::StackCell => {
self.stack[r1.get_value() as usize] = t2;
}
RefTag::HeapCell => {
self.heap[r1.get_value() as usize] = t2;
}
RefTag::AttrVar => {
self.bind_attr_var(r1.get_value() as usize, t2);
}
};
self.trail(TrailRef::Ref(r1));
} else {
read_heap_cell!(a2,
(HeapCellValueTag::StackVar, s) => {
self.stack[s] = t1;
self.trail(TrailRef::Ref(Ref::stack_cell(s)));
}
(HeapCellValueTag::Var, h) => {
self.heap[h] = t1;
self.trail(TrailRef::Ref(Ref::heap_cell(h)));
}
(HeapCellValueTag::AttrVar, h) => {
self.bind_attr_var(h, t1);
}
_ => {
unreachable!();
}
);
}
}
pub fn bind_attr_var(&mut self, h: usize, addr: HeapCellValue) {
read_heap_cell!(addr,
(HeapCellValueTag::Var, hc) => {
self.heap[hc] = attr_var_as_cell!(h);
self.trail(TrailRef::Ref(Ref::heap_cell(hc)));
}
(HeapCellValueTag::StackVar, hc) => {
self.stack[hc] = attr_var_as_cell!(h);
self.trail(TrailRef::Ref(Ref::stack_cell(hc)));
}
_ => {
self.push_attr_var_binding(h, addr);
self.heap[h] = addr;
self.trail(TrailRef::Ref(Ref::attr_var(h)));
}
)
}
fn unify_structure(&mut self, s1: usize, value: HeapCellValue) {
// s1 is the value of a STR cell.
let (n1, a1) = cell_as_atom_cell!(self.heap[s1]).get_name_and_arity();
read_heap_cell!(value,
(HeapCellValueTag::Str, s2) => {
let (n2, a2) = cell_as_atom_cell!(self.heap[s2])
.get_name_and_arity();
if n1 == n2 && a1 == a2 {
for idx in 0..a1 {
self.pdl.push(heap_loc_as_cell!(s2+1+idx));
self.pdl.push(heap_loc_as_cell!(s1+1+idx));
}
} else {
self.fail = true;
}
}
(HeapCellValueTag::Lis, l2) => {
if a1 == 2 && n1 == atom!(".") {
for idx in 0..2 {
self.pdl.push(heap_loc_as_cell!(l2+1+idx));
self.pdl.push(heap_loc_as_cell!(s1+1+idx));
}
} else {
self.fail = true;
}
}
(HeapCellValueTag::Atom, (n2, a2)) => {
if !(a1 == 0 && a2 == 0 && n1 == n2) {
self.fail = true;
}
}
(HeapCellValueTag::AttrVar, h) => {
self.bind(Ref::attr_var(h), str_loc_as_cell!(s1));
}
(HeapCellValueTag::Var, h) => {
self.bind(Ref::heap_cell(h), str_loc_as_cell!(s1));
}
(HeapCellValueTag::StackVar, s) => {
self.bind(Ref::stack_cell(s), str_loc_as_cell!(s1));
}
_ => {
self.fail = true;
}
)
}
fn unify_list(&mut self, l1: usize, d2: HeapCellValue) {
read_heap_cell!(d2,
(HeapCellValueTag::Lis, l2) => {
for idx in 0..2 {
self.pdl.push(heap_loc_as_cell!(l2 + idx));
self.pdl.push(heap_loc_as_cell!(l1 + idx));
}
}
(HeapCellValueTag::Str, s2) => {
let (n2, a2) = cell_as_atom_cell!(self.heap[s2])
.get_name_and_arity();
if a2 == 2 && n2 == atom!(".") {
for idx in 0..2 {
self.pdl.push(heap_loc_as_cell!(s2+1+idx));
self.pdl.push(heap_loc_as_cell!(l1+idx));
}
} else {
self.fail = true;
}
}
(HeapCellValueTag::PStrLoc | HeapCellValueTag::CStr | HeapCellValueTag::PStr) => {
self.unify_partial_string(list_loc_as_cell!(l1), d2)
}
(HeapCellValueTag::AttrVar, h) => {
self.bind(Ref::attr_var(h), list_loc_as_cell!(l1));
}
(HeapCellValueTag::Var, h) => {
self.bind(Ref::heap_cell(h), list_loc_as_cell!(l1));
}
(HeapCellValueTag::StackVar, s) => {
self.bind(Ref::stack_cell(s), list_loc_as_cell!(l1));
}
_ => {
self.fail = true;
}
)
}
pub fn unify_complete_string(&mut self, atom: Atom, value: HeapCellValue) {
if let Some(r) = value.as_var() {
self.bind(r, atom_as_cstr_cell!(atom));
return;
}
read_heap_cell!(value,
(HeapCellValueTag::CStr, cstr_atom) => {
self.fail = atom != cstr_atom;
}
(HeapCellValueTag::Str | HeapCellValueTag::Lis | HeapCellValueTag::PStrLoc) => {
self.unify_partial_string(atom_as_cstr_cell!(atom), value);
if !self.pdl.is_empty() {
self.unify();
}
}
_ => {
self.fail = true;
}
);
}
// d1's tag is LIS, STR or PSTRLOC.
pub fn unify_partial_string(&mut self, d1: HeapCellValue, d2: HeapCellValue) {
if let Some(r) = d2.as_var() {
self.bind(r, d1);
return;
}
let s1 = self.heap.len();
self.heap.push(d1);
self.heap.push(d2);
let mut pstr_iter1 = HeapPStrIter::new(&self.heap, s1);
let mut pstr_iter2 = HeapPStrIter::new(&self.heap, s1 + 1);
match compare_pstr_prefixes(&mut pstr_iter1, &mut pstr_iter2) {
PStrCmpResult::Ordered(Ordering::Equal) => {}
PStrCmpResult::Ordered(Ordering::Less) => {
if pstr_iter2.focus.as_var().is_none() {
self.fail = true;
} else {
self.pdl.push(empty_list_as_cell!());
self.pdl.push(pstr_iter2.focus);
}
}
PStrCmpResult::Ordered(Ordering::Greater) => {
if pstr_iter1.focus.as_var().is_none() {
self.fail = true;
} else {
self.pdl.push(empty_list_as_cell!());
self.pdl.push(pstr_iter1.focus);
}
}
continuable @ PStrCmpResult::FirstIterContinuable(iteratee) |
continuable @ PStrCmpResult::SecondIterContinuable(iteratee) => {
if continuable.is_second_iter() {
std::mem::swap(&mut pstr_iter1, &mut pstr_iter2);
}
let mut chars_iter = PStrCharsIter {
iter: pstr_iter1,
item: Some(iteratee),
};
let mut focus = pstr_iter2.focus;
'outer: loop {
while let Some(c) = chars_iter.peek() {
read_heap_cell!(focus,
(HeapCellValueTag::Lis, l) => {
let val = pstr_iter2.heap[l];
self.pdl.push(val);
self.pdl.push(char_as_cell!(c));
focus = pstr_iter2.heap[l+1];
}
(HeapCellValueTag::Str, s) => {
let (name, arity) = cell_as_atom_cell!(pstr_iter2.heap[s])
.get_name_and_arity();
if name == atom!(".") && arity == 2 {
self.pdl.push(pstr_iter2.heap[s+1]);
self.pdl.push(char_as_cell!(c));
focus = pstr_iter2.heap[s+2];
} else {
self.fail = true;
break 'outer;
}
}
(HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
match chars_iter.item.unwrap() {
PStrIteratee::Char(focus, _) => {
self.pdl.push(self.heap[focus]);
self.pdl.push(heap_loc_as_cell!(h));
}
PStrIteratee::PStrSegment(focus, _, n) => {
read_heap_cell!(self.heap[focus],
(HeapCellValueTag::CStr | HeapCellValueTag::PStr, pstr_atom) => {
if focus < self.heap.len() - 2 {
self.heap.pop();
self.heap.pop();
}
if n == 0 {
let target_cell = match self.heap[focus].get_tag() {
HeapCellValueTag::CStr => {
atom_as_cstr_cell!(pstr_atom)
}
HeapCellValueTag::PStr => {
pstr_loc_as_cell!(focus)
}
_ => {
unreachable!()
}
};
self.pdl.push(target_cell);
self.pdl.push(heap_loc_as_cell!(h));
} else {
let h_len = self.heap.len();
self.heap.push(pstr_offset_as_cell!(focus));
self.heap.push(fixnum_as_cell!(
Fixnum::build_with(n as i64)
));
self.pdl.push(pstr_loc_as_cell!(h_len));
self.pdl.push(heap_loc_as_cell!(h));
}
return;
}
(HeapCellValueTag::PStrOffset, pstr_loc) => {
let n0 = cell_as_fixnum!(self.heap[focus+1])
.get_num() as usize;
if pstr_loc < self.heap.len() - 2 {
self.heap.pop();
self.heap.pop();
}
if n == n0 {
self.pdl.push(pstr_loc_as_cell!(focus));
self.pdl.push(heap_loc_as_cell!(h));
} else {
let h_len = self.heap.len();
self.heap.push(pstr_offset_as_cell!(pstr_loc));
self.heap.push(fixnum_as_cell!(
Fixnum::build_with(n as i64)
));
self.pdl.push(pstr_loc_as_cell!(h_len));
self.pdl.push(heap_loc_as_cell!(h));
}
return;
}
_ => {
}
);
if focus < self.heap.len() - 2 {
self.heap.pop();
self.heap.pop();
}
self.pdl.push(self.heap[focus]);
self.pdl.push(heap_loc_as_cell!(h));
return;
}
}
break 'outer;
}
_ => {
self.fail = true;
break 'outer;
}
);
chars_iter.next();
}
chars_iter.iter.next();
self.pdl.push(chars_iter.iter.focus);
self.pdl.push(focus);
break;
}
}
PStrCmpResult::Unordered => {
self.pdl.push(pstr_iter1.focus);
self.pdl.push(pstr_iter2.focus);
}
}
self.heap.pop();
self.heap.pop();
}
pub fn unify_atom(&mut self, atom: Atom, value: HeapCellValue) {
read_heap_cell!(value,
(HeapCellValueTag::Atom, (name, arity)) => {
self.fail = !(arity == 0 && name == atom);
}
(HeapCellValueTag::Char, c1) => {
if let Some(c2) = atom.as_char() {
self.fail = c1 != c2;
} else {
self.fail = true;
}
}
(HeapCellValueTag::AttrVar, h) => {
self.bind(Ref::attr_var(h), atom_as_cell!(atom));
}
(HeapCellValueTag::Var, h) => {
self.bind(Ref::heap_cell(h), atom_as_cell!(atom));
}
(HeapCellValueTag::StackVar, s) => {
self.bind(Ref::stack_cell(s), atom_as_cell!(atom));
}
_ => {
self.fail = true;
}
);
}
pub fn unify_char(&mut self, c: char, value: HeapCellValue) {
read_heap_cell!(value,
(HeapCellValueTag::Atom, (name, arity)) => {
if let Some(c2) = name.as_char() {
self.fail = !(c == c2 && arity == 0);
} else {
self.fail = true;
}
}
(HeapCellValueTag::Char, c2) => {
if c != c2 {
self.fail = true;
}
}
(HeapCellValueTag::AttrVar, h) => {
self.bind(Ref::attr_var(h), char_as_cell!(c));
}
(HeapCellValueTag::Var, h) => {
self.bind(Ref::heap_cell(h), char_as_cell!(c));
}
(HeapCellValueTag::StackVar, s) => {
self.bind(Ref::stack_cell(s), char_as_cell!(c));
}
_ => {
self.fail = true;
}
);
}
pub fn unify_fixnum(&mut self, n1: Fixnum, value: HeapCellValue) {
if let Some(r) = value.as_var() {
self.bind(r, fixnum_as_cell!(n1));
return;
}
match Number::try_from(value) {
Ok(n2) => match n2 {
Number::Fixnum(n2) if n1.get_num() == n2.get_num() => {}
Number::Integer(n2) if n1.get_num() == *n2 => {}
Number::Rational(n2) if n1.get_num() == *n2 => {}
_ => {
self.fail = true;
}
},
Err(_) => {
self.fail = true;
}
}
}
pub fn unify_big_int(&mut self, n1: TypedArenaPtr<Integer>, value: HeapCellValue) {
if let Some(r) = value.as_var() {
self.bind(r, typed_arena_ptr_as_cell!(n1));
return;
}
match Number::try_from(value) {
Ok(n2) => match n2 {
Number::Fixnum(n2) if *n1 == n2.get_num() => {}
Number::Integer(n2) if *n1 == *n2 => {}
Number::Rational(n2) if *n1 == *n2 => {}
_ => {
self.fail = true;
}
},
Err(_) => {
self.fail = true;
}
}
}
pub fn unify_rational(&mut self, n1: TypedArenaPtr<Rational>, value: HeapCellValue) {
if let Some(r) = value.as_var() {
self.bind(r, typed_arena_ptr_as_cell!(n1));
return;
}
match Number::try_from(value) {
Ok(n2) => match n2 {
Number::Fixnum(n2) if *n1 == n2.get_num() => {}
Number::Integer(n2) if *n1 == *n2 => {}
Number::Rational(n2) if *n1 == *n2 => {}
_ => {
self.fail = true;
}
},
Err(_) => {
self.fail = true;
}
}
}
pub fn unify_f64(&mut self, f1: F64Ptr, value: HeapCellValue) {
if let Some(r) = value.as_var() {
self.bind(r, typed_arena_ptr_as_cell!(f1));
return;
}
read_heap_cell!(value,
(HeapCellValueTag::F64, f2) => {
if *f1 != *f2 {
self.fail = true;
}
}
_ => {
self.fail = true;
}
);
}
pub fn unify_constant(&mut self, ptr: UntypedArenaPtr, value: HeapCellValue) {
if let Some(ptr2) = value.to_untyped_arena_ptr() {
if ptr.get_ptr() == ptr2.get_ptr() {
return;
}
}
match_untyped_arena_ptr!(ptr,
(ArenaHeaderTag::Integer, int_ptr) => {
self.unify_big_int(int_ptr, value);
}
(ArenaHeaderTag::Rational, rat_ptr) => {
self.unify_rational(rat_ptr, value);
}
_ => {
if let Some(r) = value.as_var() {
self.bind(r, untyped_arena_ptr_as_cell!(ptr));
} else {
self.fail = true;
}
}
);
}
pub fn unify(&mut self) {
let mut tabu_list: IndexSet<(usize, usize)> = IndexSet::new();
// self.fail = false;
while !(self.pdl.is_empty() || self.fail) {
let s1 = self.pdl.pop().unwrap();
let s1 = self.deref(s1);
let s2 = self.pdl.pop().unwrap();
let s2 = self.deref(s2);
if s1 != s2 {
let d1 = self.store(s1);
let d2 = self.store(s2);
read_heap_cell!(d1,
(HeapCellValueTag::AttrVar, h) => {
self.bind(Ref::attr_var(h), d2);
}
(HeapCellValueTag::Var, h) => {
self.bind(Ref::heap_cell(h), d2);
}
(HeapCellValueTag::StackVar, s) => {
self.bind(Ref::stack_cell(s), d2);
}
(HeapCellValueTag::Atom, (name, arity)) => {
debug_assert!(arity == 0);
self.unify_atom(name, d2);
}
(HeapCellValueTag::Str, s1) => {
if d2.is_constant() {
self.fail = true;
break;
}
let s2 = s2.get_value() as usize;
if tabu_list.contains(&(s1, s2)) {
continue;
}
self.unify_structure(s1, d2);
if !self.fail {
tabu_list.insert((s1, s2));
}
}
(HeapCellValueTag::Lis, l1) => {
if d2.is_ref() {
let l2 = s2.get_value();
if tabu_list.contains(&(l1, l2)) {
continue;
}
tabu_list.insert((l1, l2));
}
self.unify_list(l1, d2);
}
(HeapCellValueTag::PStrLoc, pstr1_loc) => {
read_heap_cell!(d2,
(HeapCellValueTag::PStrLoc |
HeapCellValueTag::Lis |
HeapCellValueTag::Str,
pstr2_loc) => {
if tabu_list.contains(&(pstr1_loc, pstr2_loc)) {
continue;
}
}
(HeapCellValueTag::CStr |
HeapCellValueTag::AttrVar |
HeapCellValueTag::Var |
HeapCellValueTag::StackVar) => {
}
_ => {
self.fail = true;
break;
}
);
self.unify_partial_string(d1, d2);
if !self.fail && !d2.is_constant() {
tabu_list.insert((pstr1_loc, d2.get_value()));
}
}
(HeapCellValueTag::CStr) => {
read_heap_cell!(d2,
(HeapCellValueTag::AttrVar, h) => {
self.bind(Ref::attr_var(h), d1);
continue;
}
(HeapCellValueTag::Var, h) => {
self.bind(Ref::heap_cell(h), d1);
continue;
}
(HeapCellValueTag::StackVar, s) => {
self.bind(Ref::stack_cell(s), d1);
continue;
}
(HeapCellValueTag::Str |
HeapCellValueTag::Lis |
HeapCellValueTag::PStrLoc) => {
}
(HeapCellValueTag::CStr) => {
self.fail = d1 != d2;
continue;
}
_ => {
self.fail = true;
return;
}
);
self.unify_partial_string(d2, d1);
}
(HeapCellValueTag::F64, f1) => {
self.unify_f64(f1, d2);
}
(HeapCellValueTag::Fixnum, n1) => {
self.unify_fixnum(n1, d2);
}
(HeapCellValueTag::Char, c1) => {
self.unify_char(c1, d2);
}
(HeapCellValueTag::Cons, ptr_1) => {
self.unify_constant(ptr_1, d2);
}
_ => {
unreachable!();
}
);
}
}
}
pub(super) fn set_ball(&mut self) {
self.ball.reset();
let addr = self.registers[1];
self.ball.boundary = self.heap.len();
copy_term(
CopyBallTerm::new(&mut self.stack, &mut self.heap, &mut self.ball.stub),
addr,
AttrVarPolicy::DeepCopy,
);
}
pub fn copy_term(&mut self, attr_var_policy: AttrVarPolicy) {
let old_h = self.heap.len();
let a1 = self.registers[1];
let a2 = self.registers[2];
copy_term(CopyTerm::new(self), a1, attr_var_policy);
unify_fn!(self, heap_loc_as_cell!(old_h), a2);
}
pub(super) fn unwind_stack(&mut self) {
self.b = self.block;
self.fail = true;
}
#[inline]
pub fn bind_with_occurs_check(&mut self, r: Ref, value: HeapCellValue) -> bool {
if let RefTag::StackCell = r.get_tag() {
// local variable optimization -- r cannot occur in the
// heap structure bound to value, so don't bother
// traversing value.
self.bind(r, value);
return false;
}
let mut occurs_triggered = false;
if !value.is_constant() {
for addr in stackful_preorder_iter(&mut self.heap, value) {
let addr = unmark_cell_bits!(addr);
if let Some(inner_r) = addr.as_var() {
if r == inner_r {
occurs_triggered = true;
break;
}
}
}
}
if occurs_triggered {
self.fail = true;
} else {
self.bind(r, value);
}
return occurs_triggered;
}
#[inline]
pub(super) fn bind_with_occurs_check_wrapper(&mut self, r: Ref, value: HeapCellValue) {
self.bind_with_occurs_check(r, value);
}
#[inline]
pub(super) fn bind_with_occurs_check_with_error_wrapper(
&mut self,
r: Ref,
value: HeapCellValue,
) {
if self.bind_with_occurs_check(r, value) {
let err = self.representation_error(RepFlag::Term);
let stub = functor_stub(atom!("unify_with_occurs_check"), 2);
let err = self.error_form(err, stub);
self.throw_exception(err);
}
}
pub(super) fn unify_with_occurs_check_with_error(&mut self) {
let mut throw_error = false;
self.unify_with_occurs_check_loop(|| throw_error = true);
if throw_error {
let err = self.representation_error(RepFlag::Term);
let stub = functor_stub(atom!("unify_with_occurs_check"), 2);
let err = self.error_form(err, stub);
self.throw_exception(err);
}
}
pub(super) fn unify_with_occurs_check(&mut self) {
self.unify_with_occurs_check_loop(|| {})
}
fn unify_structure_with_occurs_check(
&mut self,
s1: usize,
value: HeapCellValue,
mut occurs_trigger: impl FnMut(),
) {
// s1 is the value of a STR cell.
let (n1, a1) = cell_as_atom_cell!(self.heap[s1]).get_name_and_arity();
read_heap_cell!(value,
(HeapCellValueTag::Str, s2) => {
let (n2, a2) = cell_as_atom_cell!(self.heap[s2])
.get_name_and_arity();
if n1 == n2 && a1 == a2 {
for idx in 0..a1 {
self.pdl.push(heap_loc_as_cell!(s2+1+idx));
self.pdl.push(heap_loc_as_cell!(s1+1+idx));
}
} else {
self.fail = true;
}
}
(HeapCellValueTag::Lis, l2) => {
if a1 == 2 && n1 == atom!(".") {
for idx in 0..2 {
self.pdl.push(heap_loc_as_cell!(l2+idx));
self.pdl.push(heap_loc_as_cell!(s1+1+idx));
}
} else {
self.fail = true;
}
}
(HeapCellValueTag::Atom, (n2, a2)) => {
if !(a1 == 0 && a2 == 0 && n1 == n2) {
self.fail = true;
}
}
(HeapCellValueTag::AttrVar, h) => {
if self.bind_with_occurs_check(Ref::attr_var(h), str_loc_as_cell!(s1)) {
occurs_trigger();
}
}
(HeapCellValueTag::Var, h) => {
if self.bind_with_occurs_check(Ref::heap_cell(h), str_loc_as_cell!(s1)) {
occurs_trigger();
}
}
(HeapCellValueTag::StackVar, s) => {
if self.bind_with_occurs_check(Ref::stack_cell(s), str_loc_as_cell!(s1)) {
occurs_trigger();
}
}
_ => {
self.fail = true;
}
)
}
// the return value of unify_partial_string_with_occurs_check is
// interpreted as follows:
//
// Some(None) -- the strings are equal, nothing to unify
// Some(Some(f2,f1)) -- prefixes equal, try to unify focus values f2, f1
// None -- prefixes not equal, unification fails
//
// d1's tag is assumed to be one of LIS, STR or PSTRLOC.
pub fn unify_partial_string_with_occurs_check(
&mut self,
d1: HeapCellValue,
d2: HeapCellValue,
mut occurs_trigger: impl FnMut(),
) {
if let Some(r) = d2.as_var() {
if self.bind_with_occurs_check(r, d1) {
occurs_trigger();
}
return;
}
let s1 = self.heap.len();
self.heap.push(d1);
self.heap.push(d2);
let mut pstr_iter1 = HeapPStrIter::new(&self.heap, s1);
let mut pstr_iter2 = HeapPStrIter::new(&self.heap, s1 + 1);
match compare_pstr_prefixes(&mut pstr_iter1, &mut pstr_iter2) {
PStrCmpResult::Ordered(Ordering::Equal) => {}
PStrCmpResult::Ordered(Ordering::Less) => {
if pstr_iter2.focus.as_var().is_none() {
self.fail = true;
} else {
self.pdl.push(empty_list_as_cell!());
self.pdl.push(pstr_iter2.focus);
}
}
PStrCmpResult::Ordered(Ordering::Greater) => {
if pstr_iter1.focus.as_var().is_none() {
self.fail = true;
} else {
self.pdl.push(empty_list_as_cell!());
self.pdl.push(pstr_iter1.focus);
}
}
continuable @ PStrCmpResult::FirstIterContinuable(iteratee) |
continuable @ PStrCmpResult::SecondIterContinuable(iteratee) => {
if continuable.is_second_iter() {
std::mem::swap(&mut pstr_iter1, &mut pstr_iter2);
}
let mut chars_iter = PStrCharsIter {
iter: pstr_iter1,
item: Some(iteratee),
};
let mut focus = pstr_iter2.focus;
'outer: loop {
while let Some(c) = chars_iter.peek() {
read_heap_cell!(focus,
(HeapCellValueTag::Lis, l) => {
let val = pstr_iter2.heap[l];
self.pdl.push(val);
self.pdl.push(char_as_cell!(c));
focus = pstr_iter2.heap[l+1];
}
(HeapCellValueTag::Str, s) => {
let (name, arity) = cell_as_atom_cell!(pstr_iter2.heap[s])
.get_name_and_arity();
if name == atom!(".") && arity == 2 {
self.pdl.push(pstr_iter2.heap[s+1]);
self.pdl.push(char_as_cell!(c));
focus = pstr_iter2.heap[s+2];
} else {
self.fail = true;
break 'outer;
}
}
(HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
match chars_iter.item.unwrap() {
PStrIteratee::Char(focus, _) => {
self.pdl.push(self.heap[focus]);
self.pdl.push(heap_loc_as_cell!(h));
}
PStrIteratee::PStrSegment(focus, _, n) => {
read_heap_cell!(self.heap[focus],
(HeapCellValueTag::CStr | HeapCellValueTag::PStr, pstr_atom) => {
if focus < self.heap.len() - 2 {
self.heap.pop();
self.heap.pop();
}
if n == 0 {
let target_cell = match self.heap[focus].get_tag() {
HeapCellValueTag::CStr => {
atom_as_cstr_cell!(pstr_atom)
}
HeapCellValueTag::PStr => {
pstr_loc_as_cell!(focus)
}
_ => {
unreachable!()
}
};
self.pdl.push(target_cell);
self.pdl.push(heap_loc_as_cell!(h));
} else {
let h_len = self.heap.len();
self.heap.push(pstr_offset_as_cell!(focus));
self.heap.push(fixnum_as_cell!(
Fixnum::build_with(n as i64)
));
self.pdl.push(pstr_loc_as_cell!(h_len));
self.pdl.push(heap_loc_as_cell!(h));
}
return;
}
(HeapCellValueTag::PStrOffset, pstr_loc) => {
let n0 = cell_as_fixnum!(self.heap[focus+1])
.get_num() as usize;
if pstr_loc < self.heap.len() - 2 {
self.heap.pop();
self.heap.pop();
}
if n == n0 {
self.pdl.push(pstr_loc_as_cell!(focus));
self.pdl.push(heap_loc_as_cell!(h));
} else {
let h_len = self.heap.len();
self.heap.push(pstr_offset_as_cell!(pstr_loc));
self.heap.push(fixnum_as_cell!(
Fixnum::build_with(n as i64)
));
self.pdl.push(pstr_loc_as_cell!(h_len));
self.pdl.push(heap_loc_as_cell!(h));
}
return;
}
_ => {
}
);
if focus < self.heap.len() - 2 {
self.heap.pop();
self.heap.pop();
}
self.pdl.push(self.heap[focus]);
self.pdl.push(heap_loc_as_cell!(h));
return;
}
}
break 'outer;
}
_ => {
self.fail = true;
break 'outer;
}
);
chars_iter.next();
}
chars_iter.iter.next();
self.pdl.push(chars_iter.iter.focus);
self.pdl.push(focus);
break;
}
}
PStrCmpResult::Unordered => {
self.pdl.push(pstr_iter1.focus);
self.pdl.push(pstr_iter2.focus);
}
}
self.heap.pop();
self.heap.pop();
}
fn unify_list_with_occurs_trigger(
&mut self,
l1: usize,
d2: HeapCellValue,
mut occurs_trigger: impl FnMut(),
) {
read_heap_cell!(d2,
(HeapCellValueTag::Lis, l2) => {
for idx in 0..2 {
self.pdl.push(heap_loc_as_cell!(l2+idx));
self.pdl.push(heap_loc_as_cell!(l1+idx));
}
}
(HeapCellValueTag::Str, s2) => {
let (n2, a2) = cell_as_atom_cell!(self.heap[s2])
.get_name_and_arity();
if a2 == 2 && n2 == atom!(".") {
for idx in 0..2 {
self.pdl.push(heap_loc_as_cell!(s2+1+idx));
self.pdl.push(heap_loc_as_cell!(l1+idx));
}
} else {
self.fail = true;
}
}
(HeapCellValueTag::PStrLoc | HeapCellValueTag::CStr | HeapCellValueTag::PStr) => {
self.unify_partial_string_with_occurs_check(
list_loc_as_cell!(l1),
d2,
&mut occurs_trigger,
)
}
(HeapCellValueTag::AttrVar, h) => {
if self.bind_with_occurs_check(Ref::attr_var(h), list_loc_as_cell!(l1)) {
occurs_trigger();
}
}
(HeapCellValueTag::Var, h) => {
if self.bind_with_occurs_check(Ref::heap_cell(h), list_loc_as_cell!(l1)) {
occurs_trigger();
}
}
(HeapCellValueTag::StackVar, s) => {
if self.bind_with_occurs_check(Ref::stack_cell(s), list_loc_as_cell!(l1)) {
occurs_trigger();
}
}
_ => {
self.fail = true;
}
)
}
pub(super) fn unify_with_occurs_check_loop(&mut self, mut occurs_trigger: impl FnMut()) {
let mut tabu_list: IndexSet<(usize, usize)> = IndexSet::new();
// self.fail = false;
while !(self.pdl.is_empty() || self.fail) {
let s1 = self.pdl.pop().unwrap();
let s1 = self.deref(s1);
let s2 = self.pdl.pop().unwrap();
let s2 = self.deref(s2);
if s1 != s2 {
let d1 = self.store(s1);
let d2 = self.store(s2);
read_heap_cell!(d1,
(HeapCellValueTag::AttrVar, h) => {
if self.bind_with_occurs_check(Ref::attr_var(h), d2) {
occurs_trigger();
}
}
(HeapCellValueTag::Var, h) => {
if self.bind_with_occurs_check(Ref::heap_cell(h), d2) {
occurs_trigger();
}
}
(HeapCellValueTag::StackVar, s) => {
if self.bind_with_occurs_check(Ref::stack_cell(s), d2) {
occurs_trigger();
}
}
(HeapCellValueTag::Atom, (name, arity)) => {
debug_assert!(arity == 0);
self.unify_atom(name, d2);
}
(HeapCellValueTag::Str, s1) => {
if d2.is_constant() {
self.fail = true;
break;
}
let s2 = s2.get_value() as usize;
if tabu_list.contains(&(s1, s2)) {
continue;
}
self.unify_structure_with_occurs_check(s1, d2, &mut occurs_trigger);
if !self.fail {
tabu_list.insert((s1, s2));
}
}
(HeapCellValueTag::Lis, l1) => {
if d2.is_ref() {
let l2 = s2.get_value() as usize;
if tabu_list.contains(&(l1, l2)) {
continue;
}
tabu_list.insert((l1, l2));
}
self.unify_list_with_occurs_trigger(l1, d2, &mut occurs_trigger);
}
(HeapCellValueTag::PStrLoc, pstr1_loc) => {
read_heap_cell!(d2,
(HeapCellValueTag::PStrLoc |
HeapCellValueTag::Lis |
HeapCellValueTag::Str,
pstr2_loc) => {
if tabu_list.contains(&(pstr1_loc, pstr2_loc)) {
continue;
}
}
(HeapCellValueTag::CStr |
HeapCellValueTag::AttrVar |
HeapCellValueTag::Var |
HeapCellValueTag::StackVar) => {
}
_ => {
self.fail = true;
break;
}
);
self.unify_partial_string_with_occurs_check(
d1,
d2,
&mut occurs_trigger,
);
if !self.fail && !d2.is_constant() {
tabu_list.insert((pstr1_loc, d2.get_value()));
}
}
(HeapCellValueTag::CStr) => {
read_heap_cell!(d2,
(HeapCellValueTag::AttrVar, h) => {
self.bind(Ref::attr_var(h), d1);
continue;
}
(HeapCellValueTag::Var, h) => {
self.bind(Ref::heap_cell(h), d1);
continue;
}
(HeapCellValueTag::StackVar, s) => {
self.bind(Ref::stack_cell(s), d1);
continue;
}
(HeapCellValueTag::Str |
HeapCellValueTag::Lis |
HeapCellValueTag::PStrLoc) => {
}
_ => {
self.fail = true;
return;
}
);
self.unify_partial_string(d2, d1);
}
(HeapCellValueTag::F64, f1) => {
self.unify_f64(f1, d2);
}
(HeapCellValueTag::Fixnum, n1) => {
self.unify_fixnum(n1, d2);
}
(HeapCellValueTag::Char, c1) => {
self.unify_char(c1, d2);
}
(HeapCellValueTag::Cons, ptr_1) => {
self.unify_constant(ptr_1, d2);
}
_ => {
unreachable!();
}
);
}
}
}
fn read_s(&mut self) -> HeapCellValue {
match &self.s {
&HeapPtr::HeapCell(h) => self.deref(self.heap[h]),
&HeapPtr::PStrChar(h, n) => {
read_heap_cell!(self.heap[h],
(HeapCellValueTag::PStr, pstr_atom) => {
let pstr = PartialString::from(pstr_atom);
if let Some(c) = pstr.as_str_from(n).chars().next() {
char_as_cell!(c)
} else { // if has_tail {
self.deref(self.heap[h+1]) // heap_loc_as_cell!(h+1)
}
// } else {
// empty_list_as_cell!()
// }
}
(HeapCellValueTag::CStr, cstr_atom) => {
let pstr = PartialString::from(cstr_atom);
if let Some(c) = pstr.as_str_from(n).chars().next() {
char_as_cell!(c)
} else { // if has_tail {
empty_list_as_cell!()
}
}
_ => {
unreachable!()
}
)
}
&HeapPtr::PStrLocation(h, n) => {
read_heap_cell!(self.heap[h],
(HeapCellValueTag::PStr, pstr_atom) => {
if n < pstr_atom.len() {
let h_len = self.heap.len();
self.heap.push(pstr_offset_as_cell!(h));
self.heap.push(fixnum_as_cell!(Fixnum::build_with(n as i64)));
pstr_loc_as_cell!(h_len)
} else {
self.deref(self.heap[h+1])
}
}
(HeapCellValueTag::CStr, cstr_atom) => {
if n < cstr_atom.len() {
let h_len = self.heap.len();
self.heap.push(pstr_offset_as_cell!(h));
self.heap.push(fixnum_as_cell!(Fixnum::build_with(n as i64)));
pstr_loc_as_cell!(h_len)
} else {
empty_list_as_cell!()
}
}
_ => {
unreachable!()
}
)
}
}
}
pub fn compare_term_test(&mut self) -> Option<Ordering> {
let mut tabu_list = IndexSet::new();
while !self.pdl.is_empty() {
let s1 = self.pdl.pop().unwrap();
let s1 = self.deref(s1);
let s2 = self.pdl.pop().unwrap();
let s2 = self.deref(s2);
if s1 == s2 {
continue;
}
let v1 = self.store(s1);
let v2 = self.store(s2);
let order_cat_v1 = v1.order_category();
let order_cat_v2 = v2.order_category();
if order_cat_v1 != order_cat_v2 {
self.pdl.clear();
return Some(order_cat_v1.cmp(&order_cat_v2));
}
match order_cat_v1 {
Some(TermOrderCategory::Variable) => {
let v1 = v1.as_var().unwrap();
let v2 = v2.as_var().unwrap();
if v1 != v2 {
self.pdl.clear();
return Some(v1.cmp(&v2));
}
}
Some(TermOrderCategory::FloatingPoint) => {
let v1 = cell_as_f64_ptr!(v1);
let v2 = cell_as_f64_ptr!(v2);
if v1 != v2 {
self.pdl.clear();
return Some(v1.cmp(&v2));
}
}
Some(TermOrderCategory::Integer) => {
let v1 = Number::try_from(v1).unwrap();
let v2 = Number::try_from(v2).unwrap();
if v1 != v2 {
self.pdl.clear();
return Some(v1.cmp(&v2));
}
}
Some(TermOrderCategory::Atom) => {
read_heap_cell!(v1,
(HeapCellValueTag::Atom, (n1, _a1)) => {
read_heap_cell!(v2,
(HeapCellValueTag::Atom, (n2, _a2)) => {
if n1 != n2 {
self.pdl.clear();
return Some(n1.cmp(&n2));
}
}
(HeapCellValueTag::Char, c2) => {
if let Some(c1) = n1.as_char() {
if c1 != c2 {
self.pdl.clear();
return Some(c1.cmp(&c2));
}
} else {
self.pdl.clear();
return Some(Ordering::Greater);
}
}
_ => {
unreachable!();
}
)
}
(HeapCellValueTag::Char, c1) => {
read_heap_cell!(v2,
(HeapCellValueTag::Atom, (n2, _a2)) => {
if let Some(c2) = n2.as_char() {
if c1 != c2 {
self.pdl.clear();
return Some(c1.cmp(&c2));
}
} else {
self.pdl.clear();
return Some(Ordering::Less);
}
}
(HeapCellValueTag::Char, c2) => {
if c1 != c2 {
self.pdl.clear();
return Some(c1.cmp(&c2));
}
}
_ => {
unreachable!()
}
)
}
_ => {
unreachable!()
}
)
}
Some(TermOrderCategory::Compound) => {
fn stalled_pstr_iter_handler(
string_iter: HeapPStrIter,
stalled_iter: HeapPStrIter,
pdl: &mut Vec<HeapCellValue>,
) -> Option<Ordering> {
let l = read_heap_cell!(stalled_iter.focus,
(HeapCellValueTag::Str, s) => {
let (name, arity) = cell_as_atom_cell!(stalled_iter.heap[s])
.get_name_and_arity();
if !(name == atom!(".") && arity == 2) {
pdl.clear();
return Some((atom!("."),2).cmp(&(name,arity)));
}
s+1
}
(HeapCellValueTag::Lis, l) => {
l
}
_ => {
unreachable!()
}
);
let c2 = stalled_iter.heap[l];
let c1 = string_iter.chars().next().unwrap();
pdl.push(c2);
pdl.push(char_as_cell!(c1));
None
}
fn pstr_comparator(
heap: &[HeapCellValue],
pdl: &mut Vec<HeapCellValue>,
s1: usize,
s2: usize,
) -> Option<Ordering> {
let mut iter1 = HeapPStrIter::new(heap, s1);
let mut iter2 = HeapPStrIter::new(heap, s2);
match compare_pstr_prefixes(&mut iter1, &mut iter2) {
PStrCmpResult::Ordered(ordering) => Some(ordering),
_ => {
if iter1.num_steps() == 0 && iter2.num_steps() == 0 {
return match iter2.focus.get_tag() {
HeapCellValueTag::CStr | HeapCellValueTag::PStrLoc => {
let result = stalled_pstr_iter_handler(iter2, iter1, pdl);
if let Some(ordering) = result {
Some(ordering.reverse())
} else {
let pdl_len = pdl.len();
pdl.swap(pdl_len - 2, pdl_len - 1);
result
}
}
_ => {
stalled_pstr_iter_handler(iter1, iter2, pdl)
}
};
}
pdl.push(iter2.focus);
pdl.push(iter1.focus);
None
}
}
}
read_heap_cell!(v1,
(HeapCellValueTag::Lis, l1) => {
read_heap_cell!(v2,
(HeapCellValueTag::CStr | HeapCellValueTag::PStrLoc) => {
let h = self.heap.len();
self.heap.push(v1);
self.heap.push(v2);
if let Some(ordering) = pstr_comparator(
&self.heap, &mut self.pdl, h, h+1
) {
if ordering != Ordering::Equal {
self.heap.pop();
self.heap.pop();
self.pdl.clear();
return Some(ordering);
}
}
self.heap.pop();
self.heap.pop();
}
(HeapCellValueTag::Lis, l2) => {
if tabu_list.contains(&(l1, l2)) {
continue;
}
tabu_list.insert((l1, l2));
self.pdl.push(self.heap[l2 + 1]);
self.pdl.push(self.heap[l1 + 1]);
self.pdl.push(self.heap[l2]);
self.pdl.push(self.heap[l1]);
}
(HeapCellValueTag::Str, s2) => {
if tabu_list.contains(&(l1, s2)) {
continue;
}
let (name, arity) = cell_as_atom_cell!(self.heap[s2])
.get_name_and_arity();
match (atom!("."), 2).cmp(&(name, arity)) {
Ordering::Equal => {
tabu_list.insert((l1, s2));
self.pdl.push(self.heap[s2 + 2]);
self.pdl.push(self.heap[l1 + 1]);
self.pdl.push(self.heap[s2 + 1]);
self.pdl.push(self.heap[l1]);
}
ordering => {
self.pdl.clear();
return Some(ordering);
}
}
}
_ => {
unreachable!();
}
)
}
(HeapCellValueTag::CStr | HeapCellValueTag::PStrLoc) => {
let h = self.heap.len();
self.heap.push(v1);
self.heap.push(v2);
if let Some(ordering) = pstr_comparator(
&self.heap, &mut self.pdl, h, h+1,
) {
if ordering != Ordering::Equal {
self.heap.pop();
self.heap.pop();
self.pdl.clear();
return Some(ordering);
}
}
self.heap.pop();
self.heap.pop();
}
(HeapCellValueTag::Str, s1) => {
read_heap_cell!(v2,
(HeapCellValueTag::Str, s2) => {
if tabu_list.contains(&(s1, s2)) {
continue;
}
let (n1, a1) = cell_as_atom_cell!(self.heap[s1])
.get_name_and_arity();
let (n2, a2) = cell_as_atom_cell!(self.heap[s2])
.get_name_and_arity();
match (n1,a1).cmp(&(n2,a2)) {
Ordering::Equal => {
tabu_list.insert((s1, s2));
for idx in (1 .. a1+1).rev() {
self.pdl.push(self.heap[s2+idx]);
self.pdl.push(self.heap[s1+idx]);
}
}
ordering => {
self.pdl.clear();
return Some(ordering);
}
}
}
(HeapCellValueTag::Lis, l2) => {
if tabu_list.contains(&(s1, l2)) {
continue;
}
tabu_list.insert((s1, l2));
let (n1, a1) = cell_as_atom_cell!(self.heap[s1])
.get_name_and_arity();
match (n1,a1).cmp(&(atom!("."), 2)) {
Ordering::Equal => {
self.pdl.push(self.heap[l2]);
self.pdl.push(self.heap[s1+1]);
self.pdl.push(self.heap[l2+1]);
self.pdl.push(self.heap[s1+2]);
}
ordering => {
self.pdl.clear();
return Some(ordering);
}
}
}
(HeapCellValueTag::CStr | HeapCellValueTag::PStrLoc) => {
let h = self.heap.len();
self.heap.push(v1);
self.heap.push(v2);
if let Some(ordering) = pstr_comparator(
&self.heap, &mut self.pdl, h, h+1,
) {
if ordering != Ordering::Equal {
self.heap.pop();
self.heap.pop();
self.pdl.clear();
return Some(ordering);
}
}
self.heap.pop();
self.heap.pop();
}
_ => {
unreachable!()
}
)
}
_ => {
unreachable!()
}
);
}
None => {
if v1 != v2 {
self.pdl.clear();
return None;
}
}
}
}
Some(Ordering::Equal)
}
fn increment_s_ptr(&mut self, rhs: usize) {
match &mut self.s {
HeapPtr::HeapCell(ref mut h) => {
*h += rhs;
}
&mut HeapPtr::PStrChar(h, ref mut n) | &mut HeapPtr::PStrLocation(h, ref mut n) => {
read_heap_cell!(self.heap[h],
(HeapCellValueTag::PStr | HeapCellValueTag::CStr, pstr_atom) => {
let pstr = PartialString::from(pstr_atom);
for c in pstr.as_str_from(*n).chars().take(rhs) {
*n += c.len_utf8();
}
self.s = HeapPtr::PStrLocation(h, *n);
}
_ => {
unreachable!()
}
)
}
}
}
pub(super) fn unwind_trail(
&mut self,
a1: usize,
a2: usize,
global_variables: &mut GlobalVarDir,
) {
// the sequence is reversed to respect the chronology of trail
// additions, now that deleted attributes can be undeleted by
// backtracking.
for i in (a1..a2).rev() {
let h = self.trail[i].get_value() as usize;
match self.trail[i].get_tag() {
TrailEntryTag::TrailedHeapVar => {
self.heap[h] = heap_loc_as_cell!(h);
}
TrailEntryTag::TrailedStackVar => {
self.stack[h] = stack_loc_as_cell!(h);
}
TrailEntryTag::TrailedAttrVar => {
self.heap[h] = attr_var_as_cell!(h);
}
TrailEntryTag::TrailedAttrVarHeapLink => {
self.heap[h] = heap_loc_as_cell!(h);
}
TrailEntryTag::TrailedAttrVarListLink => {
let l = self.trail[i + 1].get_value();
self.heap[h] = list_loc_as_cell!(l);
}
TrailEntryTag::TrailedBlackboardEntry => {
let key = Atom::from(h);
match global_variables.get_mut(&key) {
Some((_, ref mut loc)) => *loc = None,
None => unreachable!(),
}
}
TrailEntryTag::TrailedBlackboardOffset => {
let key = Atom::from(h);
let value_cell = HeapCellValue::from(u64::from(self.trail[i + 1]));
match global_variables.get_mut(&key) {
Some((_, ref mut loc)) => *loc = Some(value_cell),
None => unreachable!(),
}
}
TrailEntryTag::TrailedAttachedValue => {
}
}
}
}
pub fn match_partial_string(&mut self, value: HeapCellValue, string: Atom, has_tail: bool) {
let h = self.heap.len();
self.heap.push(value);
let mut heap_pstr_iter = HeapPStrIter::new(&self.heap, h);
let s = string.as_str();
match heap_pstr_iter.compare_pstr_to_string(s) {
Some(PStrPrefixCmpResult { focus, offset, prefix_len }) if prefix_len == s.len() => {
let focus_addr = self.heap[focus];
read_heap_cell!(focus_addr,
(HeapCellValueTag::PStr | HeapCellValueTag::CStr, pstr_atom) => {
if has_tail {
self.s = HeapPtr::PStrLocation(focus, offset);
self.mode = MachineMode::Read;
} else if offset == pstr_atom.len() {
let focus_addr = heap_pstr_iter.focus;
unify!(self, focus_addr, empty_list_as_cell!());
} else {
self.fail = true;
}
}
(HeapCellValueTag::PStrLoc | HeapCellValueTag::PStrOffset, h) => {
if has_tail {
let (h, _) = pstr_loc_and_offset(&self.heap, h);
self.s = HeapPtr::PStrLocation(h, offset);
self.mode = MachineMode::Read;
} else {
let end_cell = heap_pstr_iter.focus;
self.fail = end_cell != empty_list_as_cell!();
}
}
_ => {
let focus = heap_pstr_iter.focus();
if has_tail {
self.s = HeapPtr::HeapCell(focus);
self.mode = MachineMode::Read;
} else {
let focus = heap_pstr_iter.focus;
unify!(self, focus, empty_list_as_cell!());
}
}
);
}
Some(PStrPrefixCmpResult { prefix_len, .. }) => {
// TODO: this is woefully insufficient! you need to
// match the remaining portion of string if offset <
// pstr.len().
let focus = heap_pstr_iter.focus();
let tail_addr = self.heap[focus];
let h = self.heap.len();
let target_cell = if has_tail {
self.s = HeapPtr::HeapCell(h + 1);
self.mode = MachineMode::Read;
put_partial_string(
&mut self.heap,
&string.as_str()[prefix_len ..],
&mut self.atom_tbl,
)
} else {
put_complete_string(
&mut self.heap,
&string.as_str()[prefix_len ..],
&mut self.atom_tbl,
)
};
unify!(self, tail_addr, target_cell);
}
None => {
self.fail = true;
}
}
}
pub(super) fn write_literal_to_var(&mut self, deref_v: HeapCellValue, lit: HeapCellValue) {
let store_v = self.store(deref_v);
read_heap_cell!(lit,
(HeapCellValueTag::Atom, (atom, arity)) => {
if arity == 0 {
self.unify_atom(atom, store_v);
} else {
self.fail = true;
}
}
(HeapCellValueTag::Char, c) => {
self.unify_char(c, store_v);
}
(HeapCellValueTag::Fixnum, n) => {
self.unify_fixnum(n, store_v);
}
(HeapCellValueTag::F64, f64_ptr) => {
self.unify_f64(f64_ptr, store_v);
}
(HeapCellValueTag::Cons, ptr) => {
match_untyped_arena_ptr!(ptr,
(ArenaHeaderTag::Integer, n) => {
self.unify_big_int(n, store_v);
}
(ArenaHeaderTag::Rational, r) => {
self.unify_rational(r, store_v);
}
_ => {
self.fail = true;
}
)
}
(HeapCellValueTag::CStr, cstr_atom) => {
match store_v.get_tag() {
HeapCellValueTag::PStrLoc
| HeapCellValueTag::Lis
| HeapCellValueTag::Str => {
self.match_partial_string(store_v, cstr_atom, false);
}
_ => {
self.fail = true;
}
}
}
_ => {
unreachable!()
}
)
}
pub fn execute_arith_instr(&mut self, instr: &ArithmeticInstruction) {
let stub_gen = || functor_stub(atom!("is"), 2);
match instr {
&ArithmeticInstruction::Add(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(
self,
try_numeric_result!(add(n1, n2, &mut self.arena), stub_gen)
);
self.p += 1;
}
&ArithmeticInstruction::Sub(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(
self,
try_numeric_result!(sub(n1, n2, &mut self.arena), stub_gen)
);
self.p += 1;
}
&ArithmeticInstruction::Mul(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(
self,
try_numeric_result!(mul(n1, n2, &mut self.arena), stub_gen)
);
self.p += 1;
}
&ArithmeticInstruction::Max(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, max(n1, n2));
self.p += 1;
}
&ArithmeticInstruction::Min(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, min(n1, n2));
self.p += 1;
}
&ArithmeticInstruction::IntPow(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, int_pow(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Gcd(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, gcd(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Pow(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, pow(n1, n2, atom!("**")));
self.p += 1;
}
&ArithmeticInstruction::RDiv(ref a1, ref a2, t) => {
let stub_gen = || functor_stub(atom!("(rdiv)"), 2);
let r1 = try_or_fail!(self, self.get_rational(a1, stub_gen));
let r2 = try_or_fail!(self, self.get_rational(a2, stub_gen));
self.interms[t - 1] = Number::Rational(arena_alloc!(
try_or_fail_gen!(self, rdiv(r1, r2)),
self.arena
));
self.p += 1;
}
&ArithmeticInstruction::IntFloorDiv(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] =
try_or_fail_gen!(self, int_floor_div(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::IDiv(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, idiv(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Abs(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = abs(n1, &mut self.arena);
self.p += 1;
}
&ArithmeticInstruction::Sign(ref a1, t) => {
let n = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = sign(n);
self.p += 1;
}
&ArithmeticInstruction::Neg(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = neg(n1, &mut self.arena);
self.p += 1;
}
&ArithmeticInstruction::BitwiseComplement(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] =
try_or_fail_gen!(self, bitwise_complement(n1, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Div(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, div(n1, n2));
self.p += 1;
}
&ArithmeticInstruction::Shr(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, shr(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Shl(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, shl(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Xor(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, xor(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::And(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, and(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Or(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, or(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Mod(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, modulus(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Rem(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] = try_or_fail_gen!(self, remainder(n1, n2, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Cos(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, cos(n1))));
self.p += 1;
}
&ArithmeticInstruction::Sin(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, sin(n1))));
self.p += 1;
}
&ArithmeticInstruction::Tan(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, tan(n1))));
self.p += 1;
}
&ArithmeticInstruction::Sqrt(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, sqrt(n1))));
self.p += 1;
}
&ArithmeticInstruction::Log(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, log(n1))));
self.p += 1;
}
&ArithmeticInstruction::Exp(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, exp(n1))));
self.p += 1;
}
&ArithmeticInstruction::ACos(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, acos(n1))));
self.p += 1;
}
&ArithmeticInstruction::ASin(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, asin(n1))));
self.p += 1;
}
&ArithmeticInstruction::ATan(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = Number::Float(OrderedFloat(try_or_fail_gen!(self, atan(n1))));
self.p += 1;
}
&ArithmeticInstruction::ATan2(ref a1, ref a2, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
let n2 = try_or_fail!(self, self.get_number(a2));
self.interms[t - 1] =
Number::Float(OrderedFloat(try_or_fail_gen!(self, atan2(n1, n2))));
self.p += 1;
}
&ArithmeticInstruction::Float(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] =
Number::Float(OrderedFloat(try_or_fail_gen!(self, float(n1))));
self.p += 1;
}
&ArithmeticInstruction::Truncate(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = truncate(n1, &mut self.arena);
self.p += 1;
}
&ArithmeticInstruction::Round(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = try_or_fail_gen!(self, round(n1, &mut self.arena));
self.p += 1;
}
&ArithmeticInstruction::Ceiling(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = ceiling(n1, &mut self.arena);
self.p += 1;
}
&ArithmeticInstruction::Floor(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = floor(n1, &mut self.arena);
self.p += 1;
}
&ArithmeticInstruction::Plus(ref a1, t) => {
let n1 = try_or_fail!(self, self.get_number(a1));
self.interms[t - 1] = n1;
self.p += 1;
}
};
}
pub fn execute_fact_instr(&mut self, instr: &FactInstruction) {
match instr {
&FactInstruction::GetConstant(_, c, reg) => {
let value = self.deref(self[reg]);
self.write_literal_to_var(value, c);
}
&FactInstruction::GetList(_, reg) => {
let deref_v = self.deref(self[reg]);
let store_v = self.store(deref_v);
read_heap_cell!(store_v,
(HeapCellValueTag::PStrLoc, h) => {
let (h, n) = pstr_loc_and_offset(&self.heap, h);
self.s = HeapPtr::PStrChar(h, n.get_num() as usize);
self.mode = MachineMode::Read;
}
(HeapCellValueTag::CStr) => {
let h = self.heap.len();
self.heap.push(store_v);
self.s = HeapPtr::PStrChar(h, 0);
self.mode = MachineMode::Read;
}
(HeapCellValueTag::Lis, l) => {
self.s = HeapPtr::HeapCell(l);
self.mode = MachineMode::Read;
}
(HeapCellValueTag::AttrVar | HeapCellValueTag::Var | HeapCellValueTag::StackVar) => {
let h = self.heap.len();
self.heap.push(list_loc_as_cell!(h+1));
self.bind(store_v.as_var().unwrap(), heap_loc_as_cell!(h));
self.mode = MachineMode::Write;
}
_ => {
self.fail = true;
}
);
}
&FactInstruction::GetPartialString(_, string, reg, has_tail) => {
let deref_v = self.deref(self[reg]);
let store_v = self.store(deref_v);
read_heap_cell!(store_v,
(HeapCellValueTag::Str | HeapCellValueTag::Lis |
HeapCellValueTag::PStrLoc | HeapCellValueTag::AttrVar |
HeapCellValueTag::StackVar | HeapCellValueTag::Var |
HeapCellValueTag::CStr) => {
self.match_partial_string(store_v, string, has_tail);
}
_ => {
self.fail = true;
}
);
}
&FactInstruction::GetStructure(ref ct, arity, reg) => {
let deref_v = self.deref(self[reg]);
let store_v = self.store(deref_v);
read_heap_cell!(store_v,
(HeapCellValueTag::Str, a) => {
let result = self.heap[a];
read_heap_cell!(result,
(HeapCellValueTag::Atom, (name, narity)) => {
if narity == arity && ct.name() == name {
self.s = HeapPtr::HeapCell(a + 1);
self.mode = MachineMode::Read;
} else {
self.fail = true;
}
}
_ => {
unreachable!();
}
);
}
(HeapCellValueTag::AttrVar | HeapCellValueTag::Var | HeapCellValueTag::StackVar) => {
let h = self.heap.len();
self.heap.push(str_loc_as_cell!(h+1));
self.heap.push(atom_as_cell!(ct.name(), arity));
self.bind(store_v.as_var().unwrap(), heap_loc_as_cell!(h));
self.mode = MachineMode::Write;
}
_ => {
self.fail = true;
}
);
}
&FactInstruction::GetVariable(norm, arg) => {
self[norm] = self.registers[arg];
}
&FactInstruction::GetValue(norm, arg) => {
let norm_addr = self[norm];
let reg_addr = self.registers[arg];
unify_fn!(self, norm_addr, reg_addr);
}
&FactInstruction::UnifyConstant(v) => {
match self.mode {
MachineMode::Read => {
let addr = self.read_s();
self.write_literal_to_var(addr, v);
self.increment_s_ptr(1);
}
MachineMode::Write => {
self.heap.push(v);
}
};
}
&FactInstruction::UnifyVariable(reg) => {
match self.mode {
MachineMode::Read => {
self[reg] = self.read_s();
self.increment_s_ptr(1);
}
MachineMode::Write => {
let h = self.heap.len();
self.heap.push(heap_loc_as_cell!(h));
self[reg] = heap_loc_as_cell!(h);
}
};
}
&FactInstruction::UnifyLocalValue(reg) => {
match self.mode {
MachineMode::Read => {
let reg_addr = self[reg];
let value = self.read_s();
unify_fn!(self, reg_addr, value);
self.increment_s_ptr(1);
}
MachineMode::Write => {
let value = self.store(self.deref(self[reg]));
let h = self.heap.len();
read_heap_cell!(value,
(HeapCellValueTag::Var | HeapCellValueTag::AttrVar, hc) => {
let value = self.heap[hc];
self.heap.push(value);
self.increment_s_ptr(1);
return;
}
_ => {
}
);
self.heap.push(heap_loc_as_cell!(h));
(self.bind_fn)(self, Ref::heap_cell(h), value);
}
};
}
&FactInstruction::UnifyValue(reg) => {
match self.mode {
MachineMode::Read => {
let reg_addr = self[reg];
let value = self.read_s();
unify_fn!(self, reg_addr, value);
self.increment_s_ptr(1);
}
MachineMode::Write => {
let h = self.heap.len();
self.heap.push(heap_loc_as_cell!(h));
let addr = self.store(self[reg]);
(self.bind_fn)(self, Ref::heap_cell(h), addr);
// the former code of this match arm was:
// let addr = self.store(self[reg]);
// self.heap.push(HeapCellValue::Addr(addr));
// the old code didn't perform the occurs
// check when enabled and so it was changed to
// the above, which is only slightly less
// efficient when the occurs_check is disabled.
}
};
}
&FactInstruction::UnifyVoid(n) => {
match self.mode {
MachineMode::Read => {
self.increment_s_ptr(n);
}
MachineMode::Write => {
let h = self.heap.len();
for i in h..h + n {
self.heap.push(heap_loc_as_cell!(i));
}
}
};
}
};
}
pub(super) fn execute_indexing_instr(
&mut self,
indexing_lines: &Vec<IndexingLine>,
code_repo: &CodeRepo,
) {
fn dynamic_external_of_clause_is_valid(
machine_st: &mut MachineState,
code: &Code,
p: usize,
) -> bool {
match &code[p] {
Line::Choice(ChoiceInstruction::DynamicInternalElse(..)) => {
machine_st.dynamic_mode = FirstOrNext::First;
return true;
}
_ => {}
}
match &code[p - 1] {
&Line::Choice(ChoiceInstruction::DynamicInternalElse(birth, death, _)) => {
if birth < machine_st.cc && Death::Finite(machine_st.cc) <= death {
return true;
} else {
return false;
}
}
_ => {}
}
true
}
let mut index = 0;
let addr = match &indexing_lines[0] {
&IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(arg, ..)) => {
self.store(self.deref(self[temp_v!(arg)]))
}
_ => {
unreachable!()
}
};
loop {
match &indexing_lines[index] {
&IndexingLine::Indexing(IndexingInstruction::SwitchOnTerm(_, v, c, l, s)) => {
let offset = read_heap_cell!(addr,
(HeapCellValueTag::Var
| HeapCellValueTag::StackVar
| HeapCellValueTag::AttrVar) => {
v
}
(HeapCellValueTag::PStrLoc
| HeapCellValueTag::Lis
| HeapCellValueTag::CStr) => {
l
}
(HeapCellValueTag::Fixnum
| HeapCellValueTag::Char
| HeapCellValueTag::F64) => {
c
}
(HeapCellValueTag::Atom, (_name, arity)) => {
// if arity == 0 { c } else { s }
debug_assert!(arity == 0);
c
}
(HeapCellValueTag::Str) => {
s
}
(HeapCellValueTag::Cons, ptr) => {
match ptr.get_tag() {
ArenaHeaderTag::Rational | ArenaHeaderTag::Integer |
ArenaHeaderTag::F64 => {
c
}
_ => {
IndexingCodePtr::Fail
}
}
}
_ => {
unreachable!();
}
);
match offset {
IndexingCodePtr::Fail => {
self.fail = true;
break;
}
IndexingCodePtr::DynamicExternal(o) => {
// either points directly to a
// DynamicInternalElse, or just ahead of
// one. Or neither!
let p = self.p.local().abs_loc();
if !dynamic_external_of_clause_is_valid(self, &code_repo.code, p + o) {
self.fail = true;
} else {
self.p += o;
}
break;
}
IndexingCodePtr::External(o) => {
self.p += o;
break;
}
IndexingCodePtr::Internal(o) => {
index += o;
}
}
}
&IndexingLine::Indexing(IndexingInstruction::SwitchOnConstant(ref hm)) => {
let lit = read_heap_cell!(addr,
(HeapCellValueTag::Char, c) => {
Literal::Char(c)
}
(HeapCellValueTag::Fixnum, n) => {
Literal::Fixnum(n)
}
(HeapCellValueTag::F64, f) => {
Literal::Float(f)
}
(HeapCellValueTag::Atom, (atom, arity)) => {
debug_assert_eq!(arity, 0);
Literal::Atom(atom)
}
(HeapCellValueTag::Cons, cons_ptr) => {
match_untyped_arena_ptr!(cons_ptr,
(ArenaHeaderTag::Rational, r) => {
Literal::Rational(r)
}
(ArenaHeaderTag::F64, f) => {
Literal::Float(F64Ptr(f))
}
(ArenaHeaderTag::Integer, n) => {
Literal::Integer(n)
}
_ => {
unreachable!()
}
)
}
_ => {
unreachable!()
}
);
let offset = match hm.get(&lit) {
Some(offset) => *offset,
_ => IndexingCodePtr::Fail,
};
match offset {
IndexingCodePtr::Fail => {
self.fail = true;
break;
}
IndexingCodePtr::DynamicExternal(o) => {
// either points directly to a
// DynamicInternalElse, or just ahead of
// one. Or neither!
let p = self.p.local().abs_loc();
if !dynamic_external_of_clause_is_valid(self, &code_repo.code, p + o) {
self.fail = true;
} else {
self.p += o;
}
break;
}
IndexingCodePtr::External(o) => {
self.p += o;
break;
}
IndexingCodePtr::Internal(o) => {
index += o;
}
}
}
&IndexingLine::Indexing(IndexingInstruction::SwitchOnStructure(ref hm)) => {
let offset = read_heap_cell!(addr,
(HeapCellValueTag::Atom, (name, arity)) => {
match hm.get(&(name, arity)) {
Some(offset) => *offset,
None => IndexingCodePtr::Fail,
}
}
(HeapCellValueTag::Str, s) => {
let (name, arity) = cell_as_atom_cell!(self.heap[s]).get_name_and_arity();
match hm.get(&(name, arity)) {
Some(offset) => *offset,
None => IndexingCodePtr::Fail,
}
}
_ => {
IndexingCodePtr::Fail
}
);
match offset {
IndexingCodePtr::Fail => {
self.fail = true;
break;
}
IndexingCodePtr::DynamicExternal(o) => {
let p = self.p.local().abs_loc();
if !dynamic_external_of_clause_is_valid(self, &code_repo.code, p + o) {
self.fail = true;
} else {
self.p += o;
}
break;
}
IndexingCodePtr::External(o) => {
self.p += o;
break;
}
IndexingCodePtr::Internal(o) => {
index += o;
}
}
}
&IndexingLine::IndexedChoice(_) => {
if let LocalCodePtr::DirEntry(p) = self.p.local() {
self.p = CodePtr::Local(LocalCodePtr::IndexingBuf(p, index, 0));
} else {
unreachable!()
}
break;
}
&IndexingLine::DynamicIndexedChoice(_) => {
self.dynamic_mode = FirstOrNext::First;
if let LocalCodePtr::DirEntry(p) = self.p.local() {
self.p = CodePtr::Local(LocalCodePtr::IndexingBuf(p, index, 0));
} else {
unreachable!()
}
break;
}
}
}
}
pub(super) fn execute_query_instr(&mut self, instr: &QueryInstruction) {
match instr {
&QueryInstruction::GetVariable(norm, arg) => {
self[norm] = self.registers[arg];
}
&QueryInstruction::PutConstant(_, c, reg) => {
self[reg] = c;
}
&QueryInstruction::PutList(_, reg) => {
self[reg] = list_loc_as_cell!(self.heap.len());
}
&QueryInstruction::PutPartialString(_, string, reg, has_tail) => {
let pstr_addr = if has_tail {
if string != atom!("") {
let h = self.heap.len();
self.heap.push(string_as_pstr_cell!(string));
// the tail will be pushed by the next
// instruction, so don't push one here.
pstr_loc_as_cell!(h)
} else {
empty_list_as_cell!()
}
} else {
string_as_cstr_cell!(string)
};
self[reg] = pstr_addr;
}
&QueryInstruction::PutStructure(ref ct, arity, reg) => {
let h = self.heap.len();
self.heap.push(atom_as_cell!(ct.name(), arity));
self[reg] = str_loc_as_cell!(h);
}
&QueryInstruction::PutUnsafeValue(n, arg) => {
let s = stack_loc!(AndFrame, self.e, n);
let addr = self.store(self.deref(stack_loc_as_cell!(s)));
if addr.is_protected(self.e) {
self.registers[arg] = addr;
} else {
let h = self.heap.len();
self.heap.push(heap_loc_as_cell!(h));
(self.bind_fn)(self, Ref::heap_cell(h), addr);
self.registers[arg] = heap_loc_as_cell!(h);
}
}
&QueryInstruction::PutValue(norm, arg) => {
self.registers[arg] = self[norm];
}
&QueryInstruction::PutVariable(norm, arg) => {
match norm {
RegType::Perm(n) => {
self[norm] = stack_loc_as_cell!(AndFrame, self.e, n);
self.registers[arg] = self[norm];
}
RegType::Temp(_) => {
let h = self.heap.len();
self.heap.push(heap_loc_as_cell!(h));
self[norm] = heap_loc_as_cell!(h);
self.registers[arg] = heap_loc_as_cell!(h);
}
};
}
&QueryInstruction::SetConstant(c) => {
self.heap.push(c);
}
&QueryInstruction::SetLocalValue(reg) => {
let addr = self.deref(self[reg]);
let h = self.heap.len();
if addr < Ref::heap_cell(h) {
self.heap.push(addr);
return;
}
self.heap.push(heap_loc_as_cell!(h));
(self.bind_fn)(self, Ref::heap_cell(h), addr);
}
&QueryInstruction::SetVariable(reg) => {
let h = self.heap.len();
self.heap.push(heap_loc_as_cell!(h));
self[reg] = heap_loc_as_cell!(h);
}
&QueryInstruction::SetValue(reg) => {
let heap_val = self.store(self[reg]);
self.heap.push(heap_val);
}
&QueryInstruction::SetVoid(n) => {
let h = self.heap.len();
for i in h..h + n {
self.heap.push(heap_loc_as_cell!(i));
}
}
}
}
pub(super) fn handle_internal_call_n(&mut self, arity: usize) {
let arity = arity + 1;
let pred = self.registers[1];
for i in 2..arity {
self.registers[i - 1] = self.registers[i];
}
if arity > 1 {
self.registers[arity - 1] = pred;
return;
}
self.fail = true;
}
pub(super) fn setup_call_n(&mut self, arity: usize) -> Option<PredicateKey> {
let addr = self.store(self.deref(self.registers[arity]));
let (name, narity) = read_heap_cell!(addr,
(HeapCellValueTag::Str, s) => {
let (name, narity) = cell_as_atom_cell!(self.heap[s]).get_name_and_arity();
if narity + arity > MAX_ARITY {
let stub = functor_stub(atom!("call"), arity + 1);
let err = self.representation_error(RepFlag::MaxArity);
let representation_error = self.error_form(err, stub);
self.throw_exception(representation_error);
return None;
}
for i in (1..arity).rev() {
self.registers[i + narity] = self.registers[i];
}
for i in 1..narity + 1 {
self.registers[i] = self.heap[s + i];
}
(name, narity)
}
(HeapCellValueTag::Atom, (name, arity)) => {
if arity == 0 {
(name, 0)
} else {
self.fail = true;
return None;
}
}
(HeapCellValueTag::Char, c) => {
(self.atom_tbl.build_with(&c.to_string()), 0)
}
(HeapCellValueTag::Var | HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar, _h) => {
let stub = functor_stub(atom!("call"), arity + 1);
let err = self.instantiation_error();
let instantiation_error = self.error_form(err, stub);
self.throw_exception(instantiation_error);
return None;
}
_ => {
let stub = functor_stub(atom!("call"), arity + 1);
let err = self.type_error(ValidType::Callable, addr);
let type_error = self.error_form(err, stub);
self.throw_exception(type_error);
return None;
}
);
Some((name, arity + narity - 1))
}
#[inline]
pub fn is_cyclic_term(&mut self, addr: HeapCellValue) -> bool {
if addr.is_constant() {
return false;
}
let mut iter = stackful_preorder_iter(&mut self.heap, addr);
while let Some(value) = iter.next() {
if value.is_forwarded() {
let value = heap_bound_store(iter.heap, heap_bound_deref(iter.heap, value));
if value.is_compound() {
return true;
}
}
}
false
}
// arg(+N, +Term, ?Arg)
pub fn try_arg(&mut self) -> CallResult {
let stub_gen = || functor_stub(atom!("arg"), 3);
let n = self.store(self.deref(self.registers[1]));
read_heap_cell!(n,
(HeapCellValueTag::Var | HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar) => {
// 8.5.2.3 a)
let err = self.instantiation_error();
return Err(self.error_form(err, stub_gen()));
}
_ => {
let n = match Number::try_from(n) {
Ok(Number::Fixnum(n)) => Number::Fixnum(n),
Ok(Number::Integer(n)) => Number::Integer(n),
_ => {
let err = self.type_error(ValidType::Integer, n);
return Err(self.error_form(err, stub_gen()));
}
};
if n < 0 {
// 8.5.2.3 e)
let err = self.domain_error(DomainErrorType::NotLessThanZero, n);
return Err(self.error_form(err, stub_gen()));
}
let n = match n {
Number::Fixnum(n) => n.get_num() as usize,
Number::Integer(n) => n.to_usize().unwrap(),
_ => {
self.fail = true;
return Ok(());
}
};
let term = self.deref(self.registers[2]);
read_heap_cell!(self.store(term),
(HeapCellValueTag::Var | HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar) => {
let err = self.instantiation_error();
return Err(self.error_form(err, stub_gen()));
}
(HeapCellValueTag::Str, o) => {
let arity = cell_as_atom_cell!(self.heap[o]).get_arity();
if 1 <= n && n <= arity {
let a3 = self.registers[3];
unify_fn!(self, a3, heap_loc_as_cell!(o + n));
} else {
self.fail = true;
}
}
(HeapCellValueTag::Lis, l) => {
if n == 1 || n == 2 {
let a3 = self.registers[3];
unify_fn!(self, a3, heap_loc_as_cell!(l + n - 1));
} else {
self.fail = true;
}
}
(HeapCellValueTag::PStrLoc, pstr_loc) => {
if n == 1 || n == 2 {
let a3 = self.registers[3];
let (h, offset) = pstr_loc_and_offset(&self.heap, pstr_loc);
let pstr = cell_as_string!(self.heap[h]);
let offset = offset.get_num() as usize;
if let Some(c) = pstr.as_str_from(offset).chars().next() {
if n == 1 {
self.unify_char(c, a3);
} else {
let offset = (offset + c.len_utf8()) as i64;
let h_len = self.heap.len();
self.heap.push(pstr_offset_as_cell!(h_len));
self.heap.push(fixnum_as_cell!(Fixnum::build_with(offset)));
unify_fn!(self, pstr_loc_as_cell!(h_len), a3);
}
} else {
unreachable!()
}
} else {
self.fail = true;
}
}
_ => {
// 8.5.2.3 d)
let err = self.type_error(ValidType::Compound, term);
return Err(self.error_form(err, stub_gen()));
}
)
}
);
Ok(())
}
pub fn compare_numbers(&mut self, cmp: CompareNumberQT, n1: Number, n2: Number) {
let ordering = n1.cmp(&n2);
self.fail = match cmp {
CompareNumberQT::GreaterThan if ordering == Ordering::Greater => false,
CompareNumberQT::GreaterThanOrEqual if ordering != Ordering::Less => false,
CompareNumberQT::LessThan if ordering == Ordering::Less => false,
CompareNumberQT::LessThanOrEqual if ordering != Ordering::Greater => false,
CompareNumberQT::NotEqual if ordering != Ordering::Equal => false,
CompareNumberQT::Equal if ordering == Ordering::Equal => false,
_ => true,
};
self.p += 1;
}
pub fn compare_term(&mut self, qt: CompareTermQT) {
let a1 = self.registers[1];
let a2 = self.registers[2];
match compare_term_test!(self, a1, a2) {
Some(Ordering::Greater) => match qt {
CompareTermQT::GreaterThan | CompareTermQT::GreaterThanOrEqual => {}
_ => self.fail = true,
},
Some(Ordering::Equal) => match qt {
CompareTermQT::GreaterThanOrEqual | CompareTermQT::LessThanOrEqual => {}
_ => self.fail = true,
},
Some(Ordering::Less) => match qt {
CompareTermQT::LessThan | CompareTermQT::LessThanOrEqual => {}
_ => self.fail = true,
},
None => {
self.fail = true;
}
}
}
// returns true on failure, false on success.
pub fn eq_test(&mut self, h1: HeapCellValue, h2: HeapCellValue) -> bool {
if h1 == h2 {
return false;
}
compare_term_test!(self, h1, h2)
.map(|o| o != Ordering::Equal)
.unwrap_or(true)
}
pub fn reset_block(&mut self, addr: HeapCellValue) {
read_heap_cell!(self.store(addr),
(HeapCellValueTag::Fixnum, n) => {
self.block = n.get_num() as usize;
}
_ => {
self.fail = true;
}
)
}
pub fn execute_inlined(&mut self, inlined: &InlinedClauseType) {
match inlined {
&InlinedClauseType::CompareNumber(cmp, ref at_1, ref at_2) => {
let n1 = try_or_fail!(self, self.get_number(at_1));
let n2 = try_or_fail!(self, self.get_number(at_2));
self.compare_numbers(cmp, n1, n2);
}
&InlinedClauseType::IsAtom(r1) => {
let d = self.store(self.deref(self[r1]));
read_heap_cell!(d,
(HeapCellValueTag::Atom, (_name, arity)) => {
if arity == 0 {
self.p += 1;
} else {
self.fail = true;
}
}
(HeapCellValueTag::Char) => {
self.p += 1;
}
_ => {
self.fail = true;
}
);
}
&InlinedClauseType::IsAtomic(r1) => {
let d = self.store(self.deref(self[r1]));
read_heap_cell!(d,
(HeapCellValueTag::Char | HeapCellValueTag::Fixnum | HeapCellValueTag::F64 |
HeapCellValueTag::Cons) => {
self.p += 1;
}
(HeapCellValueTag::Atom, (_name, arity)) => {
if arity == 0 {
self.p += 1;
} else {
self.fail = true;
}
}
_ => {
self.fail = true;
}
);
}
&InlinedClauseType::IsInteger(r1) => {
let d = self.store(self.deref(self[r1]));
match Number::try_from(d) {
Ok(Number::Fixnum(_)) => {
self.p += 1;
}
Ok(Number::Integer(_)) => {
self.p += 1;
}
Ok(Number::Rational(n)) => {
if n.denom() == &1 {
self.p += 1;
} else {
self.fail = true;
}
}
_ => {
self.fail = true;
}
}
}
&InlinedClauseType::IsCompound(r1) => {
let d = self.store(self.deref(self[r1]));
read_heap_cell!(d,
(HeapCellValueTag::Str | HeapCellValueTag::Lis |
HeapCellValueTag::PStrLoc | HeapCellValueTag::CStr) => {
self.p += 1;
}
(HeapCellValueTag::Atom, (_name, arity)) => {
if arity > 0 {
self.p += 1;
} else {
self.fail = true;
}
}
_ => {
self.fail = true;
}
);
}
&InlinedClauseType::IsFloat(r1) => {
let d = self.store(self.deref(self[r1]));
match Number::try_from(d) {
Ok(Number::Float(_)) => {
self.p += 1;
}
_ => {
self.fail = true;
}
}
}
&InlinedClauseType::IsNumber(r1) => {
let d = self.store(self.deref(self[r1]));
match Number::try_from(d) {
Ok(Number::Fixnum(_)) => {
self.p += 1;
}
Ok(Number::Integer(_)) => {
self.p += 1;
}
Ok(Number::Rational(n)) => {
if n.denom() == &1 {
self.p += 1;
} else {
self.fail = true;
}
}
Ok(Number::Float(_)) => {
self.p += 1;
}
_ => {
self.fail = true;
}
}
}
&InlinedClauseType::IsRational(r1) => {
let d = self.store(self.deref(self[r1]));
read_heap_cell!(d,
(HeapCellValueTag::Cons, ptr) => {
match_untyped_arena_ptr!(ptr,
(ArenaHeaderTag::Rational, _r) => {
self.p += 1;
}
_ => {
self.fail = true;
}
);
}
_ => {
self.fail = true;
}
);
}
&InlinedClauseType::IsNonVar(r1) => {
let d = self.store(self.deref(self[r1]));
match d.get_tag() {
HeapCellValueTag::AttrVar
| HeapCellValueTag::Var
| HeapCellValueTag::StackVar => {
self.fail = true;
}
_ => {
self.p += 1;
}
}
}
&InlinedClauseType::IsVar(r1) => {
let d = self.store(self.deref(self[r1]));
match d.get_tag() {
HeapCellValueTag::AttrVar
| HeapCellValueTag::Var
| HeapCellValueTag::StackVar => {
self.p += 1;
}
_ => {
self.fail = true;
}
}
}
}
}
#[inline(always)]
fn try_functor_compound_case(&mut self, name: Atom, arity: usize) {
self.try_functor_unify_components(atom_as_cell!(name), arity);
}
fn try_functor_unify_components(&mut self, name: HeapCellValue, arity: usize) {
let a2 = self.deref(self.registers[2]);
self.write_literal_to_var(a2, name);
if !self.fail {
let a3 = self.store(self.deref(self.registers[3]));
self.unify_fixnum(Fixnum::build_with(arity as i64), a3);
}
}
fn try_functor_fabricate_struct(&mut self, name: Atom, arity: usize, r: Ref) {
let h = self.heap.len();
let f_a = if name == atom!(".") && arity == 2 {
self.heap.push(heap_loc_as_cell!(h));
self.heap.push(heap_loc_as_cell!(h+1));
list_loc_as_cell!(h)
} else {
self.heap.push(atom_as_cell!(name, arity));
for i in 0..arity {
self.heap.push(heap_loc_as_cell!(h + i + 1));
}
str_loc_as_cell!(h)
};
(self.bind_fn)(self, r, f_a);
}
pub fn try_functor(&mut self) -> CallResult {
let stub_gen = || functor_stub(atom!("functor"), 3);
let a1 = self.store(self.deref(self.registers[1]));
read_heap_cell!(a1,
(HeapCellValueTag::Cons | HeapCellValueTag::Char | HeapCellValueTag::Fixnum |
HeapCellValueTag::F64) => {
self.try_functor_unify_components(a1, 0);
}
(HeapCellValueTag::Atom, (_name, arity)) => {
debug_assert_eq!(arity, 0);
self.try_functor_unify_components(a1, 0);
}
(HeapCellValueTag::Str, s) => {
let (name, arity) = cell_as_atom_cell!(self.heap[s]).get_name_and_arity();
self.try_functor_compound_case(name, arity);
}
(HeapCellValueTag::Lis | HeapCellValueTag::PStrOffset) => {
self.try_functor_compound_case(atom!("."), 2);
}
(HeapCellValueTag::Var | HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar) => {
let deref_name = self.deref(self.registers[2]);
let store_name = self.store(deref_name);
let arity = self.store(self.deref(self.registers[3]));
if store_name.is_var() || arity.is_var() {
// 8.5.1.3 a) & 8.5.1.3 b)
let err = self.instantiation_error();
return Err(self.error_form(err, stub_gen()));
}
let arity = match Number::try_from(arity) {
Ok(Number::Fixnum(n)) => Some(n.get_num()),
Ok(Number::Integer(n)) => n.to_i64(),
Ok(Number::Rational(n)) if n.denom() == &1 => n.numer().to_i64(),
_ => {
let err = self.type_error(ValidType::Integer, arity);
return Err(self.error_form(err, stub_gen()));
}
};
let arity = match arity {
Some(arity) => arity,
None => {
self.fail = true;
return Ok(());
}
};
if arity > MAX_ARITY as i64 {
// 8.5.1.3 f)
let err = self.representation_error(RepFlag::MaxArity);
return Err(self.error_form(err, stub_gen()));
} else if arity < 0 {
// 8.5.1.3 g)
let arity = Number::Fixnum(Fixnum::build_with(arity));
let err = self.domain_error(DomainErrorType::NotLessThanZero, arity);
return Err(self.error_form(err, stub_gen()));
}
read_heap_cell!(store_name,
(HeapCellValueTag::Cons | HeapCellValueTag::Char | HeapCellValueTag::Fixnum |
HeapCellValueTag::F64) if arity == 0 => {
self.bind(a1.as_var().unwrap(), deref_name);
}
(HeapCellValueTag::Atom, (name, atom_arity)) => {
debug_assert_eq!(atom_arity, 0);
self.try_functor_fabricate_struct(
name,
arity as usize,
a1.as_var().unwrap(),
);
}
(HeapCellValueTag::Char, c) => {
let c = self.atom_tbl.build_with(&c.to_string());
self.try_functor_fabricate_struct(
c,
arity as usize,
a1.as_var().unwrap(),
);
}
_ => {
let err = self.type_error(ValidType::Atomic, store_name);
return Err(self.error_form(err, stub_gen()));
} // 8.5.1.3 c)
);
}
_ => {
self.fail = true;
}
);
Ok(())
}
pub fn try_from_list(
&mut self,
value: HeapCellValue,
stub_gen: impl Fn() -> FunctorStub,
) -> Result<Vec<HeapCellValue>, MachineStub> {
let deref_v = self.deref(value);
let store_v = self.store(deref_v);
read_heap_cell!(store_v,
(HeapCellValueTag::Lis, l) => {
self.try_from_inner_list(vec![], l, stub_gen, store_v)
}
(HeapCellValueTag::PStrLoc, h) => {
self.try_from_partial_string(vec![], h, stub_gen, store_v)
}
(HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar | HeapCellValueTag::Var) => {
let err = self.instantiation_error();
Err(self.error_form(err, stub_gen()))
}
(HeapCellValueTag::Atom, (name, arity)) => {
if name == atom!("[]") && arity == 0 {
Ok(vec![])
} else {
let err = self.type_error(ValidType::List, store_v);
Err(self.error_form(err, stub_gen()))
}
}
(HeapCellValueTag::CStr, cstr_atom) => {
let cstr = cstr_atom.as_str();
Ok(cstr.chars().map(|c| char_as_cell!(c)).collect())
}
_ => {
let err = self.type_error(ValidType::List, store_v);
Err(self.error_form(err, stub_gen()))
}
)
}
fn try_from_inner_list(
&mut self,
mut result: Vec<HeapCellValue>,
mut l: usize,
stub_gen: impl Fn() -> FunctorStub,
a1: HeapCellValue,
) -> Result<Vec<HeapCellValue>, MachineStub> {
result.push(self.heap[l]);
l += 1;
loop {
let deref_v = self.deref(self.heap[l]);
let store_v = self.store(self.heap[l]);
read_heap_cell!(store_v,
(HeapCellValueTag::Lis, hcp) => {
result.push(self.heap[hcp]);
l = hcp + 1;
}
(HeapCellValueTag::PStrOffset) => {
return self.try_from_partial_string(result, deref_v.get_value(), stub_gen, a1);
}
(HeapCellValueTag::Atom, (name, arity)) => {
if name == atom!("[]") && arity == 0 {
break;
} else {
let err = self.type_error(ValidType::List, a1);
return Err(self.error_form(err, stub_gen()));
}
}
_ => {
if store_v.is_var() {
let err = self.instantiation_error();
return Err(self.error_form(err, stub_gen()));
} else {
let err = self.type_error(ValidType::List, a1);
return Err(self.error_form(err, stub_gen()));
}
}
);
}
Ok(result)
}
fn try_from_partial_string(
&mut self,
mut chars: Vec<HeapCellValue>,
h: usize,
stub_gen: impl Fn() -> FunctorStub,
a1: HeapCellValue,
) -> Result<Vec<HeapCellValue>, MachineStub> {
let mut heap_pstr_iter = HeapPStrIter::new(&self.heap, h);
while let Some(iteratee) = heap_pstr_iter.next() {
match iteratee {
PStrIteratee::Char(_, c) =>
chars.push(char_as_cell!(c)),
PStrIteratee::PStrSegment(_, pstr_atom, n) => {
let pstr = PartialString::from(pstr_atom);
chars.extend(pstr.as_str_from(n).chars().map(|c| char_as_cell!(c)));
}
}
}
match self.heap[h].get_tag() {
HeapCellValueTag::PStr => {
if heap_pstr_iter.at_string_terminator() {
Ok(chars)
} else {
read_heap_cell!(self.heap[heap_pstr_iter.focus()],
(HeapCellValueTag::Lis, l) => {
self.try_from_inner_list(chars, l, stub_gen, a1)
}
(HeapCellValueTag::Atom, (name, arity)) => {
if name == atom!(".") && arity == 2 {
let l = heap_pstr_iter.focus() + 1;
self.try_from_inner_list(chars, l, stub_gen, a1)
} else {
let err = self.type_error(ValidType::List, a1);
Err(self.error_form(err, stub_gen()))
}
}
_ => {
let err = self.type_error(ValidType::List, a1);
Err(self.error_form(err, stub_gen()))
}
)
}
}
HeapCellValueTag::CStr => Ok(chars),
_ => {
unreachable!()
}
}
}
// returns true on failure.
pub fn ground_test(&mut self) -> bool {
if self.registers[1].is_constant() {
return false;
}
let value = self.registers[1];
for v in stackful_preorder_iter(&mut self.heap, value) {
if v.is_var() {
return true;
}
}
false
}
pub fn integers_to_bytevec(
&mut self,
value: HeapCellValue,
stub_gen: impl Fn() -> FunctorStub,
) -> Vec<u8> {
let mut bytes: Vec<u8> = Vec::new();
match self.try_from_list(value, stub_gen) {
Err(_) => {
unreachable!()
}
Ok(addrs) => {
for addr in addrs {
let addr = self.store(self.deref(addr));
match Number::try_from(addr) {
Ok(Number::Fixnum(n)) => match u8::try_from(n.get_num()) {
Ok(b) => bytes.push(b),
Err(_) => {}
},
Ok(Number::Integer(n)) => {
if let Some(b) = n.to_u8() {
bytes.push(b);
}
}
_ => {}
}
}
}
}
bytes
}
// see 8.4.4.3 of Draft Technical Corrigendum 2 for an error guide.
pub fn project_onto_key(&mut self, value: HeapCellValue) -> Result<HeapCellValue, MachineStub> {
let stub_gen = || functor_stub(atom!("keysort"), 2);
let store_v = self.store(self.deref(value));
if store_v.is_var() {
let err = self.instantiation_error();
return Err(self.error_form(err, stub_gen()));
}
read_heap_cell!(store_v,
(HeapCellValueTag::Str, s) => {
let (name, arity) = cell_as_atom_cell!(self.heap[s]).get_name_and_arity();
if name == atom!("-") && arity == 2 {
Ok(heap_loc_as_cell!(s + 1))
} else {
let err = self.type_error(ValidType::Pair, self.heap[s]);
Err(self.error_form(err, stub_gen()))
}
}
_ => {
let err = self.type_error(ValidType::Pair, store_v);
Err(self.error_form(err, stub_gen()))
}
)
}
pub fn setup_built_in_call(&mut self, ct: BuiltInClauseType) {
self.num_of_args = ct.arity();
self.b0 = self.b;
self.p = CodePtr::BuiltInClause(ct, self.p.local());
}
pub fn deallocate(&mut self) {
let e = self.e;
let frame = self.stack.index_and_frame(e);
self.cp = frame.prelude.cp;
self.e = frame.prelude.e;
if e > self.b {
self.stack.truncate(e);
}
self.p += 1;
}
fn throw_interrupt_exception(&mut self) {
let err = self.interrupt_error();
let src = functor_stub(atom!("repl"), 0);
let err = self.error_form(err, src);
self.throw_exception(err);
}
fn handle_call_clause(
&mut self,
indices: &mut IndexStore,
code_repo: &CodeRepo,
call_policy: &mut Box<dyn CallPolicy>,
cut_policy: &mut Box<dyn CutPolicy>,
current_input_stream: &mut Stream,
current_output_stream: &mut Stream,
ct: &ClauseType,
arity: usize,
lco: bool,
use_default_cp: bool,
) {
let interrupted = INTERRUPT.load(std::sync::atomic::Ordering::Relaxed);
match INTERRUPT.compare_exchange(
interrupted,
false,
std::sync::atomic::Ordering::Relaxed,
std::sync::atomic::Ordering::Relaxed,
) {
Ok(interruption) => {
if interruption {
self.throw_interrupt_exception();
return;
}
}
Err(_) => unreachable!(),
}
let mut default_call_policy: Box<dyn CallPolicy> = Box::new(DefaultCallPolicy {});
let call_policy = if use_default_cp {
&mut default_call_policy
} else {
call_policy
};
self.last_call = lco;
match ct {
&ClauseType::BuiltIn(ref ct) => try_or_fail!(
self,
call_policy.call_builtin(
self,
ct,
&indices.code_dir,
&indices.op_dir,
&indices.stream_aliases,
)
),
&ClauseType::CallN => try_or_fail!(
self,
call_policy.call_n(
self,
arity,
&indices.code_dir,
&indices.op_dir,
&indices.stream_aliases,
)
),
&ClauseType::Inlined(ref ct) => {
self.execute_inlined(ct);
if lco {
self.p = CodePtr::Local(self.cp);
}
}
&ClauseType::Named(ref name, _, ref idx) => {
try_or_fail!(self, call_policy.context_call(self, *name, arity, idx))
}
&ClauseType::System(ref ct) => try_or_fail!(
self,
self.system_call(
ct,
code_repo,
indices,
call_policy,
cut_policy,
current_input_stream,
current_output_stream,
)
),
};
self.last_call = false;
}
pub fn execute_ctrl_instr(
&mut self,
indices: &mut IndexStore,
code_repo: &CodeRepo,
call_policy: &mut Box<dyn CallPolicy>,
cut_policy: &mut Box<dyn CutPolicy>,
current_input_stream: &mut Stream,
current_output_stream: &mut Stream,
instr: &ControlInstruction,
) {
match instr {
&ControlInstruction::Allocate(num_cells) => {
self.allocate(num_cells);
}
&ControlInstruction::CallClause(ref ct, arity, _, lco, use_default_cp) => self
.handle_call_clause(
indices,
code_repo,
call_policy,
cut_policy,
current_input_stream,
current_output_stream,
ct,
arity,
lco,
use_default_cp,
),
&ControlInstruction::Deallocate => self.deallocate(),
&ControlInstruction::JmpBy(arity, offset, _, lco) => {
if !lco {
self.cp.assign_if_local(self.p.clone() + 1);
}
self.num_of_args = arity;
self.b0 = self.b;
self.p += offset;
}
&ControlInstruction::RevJmpBy(offset) => {
self.p -= offset;
}
&ControlInstruction::Proceed => {
self.p = CodePtr::Local(self.cp);
}
};
}
pub(super) fn execute_dynamic_indexed_choice_instr(
&mut self,
code_repo: &CodeRepo,
call_policy: &mut Box<dyn CallPolicy>,
global_variables: &mut GlobalVarDir,
) {
let p = self.p.local();
match code_repo.find_living_dynamic(p, self.cc) {
Some((offset, oi, ii, is_next_clause)) => {
self.p = CodePtr::Local(LocalCodePtr::IndexingBuf(p.abs_loc(), oi, ii));
match self.dynamic_mode {
FirstOrNext::First if !is_next_clause => {
self.p = CodePtr::Local(LocalCodePtr::DirEntry(p.abs_loc() + offset));
}
FirstOrNext::First => {
// there's a leading DynamicElse that sets self.cc.
// self.cc = self.global_clock;
match code_repo.find_living_dynamic(
LocalCodePtr::IndexingBuf(p.abs_loc(), oi, ii + 1),
self.cc,
) {
Some(_) => {
self.registers[self.num_of_args + 1] =
fixnum_as_cell!(Fixnum::build_with(self.cc as i64));
self.num_of_args += 1;
self.execute_indexed_choice_instr(
&IndexedChoiceInstruction::Try(offset),
call_policy,
global_variables,
);
self.num_of_args -= 1;
}
None => {
self.p =
CodePtr::Local(LocalCodePtr::DirEntry(p.abs_loc() + offset));
}
}
}
FirstOrNext::Next => {
let n = self
.stack
.index_or_frame(self.b)
.prelude
.univ_prelude
.num_cells;
self.cc = cell_as_fixnum!(self.stack[n - 1]).get_num() as usize;
if is_next_clause {
match code_repo.find_living_dynamic(
LocalCodePtr::IndexingBuf(p.abs_loc(), oi, ii + 1),
self.cc,
) {
Some(_) => {
try_or_fail!(
self,
call_policy.retry(self, offset, global_variables,)
)
}
None => {
try_or_fail!(
self,
call_policy.trust(self, offset, global_variables,)
)
}
}
} else {
try_or_fail!(self, call_policy.trust(self, offset, global_variables))
}
}
}
}
None => {
self.fail = true;
}
}
self.dynamic_mode = FirstOrNext::Next;
}
pub(super) fn execute_indexed_choice_instr(
&mut self,
instr: &IndexedChoiceInstruction,
call_policy: &mut Box<dyn CallPolicy>,
global_variables: &mut GlobalVarDir,
) {
match instr {
&IndexedChoiceInstruction::Try(offset) => {
let n = self.num_of_args;
let b = self.stack.allocate_or_frame(n);
let or_frame = self.stack.index_or_frame_mut(b);
or_frame.prelude.univ_prelude.num_cells = n;
or_frame.prelude.e = self.e;
or_frame.prelude.cp = self.cp;
or_frame.prelude.b = self.b;
or_frame.prelude.bp = self.p.local() + 1;
or_frame.prelude.tr = self.tr;
or_frame.prelude.h = self.heap.len();
or_frame.prelude.b0 = self.b0;
self.b = b;
for i in 1..n + 1 {
self.stack.index_or_frame_mut(b)[i - 1] = self.registers[i];
}
self.hb = self.heap.len();
self.p = CodePtr::Local(dir_entry!(self.p.local().abs_loc() + offset));
}
&IndexedChoiceInstruction::Retry(l) => {
try_or_fail!(self, call_policy.retry(self, l, global_variables));
}
&IndexedChoiceInstruction::Trust(l) => {
try_or_fail!(self, call_policy.trust(self, l, global_variables));
}
};
}
pub(super) fn execute_choice_instr(
&mut self,
instr: &ChoiceInstruction,
code_repo: &CodeRepo,
call_policy: &mut Box<dyn CallPolicy>,
global_variables: &mut GlobalVarDir,
) {
match instr {
&ChoiceInstruction::DynamicElse(..) => {
if let FirstOrNext::First = self.dynamic_mode {
self.cc = self.global_clock;
}
let p = self.p.local().abs_loc();
match code_repo.find_living_dynamic_else(p, self.cc) {
Some((p, next_i)) => {
self.p = CodePtr::Local(LocalCodePtr::DirEntry(p));
match self.dynamic_mode {
FirstOrNext::First if next_i == 0 => {
self.p = CodePtr::Local(LocalCodePtr::DirEntry(p + 1));
}
FirstOrNext::First => {
self.cc = self.global_clock;
match code_repo.find_living_dynamic_else(p + next_i, self.cc) {
Some(_) => {
self.registers[self.num_of_args + 1] =
fixnum_as_cell!(Fixnum::build_with(self.cc as i64));
self.num_of_args += 1;
self.execute_choice_instr(
&ChoiceInstruction::TryMeElse(next_i),
code_repo,
call_policy,
global_variables,
);
self.num_of_args -= 1;
}
None => {
self.p += 1;
}
}
}
FirstOrNext::Next => {
let n = self
.stack
.index_or_frame(self.b)
.prelude
.univ_prelude
.num_cells;
self.cc = cell_as_fixnum!(self.stack.index_or_frame(self.b)[n - 1])
.get_num() as usize;
if next_i > 0 {
match code_repo.find_living_dynamic_else(p + next_i, self.cc) {
Some(_) => {
try_or_fail!(
self,
call_policy.retry_me_else(
self,
next_i,
global_variables,
)
)
}
None => {
try_or_fail!(
self,
call_policy.trust_me(self, global_variables)
)
}
}
} else {
try_or_fail!(self, call_policy.trust_me(self, global_variables))
}
}
}
}
None => {
self.fail = true;
}
}
self.dynamic_mode = FirstOrNext::Next;
}
&ChoiceInstruction::DynamicInternalElse(..) => {
let p = self.p.local().abs_loc();
match code_repo.find_living_dynamic_else(p, self.cc) {
Some((p, next_i)) => {
self.p = CodePtr::Local(LocalCodePtr::DirEntry(p));
match self.dynamic_mode {
FirstOrNext::First if next_i == 0 => {
self.p = CodePtr::Local(LocalCodePtr::DirEntry(p + 1));
}
FirstOrNext::First => {
match code_repo.find_living_dynamic_else(p + next_i, self.cc) {
Some(_) => {
self.registers[self.num_of_args + 1] =
fixnum_as_cell!(Fixnum::build_with(self.cc as i64));
self.num_of_args += 1;
self.execute_choice_instr(
&ChoiceInstruction::TryMeElse(next_i),
code_repo,
call_policy,
global_variables,
);
self.num_of_args -= 1;
}
None => {
self.p += 1;
}
}
}
FirstOrNext::Next => {
let n = self
.stack
.index_or_frame(self.b)
.prelude
.univ_prelude
.num_cells;
self.cc = cell_as_fixnum!(self.stack.index_or_frame(self.b)[n - 1])
.get_num() as usize;
if next_i > 0 {
match code_repo.find_living_dynamic_else(p + next_i, self.cc) {
Some(_) => {
try_or_fail!(
self,
call_policy.retry_me_else(
self,
next_i,
global_variables,
)
)
}
None => {
try_or_fail!(
self,
call_policy.trust_me(self, global_variables,)
)
}
}
} else {
try_or_fail!(
self,
call_policy.trust_me(self, global_variables,)
)
}
}
}
}
None => {
self.fail = true;
}
}
self.dynamic_mode = FirstOrNext::Next;
}
&ChoiceInstruction::TryMeElse(offset) => {
let n = self.num_of_args;
let b = self.stack.allocate_or_frame(n);
let or_frame = self.stack.index_or_frame_mut(b);
or_frame.prelude.univ_prelude.num_cells = n;
or_frame.prelude.e = self.e;
or_frame.prelude.cp = self.cp;
or_frame.prelude.b = self.b;
or_frame.prelude.bp = self.p.local() + offset;
or_frame.prelude.tr = self.tr;
or_frame.prelude.h = self.heap.len();
or_frame.prelude.b0 = self.b0;
self.b = b;
for i in 1..n + 1 {
self.stack.index_or_frame_mut(b)[i - 1] = self.registers[i];
}
self.hb = self.heap.len();
self.p += 1;
}
&ChoiceInstruction::DefaultRetryMeElse(offset) => {
let mut call_policy = DefaultCallPolicy {};
try_or_fail!(
self,
call_policy.retry_me_else(self, offset, global_variables)
)
}
&ChoiceInstruction::DefaultTrustMe(_) => {
let mut call_policy = DefaultCallPolicy {};
try_or_fail!(self, call_policy.trust_me(self, global_variables))
}
&ChoiceInstruction::RetryMeElse(offset) => {
try_or_fail!(
self,
call_policy.retry_me_else(self, offset, global_variables)
)
}
&ChoiceInstruction::TrustMe(_) => {
try_or_fail!(self, call_policy.trust_me(self, global_variables))
}
}
}
pub(super) fn execute_cut_instr(
&mut self,
instr: &CutInstruction,
cut_policy: &mut Box<dyn CutPolicy>,
) {
match instr {
&CutInstruction::NeckCut => {
let b = self.b;
let b0 = self.b0;
if b > b0 {
self.b = b0;
if b > self.e {
self.stack.truncate(b);
}
}
self.p += 1;
}
&CutInstruction::GetLevel(r) => {
let b0 = self.b0;
self[r] = fixnum_as_cell!(Fixnum::build_with(b0 as i64));
self.p += 1;
}
&CutInstruction::GetLevelAndUnify(r) => {
let b0 = self[perm_v!(1)];
let a = self[r];
unify_fn!(self, a, b0);
self.p += 1;
}
&CutInstruction::Cut(r) => {
if !cut_policy.cut(self, r) {
self.p += 1;
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink