From 56e5da6680f9259e292285b7a1dd2901d55b13a7 Mon Sep 17 00:00:00 2001 From: Markus Triska Date: Tue, 6 Dec 2022 20:24:08 +0100 Subject: [PATCH] introduce and use deref_register(n) --- src/machine/system_calls.rs | 411 ++++++++++++++++-------------------- 1 file changed, 187 insertions(+), 224 deletions(-) diff --git a/src/machine/system_calls.rs b/src/machine/system_calls.rs index 87ab9e48..f0dbc178 100644 --- a/src/machine/system_calls.rs +++ b/src/machine/system_calls.rs @@ -988,6 +988,11 @@ impl MachineState { } 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, @@ -995,7 +1000,7 @@ impl Machine { 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 { read_heap_cell!(goal, @@ -1060,8 +1065,8 @@ impl Machine { #[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. @@ -1364,7 +1369,7 @@ impl Machine { #[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(), @@ -1393,9 +1398,10 @@ impl Machine { 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; @@ -1410,7 +1416,7 @@ impl Machine { #[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() { @@ -1445,7 +1451,7 @@ impl Machine { #[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() { @@ -1562,9 +1568,7 @@ impl Machine { #[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 { @@ -1677,16 +1681,17 @@ impl Machine { 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() { @@ -1717,9 +1722,10 @@ impl Machine { 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(()); @@ -1735,7 +1741,8 @@ impl Machine { #[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) => { @@ -1753,7 +1760,7 @@ impl Machine { 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; @@ -1763,14 +1770,14 @@ impl Machine { 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 { @@ -1800,7 +1807,7 @@ impl Machine { #[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) => { @@ -1861,7 +1868,7 @@ impl Machine { #[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) => { @@ -1891,16 +1898,17 @@ impl Machine { } ); + 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), @@ -1925,7 +1933,7 @@ impl Machine { #[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( @@ -1938,7 +1946,7 @@ impl Machine { #[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!("") { @@ -1961,7 +1969,7 @@ impl Machine { #[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); @@ -1978,7 +1986,8 @@ impl Machine { #[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) => { @@ -1987,20 +1996,20 @@ impl Machine { 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) => { @@ -2043,18 +2052,20 @@ impl Machine { } } + 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)) => { @@ -2136,20 +2147,20 @@ impl Machine { } } + 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 @@ -2233,20 +2244,20 @@ impl Machine { } } + 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 @@ -2319,10 +2330,8 @@ impl Machine { #[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))) => { @@ -2344,13 +2353,13 @@ impl Machine { 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) { @@ -2406,7 +2415,8 @@ impl Machine { #[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)) => { @@ -2423,8 +2433,6 @@ impl Machine { 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) { @@ -2462,7 +2470,7 @@ impl Machine { 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(()) @@ -2470,8 +2478,8 @@ impl Machine { #[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) => { @@ -2558,7 +2566,7 @@ impl Machine { #[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; @@ -2576,7 +2584,7 @@ impl Machine { #[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) { @@ -2621,7 +2629,7 @@ impl Machine { )?; 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(); @@ -2671,7 +2679,7 @@ impl Machine { )?; 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(); @@ -2757,7 +2765,7 @@ impl Machine { )?; 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(); @@ -2833,7 +2841,7 @@ impl Machine { } 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 @@ -2912,13 +2920,15 @@ impl Machine { } } + 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(()); @@ -2927,8 +2937,6 @@ impl Machine { 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 { @@ -2983,7 +2991,7 @@ impl Machine { 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, @@ -3025,7 +3033,7 @@ impl Machine { } }; - 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); @@ -3057,19 +3065,20 @@ impl Machine { } } + 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 @@ -3155,9 +3164,7 @@ impl Machine { 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 { @@ -3167,9 +3174,7 @@ impl Machine { #[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(); @@ -3191,9 +3196,7 @@ impl Machine { 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); @@ -3252,9 +3255,10 @@ impl Machine { _ => 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(()) @@ -3262,12 +3266,10 @@ impl Machine { #[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() } @@ -3337,7 +3339,7 @@ impl Machine { #[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]; @@ -3354,7 +3356,7 @@ impl Machine { #[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(); @@ -3392,7 +3394,7 @@ impl Machine { #[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); @@ -3422,9 +3424,7 @@ impl Machine { &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)) => { @@ -3446,9 +3446,7 @@ impl Machine { } ); - 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)?; @@ -3477,7 +3475,7 @@ impl Machine { #[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) => { @@ -3490,7 +3488,7 @@ impl Machine { #[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(); @@ -3508,9 +3506,7 @@ impl Machine { 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)) => { @@ -3534,12 +3530,12 @@ impl Machine { #[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) { @@ -3666,9 +3662,7 @@ impl Machine { 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"), @@ -3698,9 +3692,9 @@ impl Machine { } } } 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; @@ -3783,7 +3777,7 @@ impl Machine { #[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, @@ -3806,7 +3800,7 @@ impl Machine { (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(()) @@ -3814,8 +3808,8 @@ impl Machine { #[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 { @@ -3832,8 +3826,8 @@ impl Machine { 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 = Vec::new(); if let Some(string) = self.machine_st.value_to_str_like(address_data) { bytes = string.as_str().bytes().collect(); @@ -3915,7 +3909,7 @@ impl Machine { 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 { @@ -3930,7 +3924,7 @@ impl Machine { #[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()) { @@ -3965,7 +3959,7 @@ impl Machine { }); 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(()) @@ -3973,12 +3967,12 @@ impl Machine { #[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, @@ -4056,8 +4050,8 @@ impl Machine { #[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() { @@ -4089,7 +4083,7 @@ impl Machine { }, 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) => { @@ -4139,7 +4133,7 @@ impl Machine { 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); @@ -4157,7 +4151,7 @@ impl Machine { 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); @@ -4262,7 +4256,7 @@ impl Machine { #[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 @@ -4283,7 +4277,7 @@ impl Machine { } ); - 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); } @@ -4323,12 +4317,10 @@ impl Machine { #[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(); @@ -4421,7 +4413,7 @@ impl Machine { #[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 { @@ -4457,7 +4449,7 @@ impl Machine { #[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(), @@ -4491,8 +4483,8 @@ impl Machine { #[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, @@ -4514,7 +4506,7 @@ impl Machine { 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(()) @@ -4522,24 +4514,18 @@ impl Machine { #[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() { @@ -4563,11 +4549,9 @@ impl Machine { #[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) => { @@ -4623,8 +4607,8 @@ impl Machine { } #[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; @@ -4653,9 +4637,7 @@ impl Machine { #[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(); @@ -4665,13 +4647,13 @@ impl Machine { #[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); } @@ -4720,9 +4702,7 @@ impl Machine { #[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, @@ -4750,7 +4730,7 @@ impl Machine { #[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, @@ -4792,8 +4772,8 @@ impl Machine { #[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; @@ -4807,7 +4787,7 @@ impl Machine { #[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; @@ -4819,7 +4799,7 @@ impl Machine { #[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 { @@ -4881,7 +4861,7 @@ impl Machine { 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(); @@ -4935,7 +4915,7 @@ impl Machine { #[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")); @@ -5004,7 +4984,7 @@ impl Machine { #[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, @@ -5021,7 +5001,7 @@ impl Machine { #[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) => { @@ -5102,9 +5082,7 @@ impl Machine { }; 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 { @@ -5137,7 +5115,7 @@ impl Machine { #[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) { @@ -5152,7 +5130,7 @@ impl Machine { #[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(), @@ -5171,8 +5149,8 @@ impl Machine { #[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); @@ -5259,7 +5237,7 @@ impl Machine { } }; - 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(()) @@ -5267,7 +5245,7 @@ impl Machine { #[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!("[]") { @@ -5276,7 +5254,7 @@ impl Machine { 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") @@ -5319,7 +5297,7 @@ impl Machine { } }; - 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 { @@ -5352,7 +5330,7 @@ impl Machine { } } - 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) => { @@ -5379,12 +5357,8 @@ impl Machine { 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); @@ -5433,7 +5407,7 @@ impl Machine { 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(()) @@ -5483,7 +5457,7 @@ impl Machine { 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!(); @@ -5494,7 +5468,7 @@ impl Machine { #[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) => { @@ -5543,7 +5517,7 @@ impl Machine { 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, @@ -5573,9 +5547,7 @@ impl Machine { 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") => { @@ -5647,7 +5619,7 @@ impl Machine { #[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(); @@ -5665,8 +5637,8 @@ impl Machine { #[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 { @@ -5691,9 +5663,10 @@ impl Machine { #[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; @@ -5709,13 +5682,11 @@ impl Machine { #[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; } @@ -5734,7 +5705,7 @@ impl Machine { 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( @@ -5746,7 +5717,7 @@ impl Machine { #[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); @@ -5784,15 +5755,9 @@ impl Machine { #[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, @@ -5968,9 +5933,7 @@ impl Machine { &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); @@ -5988,9 +5951,10 @@ impl Machine { 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, ); } @@ -6167,7 +6131,7 @@ impl Machine { 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(), @@ -6229,7 +6193,7 @@ impl Machine { 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(), @@ -6318,7 +6282,7 @@ impl Machine { #[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); @@ -6473,7 +6437,7 @@ impl Machine { #[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() { @@ -6596,8 +6560,9 @@ impl Machine { } } + 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") { @@ -6644,7 +6609,7 @@ impl Machine { } }; - 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); @@ -6676,9 +6641,7 @@ impl Machine { #[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; @@ -6792,7 +6755,7 @@ impl Machine { #[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)) -- 2.54.0