adjust for nested throws.

src/prolog/copier.rs

@@ -0,0 +1,102 @@
+use prolog::and_stack::*;
+use prolog::ast::*;
+
+use std::ops::IndexMut;
+
+pub trait CopierTarget
+{
+    fn source(&self) -> usize;
+    fn threshold(&self) -> usize;
+    fn push(&mut self, HeapCellValue);
+    fn store(&self, Addr) -> Addr;
+    fn deref(&self, Addr) -> Addr;
+    fn stack(&mut self) -> &mut AndStack;
+
+    // duplicate_term(L1, L2) uses Cheney's algorithm to copy the term at
+    // L1 to L2. forwarding_terms is kept to restore the innards of L1
+    // after it's been copied to L2.
+    fn duplicate_term(&mut self, a: Addr) where Self: IndexMut<usize, Output=HeapCellValue>
+    {
+        let mut forward_trail: Vec<(Ref, HeapCellValue)>= Vec::new();
+        let mut scan = self.source();
+        let old_h = self.threshold();
+
+        self.push(HeapCellValue::from(a));
+
+        while scan < self.threshold() {
+            match self[scan].clone() {
+                HeapCellValue::Con(_) | HeapCellValue::NamedStr(_, _) =>
+                    scan += 1,
+                HeapCellValue::Lis(a) => {
+                    self[scan] = HeapCellValue::Lis(self.threshold());
+
+                    let hcv = self[a].clone();
+                    self.push(hcv);
+
+                    let hcv = self[a+1].clone();
+                    self.push(hcv);
+
+                    scan += 1;
+                },
+                HeapCellValue::Ref(r) => {
+                    let ra = Addr::from(r);
+                    let rd = self.store(self.deref(ra.clone()));
+
+                    match rd {
+                        Addr::HeapCell(hc) if hc >= old_h => {
+                            self[scan] = HeapCellValue::Ref(Ref::HeapCell(hc));
+                            scan += 1;
+                        },
+                        _ if ra == rd => {
+                            self[scan] = HeapCellValue::Ref(Ref::HeapCell(scan));
+
+                            match r {
+                                Ref::HeapCell(hc) =>
+                                    self[hc] = HeapCellValue::Ref(Ref::HeapCell(scan)),
+                                Ref::StackCell(fr, sc) =>
+                                    self.stack()[fr][sc] = Addr::HeapCell(scan)
+                            };
+
+                            forward_trail.push((r, HeapCellValue::Ref(r)));
+                            scan += 1;
+                        },
+                        _ => self[scan] = HeapCellValue::from(rd)
+                    }
+                },
+                HeapCellValue::Str(s) => {
+                    match self[s].clone() {
+                        HeapCellValue::NamedStr(arity, name) => {
+                            let threshold = self.threshold();
+                            
+                            self[scan] = HeapCellValue::Str(threshold);
+                            self[s] = HeapCellValue::Str(threshold);
+
+                            forward_trail.push((Ref::HeapCell(s),
+                                                HeapCellValue::NamedStr(arity, name.clone())));
+
+                            self.push(HeapCellValue::NamedStr(arity, name));
+
+                            for i in 0 .. arity {
+                                let hcv = self[s + 1 + i].clone();
+                                self.push(hcv);
+                            }
+                        },
+                        HeapCellValue::Str(o) =>
+                            self[scan] = HeapCellValue::Str(o),
+                        _ => {}
+                    };
+
+                    scan += 1;
+                }
+            };
+        }   
+        
+        for (r, hcv) in forward_trail {
+            match r {
+                Ref::HeapCell(hc) => self[hc] = hcv,
+                Ref::StackCell(fr, sc) => self.stack()[fr][sc] = hcv.as_addr(0)
+            }
+        }
+    }
+}
+