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

use OffsetTableImpl without synchronization by default

Browse Source
This commit is contained in:
Mark Thom
2025-05-22 23:49:57 -07:00
committed by Mark Thom
parent 725def07cd
commit 1332611f83
28 changed files with 1005 additions and 990 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/machine/arithmetic_ops.rs
View File

@@ -1124,7 +1124,7 @@ impl MachineState {
&ArithmeticTerm::Reg(r) => {
let value = self.store(self.deref(self[r]));
match Number::try_from(value) {
match Number::try_from((value, &self.arena.f64_tbl)) {
Ok(n) => Ok(n),
Err(_) => {
self.heap[0] = value;
@@ -1388,7 +1388,8 @@ impl MachineState {
(HeapCellValueTag::Fixnum, n) => {
self.interms.push(Number::Fixnum(n));
}
(HeapCellValueTag::F64, fl) => {
(HeapCellValueTag::F64Offset, offset) => {
let fl = self.arena.f64_tbl.lookup(offset);
self.interms.push(Number::Float(*fl));
}
(HeapCellValueTag::Cons, ptr) => {

96
src/machine/compile.rs
View File

@@ -700,31 +700,25 @@ fn remove_non_leading_clause(
}
}
fn finalize_retract(
fn finalize_retract<'a, LS: LoadState<'a>>(
payload: &mut <LS as LoadState<'a>>::LoaderFieldType,
key: PredicateKey,
compilation_target: CompilationTarget,
skeleton: &mut PredicateSkeleton,
code_index: CodeIndex,
target_pos: usize,
index_ptr_opt: Option<IndexPtr>,
retraction_info: &mut RetractionInfo,
) -> usize {
let clause_clause_loc = delete_from_skeleton(
compilation_target,
key,
skeleton,
target_pos,
retraction_info,
&mut payload.retraction_info,
);
if let Some(index_ptr) = index_ptr_opt {
set_code_index(
retraction_info,
&compilation_target,
key,
code_index,
index_ptr,
);
set_code_index::<LS>(payload, &compilation_target, key, code_index, index_ptr);
}
clause_clause_loc
@@ -1239,7 +1233,9 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
let mut preprocessor = Preprocessor::new(settings);
let clause = preprocessor.try_term_to_tl(self, term)?;
let mut cg = CodeGenerator::new(settings);
let f64_tbl = &LS::machine_st(&mut self.payload).arena.f64_tbl;
let mut cg = CodeGenerator::new(f64_tbl, settings);
let clause_code = cg.compile_predicate(vec![clause])?;
Ok(StandaloneCompileResult {
@@ -1254,7 +1250,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
mut predicates: PredicateQueue,
settings: CodeGenSettings,
) -> Result<CodeIndex, SessionError> {
let code_index = self.get_or_insert_code_index(key, predicates.compilation_target);
let code_idx = self.get_or_insert_code_index(key, predicates.compilation_target);
LS::err_on_builtin_overwrite(self, key)?;
@@ -1268,7 +1264,9 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
clauses.push(preprocessor.try_term_to_tl(self, term)?);
}
let mut cg = CodeGenerator::new(settings);
let f64_tbl = &LS::machine_st(&mut self.payload).arena.f64_tbl;
let mut cg = CodeGenerator::new(f64_tbl, settings);
let mut code = cg.compile_predicate(clauses)?;
if settings.is_extensible {
@@ -1327,9 +1325,14 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
);
}
let index_ptr = LS::machine_st(&mut self.payload)
.arena
.code_index_tbl
.lookup(code_idx.into());
print_overwrite_warning(
&predicates.compilation_target,
code_index.get(),
*index_ptr,
key,
settings.is_dynamic(),
);
@@ -1340,16 +1343,16 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
IndexPtr::index(code_ptr)
};
set_code_index(
&mut self.payload.retraction_info,
set_code_index::<LS>(
&mut self.payload,
&predicates.compilation_target,
key,
code_index,
code_idx,
index_ptr,
);
self.wam_prelude.code.extend(code);
Ok(code_index)
Ok(code_idx)
}
fn extend_local_predicate_skeleton(
@@ -1551,19 +1554,19 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
self.push_back_to_local_predicate_skeleton(&compilation_target, &key, code_len);
let code_index = self.get_or_insert_code_index(key, compilation_target);
let code_idx = self.get_or_insert_code_index(key, compilation_target);
if let Some(new_code_ptr) = result {
set_code_index(
&mut self.payload.retraction_info,
set_code_index::<LS>(
&mut self.payload,
&compilation_target,
key,
code_index,
code_idx,
new_code_ptr,
);
}
Ok(code_index)
Ok(code_idx)
}
AppendOrPrepend::Prepend => {
let clause_index_info = standalone_skeleton.clauses.pop_back().unwrap();
@@ -1593,17 +1596,17 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
self.push_front_to_local_predicate_skeleton(&compilation_target, &key, code_len);
let code_index = self.get_or_insert_code_index(key, compilation_target);
let code_idx = self.get_or_insert_code_index(key, compilation_target);
set_code_index(
&mut self.payload.retraction_info,
set_code_index::<LS>(
&mut self.payload,
&compilation_target,
key,
code_index,
code_idx,
new_code_ptr,
);
Ok(code_index)
Ok(code_idx)
}
}
}
@@ -1651,7 +1654,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
pub(super) fn retract_clause(&mut self, key: PredicateKey, target_pos: usize) -> usize {
let payload_compilation_target = self.payload.compilation_target;
let code_index = self.get_or_insert_code_index(key, payload_compilation_target);
let code_idx_offset = self.get_or_insert_code_index(key, payload_compilation_target);
let skeleton = self
.wam_prelude
@@ -1729,14 +1732,14 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
None
};
return finalize_retract(
return finalize_retract::<LS>(
&mut self.payload,
key,
payload_compilation_target,
skeleton,
code_index,
code_idx_offset,
target_pos,
index_ptr_opt,
&mut self.payload.retraction_info,
);
}
None => {
@@ -1758,14 +1761,14 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
)
};
return finalize_retract(
return finalize_retract::<LS>(
&mut self.payload,
key,
payload_compilation_target,
skeleton,
code_index,
code_idx_offset,
target_pos,
index_ptr_opt,
&mut self.payload.retraction_info,
);
}
}
@@ -1988,14 +1991,14 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
}
};
finalize_retract(
finalize_retract::<LS>(
&mut self.payload,
key,
payload_compilation_target,
skeleton,
code_index,
code_idx_offset,
target_pos,
index_ptr_opt,
&mut self.payload.retraction_info,
)
}
}
@@ -2222,18 +2225,23 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
};
let predicates = self.payload.predicates.take();
let code_index = self.compile(key, predicates, settings)?;
let offset = self.compile(key, predicates, settings)?;
if let Some(filename) = self.listing_src_file_name() {
if let Some(ref mut module) = self.wam_prelude.indices.modules.get_mut(&filename) {
let index_ptr = code_index.get();
let code_index = *module.code_dir.entry(key).or_insert(code_index);
let code_idx = LS::machine_st(&mut self.payload)
.arena
.code_index_tbl
.lookup_mut(offset.into());
set_code_index(
&mut self.payload.retraction_info,
let index_ptr = *code_idx;
let offset = *module.code_dir.entry(key).or_insert(offset);
set_code_index::<LS>(
&mut self.payload,
&CompilationTarget::Module(filename),
key,
code_index,
offset,
index_ptr,
);
}

2
src/machine/disjuncts.rs
View File

@@ -579,7 +579,7 @@ impl VariableClassifier {
mut terms,
) if terms.len() == 3 => {
if let Some(last_arg) = terms.last() {
if let Term::Literal(_, Literal::CodeIndex(_)) = last_arg {
if let Term::Literal(_, Literal::CodeIndexOffset(_)) = last_arg {
terms.pop();
state_stack.push(TraversalState::Term(Term::Clause(
Cell::default(),

80
src/machine/dispatch.rs
View File

@@ -232,13 +232,11 @@ impl MachineState {
}
(HeapCellValueTag::PStrLoc |
HeapCellValueTag::Lis) => {
// HeapCellValueTag::CStr) => {
l
}
(HeapCellValueTag::Fixnum |
HeapCellValueTag::CutPoint |
// HeapCellValueTag::Char |
HeapCellValueTag::F64) => {
HeapCellValueTag::F64Offset) => {
c
}
(HeapCellValueTag::Atom, (_name, arity)) => {
@@ -548,19 +546,33 @@ impl Machine {
let p = self.machine_st.p;
// Find the boundaries of the current predicate
self.indices.code_dir.sort_by(|_, a, _, b| a.cmp(b));
self.indices.code_dir.sort_by(|_, a, _, b| {
let a = *self.machine_st.arena.code_index_tbl.lookup((*a).into());
let b = *self.machine_st.arena.code_index_tbl.lookup((*b).into());
a.cmp(&b)
});
let predicate_idx = self
.indices
.code_dir
.binary_search_by_key(&p, |_, x| x.get().p() as usize)
.binary_search_by_key(&p, |_, x| -> usize {
self.machine_st.arena.code_index_tbl.lookup((*x).into()).p()
as usize
})
.unwrap_or_else(|x| x - 1);
let current_pred_start = self
.indices
.code_dir
.get_index(predicate_idx)
.map(|x| x.1.as_ptr().p() as usize)
.map(|idx| {
self.machine_st
.arena
.code_index_tbl
.lookup((*idx.1).into())
.p() as usize
})
.unwrap();
debug_assert!(current_pred_start <= p);
@@ -569,7 +581,13 @@ impl Machine {
.indices
.code_dir
.get_index(predicate_idx + 1)
.map(|x| x.1.as_ptr().p() as usize)
.map(|idx| {
self.machine_st
.arena
.code_index_tbl
.lookup((*idx.1).into())
.p() as usize
})
.unwrap_or(self.code.len());
debug_assert!(current_pred_end >= p);
@@ -2343,7 +2361,7 @@ impl Machine {
.store(self.machine_st.deref(self.machine_st[r]));
read_heap_cell!(d,
(HeapCellValueTag::Fixnum | HeapCellValueTag::F64 |
(HeapCellValueTag::Fixnum | HeapCellValueTag::F64Offset |
HeapCellValueTag::Cons) => {
self.machine_st.p += 1;
}
@@ -2375,7 +2393,7 @@ impl Machine {
.store(self.machine_st.deref(self.machine_st[r]));
read_heap_cell!(d,
(HeapCellValueTag::Fixnum | HeapCellValueTag::F64 |
(HeapCellValueTag::Fixnum | HeapCellValueTag::F64Offset |
HeapCellValueTag::Cons) => {
self.machine_st.p = self.machine_st.cp;
}
@@ -2472,7 +2490,7 @@ impl Machine {
.machine_st
.store(self.machine_st.deref(self.machine_st[r]));
match Number::try_from(d) {
match Number::try_from((d, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(_) | Number::Integer(_)) => {
self.machine_st.p += 1;
}
@@ -2493,7 +2511,7 @@ impl Machine {
.machine_st
.store(self.machine_st.deref(self.machine_st[r]));
match Number::try_from(d) {
match Number::try_from((d, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(_) | Number::Integer(_)) => {
self.machine_st.p = self.machine_st.cp;
}
@@ -2514,7 +2532,7 @@ impl Machine {
.machine_st
.store(self.machine_st.deref(self.machine_st[r]));
match Number::try_from(d) {
match Number::try_from((d, &self.machine_st.arena.f64_tbl)) {
Ok(_) => {
self.machine_st.p += 1;
}
@@ -2528,7 +2546,7 @@ impl Machine {
.machine_st
.store(self.machine_st.deref(self.machine_st[r]));
match Number::try_from(d) {
match Number::try_from((d, &self.machine_st.arena.f64_tbl)) {
Ok(_) => {
self.machine_st.p = self.machine_st.cp;
}
@@ -2590,7 +2608,7 @@ impl Machine {
.machine_st
.store(self.machine_st.deref(self.machine_st[r]));
match Number::try_from(d) {
match Number::try_from((d, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Float(_)) => {
self.machine_st.p += 1;
}
@@ -2604,7 +2622,7 @@ impl Machine {
.machine_st
.store(self.machine_st.deref(self.machine_st[r]));
match Number::try_from(d) {
match Number::try_from((d, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Float(_)) => {
self.machine_st.p = self.machine_st.cp;
}
@@ -2677,10 +2695,10 @@ impl Machine {
}
}
}
&Instruction::CallNamed(arity, name, ref idx) => {
let idx = idx.get();
&Instruction::CallNamed(arity, name, idx) => {
let idx = self.machine_st.arena.code_index_tbl.lookup(idx.into());
try_or_throw!(self.machine_st, self.try_call(name, arity, idx));
try_or_throw!(self.machine_st, self.try_call(name, arity, *idx));
if self.machine_st.fail {
self.machine_st.backtrack();
@@ -2688,10 +2706,10 @@ impl Machine {
increment_call_count!(self.machine_st);
}
}
&Instruction::ExecuteNamed(arity, name, ref idx) => {
let idx = idx.get();
&Instruction::ExecuteNamed(arity, name, idx) => {
let idx = self.machine_st.arena.code_index_tbl.lookup(idx.into());
try_or_throw!(self.machine_st, self.try_execute(name, arity, idx));
try_or_throw!(self.machine_st, self.try_execute(name, arity, *idx));
if self.machine_st.fail {
self.machine_st.backtrack();
@@ -2699,19 +2717,19 @@ impl Machine {
increment_call_count!(self.machine_st);
}
}
&Instruction::DefaultCallNamed(arity, name, ref idx) => {
let idx = idx.get();
&Instruction::DefaultCallNamed(arity, name, idx) => {
let idx = self.machine_st.arena.code_index_tbl.lookup(idx.into());
try_or_throw!(self.machine_st, self.try_call(name, arity, idx));
try_or_throw!(self.machine_st, self.try_call(name, arity, *idx));
if self.machine_st.fail {
self.machine_st.backtrack();
}
}
&Instruction::DefaultExecuteNamed(arity, name, ref idx) => {
let idx = idx.get();
&Instruction::DefaultExecuteNamed(arity, name, idx) => {
let idx = self.machine_st.arena.code_index_tbl.lookup(idx.into());
try_or_throw!(self.machine_st, self.try_execute(name, arity, idx));
try_or_throw!(self.machine_st, self.try_execute(name, arity, *idx));
if self.machine_st.fail {
self.machine_st.backtrack();
@@ -5251,7 +5269,7 @@ impl Machine {
let l = self.machine_st.registers[3];
let l = self.machine_st.store(self.machine_st.deref(l));
let l = match Number::try_from(l) {
let l = match Number::try_from((l, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(l)) => l.get_num() as usize,
_ => unreachable!(),
};
@@ -5259,7 +5277,7 @@ impl Machine {
let p = self.machine_st.registers[4];
let p = self.machine_st.store(self.machine_st.deref(p));
let p = match Number::try_from(p) {
let p = match Number::try_from((p, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(p)) => p.get_num() as usize,
_ => unreachable!(),
};
@@ -5297,7 +5315,7 @@ impl Machine {
let l = self.machine_st.registers[3];
let l = self.machine_st.store(self.machine_st.deref(l));
let l = match Number::try_from(l) {
let l = match Number::try_from((l, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(l)) => l.get_num() as usize,
_ => unreachable!(),
};
@@ -5305,7 +5323,7 @@ impl Machine {
let p = self.machine_st.registers[4];
let p = self.machine_st.store(self.machine_st.deref(p));
let p = match Number::try_from(p) {
let p = match Number::try_from((p, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(p)) => p.get_num() as usize,
_ => unreachable!(),
};

30
src/machine/heap.rs
View File

@@ -1,6 +1,6 @@
use crate::atom_table::*;
use crate::forms::*;
use crate::functor_macro::*;
use crate::machine::{ArenaHeaderTag, Fixnum, Integer};
use crate::types::*;
use std::alloc;
@@ -717,7 +717,7 @@ impl Heap {
pub(crate) fn slice_to_str(&self, slice_loc: usize, slice_len: usize) -> &str {
unsafe {
let slice = std::slice::from_raw_parts(self.inner.ptr.add(slice_loc), slice_len);
std::str::from_utf8_unchecked(&slice)
std::str::from_utf8_unchecked(slice)
}
}
@@ -824,7 +824,7 @@ impl Heap {
let s = unsafe {
let char_ptr = self.inner.ptr.add(byte_idx);
let slice = std::slice::from_raw_parts(char_ptr, size_of::<char>());
std::str::from_utf8_unchecked(&slice)
std::str::from_utf8_unchecked(slice)
};
s.chars().next().unwrap()
@@ -1158,14 +1158,24 @@ pub fn sized_iter_to_heap_list<SrcT: Into<HeapCellValue>>(
pub(crate) fn to_local_code_ptr(heap: &Heap, addr: HeapCellValue) -> Option<usize> {
let extract_integer = |s: usize| -> Option<usize> {
match Number::try_from(heap[s]) {
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).ok(),
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
Some(value)
read_heap_cell!(heap[s],
(HeapCellValueTag::Cons, c) => {
match_untyped_arena_ptr!(c,
(ArenaHeaderTag::Integer, n) => {
(&*n).try_into().ok()
}
_ => {
None
}
)
}
_ => None,
}
(HeapCellValueTag::Fixnum, n) => {
usize::try_from(n.get_num()).ok()
}
_ => {
None
}
)
};
read_heap_cell!(addr,

44
src/machine/lib_machine/mod.rs
View File

@@ -277,14 +277,15 @@ impl Term {
},
}
}
(HeapCellValueTag::F64, f) => {
term_stack.push(Term::Float((*f).into()));
(HeapCellValueTag::F64Offset, offset) => {
let f = *machine.machine_st.arena.f64_tbl.lookup(offset);
term_stack.push(Term::Float(f.into()));
}
(HeapCellValueTag::Fixnum, n) => {
term_stack.push(Term::Integer(n.into()));
}
(HeapCellValueTag::Cons, ptr) => {
if let Ok(n) = Number::try_from(addr) {
if let Ok(n) = Number::try_from((addr, &machine.machine_st.arena.f64_tbl)) {
match n {
Number::Integer(i) => term_stack.push(Term::Integer((*i).clone())),
Number::Rational(r) => term_stack.push(Term::Rational((*r).clone())),
@@ -312,31 +313,6 @@ impl Term {
}
}
(HeapCellValueTag::Atom, (name, arity)) => {
//let h = iter.focus().value() as usize;
//let mut arity = arity;
// Not sure why/if this is needed.
// Might find out with better testing later.
/*
if iter.heap.len() > h + arity + 1 {
let value = iter.heap[h + arity + 1];
if let Some(idx) = get_structure_index(value) {
// in the second condition, arity == 0,
// meaning idx cannot pertain to this atom
// if it is the direct subterm of a larger
// structure.
if arity > 0 || !iter.direct_subterm_of_str(h) {
term_stack.push(
Term::Literal(Cell::default(), Literal::CodeIndex(idx))
);
arity += 1;
}
}
}
*/
if arity == 0 {
let atom_name = name.as_str().to_string();
if atom_name == "[]" {
@@ -621,9 +597,15 @@ impl Machine {
.indices
.code_dir
.get(&(atom!("call"), 1))
.expect("couldn't get code index")
.local()
.unwrap();
.cloned()
.map(|offset| {
self.machine_st
.arena
.code_index_tbl
.lookup(offset.into())
.p() as usize
})
.expect("couldn't get code index");
self.machine_st.execute_at_index(1, call_index_p);

163
src/machine/load_state.rs
View File

@@ -15,35 +15,40 @@ use std::mem;
pub(super) type ModuleOpExports = Vec<(OpDecl, Option<OpDesc>)>;
pub(super) fn set_code_index(
retraction_info: &mut RetractionInfo,
pub(super) fn set_code_index<'a, LS: LoadState<'a>>(
payload: &mut <LS as LoadState<'a>>::LoaderFieldType,
compilation_target: &CompilationTarget,
key: PredicateKey,
mut code_index: CodeIndex,
code_idx: CodeIndex,
code_ptr: IndexPtr,
) {
let mut code_idx_ptr = LS::machine_st(payload)
.arena
.code_index_tbl
.lookup_mut(code_idx.into());
let record = match compilation_target {
CompilationTarget::User => {
if IndexPtrTag::Undefined == code_index.get().tag() {
code_index.set(code_ptr);
if IndexPtrTag::Undefined == code_idx_ptr.tag() {
code_idx_ptr.set(code_ptr);
RetractionRecord::AddedUserPredicate(key)
} else {
let replaced = code_index.replace(code_ptr);
let replaced = code_idx_ptr.replace(code_ptr);
RetractionRecord::ReplacedUserPredicate(key, replaced)
}
}
CompilationTarget::Module(ref module_name) => {
if IndexPtrTag::Undefined == code_index.get().tag() {
code_index.set(code_ptr);
if IndexPtrTag::Undefined == code_idx_ptr.tag() {
code_idx_ptr.set(code_ptr);
RetractionRecord::AddedModulePredicate(*module_name, key)
} else {
let replaced = code_index.replace(code_ptr);
let replaced = code_idx_ptr.replace(code_ptr);
RetractionRecord::ReplacedModulePredicate(*module_name, key, replaced)
}
}
};
retraction_info.push_record(record);
payload.retraction_info.push_record(record);
}
fn add_op_decl_as_module_export<'a, LS: LoadState<'a>>(
@@ -133,21 +138,28 @@ pub(super) fn import_module_exports<'a, LS: LoadState<'a>>(
}
if let Some(src_code_index) = imported_module.code_dir.get(&key).cloned() {
let arena = &mut LS::machine_st(payload).arena;
let code_idx_tbl = &mut LS::machine_st(payload).arena.code_index_tbl;
let target_code_index = *code_dir
.entry(key)
.or_insert_with(|| CodeIndex::default(arena));
.or_insert_with(|| CodeIndex::default(code_idx_tbl));
set_code_index(
&mut payload.retraction_info,
let src_code_index_ptr = *code_idx_tbl.lookup(src_code_index.into());
set_code_index::<LS>(
payload,
compilation_target,
key,
target_code_index,
src_code_index.get(),
src_code_index_ptr,
);
if src_code_index.as_ptr().is_dynamic_undefined() {
if LS::machine_st(payload)
.arena
.code_index_tbl
.lookup(src_code_index.into())
.is_dynamic_undefined()
{
code_dir.insert(key, src_code_index);
}
} else {
@@ -189,19 +201,20 @@ fn import_module_exports_into_module<'a, LS: LoadState<'a>>(
meta_predicates.insert(key, meta_specs.clone());
}
if let Some(src_code_index) = imported_module.code_dir.get(&key) {
let arena = &mut LS::machine_st(payload).arena;
if let Some(src_code_index) = imported_module.code_dir.get(&key).cloned() {
let code_index_tbl = &mut LS::machine_st(payload).arena.code_index_tbl;
let src_code_ptr = *code_index_tbl.lookup(src_code_index.into());
let target_code_index = *code_dir
.entry(key)
.or_insert_with(|| CodeIndex::default(arena));
.or_insert_with(|| CodeIndex::default(code_index_tbl));
set_code_index(
&mut payload.retraction_info,
set_code_index::<LS>(
payload,
compilation_target,
key,
target_code_index,
src_code_index.get(),
src_code_ptr,
);
} else {
return Err(SessionError::ModuleDoesNotContainExport(
@@ -242,21 +255,21 @@ fn import_qualified_module_exports<'a, LS: LoadState<'a>>(
.insert(key, meta_specs.clone());
}
if let Some(src_code_index) = imported_module.code_dir.get(&key) {
let arena = &mut LS::machine_st(payload).arena;
if let Some(src_code_index) = imported_module.code_dir.get(&key).cloned() {
let code_index_tbl = &mut LS::machine_st(payload).arena.code_index_tbl;
let target_code_index = *wam_prelude
.indices
.code_dir
.entry(key)
.or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena));
let src_code_ptr = *code_index_tbl.lookup(src_code_index.into());
let target_code_index =
*wam_prelude.indices.code_dir.entry(key).or_insert_with(|| {
CodeIndex::new(IndexPtr::undefined(), code_index_tbl)
});
set_code_index(
&mut payload.retraction_info,
set_code_index::<LS>(
payload,
compilation_target,
key,
target_code_index,
src_code_index.get(),
src_code_ptr,
);
} else {
return Err(SessionError::ModuleDoesNotContainExport(
@@ -303,19 +316,20 @@ fn import_qualified_module_exports_into_module<'a, LS: LoadState<'a>>(
meta_predicates.insert(key, meta_specs.clone());
}
if let Some(src_code_index) = imported_module.code_dir.get(&key) {
let arena = &mut LS::machine_st(payload).arena;
if let Some(src_code_index) = imported_module.code_dir.get(&key).cloned() {
let code_index_tbl = &mut LS::machine_st(payload).arena.code_index_tbl;
let src_code_ptr = *code_index_tbl.lookup(src_code_index.into());
let target_code_index = *code_dir
.entry(key)
.or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena));
.or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), code_index_tbl));
set_code_index(
&mut payload.retraction_info,
set_code_index::<LS>(
payload,
&payload_compilation_target,
key,
target_code_index,
src_code_index.get(),
src_code_ptr,
);
} else {
return Err(SessionError::ModuleDoesNotContainExport(
@@ -468,11 +482,14 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
.indices
.get_predicate_skeleton(local_compilation_target, key)
{
let old_index_ptr = code_index.replace(if global_skeleton.core.is_dynamic {
IndexPtr::dynamic_undefined()
} else {
IndexPtr::undefined()
});
let old_index_ptr = code_index.replace(
&mut LS::machine_st(&mut self.payload).arena.code_index_tbl,
if global_skeleton.core.is_dynamic {
IndexPtr::dynamic_undefined()
} else {
IndexPtr::undefined()
},
);
self.payload.retraction_info.push_record(
RetractionRecord::ReplacedModulePredicate(module_name, *key, old_index_ptr),
@@ -486,8 +503,11 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
continue;
}
if !code_index.as_ptr().is_undefined() && !code_index.as_ptr().is_dynamic_undefined() {
let old_index_ptr = code_index.replace(IndexPtr::undefined());
let code_index_tbl = &mut LS::machine_st(&mut self.payload).arena.code_index_tbl;
let code_ptr = code_index_tbl.lookup((*code_index).into());
if !code_ptr.is_undefined() && !code_ptr.is_dynamic_undefined() {
let old_index_ptr = code_index.replace(code_index_tbl, IndexPtr::undefined());
self.payload.retraction_info.push_record(
RetractionRecord::ReplacedModulePredicate(module_name, *key, old_index_ptr),
@@ -517,25 +537,34 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
None => return,
};
fn remove_module_exports(
fn remove_module_exports<'b, LS: LoadState<'b>>(
payload: &mut <LS as LoadState<'b>>::LoaderFieldType,
removed_module: &Module,
code_dir: &mut CodeDir,
op_dir: &mut OpDir,
retraction_info: &mut RetractionInfo,
predicate_retractor: impl Fn(PredicateKey, IndexPtr) -> RetractionRecord,
op_retractor: impl Fn(OpDecl, OpDesc) -> RetractionRecord,
) {
for export in removed_module.module_decl.exports.iter() {
match export {
ModuleExport::PredicateKey(ref key) => {
match (removed_module.code_dir.get(key), code_dir.get_mut(key)) {
(Some(module_code_index), Some(target_code_index))
if module_code_index.get() == target_code_index.get() =>
{
let old_index_ptr =
target_code_index.replace(IndexPtr::undefined());
retraction_info
.push_record(predicate_retractor(*key, old_index_ptr));
match (
removed_module.code_dir.get(key).cloned(),
code_dir.get_mut(key).cloned(),
) {
(Some(module_code_idx), Some(target_code_idx)) => {
let code_index_tbl =
&mut LS::machine_st(payload).arena.code_index_tbl;
let module_code_ptr = code_index_tbl.lookup(module_code_idx.into());
let target_code_ptr = code_index_tbl.lookup(target_code_idx.into());
if module_code_ptr == target_code_ptr {
let old_index_ptr = target_code_idx
.replace(code_index_tbl, IndexPtr::undefined());
payload
.retraction_info
.push_record(predicate_retractor(*key, old_index_ptr));
}
}
_ => {}
}
@@ -545,7 +574,9 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
.swap_remove(&(op_decl.name, op_decl.op_desc.get_spec().fixity()));
if let Some(op_desc) = op_dir_value_opt {
retraction_info.push_record(op_retractor(*op_decl, op_desc));
payload
.retraction_info
.push_record(op_retractor(*op_decl, op_desc));
}
}
}
@@ -554,11 +585,11 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
match self.payload.compilation_target {
CompilationTarget::User => {
remove_module_exports(
remove_module_exports::<LS>(
&mut self.payload,
&removed_module,
&mut self.wam_prelude.indices.code_dir,
&mut self.wam_prelude.indices.op_dir,
&mut self.payload.retraction_info,
RetractionRecord::ReplacedUserPredicate,
RetractionRecord::ReplacedUserOp,
);
@@ -578,11 +609,11 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
.modules
.get_mut(&target_module_name)
{
remove_module_exports(
remove_module_exports::<LS>(
&mut self.payload,
&removed_module,
&mut module.code_dir,
&mut module.op_dir,
&mut self.payload.retraction_info,
predicate_retractor,
op_retractor,
);
@@ -608,7 +639,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
Some(ref mut module) => *module.code_dir.entry(key).or_insert_with(|| {
CodeIndex::new(
IndexPtr::undefined(),
&mut LS::machine_st(&mut self.payload).arena,
&mut LS::machine_st(&mut self.payload).arena.code_index_tbl,
)
}),
None => {
@@ -618,7 +649,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
Some(ref mut module) => *module.code_dir.entry(key).or_insert_with(|| {
CodeIndex::new(
IndexPtr::undefined(),
&mut LS::machine_st(&mut self.payload).arena,
&mut LS::machine_st(&mut self.payload).arena.code_index_tbl,
)
}),
None => {
@@ -634,7 +665,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
key: PredicateKey,
compilation_target: CompilationTarget,
) -> CodeIndex {
let arena = &mut LS::machine_st(&mut self.payload).arena;
let code_index_tbl = &mut LS::machine_st(&mut self.payload).arena.code_index_tbl;
match compilation_target {
CompilationTarget::User => *self
@@ -642,7 +673,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
.indices
.code_dir
.entry(key)
.or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena)),
.or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), code_index_tbl)),
CompilationTarget::Module(module_name) => {
self.get_or_insert_local_code_index(module_name, key)
}
@@ -654,7 +685,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
module_name: Atom,
key: PredicateKey,
) -> CodeIndex {
let arena = &mut LS::machine_st(&mut self.payload).arena;
let code_index_tbl = &mut LS::machine_st(&mut self.payload).arena.code_index_tbl;
if module_name == atom!("user") {
return *self
@@ -662,7 +693,7 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
.indices
.code_dir
.entry(key)
.or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena));
.or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), code_index_tbl));
} else {
self.get_or_insert_local_code_index(module_name, key)
}

50
src/machine/loader.rs
View File

@@ -720,7 +720,9 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
self.wam_prelude.indices.modules.get_mut(&module_name)
{
if let Some(code_idx) = module.code_dir.get_mut(&key) {
code_idx.set(old_code_idx)
let code_index_tbl =
&mut LS::machine_st(&mut self.payload).arena.code_index_tbl;
code_idx.set(code_index_tbl, old_code_idx);
}
}
}
@@ -741,7 +743,9 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
}
RetractionRecord::ReplacedUserPredicate(key, old_code_idx) => {
if let Some(code_idx) = self.wam_prelude.indices.code_dir.get_mut(&key) {
code_idx.set(old_code_idx)
let code_index_tbl =
&mut LS::machine_st(&mut self.payload).arena.code_index_tbl;
code_idx.set(code_index_tbl, old_code_idx)
}
}
RetractionRecord::AddedIndex(index_key, clause_loc) => {
@@ -1217,14 +1221,18 @@ impl<'a, LS: LoadState<'a>> Loader<'a, LS> {
* but to multifile and discontiguous predicates as well.
*/
let code_index = self.get_or_insert_code_index(key, compilation_target);
let offset = self.get_or_insert_code_index(key, compilation_target);
let code_idx_ptr = LS::machine_st(&mut self.payload)
.arena
.code_index_tbl
.lookup_mut(offset.into());
if code_index.as_ptr().is_undefined() {
set_code_index(
&mut self.payload.retraction_info,
if code_idx_ptr.is_undefined() {
set_code_index::<LS>(
&mut self.payload,
&compilation_target,
key,
code_index,
offset,
IndexPtr::dynamic_undefined(),
);
}
@@ -1395,7 +1403,7 @@ impl MachineState {
Err(cons_term) => term_stack.push(cons_term),
}
}
(HeapCellValueTag::Cons | HeapCellValueTag::Fixnum | HeapCellValueTag::F64) => {
(HeapCellValueTag::Cons | HeapCellValueTag::Fixnum | HeapCellValueTag::F64Offset) => {
term_stack.push(Term::Literal(Cell::default(), Literal::try_from(addr).unwrap()));
}
(HeapCellValueTag::StackVar, h) => {
@@ -1410,7 +1418,7 @@ impl MachineState {
let value = iter.heap[h.saturating_sub(1)];
if let Some(idx) = get_structure_index(value) {
term_stack.push(Term::Literal(Cell::default(), Literal::CodeIndex(idx)));
term_stack.push(Term::Literal(Cell::default(), Literal::CodeIndexOffset(idx.into())));
arity += 1;
}
@@ -1588,7 +1596,7 @@ impl Machine {
let predicate_name = cell_as_atom!(self.deref_register(2));
let arity = self.deref_register(3);
let arity = match Number::try_from(arity) {
let arity = match Number::try_from((arity, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) if *n >= Integer::ZERO && *n <= Integer::from(MAX_ARITY) => {
let value: usize = (&*n).try_into().unwrap();
Ok(value)
@@ -1999,7 +2007,15 @@ impl Machine {
.wam_prelude
.indices
.get_predicate_code_index(name, arity, module_name)
.map(|code_idx| code_idx.get_tag())
.map(|offset| {
loader
.payload
.machine_st
.arena
.code_index_tbl
.lookup(offset.into())
.tag()
})
.unwrap_or(IndexPtrTag::DynamicUndefined);
if idx_tag == IndexPtrTag::Index {
@@ -2142,9 +2158,15 @@ impl Machine {
.indices
.remove_predicate_skeleton(&compilation_target, &key);
let mut code_index = loader.get_or_insert_code_index(key, compilation_target);
let offset = loader.get_or_insert_code_index(key, compilation_target);
let mut code_idx = loader
.payload
.machine_st
.arena
.code_index_tbl
.lookup_mut(offset.into());
code_index.set(IndexPtr::undefined());
code_idx.set(IndexPtr::undefined());
loader.payload.compilation_target = clause_clause_compilation_target;
@@ -2174,7 +2196,7 @@ impl Machine {
.machine_st
.store(self.machine_st.deref(self.machine_st[temp_v!(3)]));
let target_pos = match Number::try_from(target_pos) {
let target_pos = match Number::try_from((target_pos, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
value

68
src/machine/machine_indices.rs
View File

@@ -2,7 +2,6 @@
use crate::parser::ast::*;
use crate::arena::*;
use crate::atom_table::*;
use crate::forms::*;
use crate::machine::loader::*;
@@ -19,7 +18,6 @@ use scryer_modular_bitfield::{bitfield, BitfieldSpecifier};
use std::cmp::Ordering;
use std::collections::BTreeSet;
use std::ops::Deref;
use crate::types::*;
@@ -127,9 +125,18 @@ impl IndexPtr {
pub(crate) fn is_dynamic_undefined(&self) -> bool {
matches!(self.tag(), IndexPtrTag::DynamicUndefined)
}
#[inline]
pub(crate) fn local(&self) -> Option<usize> {
match self.tag() {
IndexPtrTag::Index => Some(self.p() as usize),
IndexPtrTag::DynamicIndex => Some(self.p() as usize),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, Ord, Hash, PartialOrd, Eq, PartialEq)]
#[derive(Debug, Clone, Copy)] // , Ord, Hash, PartialOrd, Eq, PartialEq)]
pub struct CodeIndex(CodeIndexOffset);
#[cfg(target_pointer_width = "32")]
@@ -141,7 +148,7 @@ const_assert!(std::mem::align_of::<CodeIndex>() == 8);
impl From<CodeIndex> for HeapCellValue {
#[inline(always)]
fn from(idx: CodeIndex) -> HeapCellValue {
HeapCellValue::from(idx.as_ptr())
HeapCellValue::from(idx.0)
}
}
@@ -152,48 +159,39 @@ impl From<CodeIndexOffset> for CodeIndex {
}
}
impl Into<CodeIndexOffset> for CodeIndex {
#[inline(always)]
fn into(self) -> CodeIndexOffset {
self.0
}
}
impl Into<CodeIndexOffset> for &'_ CodeIndex {
#[inline(always)]
fn into(self) -> CodeIndexOffset {
self.0
}
}
impl CodeIndex {
#[inline]
pub(crate) fn new(ptr: IndexPtr, arena: &mut Arena) -> Self {
unsafe { CodeIndex(arena.code_index_tbl.build_with(ptr)) }
pub(crate) fn new(ptr: IndexPtr, code_index_tbl: &mut CodeIndexTable) -> Self {
CodeIndex(code_index_tbl.build_with(ptr))
}
#[inline(always)]
pub(crate) fn default(arena: &mut Arena) -> Self {
CodeIndex::new(IndexPtr::undefined(), arena)
}
pub(crate) fn local(&self) -> Option<usize> {
match self.0.as_ptr().tag() {
IndexPtrTag::Index => Some(self.get().p() as usize),
IndexPtrTag::DynamicIndex => Some(self.get().p() as usize),
_ => None,
}
pub(crate) fn default(code_index_tbl: &mut CodeIndexTable) -> Self {
CodeIndex::new(IndexPtr::undefined(), code_index_tbl)
}
#[inline(always)]
pub(crate) fn get(&self) -> IndexPtr {
*self.as_ptr().deref()
pub(crate) fn set(&self, code_index_tbl: &mut CodeIndexTable, value: IndexPtr) {
code_index_tbl.lookup_mut(self.0).set(value);
}
#[inline(always)]
pub(crate) fn set(&mut self, value: IndexPtr) {
self.as_ptr().set(value);
}
#[inline(always)]
pub(crate) fn get_tag(self) -> IndexPtrTag {
self.get().tag()
}
#[inline(always)]
pub(crate) fn replace(&mut self, value: IndexPtr) -> IndexPtr {
self.as_ptr().replace(value)
}
#[inline(always)]
pub(crate) fn as_ptr(&self) -> CodeIndexPtr {
self.0.as_ptr()
pub(crate) fn replace(&self, code_index_tbl: &mut CodeIndexTable, value: IndexPtr) -> IndexPtr {
code_index_tbl.lookup_mut(self.0).replace(value)
}
}

3
src/machine/machine_state.rs
View File

@@ -952,6 +952,7 @@ impl MachineState {
let mut printer = HCPrinter::new(
&mut self.heap,
&mut self.stack,
&self.arena,
op_dir,
PrinterOutputter::new(),
0,
@@ -962,7 +963,7 @@ impl MachineState {
printer.quoted = quoted;
printer.double_quotes = double_quotes;
match Number::try_from(max_depth) {
match Number::try_from((max_depth, &self.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => {
if let Ok(n) = usize::try_from(n.get_num()) {
printer.max_depth = n;

199
src/machine/machine_state_impl.rs
View File

@@ -288,7 +288,7 @@ impl MachineState {
unifier.unify_big_rational(n1, value);
}
pub fn unify_f64(&mut self, f1: F64Ptr, value: HeapCellValue) {
pub fn unify_f64(&mut self, f1: F64Offset, value: HeapCellValue) {
let mut unifier = DefaultUnifier::from(self);
unifier.unify_f64(f1, value);
}
@@ -409,8 +409,11 @@ impl MachineState {
}
}
Some(TermOrderCategory::FloatingPoint) => {
let v1 = cell_as_f64_ptr!(v1);
let v2 = cell_as_f64_ptr!(v2);
let v1 = cell_as_f64_offset!(v1);
let v2 = cell_as_f64_offset!(v2);
let v1 = self.arena.f64_tbl.lookup(v1);
let v2 = self.arena.f64_tbl.lookup(v2);
if v1 != v2 {
self.pdl.clear();
@@ -418,8 +421,8 @@ impl MachineState {
}
}
Some(TermOrderCategory::Integer) => {
let v1 = Number::try_from(v1).unwrap();
let v2 = Number::try_from(v2).unwrap();
let v1 = Number::try_from((v1, &self.arena.f64_tbl)).unwrap();
let v2 = Number::try_from((v2, &self.arena.f64_tbl)).unwrap();
if v1 != v2 {
self.pdl.clear();
@@ -436,22 +439,6 @@ impl MachineState {
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(
n1.as_str().chars().next().cmp(&Some(c2))
.then(Ordering::Greater)
);
}
}
*/
(HeapCellValueTag::Str, s) => {
let n2 = cell_as_atom_cell!(self.heap[s])
.get_name();
@@ -466,52 +453,6 @@ impl MachineState {
}
)
}
/*
(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(
Some(c1).cmp(&n2.as_str().chars().next())
.then(Ordering::Less)
);
}
}
(HeapCellValueTag::Char, c2) => {
if c1 != c2 {
self.pdl.clear();
return Some(c1.cmp(&c2));
}
}
(HeapCellValueTag::Str, s) => {
let n2 = cell_as_atom_cell!(self.heap[s])
.get_name();
if let Some(c2) = n2.as_char() {
if c1 != c2 {
self.pdl.clear();
return Some(c1.cmp(&c2));
}
} else {
self.pdl.clear();
return Some(
Some(c1).cmp(&n2.as_str().chars().next())
.then(Ordering::Less)
);
}
}
_ => {
unreachable!()
}
)
}
*/
(HeapCellValueTag::Str, s) => {
let n1 = cell_as_atom_cell!(self.heap[s])
.get_name();
@@ -523,22 +464,6 @@ impl MachineState {
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(
n1.as_str().chars().next().cmp(&Some(c2))
.then(Ordering::Greater)
);
}
}
*/
(HeapCellValueTag::Str, s) => {
let n2 = cell_as_atom_cell!(self.heap[s])
.get_name();
@@ -865,7 +790,7 @@ impl MachineState {
return Err(self.error_form(err, stub_gen()));
}
_ => {
let n = match Number::try_from(n) {
let n = match Number::try_from((n, &self.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => Number::Fixnum(n),
Ok(Number::Integer(n)) => Number::Integer(n),
_ => {
@@ -917,46 +842,18 @@ impl MachineState {
(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 mut char_iter = self.heap.char_iter(pstr_loc);
// let pstr = cell_as_string!(self.heap[h]);
// let offset = offset.get_num() as usize;
if let Some(c) = char_iter.next() { // pstr.as_str_from(offset).chars().next() {
if let Some(c) = char_iter.next() {
if n == 1 {
self.unify_char(c, a3);
} else {
// let offset = (offset + c.len_utf8()) as i64;
// let h_len = self.heap.len();
// let pstr_atom: Atom = pstr.into();
if char_iter.next().is_some() {
unify_fn!(*self, pstr_loc_as_cell!(pstr_loc + c.len_utf8()), a3);
} else {
let tail_idx = Heap::pstr_tail_idx(pstr_loc + c.len_utf8());
unify_fn!(*self, self.heap[tail_idx], a3);
}
/*
if pstr_atom.len() > offset as usize {
self.heap.push(pstr_offset_as_cell!(h));
self.heap.push(fixnum_as_cell!(Fixnum::build_with_unchecked(offset as i64)));
unify_fn!(*self, pstr_loc_as_cell!(h_len), a3);
} else {
match self.heap[h].get_tag() {
HeapCellValueTag::CStr => {
self.unify_atom(atom!("[]"), self.store(self.deref(a3)));
}
HeapCellValueTag::PStr => {
unify_fn!(*self, self.heap[h+1], a3);
}
_ => {
unreachable!();
}
}
}
*/
}
} else {
unreachable!()
@@ -965,34 +862,6 @@ impl MachineState {
self.fail = true;
}
}
/*
(HeapCellValueTag::CStr, cstr_atom) => {
let cstr = PartialString::from(cstr_atom);
if let Some(c) = cstr.as_str_from(0).chars().next() {
if n == 1 {
self.unify_char(c, self.store(self.deref(self.registers[3])));
} else if n == 2 {
let offset = c.len_utf8();
let h_len = self.heap.len();
if cstr_atom.len() > offset{
self.heap.push(atom_as_cstr_cell!(cstr_atom));
self.heap.push(pstr_offset_as_cell!(h_len));
self.heap.push(fixnum_as_cell!(Fixnum::build_with_unchecked(offset as i64)));
unify_fn!(*self, pstr_loc_as_cell!(h_len+1), self.registers[3]);
} else {
self.unify_atom(atom!("[]"), self.store(self.deref(self.registers[3])));
}
} else {
self.fail = true;
}
} else {
unreachable!()
}
}
*/
_ => {
// 8.5.2.3 d)
let err = self.type_error(ValidType::Compound, term);
@@ -1077,7 +946,7 @@ impl MachineState {
read_heap_cell!(a1,
(HeapCellValueTag::Cons | HeapCellValueTag::Fixnum | // | HeapCellValueTag::Char
HeapCellValueTag::F64) => {
HeapCellValueTag::F64Offset) => {
self.try_functor_unify_components(a1, 0);
}
(HeapCellValueTag::Atom, (_name, arity)) => {
@@ -1103,17 +972,17 @@ impl MachineState {
return Err(self.error_form(err, stub_gen()));
}
let mut type_error = |arity| {
let err = self.type_error(ValidType::Integer, arity);
Err(self.error_form(err, stub_gen()))
let type_error = |machine_st: &mut Self, arity| {
let err = machine_st.type_error(ValidType::Integer, arity);
Err(machine_st.error_form(err, stub_gen()))
};
let arity = match Number::try_from(arity) {
let arity = match Number::try_from((arity, &self.arena.f64_tbl)) {
Ok(Number::Float(_)) => {
return type_error(arity);
return type_error(self, arity);
}
Ok(Number::Rational(n)) if !n.denominator().is_one() => {
return type_error(arity);
return type_error(self, arity);
}
Ok(n) if n > MAX_ARITY => {
// 8.5.1.3 f)
@@ -1135,15 +1004,15 @@ impl MachineState {
value
},
Err(_) => {
return type_error(arity);
return type_error(self, arity);
}
};
read_heap_cell!(store_name,
(HeapCellValueTag::Cons | HeapCellValueTag::Fixnum | // HeapCellValueTag::Char |
HeapCellValueTag::F64) if arity == 0 => {
self.bind(a1.as_var().unwrap(), deref_name);
}
(HeapCellValueTag::Cons | HeapCellValueTag::Fixnum | HeapCellValueTag::F64Offset)
if arity == 0 => {
self.bind(a1.as_var().unwrap(), deref_name);
}
(HeapCellValueTag::Atom, (name, atom_arity)) => {
debug_assert_eq!(atom_arity, 0);
resource_error_call_result!(
@@ -1173,22 +1042,8 @@ impl MachineState {
return Err(self.error_form(err, stub_gen()));
}
}
/*
(HeapCellValueTag::Char, c) => {
let c = AtomTable::build_with(&self.atom_tbl, &c.to_string());
resource_error_call_result!(
self,
self.try_functor_fabricate_struct(
c,
arity as usize,
a1.as_var().unwrap(),
)
);
}
*/
(HeapCellValueTag::Cons | HeapCellValueTag::Fixnum |
HeapCellValueTag::F64) if arity != 0 => {
HeapCellValueTag::F64Offset) if arity != 0 => {
let err = self.type_error(ValidType::Atom, store_name);
return Err(self.error_form(err, stub_gen())); // 8.5.1.3 e)
}
@@ -1243,12 +1098,6 @@ impl MachineState {
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, value);
Err(self.error_form(err, stub_gen()))
@@ -1372,7 +1221,7 @@ impl MachineState {
for addr in addrs {
let addr = self.store(self.deref(addr));
match Number::try_from(addr) {
match Number::try_from((addr, &self.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => {
if let Ok(b) = u8::try_from(n.get_num()) {
bytes.push(b)

1
src/machine/mock_wam.rs
View File

@@ -56,6 +56,7 @@ impl MockWAM {
let mut printer = HCPrinter::new(
&mut self.machine_st.heap,
&mut self.machine_st.stack,
&mut self.machine_st.arena,
&self.op_dir,
PrinterOutputter::new(),
term_write_result.heap_loc,

89
src/machine/mod.rs
View File

@@ -208,8 +208,8 @@ pub(crate) fn import_builtin_impls(code_dir: &CodeDir, builtins: &mut Module) {
#[inline]
pub(crate) fn get_structure_index(value: HeapCellValue) -> Option<CodeIndex> {
read_heap_cell!(value,
(HeapCellValueTag::CodeIndex, ip) => {
return Some(ip);
(HeapCellValueTag::CodeIndexOffset, offset) => {
return Some(CodeIndex::from(offset));
}
_ => {
}
@@ -242,7 +242,7 @@ impl Machine {
}
/// Runs the predicate `key` in `module_name` until completion.
/// Siltently ignores failure, thrown errors and choice points.
/// Silently ignores failure, thrown errors and choice points.
///
/// Consider using [`Machine::run_query`] if you wish to handle
/// predicates that may fail, leave a choice point or throw.
@@ -252,8 +252,10 @@ impl Machine {
key: PredicateKey,
) -> std::process::ExitCode {
if let Some(module) = self.indices.modules.get(&module_name) {
if let Some(code_index) = module.code_dir.get(&key) {
let p = code_index.local().unwrap();
if let Some(code_idx) = module.code_dir.get(&key) {
let index_ptr = self.machine_st.arena.code_index_tbl.lookup(code_idx.into());
let p = index_ptr.local().unwrap();
// Leave a halting choice point to backtrack to in case the predicate fails or throws.
self.allocate_stub_choice_point();
@@ -324,8 +326,9 @@ impl Machine {
self.load_file(path_buf.to_str().unwrap(), stream);
if let Some(module) = self.indices.modules.get(&atom!("$atts")) {
if let Some(code_index) = module.code_dir.get(&(atom!("driver"), 2)) {
self.machine_st.attr_var_init.verify_attrs_loc = code_index.local().unwrap();
if let Some(code_idx) = module.code_dir.get(&(atom!("driver"), 2)) {
let index_ptr = *self.machine_st.arena.code_index_tbl.lookup(code_idx.into());
self.machine_st.attr_var_init.verify_attrs_loc = index_ptr.local().unwrap();
}
}
}
@@ -339,13 +342,16 @@ impl Machine {
for arity in 1..66 {
let key = (atom!("call"), arity);
match loader.code_dir.get(&key) {
match loader.code_dir.get(&key).cloned() {
Some(src_code_index) => {
let target_code_index = target_code_dir
.entry(key)
.or_insert_with(|| CodeIndex::new(IndexPtr::undefined(), arena));
let code_index_tbl = &mut arena.code_index_tbl;
target_code_index.set(src_code_index.get());
let target_code_index = target_code_dir.entry(key).or_insert_with(|| {
CodeIndex::new(IndexPtr::undefined(), code_index_tbl)
});
let src_code_ptr = *code_index_tbl.lookup(src_code_index.into());
target_code_index.set(code_index_tbl, src_code_ptr);
}
None => {
unreachable!();
@@ -454,7 +460,7 @@ impl Machine {
key,
CodeIndex::new(
IndexPtr::index(p + impls_offset),
&mut self.machine_st.arena,
&mut self.machine_st.arena.code_index_tbl,
),
);
}
@@ -535,37 +541,8 @@ impl Machine {
if cell.is_var() {
offset += 1;
/*
} else if lit.get_tag() == HeapCellValueTag::CStr {
read_heap_cell!(cell,
(HeapCellValueTag::CStr) => {
if cell == lit {
offset += 1;
} else {
return false;
}
}
(HeapCellValueTag::Lis | HeapCellValueTag::PStrLoc) => {
offset += 1;
}
(HeapCellValueTag::Str, s) => {
let (name, arity) = cell_as_atom_cell!(self.machine_st.heap[s])
.get_name_and_arity();
if name == atom!(".") && arity == 2 {
offset += 1;
} else {
return false;
}
}
_ => {
return false;
}
);
*/
} else {
unify!(self.machine_st, cell, lit);
// self.machine_st.write_literal_to_var(cell, lit);
if self.machine_st.fail {
self.machine_st.fail = false;
@@ -1068,13 +1045,15 @@ impl Machine {
if module_name == atom!("user") {
if let Some(idx) = self.indices.code_dir.get(&(name, arity)).cloned() {
self.try_call(name, arity, idx.get())
let index_ptr = *self.machine_st.arena.code_index_tbl.lookup(idx.into());
self.try_call(name, arity, index_ptr)
} else {
Err(self.machine_st.throw_undefined_error(name, arity))
}
} else if let Some(module) = self.indices.modules.get(&module_name) {
if let Some(idx) = module.code_dir.get(&(name, arity)).cloned() {
self.try_call(name, arity, idx.get())
let index_ptr = *self.machine_st.arena.code_index_tbl.lookup(idx.into());
self.try_call(name, arity, index_ptr)
} else {
self.undefined_procedure(name, arity)
}
@@ -1098,13 +1077,15 @@ impl Machine {
if module_name == atom!("user") {
if let Some(idx) = self.indices.code_dir.get(&(name, arity)).cloned() {
self.try_execute(name, arity, idx.get())
let index_ptr = *self.machine_st.arena.code_index_tbl.lookup(idx.into());
self.try_execute(name, arity, index_ptr)
} else {
self.undefined_procedure(name, arity)
}
} else if let Some(module) = self.indices.modules.get(&module_name) {
if let Some(idx) = module.code_dir.get(&(name, arity)).cloned() {
self.try_execute(name, arity, idx.get())
let index_ptr = *self.machine_st.arena.code_index_tbl.lookup(idx.into());
self.try_execute(name, arity, index_ptr)
} else {
self.undefined_procedure(name, arity)
}
@@ -1146,12 +1127,24 @@ impl Machine {
let r_c_w_h = self
.indices
.get_predicate_code_index(r_c_w_h_atom, 0, iso_ext)
.and_then(|item| item.local())
.and_then(|code_idx| {
self.machine_st
.arena
.code_index_tbl
.lookup(code_idx.into())
.local()
})
.unwrap();
let r_c_wo_h = self
.indices
.get_predicate_code_index(r_c_wo_h_atom, 1, iso_ext)
.and_then(|item| item.local())
.and_then(|code_idx| {
self.machine_st
.arena
.code_index_tbl
.lookup(code_idx.into())
.local()
})
.unwrap();
(r_c_w_h, r_c_wo_h)
});

16
src/machine/preprocessor.rs
View File

@@ -424,7 +424,7 @@ fn build_meta_predicate_clause<'a, LS: LoadState<'a>>(
let term = match term {
Term::Clause(cell, name, mut terms) => {
if let Some(Term::Literal(_, Literal::CodeIndex(_))) = terms.last() {
if let Some(Term::Literal(_, Literal::CodeIndexOffset(_))) = terms.last() {
arg_terms
.push(process_term(module_name, Term::Clause(cell, name, terms)));
@@ -433,7 +433,10 @@ fn build_meta_predicate_clause<'a, LS: LoadState<'a>>(
let idx = loader.get_or_insert_qualified_code_index(module_name, key);
terms.push(Term::Literal(Cell::default(), Literal::CodeIndex(idx)));
terms.push(Term::Literal(
Cell::default(),
Literal::CodeIndexOffset(idx.into()),
));
process_term(module_name, Term::Clause(cell, name, terms))
}
Term::Literal(cell, Literal::Atom(name)) => {
@@ -444,7 +447,10 @@ fn build_meta_predicate_clause<'a, LS: LoadState<'a>>(
Term::Clause(
cell,
name,
vec![Term::Literal(Cell::default(), Literal::CodeIndex(idx))],
vec![Term::Literal(
Cell::default(),
Literal::CodeIndexOffset(idx.into()),
)],
),
)
}
@@ -469,7 +475,7 @@ pub(super) fn clause_to_query_term<'a, LS: LoadState<'a>>(
mut terms: Vec<Term>,
call_policy: CallPolicy,
) -> QueryTerm {
if let Some(Term::Literal(_, Literal::CodeIndex(_))) = terms.last() {
if let Some(Term::Literal(_, Literal::CodeIndexOffset(_))) = terms.last() {
// supplementary code vector indices are unnecessary for
// root-level clauses.
terms.pop();
@@ -504,7 +510,7 @@ pub(super) fn qualified_clause_to_query_term<'a, LS: LoadState<'a>>(
mut terms: Vec<Term>,
call_policy: CallPolicy,
) -> QueryTerm {
if let Some(Term::Literal(_, Literal::CodeIndex(_))) = terms.last() {
if let Some(Term::Literal(_, Literal::CodeIndexOffset(_))) = terms.last() {
// supplementary code vector indices are unnecessary for
// root-level clauses.
terms.pop();

182
src/machine/system_calls.rs
View File

@@ -25,6 +25,7 @@ use crate::machine::partial_string::*;
use crate::machine::stack::*;
use crate::machine::streams::*;
use crate::machine::{get_structure_index, Machine, VERIFY_ATTR_INTERRUPT_LOC};
use crate::offset_table::*;
use crate::parser::ast::*;
use crate::parser::char_reader::*;
use crate::parser::dashu::Integer;
@@ -821,7 +822,7 @@ impl MachineState {
let mut max_old = -1i64;
if !max_steps.is_var() {
let max_steps = Number::try_from(max_steps);
let max_steps = Number::try_from((max_steps, &self.arena.f64_tbl));
let max_steps_n = match max_steps {
Ok(Number::Fixnum(n)) => Some(n.get_num()),
@@ -1132,7 +1133,7 @@ impl MachineState {
for addr in addrs {
let addr = self.store(self.deref(addr));
match Number::try_from(addr) {
match Number::try_from((addr, &self.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => {
if let Ok(n) = u32::try_from(n.get_num()) {
if let Some(c) = std::char::from_u32(n) {
@@ -1241,7 +1242,13 @@ impl Machine {
let mut bp = self
.indices
.get_predicate_code_index(atom!("$clause"), 2, module_name)
.and_then(|idx| idx.local())
.and_then(|idx| {
self.machine_st
.arena
.code_index_tbl
.lookup(idx.into())
.local()
})
.unwrap();
macro_rules! extract_ptr {
@@ -1431,7 +1438,7 @@ impl Machine {
self.machine_st.error_form(err, stub)
})?;
let index_cell = if index_cell_opt.is_some() {
let index_cell_opt = if index_cell_opt.is_some() {
index_cell_opt
} else {
let is_internal_call = name == atom!("$call") && goal_arity > 0;
@@ -1469,11 +1476,13 @@ impl Machine {
}
};
if let Some(code_index) = index_cell {
if !code_index.as_ptr().is_undefined() {
if let Some(code_idx) = index_cell_opt {
let index_ptr = *self.machine_st.arena.code_index_tbl.lookup(code_idx.into());
if !index_ptr.is_undefined() {
load_registers(&mut self.machine_st, goal, goal_arity);
self.machine_st.neck_cut();
return call_at_index(self, name, arity, code_index.get());
return call_at_index(self, name, arity, index_ptr);
}
}
@@ -1653,7 +1662,7 @@ impl Machine {
let idx = CodeIndex::new(
IndexPtr::index(helper_clause_loc),
&mut self.machine_st.arena,
&mut self.machine_st.arena.code_index_tbl,
);
writer.write_with(|section| {
@@ -1694,7 +1703,7 @@ impl Machine {
let idx_cell = self.machine_st.heap[s.saturating_sub(1)];
if HeapCellValueTag::CodeIndex == idx_cell.get_tag() {
if HeapCellValueTag::CodeIndexOffset == idx_cell.get_tag() {
return true;
}
}
@@ -1846,7 +1855,7 @@ impl Machine {
#[inline(always)]
pub(crate) fn bind_from_register(&mut self) {
let reg = self.deref_register(2);
let n = match Number::try_from(reg) {
let n = match Number::try_from((reg, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).ok(),
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
@@ -2608,7 +2617,7 @@ impl Machine {
let addr = match addr {
addr if addr.is_var() => addr,
addr => match Number::try_from(addr) {
addr => match Number::try_from((addr, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let result: Result<u8, _> = (&*n).try_into();
if let Ok(value) = result {
@@ -2797,7 +2806,7 @@ impl Machine {
a2
}
_ => {
match Number::try_from(a2) {
match Number::try_from((a2, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let n: u32 = (&*n).try_into().unwrap();
@@ -2864,7 +2873,7 @@ impl Machine {
let n = self.deref_register(1);
let chs = self.deref_register(2);
let string = match Number::try_from(n) {
let string = match Number::try_from((n, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Float(OrderedFloat(n))) => fmt_float(n),
Ok(Number::Fixnum(n)) => n.get_num().to_string(),
Ok(Number::Integer(n)) => n.to_string(),
@@ -2892,7 +2901,7 @@ impl Machine {
let n = self.deref_register(1);
let chs = self.machine_st.registers[2];
let string = match Number::try_from(n) {
let string = match Number::try_from((n, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Float(OrderedFloat(n))) => {
format!("{0:<20?}", n)
}
@@ -2979,13 +2988,8 @@ impl Machine {
debug_assert_eq!(arity, 0);
name.as_char().unwrap()
}
/*
(HeapCellValueTag::Char, c) => {
c
}
*/
_ => {
match Number::try_from(a2) {
match Number::try_from((a2, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let n: u32 = (&*n).try_into().unwrap();
let n = std::char::from_u32(n);
@@ -3223,7 +3227,7 @@ impl Machine {
let err = self.machine_st.instantiation_error();
Err(self.machine_st.error_form(err, stub_gen()))
} else {
match Number::try_from(addr) {
match Number::try_from((addr, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let n: u32 = (&*n).try_into().unwrap();
let n = char::try_from(n);
@@ -3370,7 +3374,7 @@ impl Machine {
let err = self.machine_st.instantiation_error();
return Err(self.machine_st.error_form(err, stub_gen()));
} else {
match Number::try_from(addr) {
match Number::try_from((addr, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let n: u8 = (&*n).try_into().unwrap();
@@ -3449,7 +3453,7 @@ impl Machine {
let addr = if addr.is_var() {
addr
} else {
match Number::try_from(addr) {
match Number::try_from((addr, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(ref n)) if (**n).num_eq(&1_i64) => {
fixnum_as_cell!(Fixnum::build_with(-1))
}
@@ -3603,7 +3607,7 @@ impl Machine {
3,
)?;
let num = match Number::try_from(self.deref_register(2)) {
let num = match Number::try_from((self.deref_register(2), &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).unwrap(),
Ok(Number::Integer(n)) => match (&*n).try_into() as Result<usize, _> {
Ok(u) => u,
@@ -3704,7 +3708,7 @@ impl Machine {
let addr = if addr.is_var() {
addr
} else {
match Number::try_from(addr) {
match Number::try_from((addr, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let n: u32 = (&*n).try_into().unwrap();
let n = std::char::from_u32(n);
@@ -4040,7 +4044,7 @@ impl Machine {
} else {
arity_match = |arity_1, arity_2| arity_1 == arity_2;
let arity = match Number::try_from(arity) {
let arity = match Number::try_from((arity, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => Some(n.get_num() as usize),
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
@@ -4299,7 +4303,10 @@ impl Machine {
pub(crate) fn random_integer(&mut self) {
let a1 = self.deref_register(1);
let a2 = self.deref_register(2);
let value = match (Number::try_from(a1), Number::try_from(a2)) {
let value = match (
Number::try_from((a1, &self.machine_st.arena.f64_tbl)),
Number::try_from((a2, &self.machine_st.arena.f64_tbl)),
) {
(Ok(Number::Fixnum(lower)), Ok(Number::Fixnum(upper))) => {
let (lower, upper) = (lower.get_num(), upper.get_num());
if lower >= upper {
@@ -4390,7 +4397,7 @@ impl Machine {
let stub_gen = || functor_stub(atom!("length"), 2);
let len = self.deref_register(2);
let n = match Number::try_from(len) {
let n = match Number::try_from((len, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => n.get_num() as usize,
Ok(Number::Integer(n)) => match (&*n).try_into() as Result<usize, _> {
Ok(n) => n,
@@ -4581,23 +4588,24 @@ impl Machine {
let tls_cert = self.deref_register(4);
let content_length_limit = self.deref_register(5);
const CONTENT_LENGTH_LIMIT_DEFAULT: u64 = 32768;
let content_length_limit = match Number::try_from(content_length_limit) {
Ok(Number::Fixnum(n)) => {
if n.get_num() >= 0 {
n.get_num() as u64
} else {
CONTENT_LENGTH_LIMIT_DEFAULT
let content_length_limit =
match Number::try_from((content_length_limit, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => {
if n.get_num() >= 0 {
n.get_num() as u64
} else {
CONTENT_LENGTH_LIMIT_DEFAULT
}
}
}
Ok(Number::Integer(n)) => {
let n: Result<u64, _> = (&*n).try_into();
match n {
Ok(u) => u,
Err(_) => CONTENT_LENGTH_LIMIT_DEFAULT,
Ok(Number::Integer(n)) => {
let n: Result<u64, _> = (&*n).try_into();
match n {
Ok(u) => u,
Err(_) => CONTENT_LENGTH_LIMIT_DEFAULT,
}
}
}
_ => CONTENT_LENGTH_LIMIT_DEFAULT,
};
_ => CONTENT_LENGTH_LIMIT_DEFAULT,
};
let ssl_server: Option<(String, String)> = {
match self.machine_st.value_to_str_like(tls_key) {
@@ -4864,7 +4872,8 @@ impl Machine {
pub(crate) fn http_answer(&mut self) -> CallResult {
let culprit = self.deref_register(1);
let status_code = self.deref_register(2);
let status_code: u16 = match Number::try_from(status_code) {
let status_code: u16 = match Number::try_from((status_code, &self.machine_st.arena.f64_tbl))
{
Ok(Number::Fixnum(n)) => n.get_num() as u16,
Ok(Number::Integer(n)) => {
let n: Result<u16, _> = (&*n).try_into();
@@ -4994,7 +5003,7 @@ impl Machine {
if let Some(function_name) = self.machine_st.value_to_str_like(function_name) {
let stub_gen = || functor_stub(atom!("foreign_call"), 3);
fn map_arg(machine_st: &mut MachineState, source: HeapCellValue) -> crate::ffi::Value {
match Number::try_from(source) {
match Number::try_from((source, &machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => Value::Int(n.get_num()),
Ok(Number::Float(n)) => Value::Float(n.into_inner()),
_ => {
@@ -5297,7 +5306,7 @@ impl Machine {
let priority = self.deref_register(1);
let specifier = cell_as_atom_cell!(self.deref_register(2)).get_name();
let priority = match Number::try_from(priority) {
let priority = match Number::try_from((priority, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let n: u16 = (&*n).try_into().unwrap();
n
@@ -5465,7 +5474,7 @@ impl Machine {
pub(crate) fn get_attr_var_queue_beyond(&mut self) {
let addr = self.deref_register(1);
let b = match Number::try_from(addr) {
let b = match Number::try_from((addr, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
Some(value)
@@ -5892,7 +5901,7 @@ impl Machine {
pub(crate) fn halt(&mut self) -> std::process::ExitCode {
let code = self.deref_register(1);
let code = match Number::try_from(code) {
let code = match Number::try_from((code, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => u8::try_from(n.get_num()).unwrap(),
Ok(Number::Integer(n)) => {
let n: u8 = (&*n).try_into().unwrap();
@@ -5929,7 +5938,7 @@ impl Machine {
let a1 = self.deref_register(1);
let a2 = self.deref_register(2);
let n = match Number::try_from(a2) {
let n = match Number::try_from((a2, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(bp)) => Integer::from(bp.get_num() as usize),
Ok(Number::Integer(n)) => (*n).clone(),
_ => {
@@ -5974,7 +5983,7 @@ impl Machine {
let name = cell_as_atom!(self.deref_register(2));
let a3 = self.deref_register(3);
let arity = match Number::try_from(a3) {
let arity = match Number::try_from((a3, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => n.get_num() as usize,
Ok(Number::Integer(n)) => {
let result = (&*n).try_into();
@@ -5992,7 +6001,14 @@ impl Machine {
self.indices
.get_predicate_code_index(name, arity, module_name)
.map(|index| index.local().is_some())
.map(|idx| {
self.machine_st
.arena
.code_index_tbl
.lookup(idx.into())
.local()
.is_some()
})
.unwrap_or(false)
}
@@ -6014,7 +6030,10 @@ impl Machine {
arity,
module_name,
)
.map(|index| index.get())
.map(|idx| *self.machine_st
.arena
.code_index_tbl
.lookup(idx.into()))
.unwrap_or(IndexPtr::dynamic_undefined());
!matches!(index.tag(), IndexPtrTag::DynamicUndefined | IndexPtrTag::Undefined)
@@ -6031,7 +6050,10 @@ impl Machine {
0,
module_name,
)
.map(|index| index.get())
.map(|idx| *self.machine_st
.arena
.code_index_tbl
.lookup(idx.into()))
.unwrap_or(IndexPtr::dynamic_undefined());
!matches!(index.tag(), IndexPtrTag::DynamicUndefined)
@@ -6667,7 +6689,7 @@ impl Machine {
pub(crate) fn set_seed(&mut self) {
let seed = self.deref_register(1);
match Number::try_from(seed) {
match Number::try_from((seed, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => {
let n: u64 = Integer::from(n).try_into().unwrap();
let rng: StdRng = SeedableRng::seed_from_u64(n);
@@ -6695,7 +6717,7 @@ impl Machine {
pub(crate) fn sleep(&mut self) {
let time = self.deref_register(1);
let time = match Number::try_from(time) {
let time = match Number::try_from((time, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Float(n)) => n.into_inner(),
Ok(Number::Fixnum(n)) => n.get_num() as f64,
Ok(Number::Integer(n)) => n.to_f64().value(),
@@ -6730,7 +6752,7 @@ impl Machine {
name
}
_ => {
AtomTable::build_with(&self.machine_st.atom_tbl, &match Number::try_from(port) {
AtomTable::build_with(&self.machine_st.atom_tbl, &match Number::try_from((port, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => n.get_num().to_string(),
Ok(Number::Integer(n)) => n.to_string(),
_ => {
@@ -6829,7 +6851,7 @@ impl Machine {
let port = if port.is_var() {
String::from("0")
} else {
match Number::try_from(port) {
match Number::try_from((port, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => n.get_num().to_string(),
Ok(Number::Integer(n)) => n.to_string(),
_ => {
@@ -7107,7 +7129,7 @@ impl Machine {
let position = self.deref_register(2);
let position = match Number::try_from(position) {
let position = match Number::try_from((position, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => n.get_num() as u64,
Ok(Number::Integer(n)) => {
let n: Result<u64, _> = (&*n).try_into();
@@ -7426,7 +7448,7 @@ impl Machine {
let name = cell_as_atom!(self.deref_register(2));
let arity = self.deref_register(3);
let arity = match Number::try_from(arity) {
let arity = match Number::try_from((arity, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => n.get_num() as usize,
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
@@ -7454,22 +7476,23 @@ impl Machine {
},
};
let first_idx = match first_idx {
Some(idx) if idx.local().is_some() => {
if let Some(idx) = idx.local() {
idx
} else {
unreachable!()
}
}
_ => {
let stub = functor_stub(name, arity);
let err = self
.machine_st
.existence_error(ExistenceError::Procedure(name, arity));
let first_idx = first_idx.and_then(|first_idx| {
self.machine_st
.arena
.code_index_tbl
.lookup(first_idx.into())
.local()
});
return Err(self.machine_st.error_form(err, stub));
}
let first_idx = if let Some(idx) = first_idx {
idx
} else {
let stub = functor_stub(name, arity);
let err = self
.machine_st
.existence_error(ExistenceError::Procedure(name, arity));
return Err(self.machine_st.error_form(err, stub));
};
let listing =
@@ -7484,7 +7507,7 @@ impl Machine {
#[inline(always)]
pub(crate) fn inlined_instructions(&mut self) {
let index_ptr = self.deref_register(1);
let index_ptr = match Number::try_from(index_ptr) {
let index_ptr = match Number::try_from((index_ptr, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => n.get_num() as usize,
Ok(Number::Integer(n)) => {
let value: usize = (&*n).try_into().unwrap();
@@ -7843,7 +7866,7 @@ impl Machine {
let length = self.deref_register(6);
let length = match Number::try_from(length) {
let length = match Number::try_from((length, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).unwrap(),
Ok(Number::Integer(n)) => match (&*n).try_into() as Result<usize, _> {
Ok(u) => u,
@@ -7909,7 +7932,7 @@ impl Machine {
let iterations = self.deref_register(3);
let iterations = match Number::try_from(iterations) {
let iterations = match Number::try_from((iterations, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Fixnum(n)) => u64::try_from(n.get_num()).unwrap(),
Ok(Number::Integer(n)) => {
let n: Result<u64, _> = (&*n).try_into();
@@ -8555,7 +8578,10 @@ impl Machine {
#[inline(always)]
pub(crate) fn pop_count(&mut self) {
let number = self.deref_register(1);
let pop_count = integer_as_cell!(match Number::try_from(number) {
let pop_count = integer_as_cell!(match Number::try_from((
number,
&self.machine_st.arena.f64_tbl
)) {
Ok(Number::Fixnum(n)) => {
Number::Fixnum(Fixnum::build_with(n.get_num().count_ones()))
}

28
src/machine/unify.rs
View File

@@ -216,7 +216,9 @@ pub(crate) trait Unifier: DerefMut<Target = MachineState> {
return;
}
match Number::try_from(value) {
let machine_st = self.deref();
match Number::try_from((value, &machine_st.arena.f64_tbl)) {
Ok(n2) => match n2 {
Number::Fixnum(n2) if n1.get_num() == n2.get_num() => {}
Number::Integer(n2) if (*n2).num_eq(&n1.get_num()) => {}
@@ -237,7 +239,9 @@ pub(crate) trait Unifier: DerefMut<Target = MachineState> {
return;
}
match Number::try_from(value) {
let machine_st = self.deref();
match Number::try_from((value, &machine_st.arena.f64_tbl)) {
Ok(n2) => match n2 {
Number::Fixnum(n2) if (*n1).num_eq(&n2.get_num()) => {}
Number::Integer(n2) if (*n1).num_eq(&*n2) => {}
@@ -258,7 +262,9 @@ pub(crate) trait Unifier: DerefMut<Target = MachineState> {
return;
}
match Number::try_from(value) {
let machine_st = self.deref_mut();
match Number::try_from((value, &machine_st.arena.f64_tbl)) {
Ok(n2) => match n2 {
Number::Fixnum(n2) if (*n1).num_eq(&Integer::from(n2.get_num())) => {}
Number::Integer(n2) if (*n1).num_eq(&*n2) => {}
@@ -273,14 +279,19 @@ pub(crate) trait Unifier: DerefMut<Target = MachineState> {
}
}
fn unify_f64(&mut self, f1: F64Ptr, value: HeapCellValue) {
fn unify_f64(&mut self, f1: F64Offset, value: HeapCellValue) {
if let Some(r) = value.as_var() {
Self::bind(self, r, HeapCellValue::from(f1));
return;
}
read_heap_cell!(value,
(HeapCellValueTag::F64, f2) => {
(HeapCellValueTag::F64Offset, f2) => {
let machine_st = self.deref_mut();
let f1 = machine_st.arena.f64_tbl.lookup(f1);
let f2 = machine_st.arena.f64_tbl.lookup(f2.into());
self.fail = **f1 != **f2;
}
_ => {
@@ -414,17 +425,12 @@ pub(crate) trait Unifier: DerefMut<Target = MachineState> {
tabu_list.insert((d1, d2));
}
}
(HeapCellValueTag::F64, f1) => {
(HeapCellValueTag::F64Offset, f1) => {
Self::unify_f64(self, f1, d2);
}
(HeapCellValueTag::Fixnum, n1) => {
Self::unify_fixnum(self, n1, d2);
}
/*
(HeapCellValueTag::Char, c1) => {
Self::unify_char(self, c1, d2);
}
*/
(HeapCellValueTag::Cons, ptr_1) => {
Self::unify_constant(self, ptr_1, d2);
}