1 //: Support jumps to a specific label (the 'jump target') in the same recipe.
  2 //: Jump targets must be unique and unambiguous within any recipe.
  3 //:
  4 //: The 'break' and 'loop' pseudo instructions can also take jump targets.
  5 //: Which instruction you use is just documentation about intent; use 'break'
  6 //: to indicate you're exiting one or more loop nests, and 'loop' to indicate
  7 //: you're skipping to the next iteration of some containing loop nest.
  8 
  9 //: Since they have to be unique in a recipe, not all labels can be jump
 10 //: targets.
 11 bool is_jump_target(const string& label) {
 12   if (label == "{" || label == "}") return false;
 13   // End is_jump_target Special-cases
 14   return is_label_word(label);
 15 }
 16 
 17 :(scenario jump_to_label)
 18 def main [
 19   jump +target:label
 20   1:num <- copy 0
 21   +target
 22 ]
 23 -mem: storing 0 in location 1
 24 
 25 :(before "End Mu Types Initialization")
 26 put(Type_ordinal, "label", 0);
 27 
 28 :(before "End Instruction Modifying Transforms")
 29 Transform.push_back(transform_labels);  // idempotent
 30 
 31 :(code)
 32 void transform_labels(const recipe_ordinal r) {
 33   map<string, int> offset;
 34   for (int i = 0;  i < SIZE(get(Recipe, r).steps);  ++i) {
 35     const instruction& inst = get(Recipe, r).steps.at(i);
 36     if (!inst.is_label) continue;
 37     if (is_jump_target(inst.label)) {
 38       if (!contains_key(offset, inst.label)) {
 39         put(offset, inst.label, i);
 40       }
 41       else {
 42         raise << maybe(get(Recipe, r).name) << "duplicate label '" << inst.label << "'" << end();
 43         // have all jumps skip some random but noticeable and deterministic amount of code
 44         put(offset, inst.label, 9999);
 45       }
 46     }
 47   }
 48   for (int i = 0;  i < SIZE(get(Recipe, r).steps);  ++i) {
 49     instruction& inst = get(Recipe, r).steps.at(i);
 50     if (inst.name == "jump") {
 51       if (inst.ingredients.empty()) {
 52         raise << maybe(get(Recipe, r).name) << "'" << to_original_string(inst) << "' expects an ingredient but got 0\n" << end();
 53         return;
 54       }
 55       replace_offset(inst.ingredients.at(0), offset, i, r);
 56     }
 57     if (inst.name == "jump-if" || inst.name == "jump-unless") {
 58       if (SIZE(inst.ingredients) < 2) {
 59         raise << maybe(get(Recipe, r).name) << "'" << to_original_string(inst) << "' expects 2 ingredients but got " << SIZE(inst.ingredients) << '\n' << end();
 60         return;
 61       }
 62       replace_offset(inst.ingredients.at(1), offset, i, r);
 63     }
 64     if ((inst.name == "loop" || inst.name == "break")
 65         && SIZE(inst.ingredients) >= 1) {
 66       replace_offset(inst.ingredients.at(0), offset, i, r);
 67     }
 68     if ((inst.name == "loop-if" || inst.name == "loop-unless"
 69             || inst.name == "break-if" || inst.name == "break-unless")
 70         && SIZE(inst.ingredients) >= 2) {
 71       replace_offset(inst.ingredients.at(1), offset, i, r);
 72     }
 73   }
 74 }
 75 
 76 void replace_offset(reagent& x, /*const*/ map<string, int>& offset, const int current_offset, const recipe_ordinal r) {
 77   if (!is_literal(x)) {
 78     raise << maybe(get(Recipe, r).name) << "jump target must be offset or label but is '" << x.original_string << "'\n" << end();
 79     x.set_value(0);  // no jump by default
 80     return;
 81   }
 82   if (x.initialized) return;
 83   if (is_integer(x.name)) return;  // non-labels will be handled like other number operands
 84   if (!is_jump_target(x.name)) {
 85     raise << maybe(get(Recipe, r).name) << "can't jump to label '" << x.name << "'\n" << end();
 86     x.set_value(0);  // no jump by default
 87     return;
 88   }
 89   if (!contains_key(offset, x.name)) {
 90     raise << maybe(get(Recipe, r).name) << "can't find label '" << x.name << "'\n" << end();
 91     x.set_value(0);  // no jump by default
 92     return;
 93   }
 94   x.set_value(get(offset, x.name) - current_offset);
 95 }
 96 
 97 :(scenario break_to_label)
 98 def main [
 99   {
100     {
101       break +target:label
102       1:num <- copy 0
103     }
104   }
105   +target
106 ]
107 -mem: storing 0 in location 1
108 
109 :(scenario jump_if_to_label)
110 def main [
111   {
112     {
113       jump-if 1, +target:label
114       1:num <- copy 0
115     }
116   }
117   +target
118 ]
119 -mem: storing 0 in location 1
120 
121 :(scenario loop_unless_to_label)
122 def main [
123   {
124     {
125       loop-unless 0, +target:label  # loop/break with a label don't care about braces
126       1:num <- copy 0
127     }
128   }
129   +target
130 ]
131 -mem: storing 0 in location 1
132 
133 :(scenario jump_runs_code_after_label)
134 def main [
135   # first a few lines of padding to exercise the offset computation
136   1:num <- copy 0
137   2:num <- copy 0
138   3:num <- copy 0
139   jump +target:label
140   4:num <- copy 0
141   +target
142   5:num <- copy 0
143 ]
144 +mem: storing 0 in location 5
145 -mem: storing 0 in location 4
146 
147 :(scenario jump_fails_without_target)
148 % Hide_errors = true;
149 def main [
150   jump
151 ]
152 +error: main: 'jump' expects an ingredient but got 0
153 
154 :(scenario jump_fails_without_target_2)
155 % Hide_errors = true;
156 def main [
157   jump-if true
158 ]
159 +error: main: 'jump-if true' expects 2 ingredients but got 1
160 
161 :(scenario recipe_fails_on_duplicate_jump_target)
162 % Hide_errors = true;
163 def main [
164   +label
165   1:num <- copy 0
166   +label
167   2:num <- copy 0
168 ]
169 +error: main: duplicate label '+label'
170 
171 :(scenario jump_ignores_nontarget_label)
172 % Hide_errors = true;
173 def main [
174   # first a few lines of padding to exercise the offset computation
175   1:num <- copy 0
176   2:num <- copy 0
177   3:num <- copy 0
178   jump $target:label
179   4:num <- copy 0
180   $target
181   5:num <- copy 0
182 ]
183 +error: main: can't jump to label '$target'