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

diff options

Diffstat (limited to 'archive/0.vm.arc/chessboard.mu')

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>~/Desktop/s/mu/035call.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v1"> <meta name="syntax" content="cpp"> <meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> <meta name="colorscheme" content="minimal"> <style type="text/css">  </style> <script type='text/javascript'>  </script> </head> <body> <pre id='vimCodeElement'> //: So far the recipes we define can't run each other. Let's fix that. :(scenario calling_recipe) recipe main [ f ] recipe f [ 3:number <- add 2:literal, 2:literal ] +mem: storing 4 in location 3 :(scenario return_on_fallthrough) recipe main [ f 1:number <- copy 34:literal 2:number <- copy 34:literal 3:number <- copy 34:literal ] recipe f [ 4:number <- copy 34:literal 5:number <- copy 34:literal ] +run: instruction main/0 +run: instruction f/0 +run: instruction f/1 +run: instruction main/1 +run: instruction main/2 +run: instruction main/3 :(before "struct routine {") // Everytime a recipe runs another, we interrupt it and start running the new // recipe. When that finishes, we continue this one where we left off. // This requires maintaining a 'stack' of interrupted recipes or 'calls'. struct call { recipe_number running_recipe; index_t running_step_index; // End call Fields call(recipe_number r) :running_recipe(r), running_step_index(0) {} }; typedef list<call> call_stack; :(replace{} "struct routine") struct routine { call_stack calls; // End routine Fields routine(recipe_number r); bool completed() const; const vector<instruction>& steps() const; }; :(code) routine::routine(recipe_number r) { calls.push_front(call(r)); // End routine Constructor } //:: now update routine's helpers :(replace{} "inline index_t& current_step_index()") inline index_t& current_step_index() { assert(!Current_routine->calls.empty()); return Current_routine->calls.front().running_step_index; } :(replace{} "inline const string& current_recipe_name()") inline const string& current_recipe_name() { assert(!Current_routine->calls.empty()); return Recipe[Current_routine->calls.front().running_recipe].name; } :(replace{} "inline const instruction& current_instruction()") inline const instruction& current_instruction() { assert(!Current_routine->calls.empty()); return Recipe[Current_routine->calls.front().running_recipe].steps.at(Current_routine->calls.front().running_step_index); } :(replace{} "default:" following "End Primitive Recipe Implementations") default: { // not a primitive; try to look up the book of recipes if (Recipe.find(current_instruction().operation) == Recipe.end()) { raise << "undefined operation " << current_instruction().operation << ": " << current_instruction().to_string() << '\n'; break; } Current_routine->calls.push_front(call(current_instruction().operation)); continue; // not done with caller; don't increment current_step_index() } //:: finally, we need to fix the termination conditions for the run loop :(replace{} "inline bool routine::completed() const") inline bool routine::completed() const { return calls.empty(); } inline const vector<instruction>& routine::steps() const { assert(!calls.empty()); return Recipe[calls.front().running_recipe].steps; } :(before "Running One Instruction") // when we reach the end of one call, we may reach the end of the one below // it, and the one below that, and so on while (current_step_index() >= Current_routine->steps().size()) { Current_routine->calls.pop_front(); if (Current_routine->calls.empty()) return; // todo: no results returned warning ++current_step_index(); } :(before "End Includes") #include <stack> using std::stack; </pre> </body> </html>


context:
space:
mode: