profani-tty - Profanity fork with TTY improvements

diff options

Diffstat (limited to 'tests/unittests/test_cmd_connect.c')

0 files changed, 0 insertions, 0 deletions

//: Allow code for recipes to be pulled in from multiple places and inserted //: at special labels called 'waypoints'. Unlike jump targets, a recipe can //: have multiple ambiguous waypoints with the same name. Any 'before' and //: 'after' fragments will simply be inserted at all applicable waypoints. //: Waypoints are always surrounded by '<>', e.g. <handle-request>. //: //: TODO: switch recipe.steps to a more efficient data structure. :(scenario tangle_before) recipe main [ 1:number <- copy 0 <label1> 3:number <- copy 0 ] before <label1> [ 2:number <- copy 0 ] +mem: storing 0 in location 1 +mem: storing 0 in location 2 +mem: storing 0 in location 3 # nothing else $mem: 3 //: while loading recipes, load before/after fragments :(before "End Globals") map<string /*label*/, recipe> Before_fragments, After_fragments; set<string /*label*/> Fragments_used; :(before "End Setup") Before_fragments.clear(); After_fragments.clear(); Fragments_used.clear(); :(before "End Command Handlers") else if (command == "before") { string label = next_word(in); recipe tmp = slurp_body(in); if (is_waypoint(label)) Before_fragments[label].steps.insert(Before_fragments[label].steps.end(), tmp.steps.begin(), tmp.steps.end()); else raise_error << "can't tangle before label " << label << '\n' << end(); } else if (command == "after") { string label = next_word(in); recipe tmp = slurp_body(in); if (is_waypoint(label)) After_fragments[label].steps.insert(After_fragments[label].steps.begin(), tmp.steps.begin(), tmp.steps.end()); else raise_error << "can't tangle after label " << label << '\n' << end(); } //: after all recipes are loaded, insert fragments at appropriate labels. :(after "int main") Transform.push_back(insert_fragments); //; We might need to perform multiple passes, in case inserted fragments //: include more labels that need further insertions. Track which labels we've //: already processed using an extra field. :(before "End instruction Fields") mutable bool tangle_done; :(before "End instruction Constructor") tangle_done = false; :(code) void insert_fragments(const recipe_ordinal r) { bool made_progress = true; long long int pass = 0; while (made_progress) { made_progress = false; // create a new vector because insertions invalidate iterators vector<instruction> result; for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { const instruction& inst = Recipe[r].steps.at(i); if (!inst.is_label || !is_waypoint(inst.label) || inst.tangle_done) { result.push_back(inst); continue; } inst.tangle_done = true; made_progress = true; Fragments_used.insert(inst.label); ostringstream prefix; prefix << '+' << Recipe[r].name << '_' << pass << '_' << i; if (Before_fragments.find(inst.label) != Before_fragments.end()) { append_fragment(result, Before_fragments[inst.label].steps, prefix.str()); } result.push_back(inst); if (After_fragments.find(inst.label) != After_fragments.end()) { append_fragment(result, After_fragments[inst.label].steps, prefix.str()); } } Recipe[r].steps.swap(result); ++pass; } } void append_fragment(vector<instruction>& base, const vector<instruction>& patch, const string prefix) { // append 'patch' to 'base' while keeping 'base' oblivious to any new jump // targets in 'patch' oblivious to 'base' by prepending 'prefix' to them. // we might tangle the same fragment at multiple points in a single recipe, // and we need to avoid duplicate jump targets. // so we'll keep jump targets local to the specific before/after fragment // that introduces them. set<string> jump_targets; for (long long int i = 0; i < SIZE(patch); ++i) { const instruction& inst = patch.at(i); if (inst.is_label && is_jump_target(inst.label)) jump_targets.insert(inst.label); } for (long long int i = 0; i < SIZE(patch); ++i) { instruction inst = patch.at(i); if (inst.is_label) { if (jump_targets.find(inst.label) != jump_targets.end()) inst.label = prefix+inst.label; base.push_back(inst); continue; } for (long long int j = 0; j < SIZE(inst.ingredients); ++j) { reagent& x = inst.ingredients.at(j); if (!is_literal(x)) continue; if (x.properties.at(0).second.at(0) == "label" && jump_targets.find(x.name) != jump_targets.end()) x.name = prefix+x.name; } base.push_back(inst); } } bool is_waypoint(string label) { return *label.begin() == '<' && *label.rbegin() == '>'; } //: complain about unapplied fragments :(before "End Globals") bool Transform_check_insert_fragments_Ran = false; :(before "End One-time Setup") Transform.push_back(check_insert_fragments); // final transform :(code) void check_insert_fragments(unused recipe_ordinal) { if (Transform_check_insert_fragments_Ran) return; Transform_check_insert_fragments_Ran = true; for (map<string, recipe>::iterator p = Before_fragments.begin(); p != Before_fragments.end(); ++p) { if (Fragments_used.find(p->first) == Fragments_used.end()) raise_error << "could not locate insert before " << p->first << '\n' << end(); } for (map<string, recipe>::iterator p = After_fragments.begin(); p != After_fragments.end(); ++p) { if (Fragments_used.find(p->first) == Fragments_used.end()) raise_error << "could not locate insert after " << p->first << '\n' << end(); } } :(scenario tangle_before_and_after) recipe main [ 1:number <- copy 0 <label1> 4:number <- copy 0 ] before <label1> [ 2:number <- copy 0 ] after <label1> [ 3:number <- copy 0 ] +mem: storing 0 in location 1 +mem: storing 0 in location 2 # label1 +mem: storing 0 in location 3 +mem: storing 0 in location 4 # nothing else $mem: 4 :(scenario tangle_ignores_jump_target) % Hide_errors = true; recipe main [ 1:number <- copy 0 +label1 4:number <- copy 0 ] before +label1 [ 2:number <- copy 0 ] +error: can't tangle before label +label1 +mem: storing 0 in location 1 +mem: storing 0 in location 4 # label1 -mem: storing 0 in location 2 # nothing else $mem: 2 :(scenario tangle_keeps_labels_separate) recipe main [ 1:number <- copy 0 <label1> <label2> 6:number <- copy 0 ] before <label1> [ 2:number <- copy 0 ] after <label1> [ 3:number <- copy 0 ] before <label2> [ 4:number <- copy 0 ] after <label2> [ 5:number <- copy 0 ] +mem: storing 0 in location 1 +mem: storing 0 in location 2 # label1 +mem: storing 0 in location 3 # 'after' fragments for earlier label always go before 'before' fragments for later label +mem: storing 0 in location 4 # label2 +mem: storing 0 in location 5 +mem: storing 0 in location 6 # nothing else $mem: 6 :(scenario tangle_stacks_multiple_fragments) recipe main [ 1:number <- copy 0 <label1> 6:number <- copy 0 ] before <label1> [ 2:number <- copy 0 ] after <label1> [ 3:number <- copy 0 ] before <label1> [ 4:number <- copy 0 ] after <label1> [ 5:number <- copy 0 ] +mem: storing 0 in location 1 # 'before' fragments stack in order +mem: storing 0 in location 2 +mem: storing 0 in location 4 # label1 # 'after' fragments stack in reverse order +mem: storing 0 in location 5 +mem: storing 0 in location 3 +mem: storing 0 in location 6 # nothing else $mem: 6 :(scenario tangle_supports_fragments_with_multiple_instructions) recipe main [ 1:number <- copy 0 <label1> 6:number <- copy 0 ] before <label1> [ 2:number <- copy 0 3:number <- copy 0 ] after <label1> [ 4:number <- copy 0 5:number <- copy 0 ] +mem: storing 0 in location 1 +mem: storing 0 in location 2 +mem: storing 0 in location 3 # label1 +mem: storing 0 in location 4 +mem: storing 0 in location 5 +mem: storing 0 in location 6 # nothing else $mem: 6 :(scenario tangle_tangles_into_all_labels_with_same_name) recipe main [ 1:number <- copy 10 <label1> 4:number <- copy 10 recipe2 ] recipe recipe2 [ 1:number <- copy 11 <label1> 4:number <- copy 11 ] before <label1> [ 2:number <- copy 12 ] after <label1> [ 3:number <- copy 12 ] +mem: storing 10 in location 1 +mem: storing 12 in location 2 # label1 +mem: storing 12 in location 3 +mem: storing 10 in location 4 # recipe2 +mem: storing 11 in location 1 +mem: storing 12 in location 2 # label1 +mem: storing 12 in location 3 +mem: storing 11 in location 4 # nothing else $mem: 8 :(scenario tangle_tangles_into_all_labels_with_same_name_2) recipe main [ 1:number <- copy 10 <label1> <label1> 4:number <- copy 10 ] before <label1> [ 2:number <- copy 12 ] after <label1> [ 3:number <- copy 12 ] +mem: storing 10 in location 1 +mem: storing 12 in location 2 # label1 +mem: storing 12 in location 3 +mem: storing 12 in location 2 # label1 +mem: storing 12 in location 3 +mem: storing 10 in location 4 # nothing else $mem: 6 :(scenario tangle_tangles_into_all_labels_with_same_name_3) recipe main [ 1:number <- copy 10 <label1> <foo> 4:number <- copy 10 ] before <label1> [ 2:number <- copy 12 ] after <label1> [ 3:number <- copy 12 ] after <foo> [ <label1> ] +mem: storing 10 in location 1 +mem: storing 12 in location 2 # label1 +mem: storing 12 in location 3 +mem: storing 12 in location 2 # foo/label1 +mem: storing 12 in location 3 +mem: storing 10 in location 4 # nothing else $mem: 6 :(scenario tangle_handles_jump_target_inside_fragment) recipe main [ 1:number <- copy 10 <label1> 4:number <- copy 10 ] before <label1> [ jump +label2:label 2:number <- copy 12 +label2 3:number <- copy 12 ] +mem: storing 10 in location 1 # label1 +mem: storing 12 in location 3 +mem: storing 10 in location 4 # ignored by jump -mem: storing 12 in label 2 # nothing else $mem: 3 :(scenario tangle_renames_jump_target) recipe main [ 1:number <- copy 10 <label1> +label2 4:number <- copy 10 ] before <label1> [ jump +label2:label 2:number <- copy 12 +label2 # renamed 3:number <- copy 12 ] +mem: storing 10 in location 1 # label1 +mem: storing 12 in location 3 +mem: storing 10 in location 4 # ignored by jump -mem: storing 12 in label 2 # nothing else $mem: 3 :(scenario tangle_jump_to_base_recipe) recipe main [ 1:number <- copy 10 <label1> +label2 4:number <- copy 10 ] before <label1> [ jump +label2:label 2:number <- copy 12 3:number <- copy 12 ] +mem: storing 10 in location 1 # label1 +mem: storing 10 in location 4 # ignored by jump -mem: storing 12 in label 2 -mem: storing 12 in location 3 # nothing else $mem: 2


context:
space:
mode: