From 8d7839b99723553c08b33c30980a001e7a3557b6 Mon Sep 17 00:00:00 2001
From: "Kartik K. Agaram" <vc@akkartik.com>
Date: Thu, 19 Feb 2015 16:46:47 -0800
Subject: 788 - reorg, showing off how tangle makes it

---
 cpp/012run        | 199 ------------------------------------------------
 cpp/013arithmetic | 220 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 220 insertions(+), 199 deletions(-)
 create mode 100644 cpp/013arithmetic

diff --git a/cpp/012run b/cpp/012run
index abbe954a..aa6bceb4 100644
--- a/cpp/012run
+++ b/cpp/012run
@@ -61,205 +61,6 @@ void write_memory(reagent x, vector<int> data) {
   Memory[dest] = data[0];
 }
 
-:(before "End Primitive Recipe Numbers")
-// Arithmetic ops.
-Recipe_number["add"] = 2;
-Next_recipe_number++;
-Recipe_number["subtract"] = 3;
-Next_recipe_number++;
-Recipe_number["multiply"] = 4;
-Next_recipe_number++;
-Recipe_number["divide"] = 5;
-Next_recipe_number++;
-Recipe_number["divide_with_remainder"] = 6;
-Next_recipe_number++;
-:(before "End Primitive Recipe Implementations")
-  case 2: {  // add
-    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
-    vector<int> arg0 = read_memory(p->ingredients[0]);
-    assert(arg0.size() == 1);
-    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
-    vector<int> arg1 = read_memory(p->ingredients[1]);
-    assert(arg1.size() == 1);
-    vector<int> result;
-    result.push_back(arg0[0]+arg1[0]);
-    trace("run") << "product 0 is " << result[0];
-    write_memory(p->products[0], result);
-    break;
-  }
-  case 3: {  // subtract
-    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
-    vector<int> arg0 = read_memory(p->ingredients[0]);
-    assert(arg0.size() == 1);
-    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
-    vector<int> arg1 = read_memory(p->ingredients[1]);
-    assert(arg1.size() == 1);
-    vector<int> result;
-    result.push_back(arg0[0]-arg1[0]);
-    trace("run") << "product 0 is " << result[0];
-    write_memory(p->products[0], result);
-    break;
-  }
-  case 4: {  // multiply
-    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
-    vector<int> arg0 = read_memory(p->ingredients[0]);
-    assert(arg0.size() == 1);
-    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
-    vector<int> arg1 = read_memory(p->ingredients[1]);
-    assert(arg1.size() == 1);
-    trace("run") << "ingredient 1 is " << arg1[0];
-    vector<int> result;
-    result.push_back(arg0[0]*arg1[0]);
-    trace("run") << "product 0 is " << result[0];
-    write_memory(p->products[0], result);
-    break;
-  }
-  case 5: {  // divide
-    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
-    vector<int> arg0 = read_memory(p->ingredients[0]);
-    assert(arg0.size() == 1);
-    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
-    vector<int> arg1 = read_memory(p->ingredients[1]);
-    assert(arg1.size() == 1);
-    trace("run") << "ingredient 1 is " << arg1[0];
-    vector<int> result;
-    result.push_back(arg0[0]/arg1[0]);
-    trace("run") << "product 0 is " << result[0];
-    write_memory(p->products[0], result);
-    break;
-  }
-  case 6: {  // divide_with_remainder
-    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
-    vector<int> arg0 = read_memory(p->ingredients[0]);
-    assert(arg0.size() == 1);
-    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
-    vector<int> arg1 = read_memory(p->ingredients[1]);
-    assert(arg1.size() == 1);
-    vector<int> result0;
-    result0.push_back(arg0[0]/arg1[0]);
-    trace("run") << "product 0 is " << result0[0];
-    write_memory(p->products[0], result0);
-    vector<int> result1;
-    result1.push_back(arg0[0]%arg1[0]);
-    trace("run") << "product 1 is " << result1[0];
-    write_memory(p->products[1], result1);
-    break;
-  }
-:(scenario "add_literal")
-recipe main [
-  1:integer <- add 23:literal, 34:literal
-]
-+run: instruction 0
-+run: ingredient 0 is 23
-+run: ingredient 1 is 34
-+run: product 0 is 57
-+mem: storing in location 1
-:(scenario "add")
-recipe main [
-  1:integer <- copy 23:literal
-  2:integer <- copy 34:literal
-  3:integer <- add 1:integer, 2:integer
-]
-+run: instruction 2
-+run: ingredient 0 is 1
-+mem: location 1 is 23
-+run: ingredient 1 is 2
-+mem: location 2 is 34
-+run: product 0 is 57
-+mem: storing in location 3
-:(scenario "subtract_literal")
-recipe main [
-  1:integer <- subtract 5:literal, 2:literal
-]
-+run: instruction 0
-+run: ingredient 0 is 5
-+run: ingredient 1 is 2
-+run: product 0 is 3
-+mem: storing in location 1
-:(scenario "subtract")
-recipe main [
-  1:integer <- copy 23:literal
-  2:integer <- copy 34:literal
-  3:integer <- subtract 1:integer, 2:integer
-]
-+run: instruction 2
-+run: ingredient 0 is 1
-+mem: location 1 is 23
-+run: ingredient 1 is 2
-+mem: location 2 is 34
-+run: product 0 is -11
-+mem: storing in location 3
-:(scenario "multiply_literal")
-recipe main [
-  1:integer <- multiply 2:literal, 3:literal
-]
-+run: instruction 0
-+run: ingredient 0 is 2
-+run: ingredient 1 is 3
-+run: product 0 is 6
-+mem: storing in location 1
-:(scenario "multiply")
-recipe main [
-  1:integer <- copy 4:literal
-  2:integer <- copy 6:literal
-  3:integer <- multiply 1:integer, 2:integer
-]
-+run: instruction 2
-+run: ingredient 0 is 1
-+mem: location 1 is 4
-+run: ingredient 1 is 2
-+mem: location 2 is 6
-+run: product 0 is 24
-+mem: storing in location 3
-:(scenario "divide_literal")
-recipe main [
-  1:integer <- divide 8:literal, 2:literal
-]
-+run: instruction 0
-+run: ingredient 0 is 8
-+run: ingredient 1 is 2
-+run: product 0 is 4
-+mem: storing in location 1
-:(scenario "divide")
-recipe main [
-  1:integer <- copy 27:literal
-  2:integer <- copy 3:literal
-  3:integer <- divide 1:integer, 2:integer
-]
-+run: instruction 2
-+run: ingredient 0 is 1
-+mem: location 1 is 27
-+run: ingredient 1 is 2
-+mem: location 2 is 3
-+run: product 0 is 9
-+mem: storing in location 3
-:(scenario "divide_with_remainder_literal")
-recipe main [
-  1:integer, 2:integer <- divide_with_remainder 9:literal, 2:literal
-]
-+run: instruction 0
-+run: ingredient 0 is 9
-+run: ingredient 1 is 2
-+run: product 0 is 4
-+mem: storing in location 1
-+run: product 1 is 1
-+mem: storing in location 2
-:(scenario "divide_with_remainder")
-recipe main [
-  1:integer <- copy 27:literal
-  2:integer <- copy 11:literal
-  3:integer, 4:integer <- divide_with_remainder 1:integer, 2:integer
-]
-+run: instruction 2
-+run: ingredient 0 is 1
-+mem: location 1 is 27
-+run: ingredient 1 is 2
-+mem: location 2 is 11
-+run: product 0 is 2
-+mem: storing in location 3
-+run: product 1 is 5
-+mem: storing in location 4
-
 :(code)
 int to_int(string n) {
   char* end = NULL;
diff --git a/cpp/013arithmetic b/cpp/013arithmetic
new file mode 100644
index 00000000..1c3f9d92
--- /dev/null
+++ b/cpp/013arithmetic
@@ -0,0 +1,220 @@
+:(before "End Primitive Recipe Numbers")
+// Arithmetic ops.
+Recipe_number["add"] = 2;
+Next_recipe_number++;
+:(before "End Primitive Recipe Implementations")
+  case 2: {  // add
+    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
+    vector<int> arg0 = read_memory(p->ingredients[0]);
+    assert(arg0.size() == 1);
+    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
+    vector<int> arg1 = read_memory(p->ingredients[1]);
+    assert(arg1.size() == 1);
+    vector<int> result;
+    result.push_back(arg0[0]+arg1[0]);
+    trace("run") << "product 0 is " << result[0];
+    write_memory(p->products[0], result);
+    break;
+  }
+
+:(scenario "add_literal")
+recipe main [
+  1:integer <- add 23:literal, 34:literal
+]
++run: instruction 0
++run: ingredient 0 is 23
++run: ingredient 1 is 34
++run: product 0 is 57
++mem: storing in location 1
+
+:(scenario "add")
+recipe main [
+  1:integer <- copy 23:literal
+  2:integer <- copy 34:literal
+  3:integer <- add 1:integer, 2:integer
+]
++run: instruction 2
++run: ingredient 0 is 1
++mem: location 1 is 23
++run: ingredient 1 is 2
++mem: location 2 is 34
++run: product 0 is 57
++mem: storing in location 3
+
+:(before "End Primitive Recipe Numbers")
+Recipe_number["subtract"] = 3;
+Next_recipe_number++;
+:(before "End Primitive Recipe Implementations")
+  case 3: {  // subtract
+    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
+    vector<int> arg0 = read_memory(p->ingredients[0]);
+    assert(arg0.size() == 1);
+    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
+    vector<int> arg1 = read_memory(p->ingredients[1]);
+    assert(arg1.size() == 1);
+    vector<int> result;
+    result.push_back(arg0[0]-arg1[0]);
+    trace("run") << "product 0 is " << result[0];
+    write_memory(p->products[0], result);
+    break;
+  }
+
+:(scenario "subtract_literal")
+recipe main [
+  1:integer <- subtract 5:literal, 2:literal
+]
++run: instruction 0
++run: ingredient 0 is 5
++run: ingredient 1 is 2
++run: product 0 is 3
++mem: storing in location 1
+
+:(scenario "subtract")
+recipe main [
+  1:integer <- copy 23:literal
+  2:integer <- copy 34:literal
+  3:integer <- subtract 1:integer, 2:integer
+]
++run: instruction 2
++run: ingredient 0 is 1
++mem: location 1 is 23
++run: ingredient 1 is 2
++mem: location 2 is 34
++run: product 0 is -11
++mem: storing in location 3
+
+:(before "End Primitive Recipe Numbers")
+Recipe_number["multiply"] = 4;
+Next_recipe_number++;
+:(before "End Primitive Recipe Implementations")
+  case 4: {  // multiply
+    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
+    vector<int> arg0 = read_memory(p->ingredients[0]);
+    assert(arg0.size() == 1);
+    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
+    vector<int> arg1 = read_memory(p->ingredients[1]);
+    assert(arg1.size() == 1);
+    trace("run") << "ingredient 1 is " << arg1[0];
+    vector<int> result;
+    result.push_back(arg0[0]*arg1[0]);
+    trace("run") << "product 0 is " << result[0];
+    write_memory(p->products[0], result);
+    break;
+  }
+
+:(scenario "multiply_literal")
+recipe main [
+  1:integer <- multiply 2:literal, 3:literal
+]
++run: instruction 0
++run: ingredient 0 is 2
++run: ingredient 1 is 3
++run: product 0 is 6
++mem: storing in location 1
+
+:(scenario "multiply")
+recipe main [
+  1:integer <- copy 4:literal
+  2:integer <- copy 6:literal
+  3:integer <- multiply 1:integer, 2:integer
+]
++run: instruction 2
++run: ingredient 0 is 1
++mem: location 1 is 4
++run: ingredient 1 is 2
++mem: location 2 is 6
++run: product 0 is 24
++mem: storing in location 3
+
+:(before "End Primitive Recipe Numbers")
+Recipe_number["divide"] = 5;
+Next_recipe_number++;
+:(before "End Primitive Recipe Implementations")
+  case 5: {  // divide
+    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
+    vector<int> arg0 = read_memory(p->ingredients[0]);
+    assert(arg0.size() == 1);
+    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
+    vector<int> arg1 = read_memory(p->ingredients[1]);
+    assert(arg1.size() == 1);
+    trace("run") << "ingredient 1 is " << arg1[0];
+    vector<int> result;
+    result.push_back(arg0[0]/arg1[0]);
+    trace("run") << "product 0 is " << result[0];
+    write_memory(p->products[0], result);
+    break;
+  }
+
+:(scenario "divide_literal")
+recipe main [
+  1:integer <- divide 8:literal, 2:literal
+]
++run: instruction 0
++run: ingredient 0 is 8
++run: ingredient 1 is 2
++run: product 0 is 4
++mem: storing in location 1
+
+:(scenario "divide")
+recipe main [
+  1:integer <- copy 27:literal
+  2:integer <- copy 3:literal
+  3:integer <- divide 1:integer, 2:integer
+]
++run: instruction 2
++run: ingredient 0 is 1
++mem: location 1 is 27
++run: ingredient 1 is 2
++mem: location 2 is 3
++run: product 0 is 9
++mem: storing in location 3
+
+:(before "End Primitive Recipe Numbers")
+Recipe_number["divide_with_remainder"] = 6;
+Next_recipe_number++;
+:(before "End Primitive Recipe Implementations")
+  case 6: {  // divide_with_remainder
+    trace("run") << "ingredient 0 is " << p->ingredients[0].name;
+    vector<int> arg0 = read_memory(p->ingredients[0]);
+    assert(arg0.size() == 1);
+    trace("run") << "ingredient 1 is " << p->ingredients[1].name;
+    vector<int> arg1 = read_memory(p->ingredients[1]);
+    assert(arg1.size() == 1);
+    vector<int> result0;
+    result0.push_back(arg0[0]/arg1[0]);
+    trace("run") << "product 0 is " << result0[0];
+    write_memory(p->products[0], result0);
+    vector<int> result1;
+    result1.push_back(arg0[0]%arg1[0]);
+    trace("run") << "product 1 is " << result1[0];
+    write_memory(p->products[1], result1);
+    break;
+  }
+
+:(scenario "divide_with_remainder_literal")
+recipe main [
+  1:integer, 2:integer <- divide_with_remainder 9:literal, 2:literal
+]
++run: instruction 0
++run: ingredient 0 is 9
++run: ingredient 1 is 2
++run: product 0 is 4
++mem: storing in location 1
++run: product 1 is 1
++mem: storing in location 2
+
+:(scenario "divide_with_remainder")
+recipe main [
+  1:integer <- copy 27:literal
+  2:integer <- copy 11:literal
+  3:integer, 4:integer <- divide_with_remainder 1:integer, 2:integer
+]
++run: instruction 2
++run: ingredient 0 is 1
++mem: location 1 is 27
++run: ingredient 1 is 2
++mem: location 2 is 11
++run: product 0 is 2
++mem: storing in location 3
++run: product 1 is 5
++mem: storing in location 4
-- 
cgit 1.4.1-2-gfad0