mu - Soul of a tiny new machine. More thorough tests → More comprehensible and rewrite-friendly software → More resilient society.

diff options

Diffstat (limited to 'html')

0 files changed, 0 insertions, 0 deletions

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <title>Mu - 026call.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v2"> <meta name="syntax" content="cpp"> <meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy="> <meta name="colorscheme" content="minimal"> <style type="text/css">  </style> <script type='text/javascript'>  </script> </head> <body onload='JumpToLine();'> <pre id='vimCodeElement'> 1 //: So far the recipes we define can't run each other. Let's fix that. 2 3 :(scenario calling_recipe) 4 def <a href='000organization.cc.html#L113'>main</a> [ 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 <a href='000organization.cc.html#L113'>main</a> [ 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 <a href='010vm.cc.html#L14'>recipe_ordinal</a> running_recipe; 38 int running_step_index; 39 // End call Fields 40 call(<a href='010vm.cc.html#L14'>recipe_ordinal</a> 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(<a href='010vm.cc.html#L14'>recipe_ordinal</a> r); 56 bool completed() const; 57 const vector<instruction>& steps() const; 58 }; 59 :(code) 60 routine::routine(<a href='010vm.cc.html#L14'>recipe_ordinal</a> r) { 61 if (Trace_stream) { 62 ¦ ++Trace_stream->callstack_depth; 63 ¦ <a href='003trace.cc.html#L161'>trace</a>(9999, "trace") << "new routine; incrementing callstack depth to " << Trace_stream->callstack_depth << <a href='003trace.cc.html#L185'>end</a>(); 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 <a href='003trace.cc.html#L168'>raise</a> << <a href='013update_operation.cc.html#L25'>maybe</a>(get(Recipe, r).name) << "undefined operation in '" << inst.original_string << "'\n" << <a href='003trace.cc.html#L185'>end</a>(); 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.<a href='003trace.cc.html#L185'>end</a>()) { // 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 ¦ <a href='003trace.cc.html#L161'>trace</a>(9999, "trace") << "incrementing callstack depth to " << Trace_stream->callstack_depth << <a href='003trace.cc.html#L185'>end</a>(); 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 <a href='000organization.cc.html#L113'>main</a> [ 134 foo 135 ] 136 +error: <a href='000organization.cc.html#L113'>main</a>: undefined operation in 'foo' 137 138 :(scenario calling_undefined_recipe_handles_missing_result) 139 % Hide_errors = true; 140 def <a href='000organization.cc.html#L113'>main</a> [ 141 x:num <- foo 142 ] 143 +error: <a href='000organization.cc.html#L113'>main</a>: 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 :(after "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() >= <a href='001help.cc.html#L138'>SIZE</a>(Current_routine->steps())) { 162 // Falling Through End Of Recipe 163 if (Trace_stream) { 164 ¦ <a href='003trace.cc.html#L161'>trace</a>(9999, "trace") << "fall-through: exiting " << current_recipe_name() << "; decrementing callstack depth from " << Trace_stream->callstack_depth << <a href='003trace.cc.html#L185'>end</a>(); 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 } </pre> </body> </html>


context:
space:
mode: