}
impl Machine {
+ #[inline(always)]
+ pub(crate) fn deref_register(&mut self, i: usize) -> HeapCellValue {
+ self.machine_st.store(self.machine_st.deref(self.machine_st.registers[i]))
+ }
+
#[inline(always)]
pub(crate) fn call_inline(
&mut self,
call_at_index: impl Fn(&mut Machine, Atom, usize, IndexPtr) -> CallResult,
) -> CallResult {
let arity = arity - 1;
- let goal = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let goal = self.deref_register(1);
let load_registers = |machine_st: &mut MachineState, goal: HeapCellValue| -> Option<PredicateKey> {
read_heap_cell!(goal,
#[inline(always)]
pub(crate) fn compile_inline_or_expanded_goal(&mut self) -> CallResult {
- let goal = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let module_name = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[4]));
+ let goal = self.deref_register(1);
+ let module_name = self.deref_register(4);
// supp_vars are the supplementary variables generated by
// complete_partial_goal prior to goal_expansion.
#[inline(always)]
pub(crate) fn bind_from_register(&mut self) {
- let reg = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let reg = self.deref_register(2);
let n = match Number::try_from(reg) {
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).ok(),
Ok(Number::Integer(n)) => n.to_usize(),
Some(host) => {
let hostname = self.machine_st.atom_tbl.build_with(host);
+ let a1 = self.deref_register(1);
self.machine_st.unify_atom(
hostname,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]))
+ a1
);
return;
#[inline(always)]
pub(crate) fn current_input(&mut self) -> CallResult {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
let stream = self.user_input;
if let Some(var) = addr.as_var() {
#[inline(always)]
pub(crate) fn current_output(&mut self) -> CallResult {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
let stream = self.user_output;
if let Some(var) = addr.as_var() {
#[inline(always)]
pub(crate) fn file_time(&mut self) {
if let Some(file) = self.machine_st.value_to_str_like(self.machine_st.registers[1]) {
- let which = cell_as_atom!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2]
- )));
+ let which = cell_as_atom!(self.deref_register(2));
if let Ok(md) = fs::metadata(file.as_str()) {
if let Ok(time) = match which {
let current_atom = self.machine_st.atom_tbl.build_with(¤t);
+ let a1 = self.deref_register(1);
self.machine_st.unify_complete_string(
current_atom,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1])),
+ a1
);
if self.machine_st.fail {
return Ok(());
}
- let target = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let target = self.deref_register(2);
if let Some(next) = self.machine_st.value_to_str_like(target) {
if env::set_current_dir(std::path::Path::new(next.as_str())).is_ok() {
let canonical_atom = self.machine_st.atom_tbl.build_with(cs);
+ let a2 = self.deref_register(2);
self.machine_st.unify_complete_string(
canonical_atom,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ a2
);
return Ok(());
#[inline(always)]
pub(crate) fn atom_chars(&mut self) {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
+ let a2 = self.deref_register(2);
read_heap_cell!(a1,
(HeapCellValueTag::Char) => {
if arity == 0 {
self.machine_st.unify_complete_string(
name,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ a2,
);
} else {
self.machine_st.fail = true;
if arity == 0 {
self.machine_st.unify_complete_string(
name,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ a2,
);
} else {
self.machine_st.fail = true;
}
}
(HeapCellValueTag::Var | HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar) => {
- let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let a2 = self.deref_register(2);
if let Some(str_like) = self.machine_st.value_to_str_like(a2) {
let atom_cell = match str_like {
#[inline(always)]
pub(crate) fn atom_codes(&mut self) -> CallResult {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
read_heap_cell!(a1,
(HeapCellValueTag::Char, c) => {
#[inline(always)]
pub(crate) fn atom_length(&mut self) {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
let len: i64 = read_heap_cell!(a1,
(HeapCellValueTag::Str, s) => {
}
);
+ let a2 = self.deref_register(2);
self.machine_st.unify_fixnum(
Fixnum::build_with(len),
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ a2,
);
}
#[inline(always)]
pub(crate) fn call_continuation(&mut self, last_call: bool) -> CallResult {
let stub_gen = || functor_stub(atom!("call_continuation"), 1);
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
match self.machine_st.try_from_list(a1, stub_gen) {
Err(e) => Err(e),
#[inline(always)]
pub(crate) fn chars_to_number(&mut self) -> CallResult {
let stub_gen = || functor_stub(atom!("number_chars"), 2);
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
let atom_or_string = self.machine_st.value_to_str_like(a1).unwrap();
self.machine_st.parse_number_from_string(
#[inline(always)]
pub(crate) fn create_partial_string(&mut self) {
let atom = cell_as_atom!(
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]))
+ self.deref_register(1)
);
if atom == atom!("") {
#[inline(always)]
pub(crate) fn is_partial_string(&mut self) {
- let value = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let value = self.deref_register(1);
let h = self.machine_st.heap.len();
self.machine_st.heap.push(value);
#[inline(always)]
pub(crate) fn partial_string_tail(&mut self) {
- let pstr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let pstr = self.deref_register(1);
+ let a2 = self.deref_register(2);
read_heap_cell!(pstr,
(HeapCellValueTag::PStrLoc, h) => {
if HeapCellValueTag::CStr == self.machine_st.heap[h].get_tag() {
self.machine_st.unify_atom(
atom!("[]"),
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]))
+ a2
);
} else {
unify_fn!(
self.machine_st,
heap_loc_as_cell!(h+1),
- self.machine_st.registers[2]
+ a2
);
}
}
(HeapCellValueTag::CStr) => {
self.machine_st.unify_atom(
atom!("[]"),
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]))
+ a2
);
}
(HeapCellValueTag::Lis, h) => {
}
}
+ let addr = self.deref_register(2);
+
if stream.at_end_of_stream() {
stream.set_past_end_of_stream(true);
self.machine_st.unify_fixnum(
Fixnum::build_with(-1),
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ addr,
);
return Ok(());
}
- let addr = match self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])) {
+ match addr {
addr if addr.is_var() => addr,
addr => match Number::try_from(addr) {
Ok(Number::Integer(n)) => {
}
}
+ let a2 = self.deref_register(2);
+
if stream.at_end_of_stream() {
let end_of_file = atom!("end_of_file");
stream.set_past_end_of_stream(true);
self.machine_st.unify_atom(
end_of_file,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ a2,
);
return Ok(());
}
- let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
-
let a2 = read_heap_cell!(a2,
(HeapCellValueTag::Char) => {
a2
}
}
+ let a2 = self.deref_register(2);
+
if stream.at_end_of_stream() {
let end_of_file = atom!("end_of_file");
stream.set_past_end_of_stream(true);
self.machine_st.unify_atom(
end_of_file,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ a2,
);
return Ok(());
}
- let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
-
let addr = read_heap_cell!(a2,
(HeapCellValueTag::Var | HeapCellValueTag::StackVar | HeapCellValueTag::AttrVar) => {
a2
#[inline(always)]
pub(crate) fn number_to_chars(&mut self) {
- let n = self.machine_st.registers[1];
- let chs = self.machine_st.registers[2];
-
- let n = self.machine_st.store(self.machine_st.deref(n));
+ let n = self.deref_register(1);
+ let chs = self.deref_register(2);
let string = match Number::try_from(n) {
Ok(Number::Float(OrderedFloat(n))) => {
let chars_atom = self.machine_st.atom_tbl.build_with(&string.trim());
self.machine_st.unify_complete_string(
chars_atom,
- self.machine_st.store(self.machine_st.deref(chs)),
+ chs,
);
}
#[inline(always)]
pub(crate) fn number_to_codes(&mut self) {
- let n = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let n = self.deref_register(1);
let chs = self.machine_st.registers[2];
let string = match Number::try_from(n) {
#[inline(always)]
pub(crate) fn char_code(&mut self) -> CallResult {
let stub_gen = || functor_stub(atom!("char_code"), 2);
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
+ let a2 = self.deref_register(2);
let c = read_heap_cell!(a1,
(HeapCellValueTag::Atom, (name, _arity)) => {
c
}
_ => {
- let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
-
match Number::try_from(a2) {
Ok(Number::Integer(n)) => {
let c = match n.to_u32().and_then(std::char::from_u32) {
self.machine_st.unify_fixnum(
Fixnum::build_with(c as i64),
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ a2,
);
Ok(())
#[inline(always)]
pub(crate) fn char_type(&mut self) {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let a1 = self.deref_register(1);
+ let a2 = self.deref_register(2);
let c = read_heap_cell!(a1,
(HeapCellValueTag::Char, c) => {
#[inline(always)]
pub(crate) fn check_cut_point(&mut self) {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
let old_b = cell_as_fixnum!(addr).get_num() as usize;
let prev_b = self.machine_st.stack.index_or_frame(self.machine_st.b).prelude.b;
#[inline(always)]
pub(crate) fn fetch_global_var(&mut self) {
- let key = cell_as_atom!(self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1])));
+ let key = cell_as_atom!(self.deref_register(1));
let addr = self.machine_st.registers[2];
match self.indices.global_variables.get_mut(&key) {
)?;
let stub_gen = || functor_stub(atom!("put_code"), 2);
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let addr = self.deref_register(2);
if addr.is_var() {
let err = self.machine_st.instantiation_error();
)?;
let stub_gen = || functor_stub(atom!("put_char"), 2);
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let addr = self.deref_register(2);
if addr.is_var() {
let err = self.machine_st.instantiation_error();
)?;
let stub_gen = || functor_stub(atom!("put_byte"), 2);
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let addr = self.deref_register(2);
if addr.is_var() {
let err = self.machine_st.instantiation_error();
}
let stub_gen = || functor_stub(atom!("get_byte"), 2);
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let addr = self.deref_register(2);
let addr = if addr.is_var() {
addr
}
}
+ let addr = self.deref_register(2);
+
if stream.at_end_of_stream() {
let end_of_file = atom!("end_of_file");
stream.set_past_end_of_stream(true);
self.machine_st.unify_atom(
end_of_file,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]))
+ addr
);
return Ok(());
let stub_gen = || functor_stub(atom!("get_char"), 2);
let mut iter = self.machine_st.open_parsing_stream(stream, atom!("get_char"), 2)?;
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
-
let addr = if addr.is_var() {
addr
} else {
3,
)?;
- let num = match Number::try_from(self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]))) {
+ let num = match Number::try_from(self.deref_register(2)) {
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).unwrap(),
Ok(Number::Integer(n)) => match n.to_usize() {
Some(u) => u,
}
};
- let output = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
+ let output = self.deref_register(3);
let atom = self.machine_st.atom_tbl.build_with(&string);
self.machine_st.unify_complete_string(atom, output);
}
}
+ let addr = self.deref_register(2);
+
if stream.at_end_of_stream() {
stream.set_past_end_of_stream(true);
self.machine_st.unify_fixnum(
Fixnum::build_with(-1),
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ addr,
);
return Ok(());
}
let stub_gen = || functor_stub(atom!("get_code"), 2);
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
let addr = if addr.is_var() {
addr
if let Some(first_stream) = first_stream {
let stream = stream_as_cell!(first_stream);
- let var = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- )).as_var().unwrap();
+ let var = self.deref_register(1).as_var().unwrap();
self.machine_st.bind(var, stream);
} else {
#[inline(always)]
pub(crate) fn next_stream(&mut self) {
- let prev_stream = cell_as_stream!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- )));
+ let prev_stream = cell_as_stream!(self.deref_register(1));
let mut next_stream = None;
let mut null_streams = BTreeSet::new();
self.indices.streams = self.indices.streams.sub(&null_streams);
if let Some(next_stream) = next_stream {
- let var = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2]
- )).as_var().unwrap();
+ let var = self.deref_register(2).as_var().unwrap();
let next_stream = stream_as_cell!(next_stream);
self.machine_st.bind(var, next_stream);
_ => unreachable!(),
};
+ let a1 = self.deref_register(1);
self.machine_st.unify_char(
c,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1])),
+ a1,
);
Ok(())
#[inline(always)]
pub(crate) fn head_is_dynamic(&mut self) {
- let module_name = cell_as_atom!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1])
- ));
+ let module_name = cell_as_atom!(self.deref_register(1));
let (name, arity) = read_heap_cell!(
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ self.deref_register(2),
(HeapCellValueTag::Str, s) => {
cell_as_atom_cell!(self.machine_st.heap[s]).get_name_and_arity()
}
#[inline(always)]
pub(crate) fn copy_to_lifted_heap(&mut self) {
let lh_offset = cell_as_fixnum!(
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]))
+ self.deref_register(1)
).get_num() as usize;
let copy_target = self.machine_st.registers[2];
#[inline(always)]
pub(crate) fn delete_attribute(&mut self) {
- let ls0 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let ls0 = self.deref_register(1);
if let HeapCellValueTag::Lis = ls0.get_tag() {
let l1 = ls0.get_value();
#[inline(always)]
pub(crate) fn delete_head_attribute(&mut self) {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
debug_assert_eq!(addr.get_tag(), HeapCellValueTag::AttrVar);
&mut self,
narity: usize,
) -> Result<(Atom, PredicateKey), MachineStub> {
- let module_name = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- ));
+ let module_name = self.deref_register(1);
let module_name = read_heap_cell!(module_name,
(HeapCellValueTag::Atom, (name, _arity)) => {
}
);
- let goal = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2]
- ));
+ let goal = self.deref_register(2);
let (name, arity, s) = self.machine_st.setup_call_n_init_goal_info(goal, narity)?;
#[inline(always)]
pub(crate) fn enqueue_attributed_var(&mut self) {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
read_heap_cell!(addr,
(HeapCellValueTag::AttrVar, h) => {
#[inline(always)]
pub(crate) fn get_next_db_ref(&mut self) {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
if let Some(name_var) = a1.as_var() {
let mut iter = self.indices.code_dir.iter();
self.machine_st.fail = true;
} else if a1.get_tag() == HeapCellValueTag::Atom {
let name = cell_as_atom!(a1);
- let arity = cell_as_fixnum!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2])
- )).get_num() as usize;
+ let arity = cell_as_fixnum!(self.deref_register(2)).get_num() as usize;
match self.machine_st.get_next_db_ref(&self.indices, &DBRef::NamedPred(name, arity)) {
Some(DBRef::NamedPred(name, arity)) => {
#[inline(always)]
pub(crate) fn get_next_op_db_ref(&mut self) {
- let prec = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let prec = self.deref_register(1);
if let Some(prec_var) = prec.as_var() {
- let spec = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
- let op = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
- let orig_op = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[7]));
+ let spec = self.deref_register(2);
+ let op = self.deref_register(3);
+ let orig_op = self.deref_register(7);
let spec_num = if spec.get_tag() == HeapCellValueTag::Atom {
(match cell_as_atom!(spec) {
match ossified_op_dir.iter().next() {
Some(((op_atom, _), (op_prec, op_spec))) => {
- let ossified_op_dir_var = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[4]
- )).as_var().unwrap();
+ let ossified_op_dir_var = self.deref_register(4).as_var().unwrap();
let spec_atom = match *op_spec {
FX => atom!("fx"),
}
}
} else {
- let spec = cell_as_atom!(self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])));
- let op_atom = cell_as_atom!(self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3])));
- let ossified_op_dir_cell = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[4]));
+ let spec = cell_as_atom!(self.deref_register(2));
+ let op_atom = cell_as_atom!(self.deref_register(3));
+ let ossified_op_dir_cell = self.deref_register(4);
if ossified_op_dir_cell.is_var() {
self.machine_st.fail = true;
#[inline(always)]
pub(crate) fn det_length_rundown(&mut self) -> CallResult {
let stub_gen = || functor_stub(atom!("length"), 2);
- let len = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let len = self.deref_register(2);
let n = match Number::try_from(len) {
Ok(Number::Fixnum(n)) => n.get_num() as usize,
(0 .. n).map(|i| heap_loc_as_cell!(h + 2 * i + 1)),
);
- let tail = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let tail = self.deref_register(1);
self.machine_st.bind(tail.as_var().unwrap(), heap_loc_as_cell!(h));
Ok(())
#[inline(always)]
pub(crate) fn http_open(&mut self) -> CallResult {
- let address_sink = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let method = read_heap_cell!(self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3])),
+ let address_sink = self.deref_register(1);
+ let method = read_heap_cell!(self.deref_register(3),
(HeapCellValueTag::Atom, (name, arity)) => {
debug_assert_eq!(arity, 0);
match name {
unreachable!()
}
);
- let address_status = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[4]));
- let address_data = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[5]));
+ let address_status = self.deref_register(4);
+ let address_data = self.deref_register(5);
let mut bytes: Vec<u8> = Vec::new();
if let Some(string) = self.machine_st.value_to_str_like(address_data) {
bytes = string.as_str().bytes().collect();
stream_as_cell!(stream)
});
- let stream_addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let stream_addr = self.deref_register(2);
self.machine_st.bind(stream_addr.as_var().unwrap(), stream);
} else {
#[inline(always)]
pub(crate) fn http_listen(&mut self) -> CallResult {
- let address_sink = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let address_sink = self.deref_register(1);
if let Some(address_str) = self.machine_st.value_to_str_like(address_sink) {
let address_string = address_str.as_str();
let addr: SocketAddr = match address_string.to_socket_addrs().ok().and_then(|mut s| s.next()) {
});
let http_listener = HttpListener { incoming: rx };
let http_listener = arena_alloc!(http_listener, &mut self.machine_st.arena);
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let addr = self.deref_register(2);
self.machine_st.bind(addr.as_var().unwrap(), typed_arena_ptr_as_cell!(http_listener));
}
Ok(())
#[inline(always)]
pub(crate) fn http_accept(&mut self) -> CallResult {
- let culprit = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let method = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
- let path = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
- let query = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[5]));
- let stream_addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[6]));
- let handle_addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[7]));
+ let culprit = self.deref_register(1);
+ let method = self.deref_register(2);
+ let path = self.deref_register(3);
+ let query = self.deref_register(5);
+ let stream_addr = self.deref_register(6);
+ let handle_addr = self.deref_register(7);
read_heap_cell!(culprit,
(HeapCellValueTag::Cons, cons_ptr) => {
match_untyped_arena_ptr!(cons_ptr,
#[inline(always)]
pub(crate) fn http_answer(&mut self) -> CallResult {
- let culprit = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let status_code = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let culprit = self.deref_register(1);
+ let status_code = self.deref_register(2);
let status_code: u16 = match Number::try_from(status_code) {
Ok(Number::Fixnum(n)) => n.get_num() as u16,
Ok(Number::Integer(n)) => match n.to_u16() {
},
Err(e) => return Err(e)
};
- let stream_addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[4]));
+ let stream_addr = self.deref_register(4);
read_heap_cell!(culprit,
(HeapCellValueTag::Cons, cons_ptr) => {
let stream_type = self.machine_st.registers[7];
let options = self.machine_st.to_stream_options(alias, eof_action, reposition, stream_type);
- let src_sink = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let src_sink = self.deref_register(1);
if let Some(file_spec) = self.machine_st.value_to_str_like(src_sink) {
let file_spec = file_spec.as_atom(&mut self.machine_st.atom_tbl);
self.indices.stream_aliases.insert(alias, stream);
}
- let stream_var = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
+ let stream_var = self.deref_register(3);
self.machine_st.bind(stream_var.as_var().unwrap(), stream_as_cell!(stream));
} else {
let err = self.machine_st.domain_error(DomainErrorType::SourceSink, src_sink);
#[inline(always)]
pub(crate) fn get_attributed_variable_list(&mut self) {
- let attr_var = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let attr_var = self.deref_register(1);
let attr_var_list = read_heap_cell!(attr_var,
(HeapCellValueTag::AttrVar, h) => {
h + 1
}
);
- let list_addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let list_addr = self.deref_register(2);
self.machine_st.bind(Ref::heap_cell(attr_var_list), list_addr);
}
#[inline(always)]
pub(crate) fn get_continuation_chunk(&mut self) {
- let e = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let e = self.deref_register(1);
let e = cell_as_fixnum!(e).get_num() as usize;
- let p_functor = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2]
- ));
+ let p_functor = self.deref_register(2);
let p = to_local_code_ptr(&self.machine_st.heap, p_functor).unwrap();
#[inline(always)]
pub(crate) fn get_double_quotes(&mut self) {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
self.machine_st.unify_atom(
match self.machine_st.flags.double_quotes {
#[inline(always)]
pub(crate) fn halt(&mut self) {
- let code = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let code = self.deref_register(1);
let code = match Number::try_from(code) {
Ok(Number::Fixnum(n)) => i32::try_from(n.get_num()).unwrap(),
#[inline(always)]
pub(crate) fn install_inference_counter(&mut self) -> CallResult {
// A1 = B, A2 = L
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let a1 = self.deref_register(1);
+ let a2 = self.deref_register(2);
let n = match Number::try_from(a2) {
Ok(Number::Fixnum(bp)) => bp.get_num() as usize,
self.machine_st.increment_call_count_fn = MachineState::increment_call_count;
- let a3 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
+ let a3 = self.deref_register(3);
self.machine_st.unify_big_int(count, a3);
Ok(())
#[inline(always)]
pub(crate) fn module_exists(&mut self) {
- let module = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let module = self.deref_register(1);
let module_name = cell_as_atom!(module);
self.machine_st.fail = !self.indices.modules.contains_key(&module_name);
}
- pub(crate) fn predicate_defined(&self) -> bool {
- let module_name = cell_as_atom!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- )));
-
- let name = cell_as_atom!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2]
- )));
+ pub(crate) fn predicate_defined(&mut self) -> bool {
+ let module_name = cell_as_atom!(self.deref_register(1));
+ let name = cell_as_atom!(self.deref_register(2));
+ let a3 = self.deref_register(3);
- let arity = match Number::try_from(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[3]
- ))) {
+ let arity = match Number::try_from(a3) {
Ok(Number::Fixnum(n)) => n.get_num() as usize,
Ok(Number::Integer(n)) => {
if let Some(n) = n.to_usize() {
#[inline(always)]
pub(crate) fn no_such_predicate(&mut self) -> CallResult {
- let module_name = cell_as_atom!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- )));
+ let module_name = cell_as_atom!(self.deref_register(1));
- let head = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let head = self.deref_register(2);
self.machine_st.fail = read_heap_cell!(head,
(HeapCellValueTag::Str, s) => {
}
#[inline(always)]
pub(crate) fn redo_attr_var_binding(&mut self) {
- let var = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let value = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let var = self.deref_register(1);
+ let value = self.deref_register(2);
debug_assert_eq!(HeapCellValueTag::AttrVar, var.get_tag());
self.machine_st.heap[var.get_value()] = value;
#[inline(always)]
pub(crate) fn remove_call_policy_check(&mut self) {
- let bp = cell_as_fixnum!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- ))).get_num() as usize;
+ let bp = cell_as_fixnum!(self.deref_register(1)).get_num() as usize;
if bp == self.machine_st.b && self.machine_st.cwil.is_empty() {
self.machine_st.cwil.reset();
#[inline(always)]
pub(crate) fn remove_inference_counter(&mut self) {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
let bp = cell_as_fixnum!(a1).get_num() as usize;
let count = self.machine_st.cwil.remove_limit(bp).clone();
let count = arena_alloc!(count.clone(), &mut self.machine_st.arena);
- let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let a2 = self.deref_register(2);
self.machine_st.unify_big_int(count, a2);
}
#[inline(always)]
pub(crate) fn set_input(&mut self) -> CallResult {
- let addr = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- ));
+ let addr = self.deref_register(1);
let stream = self.machine_st.get_stream_or_alias(
addr,
#[inline(always)]
pub(crate) fn set_output(&mut self) -> CallResult {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
let stream = self.machine_st.get_stream_or_alias(
addr,
&self.indices.stream_aliases,
#[inline(always)]
pub(crate) fn inference_level(&mut self) {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let a2 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let a1 = self.deref_register(1);
+ let a2 = self.deref_register(2);
let bp = cell_as_fixnum!(a2).get_num() as usize;
let prev_b = self.machine_st.stack.index_or_frame(self.machine_st.b).prelude.b;
#[inline(always)]
pub(crate) fn clean_up_block(&mut self) {
- let nb = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let nb = self.deref_register(1);
let nb = cell_as_fixnum!(nb).get_num() as usize;
let b = self.machine_st.b;
#[inline(always)]
pub(crate) fn get_ball(&mut self) {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
let h = self.machine_st.heap.len();
if self.machine_st.ball.stub.len() > 0 {
pub(crate) fn get_staggered_cut_point(&mut self) {
use std::sync::Once;
- let b = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let b = self.deref_register(1);
static mut SEMICOLON_SECOND_BRANCH_LOC: usize = 0;
static LOC_INIT: Once = Once::new();
#[inline(always)]
pub(crate) fn next_ep(&mut self) {
- let first_arg = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let first_arg = self.deref_register(1);
let next_ep_atom = |machine_st: &mut MachineState, name, arity| {
debug_assert_eq!(name, atom!("first"));
#[inline(always)]
pub(crate) fn points_to_continuation_reset_marker(&mut self) {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
let p = match to_local_code_ptr(&self.machine_st.heap, addr) {
Some(p) => p + 1,
#[inline(always)]
pub(crate) fn quoted_token(&mut self) {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
read_heap_cell!(addr,
(HeapCellValueTag::Fixnum, n) => {
};
let result = heap_loc_as_cell!(term_write_result.heap_loc);
- let var = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2]
- )).as_var().unwrap();
+ let var = self.deref_register(2).as_var().unwrap();
self.machine_st.bind(var, result);
} else {
#[inline(always)]
pub(crate) fn set_seed(&mut self) {
- let seed = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let seed = self.deref_register(1);
let mut rand = RANDOM_STATE.borrow_mut();
match Number::try_from(seed) {
#[inline(always)]
pub(crate) fn sleep(&mut self) {
- let time = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let time = self.deref_register(1);
let time = match Number::try_from(time) {
Ok(Number::Float(n)) => n.into_inner(),
#[inline(always)]
pub(crate) fn socket_client_open(&mut self) -> CallResult {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
- let port = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let addr = self.deref_register(1);
+ let port = self.deref_register(2);
let socket_atom = cell_as_atom!(addr);
}
};
- let stream_addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
+ let stream_addr = self.deref_register(3);
self.machine_st.bind(stream_addr.as_var().unwrap(), stream);
Ok(())
#[inline(always)]
pub(crate) fn socket_server_open(&mut self) -> CallResult {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
let socket_atom = cell_as_atom_cell!(addr).get_name();
let socket_atom = if socket_atom == atom!("[]") {
socket_atom
};
- let port = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let port = self.deref_register(2);
let port = if port.is_var() {
String::from("0")
}
};
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
+ let addr = self.deref_register(3);
self.machine_st.bind(addr.as_var().unwrap(), typed_arena_ptr_as_cell!(tcp_listener));
if had_zero_port {
}
}
- let culprit = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let culprit = self.deref_register(1);
read_heap_cell!(culprit,
(HeapCellValueTag::Cons, cons_ptr) => {
let tcp_stream = stream_as_cell!(tcp_stream);
let client = atom_as_cell!(client);
- let client_addr = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2],
- ));
- let stream_addr = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[3],
- ));
+ let client_addr = self.deref_register(2);
+ let stream_addr = self.deref_register(3);
self.machine_st.bind(client_addr.as_var().unwrap(), client);
self.machine_st.bind(stream_addr.as_var().unwrap(), tcp_stream);
self.indices.streams.insert(stream);
self.machine_st.heap.push(stream_as_cell!(stream));
- let stream_addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
+ let stream_addr = self.deref_register(3);
self.machine_st.bind(stream_addr.as_var().unwrap(), stream_as_cell!(stream));
Ok(())
let stream = Stream::from_tls_stream(atom!("TLS"), stream, &mut self.machine_st.arena);
self.indices.streams.insert(stream);
- let stream_addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[4]));
+ let stream_addr = self.deref_register(4);
self.machine_st.bind(stream_addr.as_var().unwrap(), stream_as_cell!(stream));
} else {
unreachable!();
#[inline(always)]
pub(crate) fn socket_server_close(&mut self) -> CallResult {
- let culprit = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let culprit = self.deref_register(1);
read_heap_cell!(culprit,
(HeapCellValueTag::Cons, cons_ptr) => {
return Err(self.machine_st.error_form(err, stub));
}
- let position = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let position = self.deref_register(2);
let position = match Number::try_from(position) {
Ok(Number::Fixnum(n)) => n.get_num() as u64,
2,
)?;
- let atom = cell_as_atom!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[2]
- )));
+ let atom = cell_as_atom!(self.deref_register(2));
let property = match atom {
atom!("file_name") => {
#[inline(always)]
pub(crate) fn store_global_var(&mut self) {
- let key = cell_as_atom!(self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1])));
+ let key = cell_as_atom!(self.deref_register(1));
let value = self.machine_st.registers[2];
let mut ball = Ball::new();
#[inline(always)]
pub(crate) fn store_backtrackable_global_var(&mut self) {
- let key = cell_as_atom!(self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1])));
- let new_value = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]));
+ let key = cell_as_atom!(self.deref_register(1));
+ let new_value = self.deref_register(2);
match self.indices.global_variables.get_mut(&key) {
Some((_, ref mut loc)) => match loc {
#[inline(always)]
pub(crate) fn term_attributed_variables(&mut self) {
if self.machine_st.registers[1].is_constant() {
+ let a2 = self.deref_register(2);
self.machine_st.unify_atom(
atom!("[]"),
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2])),
+ a2,
);
return;
#[inline(always)]
pub(crate) fn term_variables(&mut self) {
- let a1 = self.machine_st.registers[1];
- let a2 = self.machine_st.registers[2];
-
- let stored_v = self.machine_st.store(self.machine_st.deref(a1));
+ let stored_v = self.deref_register(1);
+ let a2 = self.deref_register(2);
if stored_v.is_constant() {
- self.machine_st.unify_atom(atom!("[]"), self.machine_st.store(self.machine_st.deref(a2)));
+ self.machine_st.unify_atom(atom!("[]"), a2);
return;
}
pub(crate) fn term_variables_under_max_depth(&mut self) {
// Term, MaxDepth, VarList
let max_depth = cell_as_fixnum!(
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[2]))
+ self.deref_register(2)
).get_num() as usize;
self.machine_st.term_variables_under_max_depth(
#[inline(always)]
pub(crate) fn truncate_lifted_heap_to(&mut self) {
- let a1 = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let a1 = self.deref_register(1);
let lh_offset = cell_as_fixnum!(a1).get_num() as usize;
self.machine_st.lifted_heap.truncate(lh_offset);
#[inline(always)]
pub(crate) fn wam_instructions(&mut self) -> CallResult {
- let module_name = cell_as_atom!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1])
- ));
-
- let name = self.machine_st.registers[2];
- let arity = self.machine_st.registers[3];
-
- let name = cell_as_atom!(self.machine_st.store(self.machine_st.deref(name)));
- let arity = self.machine_st.store(self.machine_st.deref(arity));
+ let module_name = cell_as_atom!(self.deref_register(1));
+ let name = cell_as_atom!(self.deref_register(2));
+ let arity = self.deref_register(3);
let arity = match Number::try_from(arity) {
Ok(Number::Fixnum(n)) => n.get_num() as usize,
&mut self.machine_st.atom_tbl,
);
- let result_addr = self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- ));
+ let result_addr = self.deref_register(1);
if let Some(var) = result_addr.as_var() {
self.machine_st.bind(var, chars);
let buffer = git_version!(cargo_prefix = "cargo:", fallback = "unknown");
let buffer_atom = self.machine_st.atom_tbl.build_with(buffer);
+ let a1 = self.deref_register(1);
self.machine_st.unify_complete_string(
buffer_atom,
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1])),
+ a1,
);
}
let algorithm = cell_as_atom!(self.machine_st.registers[5]);
- let length = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[6]));
+ let length = self.deref_register(6);
let length = match Number::try_from(length) {
Ok(Number::Fixnum(n)) => usize::try_from(n.get_num()).unwrap(),
let stub2_gen = || functor_stub(atom!("crypto_password_hash"), 3);
let salt = self.machine_st.integers_to_bytevec(self.machine_st.registers[2], stub2_gen);
- let iterations = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[3]));
+ let iterations = self.deref_register(3);
let iterations = match Number::try_from(iterations) {
Ok(Number::Fixnum(n)) => u64::try_from(n.get_num()).unwrap(),
#[inline(always)]
pub(crate) fn crypto_data_decrypt(&mut self) {
let data = self.string_encoding_bytes(self.machine_st.registers[1], atom!("octet"));
- let encoding = cell_as_atom!(self.machine_st.store(self.machine_st.deref(self.machine_st.registers[5])));
+ let encoding = cell_as_atom!(self.deref_register(5));
let aad = self.string_encoding_bytes(self.machine_st.registers[2], encoding);
let stub1_gen = || functor_stub(atom!("crypto_data_decrypt"), 7);
#[inline(always)]
pub(crate) fn first_non_octet(&mut self) {
- let addr = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let addr = self.deref_register(1);
if let Some(string) = self.machine_st.value_to_str_like(addr) {
for c in string.as_str().chars() {
}
}
+ let a1 = self.deref_register(1);
let command = self.machine_st.value_to_str_like(
- self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]))
+ a1
).unwrap();
match env::var("SHELL") {
}
};
- if self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1])).is_var() {
+ if self.deref_register(1).is_var() {
let b64 = self.machine_st.value_to_str_like(self.machine_st.registers[2]).unwrap();
let bytes = base64::decode_config(b64.as_str(), config);
#[inline(always)]
pub(crate) fn load_library_as_stream(&mut self) -> CallResult {
- let library_name = cell_as_atom!(self.machine_st.store(self.machine_st.deref(
- self.machine_st.registers[1]
- )));
+ let library_name = cell_as_atom!(self.deref_register(1));
use crate::machine::LIBRARIES;
#[inline(always)]
pub(crate) fn pop_count(&mut self) {
- let number = self.machine_st.store(self.machine_st.deref(self.machine_st.registers[1]));
+ let number = self.deref_register(1);
let pop_count = integer_as_cell!(match Number::try_from(number) {
Ok(Number::Fixnum(n)) => {
Number::Fixnum(Fixnum::build_with(n.get_num().count_ones() as i64))
projects / scryer-prolog.git / commitdiff