diff options
Diffstat (limited to 'cpp/030brace')
| -rw-r--r-- | cpp/030brace | 398 |
1 files changed, 398 insertions, 0 deletions
diff --git a/cpp/030brace b/cpp/030brace new file mode 100644 index 00000000..0d68b54f --- /dev/null +++ b/cpp/030brace @@ -0,0 +1,398 @@ +//: Structured programming +//: +//: Our jump operators are quite inconvenient to use, so mu provides a +//: lightweight tool called 'transform_braces' to work in a slightly more +//: convenient format with nested braces: +//: +//: { +//: some instructions +//: { +//: more instructions +//: } +//: } +//: +//: Braces are just labels, they require no special parsing. The pseudo +//: recipes 'loop' and 'break' jump to just after the enclosing '{' and '}' +//: respectively. +//: +//: Conditional and unconditional 'loop' and 'break' should give us 80% of the +//: benefits of the control-flow primitives we're used to in other languages, +//: like 'if', 'while', 'for', etc. + +:(scenarios transform_test) +:(scenario "brace_conversion") +recipe main [ + { + break + 1:integer <- copy 0:literal + } +] ++after-brace: recipe main ++after-brace: jump 1:offset ++after-brace: copy ... + +//: one-time setup +:(after "int main") + Transform.push_back(transform_braces); + +:(code) +void transform_braces(const recipe_number r) { +//? cout << "AAA transform_braces\n"; //? 1 +//? exit(0); //? 1 + const int OPEN = 0, CLOSE = 1; + list<pair<int/*OPEN/CLOSE*/, size_t/*step index*/> > braces; + for (size_t index = 0; index < Recipe[r].steps.size(); ++index) { + const instruction& inst = Recipe[r].steps[index]; + if (inst.label == "{") { + trace("brace") << r << ": push (open, " << index << ")"; + braces.push_back(pair<int,size_t>(OPEN, index)); + } + if (inst.label == "}") { + trace("brace") << "push (close, " << index << ")"; + braces.push_back(pair<int,size_t>(CLOSE, index)); + } + } + stack<size_t/*step index*/> open_braces; + trace("after-brace") << "recipe " << Recipe[r].name; + for (size_t index = 0; index < Recipe[r].steps.size(); ++index) { + instruction& inst = Recipe[r].steps[index]; +//? cout << "AAA " << inst.name << ": " << inst.operation << '\n'; //? 1 + if (inst.label == "{") open_braces.push(index); + else if (inst.label == "}") open_braces.pop(); + else if (inst.is_label) + ; // do nothing + else if (inst.operation == Recipe_number["loop"]) { + inst.operation = Recipe_number["jump"]; + if (inst.ingredients.size() > 0 && isa_literal(inst.ingredients[0])) { + // explicit target; a later phase will handle it + trace("after-brace") << "jump " << inst.ingredients[0].name << ":offset"; + } + else { + reagent ing; + ing.set_value(open_braces.top()-index); + inst.ingredients.push_back(ing); + trace("after-brace") << "jump " << ing.value << ":offset"; + trace("after-brace") << index << ": " << ing.to_string(); + trace("after-brace") << index << ": " << Recipe[r].steps[index].ingredients[0].to_string(); + } + } + else if (inst.operation == Recipe_number["break"]) { + inst.operation = Recipe_number["jump"]; + if (inst.ingredients.size() > 0 && isa_literal(inst.ingredients[0])) { + // explicit target; a later phase will handle it + trace("after-brace") << "jump " << inst.ingredients[0].name << ":offset"; + } + else { + reagent ing; + ing.set_value(matching_brace(open_braces.top(), braces) - index - 1); + inst.ingredients.push_back(ing); + trace("after-brace") << "jump " << ing.value << ":offset"; + } + } + else if (inst.operation == Recipe_number["loop-if"]) { + inst.operation = Recipe_number["jump-if"]; + if (inst.ingredients.size() > 1 && isa_literal(inst.ingredients[1])) { + // explicit target; a later phase will handle it + trace("after-brace") << "jump " << inst.ingredients[1].name << ":offset"; + } + else { + reagent ing; + ing.set_value(open_braces.top()-index); + inst.ingredients.push_back(ing); + trace("after-brace") << "jump-if " << inst.ingredients[0].name << ", " << ing.value << ":offset"; + } + } + else if (inst.operation == Recipe_number["break-if"]) { + inst.operation = Recipe_number["jump-if"]; + if (inst.ingredients.size() > 1 && isa_literal(inst.ingredients[1])) { + // explicit target; a later phase will handle it + trace("after-brace") << "jump " << inst.ingredients[1].name << ":offset"; + } + else { + reagent ing; + ing.set_value(matching_brace(open_braces.top(), braces) - index - 1); + inst.ingredients.push_back(ing); + trace("after-brace") << "jump-if " << inst.ingredients[0].name << ", " << ing.value << ":offset"; + } + } + else if (inst.operation == Recipe_number["loop-unless"]) { + inst.operation = Recipe_number["jump-unless"]; + if (inst.ingredients.size() > 1 && isa_literal(inst.ingredients[1])) { + // explicit target; a later phase will handle it + trace("after-brace") << "jump " << inst.ingredients[1].name << ":offset"; + } + else { + reagent ing; + ing.set_value(open_braces.top()-index); + inst.ingredients.push_back(ing); + trace("after-brace") << "jump-unless " << inst.ingredients[0].name << ", " << ing.value << ":offset"; + } + } + else if (inst.operation == Recipe_number["break-unless"]) { +//? cout << "AAA break-unless\n"; //? 1 + inst.operation = Recipe_number["jump-unless"]; + if (inst.ingredients.size() > 1 && isa_literal(inst.ingredients[1])) { + // explicit target; a later phase will handle it + trace("after-brace") << "jump " << inst.ingredients[1].name << ":offset"; + } + else { + reagent ing; + ing.set_value(matching_brace(open_braces.top(), braces) - index - 1); + inst.ingredients.push_back(ing); + trace("after-brace") << "jump-unless " << inst.ingredients[0].name << ", " << ing.value << ":offset"; + } + } + else { + trace("after-brace") << inst.name << " ..."; + } + } +} + +size_t matching_brace(size_t index, const list<pair<int, size_t> >& braces) { + int stacksize; + for (list<pair<int, size_t> >::const_iterator p = braces.begin(); p != braces.end(); ++p) { + if (p->second < index) continue; + stacksize += (p->first ? 1 : -1); + if (stacksize == 0) return p->second; + } + assert(false); + return -1; +} + +// temporarily suppress run +void transform_test(string form) { +//? cout << "AAA transform_test {\n"; //? 1 + vector<recipe_number> tmp = add_recipes(form); +//? cout << "AAA done adding recipes\n"; //? 1 + transform_all(); +//? cout << "AAA }\n"; //? 1 +} + +//: Make sure these pseudo recipes get consistent numbers, even though they aren't +//: implemented. +:(before "End Globals") +const int BREAK = 24; +const int BREAK_IF = 25; +const int BREAK_UNLESS = 26; +const int LOOP = 27; +const int LOOP_IF = 28; +const int LOOP_UNLESS = 29; +:(before "End Primitive Recipe Numbers") +Recipe_number["break"] = BREAK; +assert(Next_recipe_number == BREAK); +Next_recipe_number++; +Recipe_number["break-if"] = BREAK_IF; +assert(Next_recipe_number == BREAK_IF); +Next_recipe_number++; +Recipe_number["break-unless"] = BREAK_UNLESS; +assert(Next_recipe_number == BREAK_UNLESS); +Next_recipe_number++; +Recipe_number["loop"] = LOOP; +assert(Next_recipe_number == LOOP); +Next_recipe_number++; +Recipe_number["loop-if"] = LOOP_IF; +assert(Next_recipe_number == LOOP_IF); +Next_recipe_number++; +Recipe_number["loop-unless"] = LOOP_UNLESS; +assert(Next_recipe_number == LOOP_UNLESS); +Next_recipe_number++; + +:(scenario "loop") +recipe main [ + 1:integer <- copy 0:literal + 2:integer <- copy 0:literal + { + 3:integer <- copy 0:literal + loop + } +] ++after-brace: recipe main ++after-brace: copy ... ++after-brace: copy ... ++after-brace: copy ... ++after-brace: jump -2:offset + +:(scenario "break_empty_block") +recipe main [ + 1:integer <- copy 0:literal + { + break + } +] ++after-brace: recipe main ++after-brace: copy ... ++after-brace: jump 0:offset + +:(scenario "break_cascading") +recipe main [ + 1:integer <- copy 0:literal + { + break + } + { + break + } +] ++after-brace: recipe main ++after-brace: copy ... ++after-brace: jump 0:offset ++after-brace: jump 0:offset + +:(scenario "break_cascading2") +recipe main [ + 1:integer <- copy 0:literal + 2:integer <- copy 0:literal + { + break + 3:integer <- copy 0:literal + } + { + break + } +] ++after-brace: recipe main ++after-brace: copy ... ++after-brace: copy ... ++after-brace: jump 1:offset ++after-brace: copy ... ++after-brace: jump 0:offset + +:(scenario "break_if") +recipe main [ + 1:integer <- copy 0:literal + 2:integer <- copy 0:literal + { + break-if 2:integer + 3:integer <- copy 0:literal + } + { + break + } +] ++after-brace: recipe main ++after-brace: copy ... ++after-brace: copy ... ++after-brace: jump-if 2, 1:offset ++after-brace: copy ... ++after-brace: jump 0:offset + +:(scenario "break_nested") +recipe main [ + 1:integer <- copy 0:literal + { + 2:integer <- copy 0:literal + break + { + 3:integer <- copy 0:literal + } + 4:integer <- copy 0:literal + } +] ++after-brace: jump 4:offset + +:(scenario "break_nested_degenerate") +recipe main [ + 1:integer <- copy 0:literal + { + 2:integer <- copy 0:literal + break + { + } + 4:integer <- copy 0:literal + } +] ++after-brace: jump 3:offset + +:(scenario "break_nested_degenerate2") +recipe main [ + 1:integer <- copy 0:literal + { + 2:integer <- copy 0:literal + break + { + } + } +] ++after-brace: jump 2:offset + +:(scenario "break_label") +recipe main [ + 1:integer <- copy 0:literal + { + break +foo:offset + } +] ++after-brace: jump +foo:offset + +:(scenario "break_unless") +recipe main [ + 1:integer <- copy 0:literal + 2:integer <- copy 0:literal + { + break-unless 2:integer + 3:integer <- copy 0:literal + } +] ++after-brace: recipe main ++after-brace: copy ... ++after-brace: copy ... ++after-brace: jump-unless 2, 1:offset ++after-brace: copy ... + +:(scenario "loop_unless") +recipe main [ + 1:integer <- copy 0:literal + 2:integer <- copy 0:literal + { + loop-unless 2:integer + 3:integer <- copy 0:literal + } +] ++after-brace: recipe main ++after-brace: copy ... ++after-brace: copy ... ++after-brace: jump-unless 2, -1:offset ++after-brace: copy ... + +:(scenario "loop_nested") +recipe main [ + 1:integer <- copy 0:literal + { + 2:integer <- copy 0:literal + { + 3:integer <- copy 0:literal + } + loop-if 4:boolean + 5:integer <- copy 0:literal + } +] ++after-brace: recipe main ++after-brace: jump-if 4, -5:offset + +:(scenario "loop_label") +recipe main [ + 1:integer <- copy 0:literal + +foo + 2:integer <- copy 0:literal +] ++after-brace: recipe main ++after-brace: copy ... ++after-brace: copy ... + +//: test how things actually run +:(scenarios run) +:(scenario "factorial") +recipe factorial [ + 1:integer <- copy 5:literal + 2:integer <- copy 1:literal + { + 3:boolean <- equal 1:integer 1:literal + break-if 3:boolean +# $print 1:integer + 2:integer <- multiply 2:integer, 1:integer + 1:integer <- subtract 1:integer, 1:literal + loop + } + 4:integer <- copy 2:integer # trigger a read +] ++mem: location 2 is 120 |