From 8f1db754005616054192b3f75e54af9929df26cc Mon Sep 17 00:00:00 2001
From: "Kartik K. Agaram" <vc@akkartik.com>
Date: Sat, 28 Mar 2015 20:57:21 -0700
Subject: 992 - c++ chain spaces for lexical scope

---
 cpp/028space_surround | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 cpp/028space_surround

(limited to 'cpp/028space_surround')

diff --git a/cpp/028space_surround b/cpp/028space_surround
new file mode 100644
index 00000000..9899ed89
--- /dev/null
+++ b/cpp/028space_surround
@@ -0,0 +1,42 @@
+//: So far you can have global variables by not setting default-space, and
+//: local variables by setting default-space. You can isolate variables
+//: between those extremes by creating 'surrounding' spaces.
+//:
+//: (Surrounding spaces are like lexical scopes in other languages.)
+
+:(scenario "surrounding_space")
+# location 1 in space 1 refers to the space surrounding the default space, here 20.
+recipe main [
+  default-space:address:space <- copy 10:literal
+  0:address:space <- copy 20:literal
+  1:integer <- copy 32:literal
+  1:integer/space:1 <- copy 33:literal
+]
++run: instruction main/1
++mem: storing 20 in location 11
++run: instruction main/2
++mem: storing 32 in location 12
++run: instruction main/3
++mem: storing 33 in location 22
+
+//: If you think of a space as a collection of variables with a common
+//: lifetime, surrounding allows managing shorter lifetimes inside a longer
+//: one.
+
+:(replace{} "int space(const reagent& x)")
+int space(const reagent& x) {
+  return space(x, space_index(x), Current_routine.calls.top().default_space);
+}
+
+int space(const reagent& x, int space_index, int base) {
+  if (space_index == 0) return base;
+  return space(x, space_index-1, Memory[base+1]);
+}
+
+int space_index(const reagent& x) {
+  for (size_t i = 0; i < x.properties.size(); ++i) {
+    if (x.properties[i].first == "space")
+      return to_int(x.properties[i].second[0]);
+  }
+  return 0;
+}
-- 
cgit 1.4.1-2-gfad0