From 204dae921abff0c70e017215bb3c91fa6ca11aff Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Mon, 26 Dec 2016 11:44:14 -0800 Subject: 3710 Turns out we don't need to explicitly add anchors for each line. Vim's TOhtml has magic for that out of the box. --- html/026call.cc.html | 346 +++++++++++++++++++++++++-------------------------- 1 file changed, 173 insertions(+), 173 deletions(-) (limited to 'html/026call.cc.html') diff --git a/html/026call.cc.html b/html/026call.cc.html index 33da8ff9..bfb31307 100644 --- a/html/026call.cc.html +++ b/html/026call.cc.html @@ -58,179 +58,179 @@ if ('onhashchange' in window) { 
-  1 //: So far the recipes we define can't run each other. Let's fix that.
-  2 
-  3 :(scenario calling_recipe)
-  4 def main [
-  5   f
-  6 ]
-  7 def f [
-  8   3:num <- add 2, 2
-  9 ]
- 10 +mem: storing 4 in location 3
- 11 
- 12 :(scenario return_on_fallthrough)
- 13 def main [
- 14   f
- 15   1:num <- copy 0
- 16   2:num <- copy 0
- 17   3:num <- copy 0
- 18 ]
- 19 def f [
- 20   4:num <- copy 0
- 21   5:num <- copy 0
- 22 ]
- 23 +run: f
- 24 # running f
- 25 +run: {4: "number"} <- copy {0: "literal"}
- 26 +run: {5: "number"} <- copy {0: "literal"}
- 27 # back out to main
- 28 +run: {1: "number"} <- copy {0: "literal"}
- 29 +run: {2: "number"} <- copy {0: "literal"}
- 30 +run: {3: "number"} <- copy {0: "literal"}
- 31 
- 32 :(before "struct routine {")
- 33 // Everytime a recipe runs another, we interrupt it and start running the new
- 34 // recipe. When that finishes, we continue this one where we left off.
- 35 // This requires maintaining a 'stack' of interrupted recipes or 'calls'.
- 36 struct call {
- 37   recipe_ordinal running_recipe;
- 38   int running_step_index;
- 39   // End call Fields
- 40   call(recipe_ordinal r) {
- 41     running_recipe = r;
- 42     running_step_index = 0;
- 43     // End call Constructor
- 44   }
- 45   ~call() {
- 46     // End call Destructor
- 47   }
- 48 };
- 49 typedef list<call> call_stack;
- 50 
- 51 :(replace{} "struct routine")
- 52 struct routine {
- 53   call_stack calls;
- 54   // End routine Fields
- 55   routine(recipe_ordinal r);
- 56   bool completed() const;
- 57   const vector<instruction>& steps() const;
- 58 };
- 59 :(code)
- 60 routine::routine(recipe_ordinal r) {
- 61   if (Trace_stream) {
- 62     ++Trace_stream->callstack_depth;
- 63     trace(9999, "trace") << "new routine; incrementing callstack depth to " << Trace_stream->callstack_depth << end();
- 64     assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
- 65   }
- 66   calls.push_front(call(r));
- 67   // End routine Constructor
- 68 }
- 69 
- 70 :(code)
- 71 call& current_call() {
- 72   return Current_routine->calls.front();
- 73 }
- 74 
- 75 //:: now update routine's helpers
- 76 
- 77 :(replace{} "int& current_step_index()")
- 78 int& current_step_index() {
- 79   assert(!Current_routine->calls.empty());
- 80   return current_call().running_step_index;
- 81 }
- 82 :(replace{} "const string& current_recipe_name()")
- 83 const string& current_recipe_name() {
- 84   assert(!Current_routine->calls.empty());
- 85   return get(Recipe, current_call().running_recipe).name;
- 86 }
- 87 :(replace{} "const recipe& current_recipe()")
- 88 const recipe& current_recipe() {
- 89   assert(!Current_routine->calls.empty());
- 90   return get(Recipe, current_call().running_recipe);
- 91 }
- 92 :(replace{} "const instruction& current_instruction()")
- 93 const instruction& current_instruction() {
- 94   assert(!Current_routine->calls.empty());
- 95   return to_instruction(current_call());
- 96 }
- 97 :(code)
- 98 const instruction& to_instruction(const call& call) {
- 99   return get(Recipe, call.running_recipe).steps.at(call.running_step_index);
-100 }
-101 
-102 :(after "Defined Recipe Checks")
-103 // not a primitive; check that it's present in the book of recipes
-104 if (!contains_key(Recipe, inst.operation)) {
-105   raise << maybe(get(Recipe, r).name) << "undefined operation in '" << inst.original_string << "'\n" << end();
-106   break;
-107 }
-108 :(replace{} "default:" following "End Primitive Recipe Implementations")
-109 default: {
-110   const instruction& call_instruction = current_instruction();
-111   if (Recipe.find(current_instruction().operation) == Recipe.end()) {  // duplicate from Checks
-112     // stop running this instruction immediately
-113     ++current_step_index();
-114     continue;
-115   }
-116   // not a primitive; look up the book of recipes
-117   if (Trace_stream) {
-118     ++Trace_stream->callstack_depth;
-119     trace(9999, "trace") << "incrementing callstack depth to " << Trace_stream->callstack_depth << end();
-120     assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
-121   }
-122   Current_routine->calls.push_front(call(current_instruction().operation));
-123   finish_call_housekeeping(call_instruction, ingredients);
-124   continue;  // not done with caller; don't increment step_index of caller
-125 }
-126 :(code)
-127 void finish_call_housekeeping(const instruction& call_instruction, const vector<vector<double> >& ingredients) {
-128   // End Call Housekeeping
-129 }
-130 
-131 :(scenario calling_undefined_recipe_fails)
-132 % Hide_errors = true;
-133 def main [
-134   foo
-135 ]
-136 +error: main: undefined operation in 'foo '
-137 
-138 :(scenario calling_undefined_recipe_handles_missing_result)
-139 % Hide_errors = true;
-140 def main [
-141   x:num <- foo
-142 ]
-143 +error: main: undefined operation in 'x:num <- foo '
-144 
-145 //:: finally, we need to fix the termination conditions for the run loop
-146 
-147 :(replace{} "bool routine::completed() const")
-148 bool routine::completed() const {
-149   return calls.empty();
-150 }
-151 
-152 :(replace{} "const vector<instruction>& routine::steps() const")
-153 const vector<instruction>& routine::steps() const {
-154   assert(!calls.empty());
-155   return get(Recipe, calls.front().running_recipe).steps;
-156 }
-157 
-158 :(before "Running One Instruction")
-159 // when we reach the end of one call, we may reach the end of the one below
-160 // it, and the one below that, and so on
-161 while (current_step_index() >= SIZE(Current_routine->steps())) {
-162   // Falling Through End Of Recipe
-163   if (Trace_stream) {
-164     trace(9999, "trace") << "fall-through: exiting " << current_recipe_name() << "; decrementing callstack depth from " << Trace_stream->callstack_depth << end();
-165     --Trace_stream->callstack_depth;
-166     assert(Trace_stream->callstack_depth >= 0);
-167   }
-168   Current_routine->calls.pop_front();
-169   if (Current_routine->calls.empty()) goto stop_running_current_routine;
-170   // Complete Call Fallthrough
-171   // todo: fail if no products returned
-172   ++current_step_index();
-173 }
+  1 //: So far the recipes we define can't run each other. Let's fix that.
+  2 
+  3 :(scenario calling_recipe)
+  4 def main [
+  5   f
+  6 ]
+  7 def f [
+  8   3:num <- add 2, 2
+  9 ]
+ 10 +mem: storing 4 in location 3
+ 11 
+ 12 :(scenario return_on_fallthrough)
+ 13 def main [
+ 14   f
+ 15   1:num <- copy 0
+ 16   2:num <- copy 0
+ 17   3:num <- copy 0
+ 18 ]
+ 19 def f [
+ 20   4:num <- copy 0
+ 21   5:num <- copy 0
+ 22 ]
+ 23 +run: f
+ 24 # running f
+ 25 +run: {4: "number"} <- copy {0: "literal"}
+ 26 +run: {5: "number"} <- copy {0: "literal"}
+ 27 # back out to main
+ 28 +run: {1: "number"} <- copy {0: "literal"}
+ 29 +run: {2: "number"} <- copy {0: "literal"}
+ 30 +run: {3: "number"} <- copy {0: "literal"}
+ 31 
+ 32 :(before "struct routine {")
+ 33 // Everytime a recipe runs another, we interrupt it and start running the new
+ 34 // recipe. When that finishes, we continue this one where we left off.
+ 35 // This requires maintaining a 'stack' of interrupted recipes or 'calls'.
+ 36 struct call {
+ 37   recipe_ordinal running_recipe;
+ 38   int running_step_index;
+ 39   // End call Fields
+ 40   call(recipe_ordinal r) {
+ 41     running_recipe = r;
+ 42     running_step_index = 0;
+ 43     // End call Constructor
+ 44   }
+ 45   ~call() {
+ 46     // End call Destructor
+ 47   }
+ 48 };
+ 49 typedef list<call> call_stack;
+ 50 
+ 51 :(replace{} "struct routine")
+ 52 struct routine {
+ 53   call_stack calls;
+ 54   // End routine Fields
+ 55   routine(recipe_ordinal r);
+ 56   bool completed() const;
+ 57   const vector<instruction>& steps() const;
+ 58 };
+ 59 :(code)
+ 60 routine::routine(recipe_ordinal r) {
+ 61   if (Trace_stream) {
+ 62     ++Trace_stream->callstack_depth;
+ 63     trace(9999, "trace") << "new routine; incrementing callstack depth to " << Trace_stream->callstack_depth << end();
+ 64     assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
+ 65   }
+ 66   calls.push_front(call(r));
+ 67   // End routine Constructor
+ 68 }
+ 69 
+ 70 :(code)
+ 71 call& current_call() {
+ 72   return Current_routine->calls.front();
+ 73 }
+ 74 
+ 75 //:: now update routine's helpers
+ 76 
+ 77 :(replace{} "int& current_step_index()")
+ 78 int& current_step_index() {
+ 79   assert(!Current_routine->calls.empty());
+ 80   return current_call().running_step_index;
+ 81 }
+ 82 :(replace{} "const string& current_recipe_name()")
+ 83 const string& current_recipe_name() {
+ 84   assert(!Current_routine->calls.empty());
+ 85   return get(Recipe, current_call().running_recipe).name;
+ 86 }
+ 87 :(replace{} "const recipe& current_recipe()")
+ 88 const recipe& current_recipe() {
+ 89   assert(!Current_routine->calls.empty());
+ 90   return get(Recipe, current_call().running_recipe);
+ 91 }
+ 92 :(replace{} "const instruction& current_instruction()")
+ 93 const instruction& current_instruction() {
+ 94   assert(!Current_routine->calls.empty());
+ 95   return to_instruction(current_call());
+ 96 }
+ 97 :(code)
+ 98 const instruction& to_instruction(const call& call) {
+ 99   return get(Recipe, call.running_recipe).steps.at(call.running_step_index);
+100 }
+101 
+102 :(after "Defined Recipe Checks")
+103 // not a primitive; check that it's present in the book of recipes
+104 if (!contains_key(Recipe, inst.operation)) {
+105   raise << maybe(get(Recipe, r).name) << "undefined operation in '" << inst.original_string << "'\n" << end();
+106   break;
+107 }
+108 :(replace{} "default:" following "End Primitive Recipe Implementations")
+109 default: {
+110   const instruction& call_instruction = current_instruction();
+111   if (Recipe.find(current_instruction().operation) == Recipe.end()) {  // duplicate from Checks
+112     // stop running this instruction immediately
+113     ++current_step_index();
+114     continue;
+115   }
+116   // not a primitive; look up the book of recipes
+117   if (Trace_stream) {
+118     ++Trace_stream->callstack_depth;
+119     trace(9999, "trace") << "incrementing callstack depth to " << Trace_stream->callstack_depth << end();
+120     assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
+121   }
+122   Current_routine->calls.push_front(call(current_instruction().operation));
+123   finish_call_housekeeping(call_instruction, ingredients);
+124   continue;  // not done with caller; don't increment step_index of caller
+125 }
+126 :(code)
+127 void finish_call_housekeeping(const instruction& call_instruction, const vector<vector<double> >& ingredients) {
+128   // End Call Housekeeping
+129 }
+130 
+131 :(scenario calling_undefined_recipe_fails)
+132 % Hide_errors = true;
+133 def main [
+134   foo
+135 ]
+136 +error: main: undefined operation in 'foo '
+137 
+138 :(scenario calling_undefined_recipe_handles_missing_result)
+139 % Hide_errors = true;
+140 def main [
+141   x:num <- foo
+142 ]
+143 +error: main: undefined operation in 'x:num <- foo '
+144 
+145 //:: finally, we need to fix the termination conditions for the run loop
+146 
+147 :(replace{} "bool routine::completed() const")
+148 bool routine::completed() const {
+149   return calls.empty();
+150 }
+151 
+152 :(replace{} "const vector<instruction>& routine::steps() const")
+153 const vector<instruction>& routine::steps() const {
+154   assert(!calls.empty());
+155   return get(Recipe, calls.front().running_recipe).steps;
+156 }
+157 
+158 :(before "Running One Instruction")
+159 // when we reach the end of one call, we may reach the end of the one below
+160 // it, and the one below that, and so on
+161 while (current_step_index() >= SIZE(Current_routine->steps())) {
+162   // Falling Through End Of Recipe
+163   if (Trace_stream) {
+164     trace(9999, "trace") << "fall-through: exiting " << current_recipe_name() << "; decrementing callstack depth from " << Trace_stream->callstack_depth << end();
+165     --Trace_stream->callstack_depth;
+166     assert(Trace_stream->callstack_depth >= 0);
+167   }
+168   Current_routine->calls.pop_front();
+169   if (Current_routine->calls.empty()) goto stop_running_current_routine;
+170   // Complete Call Fallthrough
+171   // todo: fail if no products returned
+172   ++current_step_index();
+173 }
-- cgit 1.4.1-2-gfad0