From b1d8eff019cd09683ea3ae7bcd67a8bee9f4919e Mon Sep 17 00:00:00 2001 From: Mark Thom Date: Tue, 17 Mar 2020 02:03:29 -0600 Subject: [PATCH] remove Addr::PStrTail (#276) --- src/prolog/heap_iter.rs | 18 +- src/prolog/heap_print.rs | 12 +- src/prolog/machine/copier.rs | 105 +++------ src/prolog/machine/heap.rs | 56 +---- src/prolog/machine/machine_errors.rs | 1 - src/prolog/machine/machine_indices.rs | 27 +-- src/prolog/machine/machine_state.rs | 23 +- src/prolog/machine/machine_state_impl.rs | 276 ++++++++--------------- src/prolog/machine/partial_string.rs | 31 +-- src/prolog/machine/system_calls.rs | 60 ++--- src/prolog/write.rs | 3 +- 11 files changed, 181 insertions(+), 431 deletions(-) diff --git a/src/prolog/heap_iter.rs b/src/prolog/heap_iter.rs index 275761cf..0c3630e6 100644 --- a/src/prolog/heap_iter.rs +++ b/src/prolog/heap_iter.rs @@ -89,7 +89,7 @@ impl<'a> HCPreOrderIterator<'a> { if pstr.len() > n + c.len_utf8() { self.state_stack.push(Addr::PStrLocation(h, n + c.len_utf8())); } else { - self.state_stack.push(Addr::PStrTail(h, n + c.len_utf8())); + self.state_stack.push(Addr::HeapCell(h + 1)); } self.state_stack.push(Addr::Con(Constant::Char(c))); @@ -102,7 +102,7 @@ impl<'a> HCPreOrderIterator<'a> { Addr::PStrLocation(h, n) } - Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(_, _) | Addr::PStrTail(..) => { + Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(_, _) => { da } Addr::Str(s) => { @@ -130,20 +130,6 @@ impl<'a> Iterator for HCPreOrderIterator<'a> { } } } - Addr::PStrTail(h, n) => { - match &self.machine_st.heap[h] { - HeapCellValue::PartialString(ref pstr) => { - if pstr.len() > n { - HeapCellValue::Addr(Addr::PStrLocation(h, n)) - } else { - HeapCellValue::Addr(pstr.tail_addr().clone()) - } - } - _ => { - unreachable!() - } - } - } Addr::StackCell(fr, sc) => { HeapCellValue::Addr(self.machine_st.stack.index_and_frame(fr)[sc].clone()) } diff --git a/src/prolog/heap_print.rs b/src/prolog/heap_print.rs index c4fd9307..eeb53794 100644 --- a/src/prolog/heap_print.rs +++ b/src/prolog/heap_print.rs @@ -437,7 +437,7 @@ fn functor_location(addr: &Addr) -> Option { Some(match addr { &Addr::Lis(l) => l, &Addr::Str(s) => s, - &Addr::PStrLocation(h, _) | &Addr::PStrTail(h, _) => h, + &Addr::PStrLocation(h, _) => h, _ => { return None; } @@ -763,7 +763,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> { Ref::StackCell(fr, sc) => { Some(format!("_s_{}_{}", fr, sc)) } - Ref::HeapCell(h) | Ref::AttrVar(h) | Ref::PStrTail(h, _) => { + Ref::HeapCell(h) | Ref::AttrVar(h) => { Some(format!("_{}", h)) } } @@ -807,12 +807,8 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> { } } } - &Addr::PStrLocation(h, _) | &Addr::PStrTail(h, _) => { - let tail = match &self.machine_st.heap[h] { - &HeapCellValue::PartialString(ref pstr) => pstr.tail_addr().clone(), - _ => unreachable!() - }; - + &Addr::PStrLocation(h, _) => { + let tail = self.machine_st.heap[h + 1].as_addr(h + 1); let tail = self.machine_st.store(self.machine_st.deref(tail)); if let Some(c) = functor_location(&tail) { diff --git a/src/prolog/machine/copier.rs b/src/prolog/machine/copier.rs index 8cc5dbd6..a08cb87a 100644 --- a/src/prolog/machine/copier.rs +++ b/src/prolog/machine/copier.rs @@ -65,20 +65,6 @@ impl CopyTermState { false } - fn copied_partial_string(&mut self, addr: usize) -> bool { - if let HeapCellValue::PartialString(ref pstr) = &self.target[addr] { - if let Addr::PStrLocation(h, n) = pstr.tail_addr() { - if *h >= self.old_h { - *self.value_at_scan() = HeapCellValue::Addr(Addr::PStrLocation(*h, *n)); - self.scan += 1; - return true; - } - } - } - - false - } - fn copy_list(&mut self, addr: usize) { if self.copied_list(addr) { return; @@ -98,14 +84,13 @@ impl CopyTermState { self.target.push(hcv); match rd.clone() { - Addr::AttrVar(h) | Addr::HeapCell(h) | Addr::PStrTail(h, _) + Addr::AttrVar(h) | Addr::HeapCell(h) if h >= self.old_h => { self.target[threshold] = HeapCellValue::Addr(rd) } var @ Addr::AttrVar(_) | var @ Addr::HeapCell(..) - | var @ Addr::StackCell(..) - | var @ Addr::PStrTail(..) => { + | var @ Addr::StackCell(..) => { if ra == rd { self.reinstantiate_var(var, threshold); @@ -130,57 +115,44 @@ impl CopyTermState { self.scan += 1; } + fn copied_partial_string(&mut self, addr: usize) -> bool { + if let &HeapCellValue::Addr(Addr::PStrLocation(h, n)) = &self.target[addr + 1] { + if h >= self.old_h { + *self.value_at_scan() = HeapCellValue::Addr(Addr::PStrLocation(h, n)); + self.scan += 1; + return true; + } + } + + false + } fn copy_partial_string(&mut self, addr: usize, n: usize) { let threshold = self.target.threshold(); - let tail_addr = - match &self.target[addr] { - HeapCellValue::PartialString(ref pstr) => { - self.trail.push(( - Ref::PStrTail(addr, 0), - HeapCellValue::Addr(pstr.tail.clone()), - )); + self.trail.push(( + Ref::HeapCell(addr + 1), + self.target[addr + 1].clone(), + )); - self.target.store(self.target.deref(pstr.tail.clone())) - } - _ => { - unreachable!() - } - }; + let tail_addr = self.target[addr + 1].as_addr(addr + 1); - let pstr = - match &mut self.target[addr] { - HeapCellValue::PartialString(ref mut pstr) => { - let mut new_pstr = pstr.clone_from_offset(n); - - if let Addr::PStrTail(h, n) = &tail_addr { - new_pstr.tail = if *h == addr { - Addr::PStrTail(threshold, *n) - } else { - Addr::HeapCell(threshold + 1) - }; - } else { - new_pstr.tail = Addr::HeapCell(threshold + 1); - } + self.target[addr + 1] = HeapCellValue::Addr( + Addr::PStrLocation(threshold, 0) + ); - pstr.tail = Addr::PStrLocation(threshold, 0); - new_pstr + let pstr = + match &self.target[addr] { + HeapCellValue::PartialString(ref pstr) => { + pstr.clone_from_offset(n) } _ => { unreachable!() } }; - match tail_addr { - Addr::PStrTail(h, _) if h == addr => { - self.target.push(HeapCellValue::PartialString(pstr)); - } - addr => { - self.target.push(HeapCellValue::PartialString(pstr)); - self.target.push(HeapCellValue::Addr(addr)); - } - } + self.target.push(HeapCellValue::PartialString(pstr)); + self.target.push(HeapCellValue::Addr(tail_addr)); } fn copy_partial_string_from(&mut self, addr: usize, n: usize) { @@ -216,22 +188,6 @@ impl CopyTermState { HeapCellValue::Addr(Addr::StackCell(fr, sc)), )); } - Addr::PStrTail(h, n) => { - match &mut self.target[h] { - HeapCellValue::PartialString(ref mut pstr) => { - pstr.tail = Addr::PStrTail(frontier, n); - } - _ => { - unreachable!() - } - } - - self.target[frontier] = HeapCellValue::Addr(Addr::PStrTail(frontier, n)); - self.trail.push(( - Ref::PStrTail(h, n), - HeapCellValue::Addr(Addr::PStrTail(h, n)) - )); - } Addr::AttrVar(h) => { let threshold = if let AttrVarPolicy::DeepCopy = self.attr_var_policy { self.target.threshold() @@ -320,8 +276,7 @@ impl CopyTermState { } addr @ Addr::AttrVar(_) | addr @ Addr::HeapCell(_) - | addr @ Addr::StackCell(..) - | addr @ Addr::PStrTail(..) => { + | addr @ Addr::StackCell(..) => { self.copy_var(addr); } Addr::Str(addr) => { @@ -349,10 +304,6 @@ impl CopyTermState { match r { Ref::AttrVar(h) | Ref::HeapCell(h) => self.target[h] = value, - Ref::PStrTail(h, _) => - if let HeapCellValue::PartialString(ref mut pstr) = &mut self.target[h] { - pstr.tail = value.as_addr(0); - }, Ref::StackCell(fr, sc) => self.target.stack().index_and_frame_mut(fr)[sc] = value.as_addr(0), } diff --git a/src/prolog/machine/heap.rs b/src/prolog/machine/heap.rs index 6fe60b85..17ccd387 100644 --- a/src/prolog/machine/heap.rs +++ b/src/prolog/machine/heap.rs @@ -152,32 +152,23 @@ impl HeapTemplate { pub(crate) fn allocate_pstr(&mut self, mut src: &str) -> Option { let orig_h = self.h(); - + loop { if src == "" { return if orig_h == self.h() { None } else { - let prev_h = self.h() - 1; - - match &mut self[prev_h] { - HeapCellValue::PartialString(ref mut pstr) => { - let s = pstr.block_as_str(); - pstr.tail = Addr::PStrTail(prev_h, s.len()); - } - _ => { - unreachable!() - } - } + let tail_h = self.h() - 1; + self[tail_h] = HeapCellValue::Addr(Addr::HeapCell(tail_h)); Some(Addr::PStrLocation(orig_h, 0)) }; } - + let h = self.h(); - let (mut pstr, rest_src) = - match PartialString::new(src, h) { + let (pstr, rest_src) = + match PartialString::new(src) { Some(tuple) => { tuple } @@ -188,46 +179,21 @@ impl HeapTemplate { } else if orig_h == h { return None; } else { - let prev_h = h - 1; - - match &mut self[prev_h] { - HeapCellValue::PartialString(ref mut pstr) => { - let s = pstr.block_as_str(); - pstr.tail = Addr::PStrTail(prev_h, s.len()); - } - _ => { - unreachable!() - } - } - + self[h - 1] = HeapCellValue::Addr(Addr::HeapCell(h - 1)); return Some(Addr::PStrLocation(orig_h, 0)); } } }; - let new_top = unsafe { - self.buf.new_block(mem::size_of::()) - }; + self.push(HeapCellValue::PartialString(pstr)); if rest_src != "" { - pstr.tail = Addr::PStrLocation(h+1, 0); + self.push(HeapCellValue::Addr(Addr::PStrLocation(h + 2, 0))); src = rest_src; } else { - pstr.tail = Addr::PStrTail(h, src.len()); - } - - unsafe{ - ptr::write( - self.buf.top as *mut _, - HeapCellValue::PartialString(pstr), - ); - } - - self.buf.top = new_top; - - if rest_src == "" { + self.push(HeapCellValue::Addr(Addr::HeapCell(h + 1))); return Some(Addr::PStrLocation(orig_h, 0)); - } + } } } diff --git a/src/prolog/machine/machine_errors.rs b/src/prolog/machine/machine_errors.rs index f120628f..315e1eee 100644 --- a/src/prolog/machine/machine_errors.rs +++ b/src/prolog/machine/machine_errors.rs @@ -432,7 +432,6 @@ pub(super) enum CycleSearchResult { CompleteString(usize, Rc), // the string length (in bytes), the string. UntouchedString(usize, Rc), // the cut off, past which is the untouched string. PStrLocation(usize, usize, usize), // the list length (up to max), the heap offset, byte offset into the string. - PStrTail(usize, usize, usize), // the list length (up to max), the heap offset, byte offset into the string. UntouchedList(usize), // the address of an uniterated Addr::Lis(address). } diff --git a/src/prolog/machine/machine_indices.rs b/src/prolog/machine/machine_indices.rs index 53f5e159..e0c26d5a 100644 --- a/src/prolog/machine/machine_indices.rs +++ b/src/prolog/machine/machine_indices.rs @@ -49,7 +49,6 @@ pub enum Addr { StackCell(usize, usize), Str(usize), PStrLocation(usize, usize), // location of pstr in heap, offset into string in bytes. - PStrTail(usize, usize), // location of pstr in heap, offset into string in bytes. Stream(Stream), } @@ -58,7 +57,6 @@ pub enum Ref { AttrVar(usize), HeapCell(usize), StackCell(usize, usize), - PStrTail(usize, usize), } impl Ref { @@ -67,7 +65,6 @@ impl Ref { Ref::AttrVar(h) => Addr::AttrVar(h), Ref::HeapCell(h) => Addr::HeapCell(h), Ref::StackCell(fr, sc) => Addr::StackCell(fr, sc), - Ref::PStrTail(h, n) => Addr::PStrTail(h, n), } } } @@ -84,7 +81,7 @@ impl PartialOrd for Addr { match self { &Addr::StackCell(fr, sc) => { match *r { - Ref::AttrVar(_) | Ref::HeapCell(_) | Ref::PStrTail(..) => { + Ref::AttrVar(_) | Ref::HeapCell(_) => { Some(Ordering::Greater) } Ref::StackCell(fr1, sc1) => { @@ -106,22 +103,6 @@ impl PartialOrd for Addr { Ref::AttrVar(h1) | Ref::HeapCell(h1) => { h.partial_cmp(h1) } - Ref::PStrTail(h1, _) => { - h.partial_cmp(h1) - } - } - } - &Addr::PStrTail(h, n) => { - match r { - Ref::StackCell(..) => { - Some(Ordering::Less) - } - Ref::AttrVar(h1) | Ref::HeapCell(h1) => { - h.partial_cmp(h1) - } - Ref::PStrTail(h1, n1) => { - Some(h.cmp(h1).then_with(|| n.cmp(n1))) - } } } _ => { @@ -134,7 +115,7 @@ impl PartialOrd for Addr { impl Addr { pub fn is_ref(&self) -> bool { match self { - Addr::HeapCell(_) | Addr::StackCell(_, _) | Addr::AttrVar(_) | Addr::PStrTail(..) => { + Addr::HeapCell(_) | Addr::StackCell(_, _) | Addr::AttrVar(_) => { true } _ => { @@ -148,7 +129,6 @@ impl Addr { &Addr::AttrVar(h) => Some(Ref::AttrVar(h)), &Addr::HeapCell(h) => Some(Ref::HeapCell(h)), &Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)), - &Addr::PStrTail(h, n) => Some(Ref::PStrTail(h, n)), _ => None, } } @@ -171,7 +151,6 @@ impl Add for Addr { Addr::HeapCell(h) => Addr::HeapCell(h + rhs), Addr::Str(s) => Addr::Str(s + rhs), Addr::PStrLocation(h, n) => Addr::PStrLocation(h + rhs, n), - Addr::PStrTail(h, n) => Addr::PStrTail(h + rhs, n), _ => self, } } @@ -187,7 +166,6 @@ impl Sub for Addr { Addr::AttrVar(h) => Addr::AttrVar(h + rhs.abs() as usize), Addr::HeapCell(h) => Addr::HeapCell(h + rhs.abs() as usize), Addr::Str(s) => Addr::Str(s + rhs.abs() as usize), - Addr::PStrTail(h, n) => Addr::PStrTail(h + rhs.abs() as usize, n), Addr::PStrLocation(h, n) => Addr::PStrLocation(h + rhs.abs() as usize, n), _ => self, } @@ -206,7 +184,6 @@ impl Sub for Addr { Addr::AttrVar(h) => Addr::AttrVar(h - rhs), Addr::HeapCell(h) => Addr::HeapCell(h - rhs), Addr::Str(s) => Addr::Str(s - rhs), - Addr::PStrTail(h, n) => Addr::PStrTail(h - rhs, n), Addr::PStrLocation(h, n) => Addr::PStrLocation(h - rhs, n), _ => self, } diff --git a/src/prolog/machine/machine_state.rs b/src/prolog/machine/machine_state.rs index 58e7f127..ec6efb5f 100644 --- a/src/prolog/machine/machine_state.rs +++ b/src/prolog/machine/machine_state.rs @@ -58,13 +58,12 @@ impl Ball { for heap_value in self.stub.iter_from(0) { stub.push(match heap_value { - HeapCellValue::Addr(ref addr) => HeapCellValue::Addr(addr.clone() - diff), - HeapCellValue::PartialString(ref pstr) => { - let mut new_pstr = pstr.clone(); - new_pstr.tail = pstr.tail.clone() - diff; - HeapCellValue::PartialString(new_pstr) + HeapCellValue::Addr(ref addr) => { + HeapCellValue::Addr(addr.clone() - diff) + } + heap_value => { + heap_value.clone() } - heap_value => heap_value.clone(), }); } @@ -250,9 +249,9 @@ pub(super) enum MachineMode { pub(super) enum HeapPtr { HeapCell(usize), PStrChar(usize, usize), - PStrTail(usize, usize), + PStrLocation(usize, usize), StringChar(usize, Rc), - StringTail(usize, Rc), + StringLocation(usize, Rc), } impl HeapPtr { @@ -269,20 +268,20 @@ impl HeapPtr { if let Some(c) = s[n ..].chars().next() { Addr::Con(Constant::Char(c)) } else { - Addr::PStrTail(h, n) + Addr::HeapCell(h + 1) } } else { unreachable!() }, - &HeapPtr::PStrTail(h, n) => - Addr::PStrTail(h, n), + &HeapPtr::PStrLocation(h, n) => + Addr::PStrLocation(h, n), &HeapPtr::StringChar(n, ref s) => if let Some(c) = s[n ..].chars().next() { Addr::Con(Constant::Char(c)) } else { Addr::Con(Constant::EmptyList) }, - &HeapPtr::StringTail(n, ref s) => + &HeapPtr::StringLocation(n, ref s) => Addr::Con(Constant::String(n, s.clone())), } } diff --git a/src/prolog/machine/machine_state_impl.rs b/src/prolog/machine/machine_state_impl.rs index 00b2eb97..b8a4d69c 100644 --- a/src/prolog/machine/machine_state_impl.rs +++ b/src/prolog/machine/machine_state_impl.rs @@ -130,12 +130,12 @@ impl MachineState { Addr::StackCell(fr, sc) => { self.stack.index_and_frame(fr)[sc].clone() } - Addr::PStrTail(h, n) => { + Addr::PStrLocation(h, n) => { if let HeapCellValue::PartialString(ref pstr) = &self.heap[h] { if pstr.len() > n { Addr::PStrLocation(h, n) } else { - pstr.tail.clone() + Addr::HeapCell(h + 1) } } else { unreachable!() @@ -179,20 +179,6 @@ impl MachineState { } } - fn bind_pstr_tail(&mut self, h: usize, t2: Addr) { - let pstr_len = match &mut self.heap[h] { - HeapCellValue::PartialString(ref mut pstr) => { - pstr.tail = t2; - pstr.len() - } - _ => { - unreachable!() - } - }; - - self.trail(TrailRef::from(Ref::PStrTail(h, pstr_len))); - } - pub(super) fn bind(&mut self, r1: Ref, a2: Addr) { let t1 = self.store(r1.as_addr()); @@ -209,9 +195,6 @@ impl MachineState { Ref::AttrVar(h) => { return self.bind_attr_var(h, t2); } - Ref::PStrTail(h, _) => { - return self.bind_pstr_tail(h, t2); - } }; self.trail(TrailRef::from(r1)); @@ -228,9 +211,6 @@ impl MachineState { Some(Ref::AttrVar(h)) => { self.bind_attr_var(h, t1); } - Some(Ref::PStrTail(h, _)) => { - self.bind_pstr_tail(h, t1); - } None => { } } @@ -308,9 +288,6 @@ impl MachineState { (Addr::StackCell(fr, sc), addr) | (addr, Addr::StackCell(fr, sc)) => { self.bind_with_occurs_check(Ref::StackCell(fr, sc), addr) } - (Addr::PStrTail(h, n), addr) | (addr, Addr::PStrTail(h, n)) => { - self.bind_with_occurs_check(Ref::PStrTail(h, n), addr); - } (Addr::Lis(a1), Addr::Str(a2)) | (Addr::Str(a2), Addr::Lis(a1)) => { if let &HeapCellValue::NamedStr(n2, ref f2, _) = &self.heap[a2] { if f2.as_str() == "." && n2 == 2 { @@ -352,7 +329,7 @@ impl MachineState { let s = pstr.block_as_str(); if let Some(c) = s[n ..].chars().next() { - pdl.push(Addr::PStrTail(h, n + c.len_utf8())); + pdl.push(Addr::PStrLocation(h, n + c.len_utf8())); pdl.push(Addr::HeapCell(l + 1)); pdl.push(Addr::Con(Constant::Char(c))); @@ -366,15 +343,20 @@ impl MachineState { if let HeapCellValue::PartialString(ref pstr) = &self.heap[h] { let pstr_s = pstr.block_as_str(); - if let Some(c) = pstr_s[n ..].chars().next() { - if let Some(c1) = s[n1 ..].chars().next() { - if c == c1 { - pdl.push(Addr::Con(Constant::String(n1 + c.len_utf8(), s))); - pdl.push(Addr::PStrTail(h, n + c.len_utf8())); + let pstr_len = pstr_s[n ..].len(); + let s_len = s[n1 ..].len(); + let m_len = std::cmp::min(s_len, pstr_len); - continue; - } + if pstr_s[n .. n + m_len] == s[n1 .. n1 + m_len] { + if s_len <= pstr_len { + pdl.push(Addr::Con(Constant::EmptyList)); + pdl.push(Addr::PStrLocation(h, n + m_len)); + } else { + pdl.push(Addr::Con(Constant::String(n1 + m_len, s))); + pdl.push(Addr::HeapCell(h + 1)); } + + continue; } self.fail = true; @@ -387,15 +369,20 @@ impl MachineState { let pstr_s1 = pstr1.block_as_str(); let pstr_s2 = pstr2.block_as_str(); - if let Some(c1) = pstr_s1[n1 ..].chars().next() { - if let Some(c2) = pstr_s2[n2 ..].chars().next() { - if c1 == c2 { - pdl.push(Addr::PStrTail(h1, n1 + c1.len_utf8())); - pdl.push(Addr::PStrTail(h2, n2 + c2.len_utf8())); + let pstr_s1_len = pstr_s1[n1 ..].len(); + let pstr_s2_len = pstr_s2[n2 ..].len(); + let m_len = std::cmp::min(pstr_s1_len, pstr_s2_len); - continue; - } + if pstr_s1[n1 .. n1 + m_len] == pstr_s2[n2 .. n2 + m_len] { + if pstr_s1_len <= pstr_s2_len { + pdl.push(Addr::HeapCell(h1 + 1)); + pdl.push(Addr::PStrLocation(h2, n2 + m_len)); + } else { + pdl.push(Addr::HeapCell(h2 + 1)); + pdl.push(Addr::PStrLocation(h1, n1 + m_len)); } + + continue; } self.fail = true; @@ -443,7 +430,7 @@ impl MachineState { pub(super) fn unify(&mut self, a1: Addr, a2: Addr) { let mut pdl = vec![a1, a2]; - + let mut tabu_list: IndexSet<(Addr, Addr)> = IndexSet::new(); self.fail = false; @@ -472,9 +459,6 @@ impl MachineState { (Addr::StackCell(fr, sc), addr) | (addr, Addr::StackCell(fr, sc)) => { self.bind(Ref::StackCell(fr, sc), addr); } - (Addr::PStrTail(h, n), addr) | (addr, Addr::PStrTail(h, n)) => { - self.bind(Ref::PStrTail(h, n), addr); - } (Addr::Lis(a1), Addr::Str(a2)) | (Addr::Str(a2), Addr::Lis(a1)) => { if let &HeapCellValue::NamedStr(n2, ref f2, _) = &self.heap[a2] { if f2.as_str() == "." && n2 == 2 { @@ -515,7 +499,7 @@ impl MachineState { let s = pstr.block_as_str(); if let Some(c) = s[n ..].chars().next() { - pdl.push(Addr::PStrTail(h, n + c.len_utf8())); + pdl.push(Addr::PStrLocation(h, n + c.len_utf8())); pdl.push(Addr::HeapCell(l + 1)); pdl.push(Addr::Con(Constant::Char(c))); @@ -529,15 +513,20 @@ impl MachineState { if let HeapCellValue::PartialString(ref pstr) = &self.heap[h] { let pstr_s = pstr.block_as_str(); - if let Some(c) = pstr_s[n ..].chars().next() { - if let Some(c1) = s[n1 ..].chars().next() { - if c == c1 { - pdl.push(Addr::Con(Constant::String(n1 + c.len_utf8(), s))); - pdl.push(Addr::PStrTail(h, n + c.len_utf8())); + let pstr_len = pstr_s[n ..].len(); + let s_len = s[n1 ..].len(); + let m_len = std::cmp::min(s_len, pstr_len); - continue; - } + if pstr_s[n .. n + m_len] == s[n1 .. n1 + m_len] { + if s_len <= pstr_len { + pdl.push(Addr::Con(Constant::EmptyList)); + pdl.push(Addr::PStrLocation(h, n + m_len)); + } else { + pdl.push(Addr::Con(Constant::String(n1 + m_len, s))); + pdl.push(Addr::HeapCell(h + 1)); } + + continue; } self.fail = true; @@ -550,15 +539,20 @@ impl MachineState { let pstr_s1 = pstr1.block_as_str(); let pstr_s2 = pstr2.block_as_str(); - if let Some(c1) = pstr_s1[n1 ..].chars().next() { - if let Some(c2) = pstr_s2[n2 ..].chars().next() { - if c1 == c2 { - pdl.push(Addr::PStrTail(h1, n1 + c1.len_utf8())); - pdl.push(Addr::PStrTail(h2, n2 + c2.len_utf8())); + let pstr_s1_len = pstr_s1[n1 ..].len(); + let pstr_s2_len = pstr_s2[n2 ..].len(); + let m_len = std::cmp::min(pstr_s1_len, pstr_s2_len); - continue; - } + if pstr_s1[n1 .. n1 + m_len] == pstr_s2[n2 .. n2 + m_len] { + if pstr_s1_len <= pstr_s2_len { + pdl.push(Addr::HeapCell(h1 + 1)); + pdl.push(Addr::PStrLocation(h2, n2 + m_len)); + } else { + pdl.push(Addr::HeapCell(h2 + 1)); + pdl.push(Addr::PStrLocation(h1, n1 + m_len)); } + + continue; } self.fail = true; @@ -618,12 +612,6 @@ impl MachineState { self.tr += 1; } } - TrailRef::Ref(Ref::PStrTail(h, n)) => { - if h < self.hb { - self.trail.push(TrailRef::Ref(Ref::PStrTail(h, n))); - self.tr += 1; - } - } TrailRef::AttrVarHeapLink(h) => { if h < self.hb { self.trail.push(TrailRef::AttrVarHeapLink(h)); @@ -650,7 +638,7 @@ impl MachineState { HeapPtr::HeapCell(ref mut h) => { *h += rhs; } - HeapPtr::PStrChar(h, n) | HeapPtr::PStrTail(h, n) => { + HeapPtr::PStrChar(h, n) | HeapPtr::PStrLocation(h, n) => { match &self.heap[*h] { HeapCellValue::PartialString(ref pstr) => { let s = pstr.block_as_str(); @@ -659,19 +647,19 @@ impl MachineState { *n += c.len_utf8(); } - self.s = HeapPtr::PStrTail(*h, *n); + self.s = HeapPtr::PStrLocation(*h, *n); } _ => { unreachable!() } } } - HeapPtr::StringChar(n, s) | HeapPtr::StringTail(n, s) => { + HeapPtr::StringChar(n, s) | HeapPtr::StringLocation(n, s) => { for c in s[*n ..].chars().take(rhs) { *n += c.len_utf8(); } - self.s = HeapPtr::StringTail(*n, s.clone()); + self.s = HeapPtr::StringLocation(*n, s.clone()); } } } @@ -692,14 +680,6 @@ impl MachineState { TrailRef::Ref(Ref::StackCell(fr, sc)) => { self.stack.index_and_frame_mut(fr)[sc] = Addr::StackCell(fr, sc) } - TrailRef::Ref(Ref::PStrTail(h, n)) => { - if let HeapCellValue::PartialString(ref mut pstr) = &mut self.heap[h] { - pstr.truncate(n); - pstr.tail = Addr::PStrTail(h, n); - - self.tr += 1; - } - } TrailRef::AttrVarHeapLink(h) => { self.heap[h] = HeapCellValue::Addr(Addr::HeapCell(h)); } @@ -724,7 +704,6 @@ impl MachineState { match self.trail[i] { TrailRef::Ref(Ref::AttrVar(tr_i)) | TrailRef::Ref(Ref::HeapCell(tr_i)) - | TrailRef::Ref(Ref::PStrTail(tr_i, _)) | TrailRef::AttrVarHeapLink(tr_i) | TrailRef::AttrVarListLink(tr_i, _) => { if tr_i >= hb { @@ -1623,8 +1602,7 @@ impl MachineState { } addr @ Addr::AttrVar(_) | addr @ Addr::StackCell(..) - | addr @ Addr::HeapCell(_) - | addr @ Addr::PStrTail(..) => { + | addr @ Addr::HeapCell(_) => { let h = self.heap.h(); self.heap.push(HeapCellValue::Addr(Addr::Lis(h + 1))); @@ -1768,8 +1746,7 @@ impl MachineState { let offset = match addr { Addr::HeapCell(_) | Addr::StackCell(..) - | Addr::AttrVar(..) | Addr::PStrTail(..) - | Addr::Stream(_) => { + | Addr::AttrVar(..) | Addr::Stream(_) => { v } Addr::Con(Constant::String(n, ref s)) => { @@ -1791,7 +1768,7 @@ impl MachineState { } Addr::Str(_) => { s - } + } Addr::DBRef(_) => { self.fail = true; return; @@ -1807,7 +1784,7 @@ impl MachineState { let a1 = self.registers[1].clone(); let addr = self.store(self.deref(a1)); - let offset = match addr { + let offset = match addr { Addr::Con(constant) => match hm.get(&constant) { Some(offset) => *offset, _ => 0, @@ -1901,7 +1878,7 @@ impl MachineState { if addr < Ref::HeapCell(h) { self.heap.push(HeapCellValue::Addr(addr)); - return; + return; } self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h))); @@ -2042,7 +2019,7 @@ impl MachineState { let n = self.store(self.deref(self[temp_v!(1)].clone())); match n { - Addr::HeapCell(_) | Addr::StackCell(..) | Addr::PStrTail(..) => + Addr::HeapCell(_) | Addr::StackCell(..) => // 8.5.2.3 a) { return Err(self.error_form(MachineError::instantiation_error(), stub)) @@ -2067,7 +2044,7 @@ impl MachineState { let term = self.store(self.deref(self[temp_v!(2)].clone())); match term { - Addr::HeapCell(_) | Addr::StackCell(..) | Addr::PStrTail(..) => + Addr::HeapCell(_) | Addr::StackCell(..) => // 8.5.2.3 b) { return Err(self.error_form(MachineError::instantiation_error(), stub)) @@ -2102,7 +2079,7 @@ impl MachineState { if n == 1 { Addr::Con(Constant::Char(c)) } else { - Addr::PStrTail(h, offset + c.len_utf8()) + Addr::PStrLocation(h, offset + c.len_utf8()) } } else { unreachable!() @@ -2137,15 +2114,20 @@ impl MachineState { _ => // 8.5.2.3 d) { - return Err(self - .error_form(MachineError::type_error(ValidType::Compound, term), stub)) + return Err(self.error_form( + MachineError::type_error(ValidType::Compound, term), + stub, + )) } } } _ => // 8.5.2.3 c) { - return Err(self.error_form(MachineError::type_error(ValidType::Integer, n), stub)) + return Err(self.error_form( + MachineError::type_error(ValidType::Integer, n), + stub, + )) } } @@ -2247,31 +2229,7 @@ impl MachineState { | ( HeapCellValue::Addr(Addr::PStrLocation(..)), HeapCellValue::Addr(Addr::PStrLocation(..)), - ) - | ( - HeapCellValue::Addr(Addr::PStrTail(..)), - HeapCellValue::Addr(Addr::PStrTail(..)), - ) => { - } - ( - HeapCellValue::Addr(Addr::PStrLocation(h1, _)), - HeapCellValue::Addr(Addr::PStrTail(h2, _)), - ) => { - return if h1 == h2 { - Ordering::Less - } else { - h1.cmp(&h2) - }; - } - ( - HeapCellValue::Addr(Addr::PStrTail(h2, _)), - HeapCellValue::Addr(Addr::PStrLocation(h1, _)), ) => { - return if h1 == h2 { - Ordering::Greater - } else { - h2.cmp(&h1) - }; } ( HeapCellValue::Addr(Addr::PStrLocation(..)), @@ -2359,29 +2317,8 @@ impl MachineState { return hc1.cmp(&hc2); } } - ( - HeapCellValue::Addr(Addr::PStrTail(hc1, _)), - HeapCellValue::Addr(Addr::HeapCell(hc2)), - ) - | ( - HeapCellValue::Addr(Addr::HeapCell(hc1)), - HeapCellValue::Addr(Addr::PStrTail(hc2, _)), - ) - | ( - HeapCellValue::Addr(Addr::PStrTail(hc1, _)), - HeapCellValue::Addr(Addr::AttrVar(hc2)), - ) - | ( - HeapCellValue::Addr(Addr::AttrVar(hc1)), - HeapCellValue::Addr(Addr::PStrTail(hc2, _)), - ) => { - if hc1 != hc2 { - return hc1.cmp(&hc2); - } - } (HeapCellValue::Addr(Addr::HeapCell(_)), _) - | (HeapCellValue::Addr(Addr::AttrVar(_)), _) - | (HeapCellValue::Addr(Addr::PStrTail(..)), _) => { + | (HeapCellValue::Addr(Addr::AttrVar(_)), _) => { return Ordering::Less; } ( @@ -2400,10 +2337,6 @@ impl MachineState { HeapCellValue::Addr(Addr::StackCell(..)), HeapCellValue::Addr(Addr::HeapCell(_)), ) - | ( - HeapCellValue::Addr(Addr::StackCell(..)), - HeapCellValue::Addr(Addr::PStrTail(..)), - ) | ( HeapCellValue::Addr(Addr::StackCell(..)), HeapCellValue::Addr(Addr::AttrVar(_)), @@ -2420,11 +2353,7 @@ impl MachineState { | ( HeapCellValue::Addr(Addr::Con(Constant::Integer(..))), HeapCellValue::Addr(Addr::AttrVar(_)), - ) - | ( - HeapCellValue::Addr(Addr::Con(Constant::Integer(..))), - HeapCellValue::Addr(Addr::PStrTail(..)), - )=> { + ) => { return Ordering::Greater; } ( @@ -2441,7 +2370,9 @@ impl MachineState { return n1.cmp(&n2); } } - (HeapCellValue::Addr(Addr::Con(Constant::Integer(_))), _) => return Ordering::Less, + (HeapCellValue::Addr(Addr::Con(Constant::Integer(_))), _) => { + return Ordering::Less; + } ( HeapCellValue::Addr(Addr::Con(Constant::Float(..))), HeapCellValue::Addr(Addr::HeapCell(_)), @@ -2449,10 +2380,6 @@ impl MachineState { | ( HeapCellValue::Addr(Addr::Con(Constant::Float(..))), HeapCellValue::Addr(Addr::AttrVar(_)), - ) - | ( - HeapCellValue::Addr(Addr::Con(Constant::Float(..))), - HeapCellValue::Addr(Addr::PStrTail(..)), ) => { return Ordering::Greater; } @@ -2478,10 +2405,6 @@ impl MachineState { | ( HeapCellValue::Addr(Addr::Con(Constant::Rational(..))), HeapCellValue::Addr(Addr::AttrVar(_)), - ) - | ( - HeapCellValue::Addr(Addr::Con(Constant::Rational(..))), - HeapCellValue::Addr(Addr::PStrTail(..)), ) => { return Ordering::Greater; } @@ -2509,10 +2432,6 @@ impl MachineState { | ( HeapCellValue::Addr(Addr::Con(Constant::String(..))), HeapCellValue::Addr(Addr::AttrVar(_)), - ) - | ( - HeapCellValue::Addr(Addr::Con(Constant::String(..))), - HeapCellValue::Addr(Addr::PStrTail(..)), ) => { return Ordering::Greater; } @@ -2561,10 +2480,6 @@ impl MachineState { HeapCellValue::Addr(Addr::Con(Constant::Atom(..))), HeapCellValue::Addr(Addr::StackCell(..)), ) => return Ordering::Greater, - ( - HeapCellValue::Addr(Addr::Con(Constant::Atom(..))), - HeapCellValue::Addr(Addr::PStrTail(..)), - ) => return Ordering::Greater, ( HeapCellValue::Addr(Addr::Con(Constant::Atom(..))), HeapCellValue::Addr(Addr::Con(Constant::Float(_))), @@ -2616,8 +2531,12 @@ impl MachineState { return n.as_str().cmp("."); } } - (HeapCellValue::NamedStr(..), _) => return Ordering::Greater, - (HeapCellValue::Addr(Addr::Lis(_)), _) => return Ordering::Greater, + (HeapCellValue::NamedStr(..), _) => { + return Ordering::Greater; + } + (HeapCellValue::Addr(Addr::Lis(_)), _) => { + return Ordering::Greater; + } _ => {} } } @@ -2711,7 +2630,7 @@ impl MachineState { let d = self.store(self.deref(self[r1].clone())); match d { - Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(..) | Addr::PStrTail(..) => { + Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(..) => { self.fail = true; } _ => { @@ -2723,7 +2642,7 @@ impl MachineState { let d = self.store(self.deref(self[r1].clone())); match d { - Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(_, _) | Addr::PStrTail(..) => { + Addr::AttrVar(_) | Addr::HeapCell(_) | Addr::StackCell(_, _) => { self.p += 1; } _ => { @@ -2809,7 +2728,7 @@ impl MachineState { let shared_op_desc = fetch_op_spec(clause_name!("."), 2, None, &indices.op_dir); self.try_functor_compound_case(clause_name!("."), 2, shared_op_desc) } - Addr::AttrVar(..) | Addr::HeapCell(_) | Addr::StackCell(..) | Addr::PStrTail(..) => { + Addr::AttrVar(..) | Addr::HeapCell(_) | Addr::StackCell(..) => { let name = self.store(self.deref(self[temp_v!(2)].clone())); let arity = self.store(self.deref(self[temp_v!(3)].clone())); @@ -2911,17 +2830,20 @@ impl MachineState { Addr::Lis(l) => { self.try_from_inner_list(vec![], l, caller, a1) } - Addr::Con(Constant::String(n, ref s)) if !self.flags.double_quotes.is_atom() => { - if s.len() > n { - Ok(Vec::from_iter(s[n ..].chars().map(|c| Addr::Con(Constant::Char(c))))) - } else { - Ok(vec![]) + Addr::Con(Constant::String(n, ref s)) + if !self.flags.double_quotes.is_atom() => { + if s.len() > n { + Ok(Vec::from_iter(s[n ..].chars().map(|c| { + Addr::Con(Constant::Char(c)) + }))) + } else { + Ok(vec![]) + } } - } Addr::PStrLocation(h, n) => { self.try_from_partial_string(vec![], h, n, caller, a1) } - Addr::HeapCell(_) | Addr::StackCell(..) | Addr::PStrTail(..) => { + Addr::HeapCell(_) | Addr::StackCell(..) => { Err(self.error_form(MachineError::instantiation_error(), caller)) } Addr::Con(Constant::EmptyList) => { @@ -3002,7 +2924,9 @@ impl MachineState { chars.extend(s[n ..].chars().map(|c| Addr::Con(Constant::Char(c)))); - match self.store(self.deref(pstr.tail.clone())) { + let tail = self.heap[h + 1].as_addr(h + 1); + + match self.store(self.deref(tail)) { Addr::Con(Constant::EmptyList) => { return Ok(chars); } diff --git a/src/prolog/machine/partial_string.rs b/src/prolog/machine/partial_string.rs index 189a8bae..49be0f6e 100644 --- a/src/prolog/machine/partial_string.rs +++ b/src/prolog/machine/partial_string.rs @@ -1,4 +1,3 @@ -use crate::prolog::machine::machine_indices::*; use crate::prolog::machine::raw_block::*; use std::mem; @@ -22,7 +21,6 @@ impl RawBlockTraits for PartialStringTraits { pub struct PartialString { pub(super) buf: RawBlock, - pub(super) tail: Addr, } impl Clone for PartialString { @@ -55,10 +53,9 @@ fn scan_for_terminator(src: &str) -> usize { impl PartialString { pub(super) - fn new(src: &str, h: usize) -> Option<(Self, &str)> { + fn new(src: &str) -> Option<(Self, &str)> { let pstr = PartialString { buf: RawBlock::with_capacity(src.len() + '\u{0}'.len_utf8()), - tail: Addr::PStrTail(h, 0), }; unsafe { @@ -68,11 +65,11 @@ impl PartialString { unsafe fn append_chars(mut self, src: &str) -> Option<(Self, &str)> { let terminator_idx = scan_for_terminator(src); - + if terminator_idx == 0 { return None; } - + let new_top = self.buf.new_block(terminator_idx + '\u{0}'.len_utf8()); ptr::copy( @@ -91,18 +88,14 @@ impl PartialString { }) } - /* Ordinarily cloning of heap cell values is done in copy_term, - * so we rely on it to set the tail correctly. here it's set to PStrTail(0, 0), - * because we don't know its heap location. */ pub(super) fn clone_from_offset(&self, n: usize) -> Self { let mut pstr = PartialString { buf: RawBlock::with_capacity(self.len() + '\u{0}'.len_utf8()), - tail: Addr::PStrTail(0, 0), }; unsafe { - let len = if self.len() > n { self.len() - n } else { 0 }; + let len = if self.len() > n { self.len() - n } else { 0 }; let new_top = pstr.buf.new_block(len + '\u{0}'.len_utf8()); if len > 0 { @@ -110,7 +103,7 @@ impl PartialString { (self.buf.base as usize + n) as *mut u8, pstr.buf.base as *mut _, len, - ); + ); } pstr.write_terminator_at(len); @@ -140,22 +133,8 @@ impl PartialString { } } - #[inline] - pub(crate) - fn tail_addr(&self) -> &Addr { - &self.tail - } - #[inline] pub fn len(&self) -> usize { self.buf.top as usize - self.buf.base as usize } - - #[inline] - pub fn truncate(&mut self, len: usize) { - if (len + self.buf.base as usize) < self.buf.top as usize { - self.buf.top = (len + self.buf.base as usize) as *const _; - self.write_terminator_at(len); - } - } } diff --git a/src/prolog/machine/system_calls.rs b/src/prolog/machine/system_calls.rs index 1a007977..c222ea11 100644 --- a/src/prolog/machine/system_calls.rs +++ b/src/prolog/machine/system_calls.rs @@ -83,10 +83,8 @@ impl BrentAlgState { } } - fn step(&mut self, hare: Addr) -> Option { - self.hare = hare; - self.steps += 1; - + #[inline] + fn conclude_or_move_tortoise(&mut self) -> Option { if self.tortoise == self.hare { return Some(CycleSearchResult::NotList); } else if self.steps == self.power { @@ -94,10 +92,17 @@ impl BrentAlgState { self.power <<= 1; } - None } + #[inline] + fn step(&mut self, hare: Addr) -> Option { + self.hare = hare; + self.steps += 1; + + self.conclude_or_move_tortoise() + } + fn to_result(self) -> CycleSearchResult { match self.hare { addr @ Addr::HeapCell(_) | addr @ Addr::StackCell(..) | addr @ Addr::AttrVar(_) => { @@ -106,9 +111,6 @@ impl BrentAlgState { Addr::PStrLocation(h, n) => { CycleSearchResult::PStrLocation(self.steps, h, n) } - Addr::PStrTail(h, n) => { - CycleSearchResult::PStrTail(self.steps, h, n) - } Addr::Con(Constant::EmptyList) => { CycleSearchResult::ProperList(self.steps) } @@ -146,16 +148,13 @@ impl MachineState { Some(CycleSearchResult::CompleteString(s.len(), s)) } } - Addr::PStrTail(h, n) => { - Some(CycleSearchResult::PStrTail(brent_st.steps, h, n)) - } Addr::PStrLocation(h, n) => { match &self.heap[h] { HeapCellValue::PartialString(ref pstr) => { let s = pstr.block_as_str(); if let Some(c) = s[n ..].chars().next() { - brent_st.step(Addr::PStrTail(h, n + c.len_utf8())) + brent_st.step(Addr::PStrLocation(h, n + c.len_utf8())) } else { unreachable!() } @@ -189,9 +188,6 @@ impl MachineState { Addr::PStrLocation(h, _) => { return CycleSearchResult::UntouchedList(h); } - Addr::PStrTail(h, n) => { - return CycleSearchResult::PStrTail(0, h, n); - } Addr::Con(Constant::EmptyList) => { return CycleSearchResult::EmptyList; } @@ -251,9 +247,6 @@ impl MachineState { Addr::PStrLocation(h, n) => { Addr::PStrLocation(h, n) } - Addr::PStrTail(h, n) => { - return CycleSearchResult::PStrTail(0, h, n); - } Addr::Con(Constant::String(0, ref s)) if !self.flags.double_quotes.is_atom() => { return CycleSearchResult::CompleteString(s.len(), s.clone()); } @@ -316,9 +309,6 @@ impl MachineState { }; match search_result { - CycleSearchResult::PStrTail(steps, h, n) => { - self.finalize_skip_max_list(steps, Addr::PStrTail(h, n)); - } CycleSearchResult::PStrLocation(steps, h, n) => { self.finalize_skip_max_list(steps, Addr::PStrLocation(h, n)); } @@ -1062,15 +1052,8 @@ impl MachineState { } }; - let pstr_tail = match &self.heap[h] { - HeapCellValue::PartialString(ref pstr) => { - pstr.tail_addr().clone() - } - _ => { - unreachable!() - } - }; - + let pstr_tail = self.heap[h + 1].as_addr(h + 1); + self.unify(self[temp_v!(2)].clone(), pstr); if !self.fail { @@ -1093,13 +1076,9 @@ impl MachineState { match pstr { Addr::PStrLocation(h, _) => { - let tail = if let HeapCellValue::PartialString(ref pstr) = &self.heap[h] { - pstr.tail.clone() - } else { - unreachable!() - }; - + let tail = self.heap[h + 1].as_addr(h + 1); let target = self[temp_v!(2)].clone(); + self.unify(tail, target); } _ => { @@ -1406,9 +1385,6 @@ impl MachineState { HeapCellValue::Addr(ref mut addr) => { *addr -= self.heap.h() + lh_offset } - HeapCellValue::PartialString(ref mut pstr) => { - pstr.tail -= self.heap.h() + lh_offset; - } _ => {} } } @@ -1872,8 +1848,7 @@ impl MachineState { self.heap.push(HeapCellValue::Addr(addr.clone() + h)); } HeapCellValue::PartialString(ref pstr) => { - let mut new_pstr = pstr.clone(); - new_pstr.tail = pstr.tail.clone() + h; + let new_pstr = pstr.clone(); self.heap.push(HeapCellValue::PartialString(new_pstr)); } value => { @@ -1922,8 +1897,7 @@ impl MachineState { self.heap.push(HeapCellValue::Addr(addr.clone() + h)) } HeapCellValue::PartialString(ref pstr) => { - let mut new_pstr = pstr.clone(); - new_pstr.tail = pstr.tail.clone() + h; + let new_pstr = pstr.clone(); self.heap.push(HeapCellValue::PartialString(new_pstr)); } value => { diff --git a/src/prolog/write.rs b/src/prolog/write.rs index 870a8330..dd91a4b0 100644 --- a/src/prolog/write.rs +++ b/src/prolog/write.rs @@ -155,7 +155,7 @@ impl fmt::Display for HeapCellValue { write!(f, "{}/{}", name.as_str(), arity) } &HeapCellValue::PartialString(ref pstr) => { - write!(f, "pstr ( buf: {}, tail: {} )", pstr.block_as_str(), pstr.tail_addr()) + write!(f, "pstr ( buf: {} )", pstr.block_as_str()) } } } @@ -183,7 +183,6 @@ impl fmt::Display for Addr { &Addr::StackCell(fr, sc) => write!(f, "Addr::StackCell({}, {})", fr, sc), &Addr::Str(s) => write!(f, "Addr::Str({})", s), &Addr::PStrLocation(h, n) => write!(f, "Addr::PStrLocation({}, {})", h, n), - &Addr::PStrTail(h, n) => write!(f, "Addr::PStrTail({}, {})", h, n), &Addr::Stream(ref stream) => write!(f, "Addr::Stream({})", stream.as_ptr() as usize), } } -- 2.54.0