From 4690ce81e079fc58cae8d6d583e5e3eb3ed81a83 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Wed, 9 Mar 2016 02:56:27 -0800 Subject: 2743 Looks like "TOhtml | " doesn't work on Mac OS X for some reason.. --- html/045closure_name.cc.html | 146 ++++++++++++++++++++++--------------------- 1 file changed, 74 insertions(+), 72 deletions(-) (limited to 'html/045closure_name.cc.html') diff --git a/html/045closure_name.cc.html b/html/045closure_name.cc.html index 8ff3c096..a7de6275 100644 --- a/html/045closure_name.cc.html +++ b/html/045closure_name.cc.html @@ -3,61 +3,54 @@ Mu - 045closure_name.cc - - + + - - + - - -
+
 //: Writing to a literal (not computed) address of 0 in a recipe chains two
 //: spaces together. When a variable has a property of /space:1, it looks up
 //: the variable in the chained/surrounding space. /space:2 looks up the
 //: surrounding space of the surrounding space, etc.
 
 :(scenario closure)
-recipe main [
-  default-space:address:shared:array:location <- new location:type, 30
-  1:address:shared:array:location/names:new-counter <- new-counter
-  2:number/raw <- increment-counter 1:address:shared:array:location/names:new-counter
-  3:number/raw <- increment-counter 1:address:shared:array:location/names:new-counter
+def main [
+  default-space:address:shared:array:location <- new location:type, 30
+  1:address:shared:array:location/names:new-counter <- new-counter
+  2:number/raw <- increment-counter 1:address:shared:array:location/names:new-counter
+  3:number/raw <- increment-counter 1:address:shared:array:location/names:new-counter
 ]
 
-recipe new-counter [
-  default-space:address:shared:array:location <- new location:type, 30
+def new-counter [
+  default-space:address:shared:array:location <- new location:type, 30
   x:number <- copy 23
   y:number <- copy 3  # variable that will be incremented
-  reply default-space:address:shared:array:location
+  return default-space:address:shared:array:location
 ]
 
-recipe increment-counter [
-  default-space:address:shared:array:location <- new location:type, 30
-  0:address:shared:array:location/names:new-counter <- next-ingredient  # outer space must be created by 'new-counter' above
+def increment-counter [
+  default-space:address:shared:array:location <- new location:type, 30
+  0:address:shared:array:location/names:new-counter <- next-ingredient  # outer space must be created by 'new-counter' above
   y:number/space:1 <- add y:number/space:1, 1  # increment
   y:number <- copy 234  # dummy
-  reply y:number/space:1
+  return y:number/space:1
 ]
 
 +name: lexically surrounding space for recipe increment-counter comes from new-counter
@@ -73,17 +66,17 @@ map<recipe_ordinal, recipe_ordinal> Surroun
 Transform.push_back(collect_surrounding_spaces);  // idempotent
 
 :(code)
-void collect_surrounding_spaces(const recipe_ordinal r) {
+void collect_surrounding_spaces(const recipe_ordinal r) {
   trace(9991, "transform") << "--- collect surrounding spaces for recipe " << get(Recipe, r).name << end();
 //?   cerr << "--- collect surrounding spaces for recipe " << get(Recipe, r).name << '\n';
-  for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
-    const instruction& inst = get(Recipe, r).steps.at(i);
-    if (inst.is_label) continue;
-    for (long long int j = 0; j < SIZE(inst.products); ++j) {
-      if (is_literal(inst.products.at(j))) continue;
-      if (inst.products.at(j).name != "0") continue;
+  for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
+    const instruction& inst = get(Recipe, r).steps.at(i);
+    if (inst.is_label) continue;
+    for (long long int j = 0; j < SIZE(inst.products); ++j) {
+      if (is_literal(inst.products.at(j))) continue;
+      if (inst.products.at(j).name != "0") continue;
       type_tree* type = inst.products.at(j).type;
-      if (!type
+      if (!type
           || type->value != get(Type_ordinal, "address")
           || !type->right
           || type->right->value != get(Type_ordinal, "shared")
@@ -92,28 +85,28 @@ void collect_surrounding_spaces(const recipe_ordi
           || !type->right->right->right
           || type->right->right->right->value != get(Type_ordinal, "location")
           || type->right->right->right->right) {
-        raise_error << "slot 0 should always have type address:shared:array:location, but is " << to_string(inst.products.at(j)) << '\n' << end();
+        raise << "slot 0 should always have type address:shared:array:location, but is " << to_string(inst.products.at(j)) << '\n' << end();
         continue;
       }
       string_tree* s = property(inst.products.at(j), "names");
-      if (!s) {
-        raise_error << "slot 0 requires a /names property in recipe " << get(Recipe, r).name << end();
+      if (!s) {
+        raise << "slot 0 requires a /names property in recipe " << get(Recipe, r).name << end();
         continue;
       }
-      if (s->right) raise_error << "slot 0 should have a single value in /names, but got " << to_string(inst.products.at(j)) << '\n' << end();
-      const string& surrounding_recipe_name = s->value;
-      if (surrounding_recipe_name.empty()) {
-        raise_error << "slot 0 doesn't initialize its /names property in recipe " << get(Recipe, r).name << end();
+      if (s->right) raise << "slot 0 should have a single value in /names, but got " << to_string(inst.products.at(j)) << '\n' << end();
+      const string& surrounding_recipe_name = s->value;
+      if (surrounding_recipe_name.empty()) {
+        raise << "slot 0 doesn't initialize its /names property in recipe " << get(Recipe, r).name << end();
         continue;
       }
-      if (contains_key(Surrounding_space, r)
+      if (contains_key(Surrounding_space, r)
           && get(Surrounding_space, r) != get(Recipe_ordinal, surrounding_recipe_name)) {
-        raise_error << "recipe " << get(Recipe, r).name << " can have only one 'surrounding' recipe but has " << get(Recipe, get(Surrounding_space, r)).name << " and " << surrounding_recipe_name << '\n' << end();
+        raise << "recipe " << get(Recipe, r).name << " can have only one 'surrounding' recipe but has " << get(Recipe, get(Surrounding_space, r)).name << " and " << surrounding_recipe_name << '\n' << end();
         continue;
       }
       trace(9993, "name") << "lexically surrounding space for recipe " << get(Recipe, r).name << " comes from " << surrounding_recipe_name << end();
-      if (!contains_key(Recipe_ordinal, surrounding_recipe_name)) {
-        raise_error << "can't find recipe providing surrounding space for " << get(Recipe, r).name << ": " << surrounding_recipe_name << '\n' << end();
+      if (!contains_key(Recipe_ordinal, surrounding_recipe_name)) {
+        raise << "can't find recipe providing surrounding space for " << get(Recipe, r).name << ": " << surrounding_recipe_name << '\n' << end();
         continue;
       }
       put(Surrounding_space, r, get(Recipe_ordinal, surrounding_recipe_name));
@@ -125,16 +118,17 @@ void collect_surrounding_spaces(const recipe_ordi
 //: /space properties.
 
 :(replace{} "long long int lookup_name(const reagent& r, const recipe_ordinal default_recipe)")
-long long int lookup_name(const reagent& x, const recipe_ordinal default_recipe) {
-  if (!has_property(x, "space")) {
-    if (Name[default_recipe].empty()) raise_error << "name not found: " << x.name << '\n' << end();
+long long int lookup_name(const reagent& x, const recipe_ordinal default_recipe) {
+  if (!has_property(x, "space")) {
+    if (Name[default_recipe].empty()) raise << "name not found: " << x.name << '\n' << end();
     return Name[default_recipe][x.name];
   }
   string_tree* p = property(x, "space");
-  if (!p || p->right) raise_error << "/space property should have exactly one (non-negative integer) value\n" << end();
-  long long int n = to_integer(p->value);
+  if (!p || p->right) raise << "/space property should have exactly one (non-negative integer) value\n" << end();
+  long long int n = to_integer(p->value);
   assert(n >= 0);
   recipe_ordinal surrounding_recipe = lookup_surrounding_recipe(default_recipe, n);
+  if (surrounding_recipe == -1) return -1;
   set<recipe_ordinal> done;
   vector<recipe_ordinal> path;
   return lookup_name(x, surrounding_recipe, done, path);
@@ -142,15 +136,15 @@ long long int lookup_name(const reagent& x// If the recipe we need to lookup this name in doesn't have names done yet,
 // recursively call transform_names on it.
-long long int lookup_name(const reagent& x, const recipe_ordinal r, set<recipe_ordinal>& done, vector<recipe_ordinal>& path) {
-  if (!Name[r].empty()) return Name[r][x.name];
-  if (contains_key(done, r)) {
-    raise_error << "can't compute address of " << to_string(x) << " because " << end();
-    for (long long int i = 1; i < SIZE(path); ++i) {
-      raise_error << path.at(i-1) << " requires computing names of " << path.at(i) << '\n' << end();
+long long int lookup_name(const reagent& x, const recipe_ordinal r, set<recipe_ordinal>& done, vector<recipe_ordinal>& path) {
+  if (!Name[r].empty()) return Name[r][x.name];
+  if (contains_key(done, r)) {
+    raise << "can't compute address of " << to_string(x) << " because " << end();
+    for (long long int i = 1; i < SIZE(path); ++i) {
+      raise << path.at(i-1) << " requires computing names of " << path.at(i) << '\n' << end();
     }
-    raise_error << path.at(SIZE(path)-1) << " requires computing names of " << r << "..ad infinitum\n" << end();
-    return 0;
+    raise << path.at(SIZE(path)-1) << " requires computing names of " << r << "..ad infinitum\n" << end();
+    return -1;
   }
   done.insert(r);
   path.push_back(r);
@@ -159,11 +153,11 @@ long long int lookup_name(const reagent& xreturn Name[r][x.name];
 }
 
-recipe_ordinal lookup_surrounding_recipe(const recipe_ordinal r, long long int n) {
-  if (n == 0) return r;
-  if (!contains_key(Surrounding_space, r)) {
-    raise_error << "don't know surrounding recipe of " << get(Recipe, r).name << '\n' << end();
-    return 0;
+recipe_ordinal lookup_surrounding_recipe(const recipe_ordinal r, long long int n) {
+  if (n == 0) return r;
+  if (!contains_key(Surrounding_space, r)) {
+    raise << "don't know surrounding recipe of " << get(Recipe, r).name << '\n' << end();
+    return -1;
   }
   assert(contains_key(Surrounding_space, r));
   return lookup_surrounding_recipe(get(Surrounding_space, r), n-1);
@@ -171,18 +165,26 @@ recipe_ordinal lookup_surrounding_recipe(const re
 
 //: weaken use-before-set detection just a tad
 :(replace{} "bool already_transformed(const reagent& r, const map<string, long long int>& names)")
-bool already_transformed(const reagent& r, const map<string, long long int>& names) {
-  if (has_property(r, "space")) {
+bool already_transformed(const reagent& r, const map<string, long long int>& names) {
+  if (has_property(r, "space")) {
     string_tree* p = property(r, "space");
-    if (!p || p->right) {
-      raise_error << "/space property should have exactly one (non-negative integer) value in " << r.original_string << '\n' << end();
+    if (!p || p->right) {
+      raise << "/space property should have exactly one (non-negative integer) value in " << r.original_string << '\n' << end();
       return false;
     }
-    if (p->value != "0") return true;
+    if (p->value != "0") return true;
   }
   return contains_key(names, r.name);
 }
+
+:(scenario missing_surrounding_space)
+% Hide_errors = true;
+def f [
+  local-scope
+  x:number/space:1 <- copy 34
+]
++error: don't know surrounding recipe of f
++error: f: can't find a place to store x
 

 
 
-
-- 
cgit 1.4.1-2-gfad0