From c495d2ac7ca0d7f1c1a9bbb7d1ad5072a7eface5 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Fri, 17 Apr 2015 11:00:56 -0700 Subject: 1075 --- cpp/054closure_name | 142 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 cpp/054closure_name (limited to 'cpp/054closure_name') diff --git a/cpp/054closure_name b/cpp/054closure_name new file mode 100644 index 00000000..76a1bdd7 --- /dev/null +++ b/cpp/054closure_name @@ -0,0 +1,142 @@ +//: 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:space <- new location:type, 30:literal + 1:address:space/names:init-counter <- init-counter +#? $print [AAAAAAAAAAAAAAAA] +#? $print 1:address:space + 2:integer/raw <- increment-counter 1:address:space/names:init-counter + 3:integer/raw <- increment-counter 1:address:space/names:init-counter +] + +recipe init-counter [ + default-space:address:space <- new location:type, 30:literal + x:integer <- copy 23:literal + y:integer <- copy 3:literal # variable that will be incremented + reply default-space:address:space +] + +recipe increment-counter [ + default-space:address:space <- new space:literal, 30:literal + 0:address:space/names:init-counter <- next-ingredient # outer space must be created by 'init-counter' above + y:integer/space:1 <- add y:integer/space:1, 1:literal # increment + y:integer <- copy 234:literal # dummy + reply y:integer/space:1 +] + ++name: recipe increment-counter is surrounded by init-counter ++mem: storing 5 in location 3 + +//: To make this work, compute the recipe that provides names for the +//: surrounding space of each recipe. This must happen before transform_names. +:(before "End Globals") +unordered_map Surrounding_space; + +:(after "int main") + Transform.push_back(collect_surrounding_spaces); + +:(code) +void collect_surrounding_spaces(const recipe_number r) { + for (size_t i = 0; i < Recipe[r].steps.size(); ++i) { + const instruction& inst = Recipe[r].steps[i]; + if (inst.is_label) continue; + for (size_t j = 0; j < inst.products.size(); ++j) { + if (isa_literal(inst.products[j])) continue; + if (inst.products[j].name != "0") continue; + if (inst.products[j].types.size() != 2 + || inst.products[j].types[0] != Type_number["address"] + || inst.products[j].types[1] != Type_number["space"]) { + raise << "slot 0 should always have type address:space, but is " << inst.products[j].to_string() << '\n'; + continue; + } + vector s = property(inst.products[j], "names"); + if (s.empty()) + raise << "slot 0 requires a /names property in recipe " << Recipe[r].name << die(); + if (s.size() > 1) raise << "slot 0 should have a single value in /names, got " << inst.products[j].to_string() << '\n'; + string surrounding_recipe_name = s[0]; + if (Surrounding_space.find(r) != Surrounding_space.end() + && Surrounding_space[r] != Recipe_number[surrounding_recipe_name]) { + raise << "recipe " << Recipe[r].name << " can have only one 'surrounding' recipe but has " << Recipe[Surrounding_space[r]].name << " and " << surrounding_recipe_name << '\n'; + continue; + } + trace("name") << "recipe " << Recipe[r].name << " is surrounded by " << surrounding_recipe_name; + Surrounding_space[r] = Recipe_number[surrounding_recipe_name]; + } + } +} + +vector property(const reagent& r, const string& name) { + for (size_t p = 0; p != r.properties.size(); ++p) { + if (r.properties[p].first == name) + return r.properties[p].second; + } + return vector(); +} + +//: Once surrounding spaces are available, transform_names uses them to handle +//: /space properties. + +:(replace{} "size_t lookup_name(const reagent& r, const recipe_number default_recipe)") +size_t lookup_name(const reagent& x, const recipe_number default_recipe) { +//? cout << "AAA " << default_recipe << " " << Recipe[default_recipe].name << '\n'; //? 2 +//? cout << "AAA " << x.to_string() << '\n'; //? 1 + if (!has_property(x, "space")) { + if (Name[default_recipe].empty()) raise << "name not found: " << x.name << '\n' << die(); + return Name[default_recipe][x.name]; + } + vector p = property(x, "space"); + if (p.size() != 1) raise << "/space property should have exactly one (non-negative integer) value\n"; + int n = to_int(p[0]); + assert(n >= 0); + recipe_number surrounding_recipe = lookup_surrounding_recipe(default_recipe, n); + set done; + vector path; + return lookup_name(x, surrounding_recipe, done, path); +} + +// If the recipe we need to lookup this name in doesn't have names done yet, +// recursively call transform_names on it. +size_t lookup_name(const reagent& x, const recipe_number r, set& done, vector& path) { + if (!Name[r].empty()) return Name[r][x.name]; + if (done.find(r) != done.end()) { + raise << "can't compute address of " << x.to_string() << " because "; + for (size_t i = 1; i < path.size(); ++i) { + raise << path[i-1] << " requires computing names of " << path[i] << '\n'; + } + raise << path[path.size()-1] << " requires computing names of " << r << "..ad infinitum\n" << die(); + return 0; + } + done.insert(r); + path.push_back(r); + transform_names(r); // Not passing 'done' through. Might this somehow cause an infinite loop? + assert(!Name[r].empty()); + return Name[r][x.name]; +} + +recipe_number lookup_surrounding_recipe(const recipe_number r, size_t n) { + if (n == 0) return r; + if (Surrounding_space.find(r) == Surrounding_space.end()) { + raise << "don't know surrounding recipe of " << Recipe[r].name << '\n'; + return 0; + } + assert(Surrounding_space[r]); + return lookup_surrounding_recipe(Surrounding_space[r], n-1); +} + +//: weaken use-before-set warnings just a tad +:(replace{} "bool already_transformed(const reagent& r, const unordered_map& names)") +bool already_transformed(const reagent& r, const unordered_map& names) { + if (has_property(r, "space")) { + vector p = property(r, "space"); + assert(p.size() == 1); + if (p[0] != "0") return true; + } + return names.find(r.name) != names.end(); +} + +:(before "End Includes") +#include +using std::set; -- cgit 1.4.1-2-gfad0 ef='#n121'>121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140