2971

Long-overdue reorganization to support general 'dilated' reagents up
front. This also allows me to move tests that are really about unrelated
layers out of layers dealing with parsing.

1 files changed, 448 insertions, 0 deletions

diff --git a/050tangle.cc b/050tangle.cc
new file mode 100644
index 00000000..ea11f58f
--- /dev/null
+++ b/050tangle.cc
@@ -0,0 +1,448 @@
+//: Allow code for recipes to be pulled in from multiple places and inserted
+//: at special labels called 'waypoints'. Unlike jump targets, a recipe can
+//: have multiple ambiguous waypoints with the same name. Any 'before' and
+//: 'after' fragments will simply be inserted at all applicable waypoints.
+//: Waypoints are always surrounded by '<>', e.g. <handle-request>.
+//:
+//: todo: switch recipe.steps to a more efficient data structure.
+
+:(scenario tangle_before)
+def main [
+  1:number <- copy 0
+  <label1>
+  3:number <- copy 0
+]
+
+before <label1> [
+  2:number <- copy 0
+]
++mem: storing 0 in location 1
++mem: storing 0 in location 2
++mem: storing 0 in location 3
+# nothing else
+$mem: 3
+
+//: while loading recipes, load before/after fragments
+
+:(before "End Globals")
+map<string /*label*/, recipe> Before_fragments, After_fragments;
+set<string /*label*/> Fragments_used;
+:(before "End Setup")
+Before_fragments.clear();
+After_fragments.clear();
+Fragments_used.clear();
+
+:(before "End Command Handlers")
+else if (command == "before") {
+  string label = next_word(in);
+  recipe tmp;
+  slurp_body(in, tmp);
+  if (is_waypoint(label))
+    Before_fragments[label].steps.insert(Before_fragments[label].steps.end(), tmp.steps.begin(), tmp.steps.end());
+  else
+    raise << "can't tangle before label " << label << '\n' << end();
+  // End before Command Handler
+}
+else if (command == "after") {
+  string label = next_word(in);
+  recipe tmp;
+  slurp_body(in, tmp);
+  if (is_waypoint(label))
+    After_fragments[label].steps.insert(After_fragments[label].steps.begin(), tmp.steps.begin(), tmp.steps.end());
+  else
+    raise << "can't tangle after label " << label << '\n' << end();
+  // End after Command Handler
+}
+
+//: after all recipes are loaded, insert fragments at appropriate labels.
+
+:(after "Begin Instruction Inserting/Deleting Transforms")
+Transform.push_back(insert_fragments);  // NOT idempotent
+
+//: We might need to perform multiple passes, in case inserted fragments
+//: include more labels that need further insertions. Track which labels we've
+//: already processed using an extra field.
+:(before "End instruction Fields")
+mutable bool tangle_done;
+:(before "End instruction Constructor")
+tangle_done = false;
+
+:(code)
+void insert_fragments(const recipe_ordinal r) {
+  bool made_progress = true;
+  int pass = 0;
+  while (made_progress) {
+    made_progress = false;
+    // create a new vector because insertions invalidate iterators
+    vector<instruction> result;
+    for (int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
+      const instruction& inst = get(Recipe, r).steps.at(i);
+      if (!inst.is_label || !is_waypoint(inst.label) || inst.tangle_done) {
+        result.push_back(inst);
+        continue;
+      }
+      inst.tangle_done = true;
+      made_progress = true;
+      Fragments_used.insert(inst.label);
+      ostringstream prefix;
+      prefix << '+' << get(Recipe, r).name << '_' << pass << '_' << i;
+      // ok to use contains_key even though Before_fragments uses [],
+      // because appending an empty recipe is a noop
+      if (contains_key(Before_fragments, inst.label))
+        append_fragment(result, Before_fragments[inst.label].steps, prefix.str());
+      result.push_back(inst);
+      if (contains_key(After_fragments, inst.label))
+        append_fragment(result, After_fragments[inst.label].steps, prefix.str());
+    }
+    get(Recipe, r).steps.swap(result);
+    ++pass;
+  }
+}
+
+void append_fragment(vector<instruction>& base, const vector<instruction>& patch, const string prefix) {
+  // append 'patch' to 'base' while keeping 'base' oblivious to any new jump
+  // targets in 'patch' oblivious to 'base' by prepending 'prefix' to them.
+  // we might tangle the same fragment at multiple points in a single recipe,
+  // and we need to avoid duplicate jump targets.
+  // so we'll keep jump targets local to the specific before/after fragment
+  // that introduces them.
+  set<string> jump_targets;
+  for (int i = 0; i < SIZE(patch); ++i) {
+    const instruction& inst = patch.at(i);
+    if (inst.is_label && is_jump_target(inst.label))
+      jump_targets.insert(inst.label);
+  }
+  for (int i = 0; i < SIZE(patch); ++i) {
+    instruction inst = patch.at(i);
+    if (inst.is_label) {
+      if (contains_key(jump_targets, inst.label))
+        inst.label = prefix+inst.label;
+      base.push_back(inst);
+      continue;
+    }
+    for (int j = 0; j < SIZE(inst.ingredients); ++j) {
+      reagent& x = inst.ingredients.at(j);
+      if (!is_literal(x)) continue;
+      if (x.type->name == "label" && contains_key(jump_targets, x.name))
+        x.name = prefix+x.name;
+    }
+    base.push_back(inst);
+  }
+}
+
+bool is_waypoint(string label) {
+  return *label.begin() == '<' && *label.rbegin() == '>';
+}
+
+//: complain about unapplied fragments
+//: This can't run during transform because later (shape-shifting recipes)
+//: we'll encounter situations where fragments might get used long after
+//: they're loaded, and we might run transform_all in between. To avoid
+//: spurious errors, run this check right at the end, after all code is
+//: loaded, right before we run main.
+:(before "End Commandline Parsing")
+check_insert_fragments();
+:(code)
+void check_insert_fragments() {
+  for (map<string, recipe>::iterator p = Before_fragments.begin(); p != Before_fragments.end(); ++p) {
+    if (!contains_key(Fragments_used, p->first))
+      raise << "could not locate insert before " << p->first << '\n' << end();
+  }
+  for (map<string, recipe>::iterator p = After_fragments.begin(); p != After_fragments.end(); ++p) {
+    if (!contains_key(Fragments_used, p->first))
+      raise << "could not locate insert after " << p->first << '\n' << end();
+  }
+}
+
+:(scenario tangle_before_and_after)
+def main [
+  1:number <- copy 0
+  <label1>
+  4:number <- copy 0
+]
+before <label1> [
+  2:number <- copy 0
+]
+after <label1> [
+  3:number <- copy 0
+]
++mem: storing 0 in location 1
++mem: storing 0 in location 2
+# label1
++mem: storing 0 in location 3
++mem: storing 0 in location 4
+# nothing else
+$mem: 4
+
+:(scenario tangle_ignores_jump_target)
+% Hide_errors = true;
+def main [
+  1:number <- copy 0
+  +label1
+  4:number <- copy 0
+]
+before +label1 [
+  2:number <- copy 0
+]
++error: can't tangle before label +label1
+
+:(scenario tangle_keeps_labels_separate)
+def main [
+  1:number <- copy 0
+  <label1>
+  <label2>
+  6:number <- copy 0
+]
+before <label1> [
+  2:number <- copy 0
+]
+after <label1> [
+  3:number <- copy 0
+]
+before <label2> [
+  4:number <- copy 0
+]
+after <label2> [
+  5:number <- copy 0
+]
++mem: storing 0 in location 1
++mem: storing 0 in location 2
+# label1
++mem: storing 0 in location 3
+# 'after' fragments for earlier label always go before 'before' fragments for later label
++mem: storing 0 in location 4
+# label2
++mem: storing 0 in location 5
++mem: storing 0 in location 6
+# nothing else
+$mem: 6
+
+:(scenario tangle_stacks_multiple_fragments)
+def main [
+  1:number <- copy 0
+  <label1>
+  6:number <- copy 0
+]
+before <label1> [
+  2:number <- copy 0
+]
+after <label1> [
+  3:number <- copy 0
+]
+before <label1> [
+  4:number <- copy 0
+]
+after <label1> [
+  5:number <- copy 0
+]
++mem: storing 0 in location 1
+# 'before' fragments stack in order
++mem: storing 0 in location 2
++mem: storing 0 in location 4
+# label1
+# 'after' fragments stack in reverse order
++mem: storing 0 in location 5
++mem: storing 0 in location 3
++mem: storing 0 in location 6
+# nothing else
+$mem: 6
+
+:(scenario tangle_supports_fragments_with_multiple_instructions)
+def main [
+  1:number <- copy 0
+  <label1>
+  6:number <- copy 0
+]
+before <label1> [
+  2:number <- copy 0
+  3:number <- copy 0
+]
+after <label1> [
+  4:number <- copy 0
+  5:number <- copy 0
+]
++mem: storing 0 in location 1
++mem: storing 0 in location 2
++mem: storing 0 in location 3
+# label1
++mem: storing 0 in location 4
++mem: storing 0 in location 5
++mem: storing 0 in location 6
+# nothing else
+$mem: 6
+
+:(scenario tangle_tangles_into_all_labels_with_same_name)
+def main [
+  1:number <- copy 10
+  <label1>
+  4:number <- copy 10
+  recipe2
+]
+def recipe2 [
+  1:number <- copy 11
+  <label1>
+  4:number <- copy 11
+]
+before <label1> [
+  2:number <- copy 12
+]
+after <label1> [
+  3:number <- copy 12
+]
++mem: storing 10 in location 1
++mem: storing 12 in location 2
+# label1
++mem: storing 12 in location 3
++mem: storing 10 in location 4
+# recipe2
++mem: storing 11 in location 1
++mem: storing 12 in location 2
+# label1
++mem: storing 12 in location 3
++mem: storing 11 in location 4
+# nothing else
+$mem: 8
+
+:(scenario tangle_tangles_into_all_labels_with_same_name_2)
+def main [
+  1:number <- copy 10
+  <label1>
+  <label1>
+  4:number <- copy 10
+]
+before <label1> [
+  2:number <- copy 12
+]
+after <label1> [
+  3:number <- copy 12
+]
++mem: storing 10 in location 1
++mem: storing 12 in location 2
+# label1
++mem: storing 12 in location 3
++mem: storing 12 in location 2
+# label1
++mem: storing 12 in location 3
++mem: storing 10 in location 4
+# nothing else
+$mem: 6
+
+:(scenario tangle_tangles_into_all_labels_with_same_name_3)
+def main [
+  1:number <- copy 10
+  <label1>
+  <foo>
+  4:number <- copy 10
+]
+before <label1> [
+  2:number <- copy 12
+]
+after <label1> [
+  3:number <- copy 12
+]
+after <foo> [
+  <label1>
+]
++mem: storing 10 in location 1
++mem: storing 12 in location 2
+# label1
++mem: storing 12 in location 3
++mem: storing 12 in location 2
+# foo/label1
++mem: storing 12 in location 3
++mem: storing 10 in location 4
+# nothing else
+$mem: 6
+
+:(scenario tangle_handles_jump_target_inside_fragment)
+def main [
+  1:number <- copy 10
+  <label1>
+  4:number <- copy 10
+]
+before <label1> [
+  jump +label2:label
+  2:number <- copy 12
+  +label2
+  3:number <- copy 12
+]
++mem: storing 10 in location 1
+# label1
++mem: storing 12 in location 3
++mem: storing 10 in location 4
+# ignored by jump
+-mem: storing 12 in label 2
+# nothing else
+$mem: 3
+
+:(scenario tangle_renames_jump_target)
+def main [
+  1:number <- copy 10
+  <label1>
+  +label2
+  4:number <- copy 10
+]
+before <label1> [
+  jump +label2:label
+  2:number <- copy 12
+  +label2  # renamed
+  3:number <- copy 12
+]
++mem: storing 10 in location 1
+# label1
++mem: storing 12 in location 3
++mem: storing 10 in location 4
+# ignored by jump
+-mem: storing 12 in label 2
+# nothing else
+$mem: 3
+
+:(scenario tangle_jump_to_base_recipe)
+def main [
+  1:number <- copy 10
+  <label1>
+  +label2
+  4:number <- copy 10
+]
+before <label1> [
+  jump +label2:label
+  2:number <- copy 12
+  3:number <- copy 12
+]
++mem: storing 10 in location 1
+# label1
++mem: storing 10 in location 4
+# ignored by jump
+-mem: storing 12 in label 2
+-mem: storing 12 in location 3
+# nothing else
+$mem: 2
+
+//: ensure that there are no new fragments created for a label after it's already been inserted to
+
+:(code)
+void test_new_fragment_after_tangle() {
+  // define a recipe
+  load("def foo [\n"
+       "  local-scope\n"
+       "  <label>\n"
+       "]\n"
+       "after <label> [\n"
+       "  1:number/raw <- copy 34\n"
+       "]\n");
+  transform_all();
+  CHECK_TRACE_DOESNT_CONTAIN_ERROR();
+  Hide_errors = true;
+  // try to tangle into recipe foo after transform
+  load("before <label> [\n"
+       "  2:number/raw <- copy 35\n"
+       "]\n");
+  CHECK_TRACE_CONTAINS_ERROR();
+}
+
+:(before "End before Command Handler")
+if (contains_key(Fragments_used, label))
+  raise << "we've already tangled some code at " << label << " in a previous call to transform_all(). Those locations won't be updated.\n" << end();
+:(before "End after Command Handler")
+if (contains_key(Fragments_used, label))
+  raise << "we've already tangled some code at " << label << " in a previous call to transform_all(). Those locations won't be updated.\n" << end();