1 //: Arithmetic primitives
  2 
  3 :(before "End Primitive Recipe Declarations")
  4 ADD,
  5 :(before "End Primitive Recipe Numbers")
  6 put(Recipe_ordinal, "add", ADD);
  7 :(before "End Primitive Recipe Checks")
  8 case ADD: {
  9   // primary goal of these checks is to forbid address arithmetic
 10   for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
 11     if (!is_mu_number(inst.ingredients.at(i))) {
 12       raise << maybe(get(Recipe, r).name) << "'add' requires number ingredients, but got '" << inst.ingredients.at(i).original_string << "'\n" << end();
 13       goto finish_checking_instruction;
 14     }
 15   }
 16   if (SIZE(inst.products) > 1) {
 17     raise << maybe(get(Recipe, r).name) << "'add' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
 18     break;
 19   }
 20   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
 21     raise << maybe(get(Recipe, r).name) << "'add' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
 22     break;
 23   }
 24   break;
 25 }
 26 :(before "End Primitive Recipe Implementations")
 27 case ADD: {
 28   double result = 0;
 29   for (int i = 0;  i < SIZE(ingredients);  ++i) {
 30     result += ingredients.at(i).at(0);
 31   }
 32   products.resize(1);
 33   products.at(0).push_back(result);
 34   break;
 35 }
 36 
 37 :(scenario add_literal)
 38 def main [
 39   1:num <- add 23, 34
 40 ]
 41 +mem: storing 57 in location 1
 42 
 43 :(scenario add)
 44 def main [
 45   1:num <- copy 23
 46   2:num <- copy 34
 47   3:num <- add 1:num, 2:num
 48 ]
 49 +mem: storing 57 in location 3
 50 
 51 :(scenario add_multiple)
 52 def main [
 53   1:num <- add 3, 4, 5
 54 ]
 55 +mem: storing 12 in location 1
 56 
 57 :(scenario add_checks_type)
 58 % Hide_errors = true;
 59 def main [
 60   1:num <- add 2:bool, 1
 61 ]
 62 +error: main: 'add' requires number ingredients, but got '2:bool'
 63 
 64 :(scenario add_checks_return_type)
 65 % Hide_errors = true;
 66 def main [
 67   1:&:num <- add 2, 2
 68 ]
 69 +error: main: 'add' should yield a number, but got '1:&:num'
 70 
 71 :(before "End Primitive Recipe Declarations")
 72 SUBTRACT,
 73 :(before "End Primitive Recipe Numbers")
 74 put(Recipe_ordinal, "subtract", SUBTRACT);
 75 :(before "End Primitive Recipe Checks")
 76 case SUBTRACT: {
 77   if (inst.ingredients.empty()) {
 78     raise << maybe(get(Recipe, r).name) << "'subtract' has no ingredients\n" << end();
 79     break;
 80   }
 81   for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
 82     if (!is_mu_number(inst.ingredients.at(i))) {
 83       raise << maybe(get(Recipe, r).name) << "'subtract' requires number ingredients, but got '" << inst.ingredients.at(i).original_string << "'\n" << end();
 84       goto finish_checking_instruction;
 85     }
 86   }
 87   if (SIZE(inst.products) > 1) {
 88     raise << maybe(get(Recipe, r).name) << "'subtract' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
 89     break;
 90   }
 91   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
 92     raise << maybe(get(Recipe, r).name) << "'subtract' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
 93     break;
 94   }
 95   break;
 96 }
 97 :(before "End Primitive Recipe Implementations")
 98 case SUBTRACT: {
 99   double result = ingredients.at(0).at(0);
100   for (int i = 1;  i < SIZE(ingredients);  ++i)
101     result -= ingredients.at(i).at(0);
102   products.resize(1);
103   products.at(0).push_back(result);
104   break;
105 }
106 
107 :(scenario subtract_literal)
108 def main [
109   1:num <- subtract 5, 2
110 ]
111 +mem: storing 3 in location 1
112 
113 :(scenario subtract)
114 def main [
115   1:num <- copy 23
116   2:num <- copy 34
117   3:num <- subtract 1:num, 2:num
118 ]
119 +mem: storing -11 in location 3
120 
121 :(scenario subtract_multiple)
122 def main [
123   1:num <- subtract 6, 3, 2
124 ]
125 +mem: storing 1 in location 1
126 
127 :(before "End Primitive Recipe Declarations")
128 MULTIPLY,
129 :(before "End Primitive Recipe Numbers")
130 put(Recipe_ordinal, "multiply", MULTIPLY);
131 :(before "End Primitive Recipe Checks")
132 case MULTIPLY: {
133   for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
134     if (!is_mu_number(inst.ingredients.at(i))) {
135       raise << maybe(get(Recipe, r).name) << "'multiply' requires number ingredients, but got '" << inst.ingredients.at(i).original_string << "'\n" << end();
136       goto finish_checking_instruction;
137     }
138   }
139   if (SIZE(inst.products) > 1) {
140     raise << maybe(get(Recipe, r).name) << "'multiply' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
141     break;
142   }
143   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
144     raise << maybe(get(Recipe, r).name) << "'multiply' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
145     break;
146   }
147   break;
148 }
149 :(before "End Primitive Recipe Implementations")
150 case MULTIPLY: {
151   double result = 1;
152   for (int i = 0;  i < SIZE(ingredients);  ++i) {
153     result *= ingredients.at(i).at(0);
154   }
155   products.resize(1);
156   products.at(0).push_back(result);
157   break;
158 }
159 
160 :(scenario multiply_literal)
161 def main [
162   1:num <- multiply 2, 3
163 ]
164 +mem: storing 6 in location 1
165 
166 :(scenario multiply)
167 def main [
168   1:num <- copy 4
169   2:num <- copy 6
170   3:num <- multiply 1:num, 2:num
171 ]
172 +mem: storing 24 in location 3
173 
174 :(scenario multiply_multiple)
175 def main [
176   1:num <- multiply 2, 3, 4
177 ]
178 +mem: storing 24 in location 1
179 
180 :(before "End Primitive Recipe Declarations")
181 DIVIDE,
182 :(before "End Primitive Recipe Numbers")
183 put(Recipe_ordinal, "divide", DIVIDE);
184 :(before "End Primitive Recipe Checks")
185 case DIVIDE: {
186   if (inst.ingredients.empty()) {
187     raise << maybe(get(Recipe, r).name) << "'divide' has no ingredients\n" << end();
188     break;
189   }
190   for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
191     if (!is_mu_number(inst.ingredients.at(i))) {
192       raise << maybe(get(Recipe, r).name) << "'divide' requires number ingredients, but got '" << inst.ingredients.at(i).original_string << "'\n" << end();
193       goto finish_checking_instruction;
194     }
195   }
196   if (SIZE(inst.products) > 1) {
197     raise << maybe(get(Recipe, r).name) << "'divide' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
198     break;
199   }
200   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
201     raise << maybe(get(Recipe, r).name) << "'divide' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
202     break;
203   }
204   break;
205 }
206 :(before "End Primitive Recipe Implementations")
207 case DIVIDE: {
208   double result = ingredients.at(0).at(0);
209   for (int i = 1;  i < SIZE(ingredients);  ++i)
210     result /= ingredients.at(i).at(0);
211   products.resize(1);
212   products.at(0).push_back(result);
213   break;
214 }
215 
216 :(scenario divide_literal)
217 def main [
218   1:num <- divide 8, 2
219 ]
220 +mem: storing 4 in location 1
221 
222 :(scenario divide)
223 def main [
224   1:num <- copy 27
225   2:num <- copy 3
226   3:num <- divide 1:num, 2:num
227 ]
228 +mem: storing 9 in location 3
229 
230 :(scenario divide_multiple)
231 def main [
232   1:num <- divide 12, 3, 2
233 ]
234 +mem: storing 2 in location 1
235 
236 //: Integer division
237 
238 :(before "End Primitive Recipe Declarations")
239 DIVIDE_WITH_REMAINDER,
240 :(before "End Primitive Recipe Numbers")
241 put(Recipe_ordinal, "divide-with-remainder", DIVIDE_WITH_REMAINDER);
242 :(before "End Primitive Recipe Checks")
243 case DIVIDE_WITH_REMAINDER: {
244   if (SIZE(inst.ingredients) != 2) {
245     raise << maybe(get(Recipe, r).name) << "'divide-with-remainder' requires exactly two ingredients, but got '" << to_original_string(inst) << "'\n" << end();
246     break;
247   }
248   if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
249     raise << maybe(get(Recipe, r).name) << "'divide-with-remainder' requires number ingredients, but got '" << to_original_string(inst) << "'\n" << end();
250     break;
251   }
252   if (SIZE(inst.products) > 2) {
253     raise << maybe(get(Recipe, r).name) << "'divide-with-remainder' yields two products in '" << to_original_string(inst) << "'\n" << end();
254     break;
255   }
256   for (int i = 0;  i < SIZE(inst.products);  ++i) {
257     if (!is_dummy(inst.products.at(i)) && !is_mu_number(inst.products.at(i))) {
258       raise << maybe(get(Recipe, r).name) << "'divide-with-remainder' should yield a number, but got '" << inst.products.at(i).original_string << "'\n" << end();
259       goto finish_checking_instruction;
260     }
261   }
262   break;
263 }
264 :(before "End Primitive Recipe Implementations")
265 case DIVIDE_WITH_REMAINDER: {
266   products.resize(2);
267   // fractions will be dropped; very large numbers will overflow
268   long long int a = static_cast<long long int>(ingredients.at(0).at(0));
269   long long int b = static_cast<long long int>(ingredients.at(1).at(0));
270   if (b == 0) {
271     raise << maybe(current_recipe_name()) << "divide by zero in '" << to_original_string(current_instruction()) << "'\n" << end();
272     products.resize(2);
273     products.at(0).push_back(0);
274     products.at(1).push_back(0);
275     break;
276   }
277   long long int quotient = a / b;
278   long long int remainder = a % b;
279   products.at(0).push_back(static_cast<double>(quotient));
280   products.at(1).push_back(static_cast<double>(remainder));
281   break;
282 }
283 
284 :(scenario divide_with_remainder_literal)
285 def main [
286   1:num, 2:num <- divide-with-remainder 9, 2
287 ]
288 +mem: storing 4 in location 1
289 +mem: storing 1 in location 2
290 
291 :(scenario divide_with_remainder)
292 def main [
293   1:num <- copy 27
294   2:num <- copy 11
295   3:num, 4:num <- divide-with-remainder 1:num, 2:num
296 ]
297 +mem: storing 2 in location 3
298 +mem: storing 5 in location 4
299 
300 :(scenario divide_with_decimal_point)
301 def main [
302   1:num <- divide 5, 2
303 ]
304 +mem: storing 2.5 in location 1
305 
306 :(scenario divide_by_zero)
307 def main [
308   1:num <- divide 4, 0
309 ]
310 +mem: storing inf in location 1
311 
312 :(scenario divide_by_zero_2)
313 % Hide_errors = true;
314 def main [
315   1:num <- divide-with-remainder 4, 0
316 ]
317 # integer division can't return floating-point infinity
318 +error: main: divide by zero in '1:num <- divide-with-remainder 4, 0'
319 
320 //: Bitwise shifts
321 
322 :(before "End Primitive Recipe Declarations")
323 SHIFT_LEFT,
324 :(before "End Primitive Recipe Numbers")
325 put(Recipe_ordinal, "shift-left", SHIFT_LEFT);
326 :(before "End Primitive Recipe Checks")
327 case SHIFT_LEFT: {
328   if (SIZE(inst.ingredients) != 2) {
329     raise << maybe(get(Recipe, r).name) << "'shift-left' requires exactly two ingredients, but got '" << to_original_string(inst) << "'\n" << end();
330     break;
331   }
332   if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
333     raise << maybe(get(Recipe, r).name) << "'shift-left' requires number ingredients, but got '" << to_original_string(inst) << "'\n" << end();
334     break;
335   }
336   if (SIZE(inst.products) > 1) {
337     raise << maybe(get(Recipe, r).name) << "'shift-left' yields one product in '" << to_original_string(inst) << "'\n" << end();
338     break;
339   }
340   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
341     raise << maybe(get(Recipe, r).name) << "'shift-left' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
342     goto finish_checking_instruction;
343   }
344   break;
345 }
346 :(before "End Primitive Recipe Implementations")
347 case SHIFT_LEFT: {
348   // ingredients must be integers
349   int a = static_cast<int>(ingredients.at(0).at(0));
350   int b = static_cast<int>(ingredients.at(1).at(0));
351   products.resize(1);
352   if (b < 0) {
353     raise << maybe(current_recipe_name()) << "second ingredient can't be negative in '" << to_original_string(current_instruction()) << "'\n" << end();
354     products.at(0).push_back(0);
355     break;
356   }
357   products.at(0).push_back(a<<b);
358   break;
359 }
360 
361 :(scenario shift_left_by_zero)
362 def main [
363   1:num <- shift-left 1, 0
364 ]
365 +mem: storing 1 in location 1
366 
367 :(scenario shift_left_1)
368 def main [
369   1:num <- shift-left 1, 4
370 ]
371 +mem: storing 16 in location 1
372 
373 :(scenario shift_left_2)
374 def main [
375   1:num <- shift-left 3, 2
376 ]
377 +mem: storing 12 in location 1
378 
379 :(scenario shift_left_by_negative)
380 % Hide_errors = true;
381 def main [
382   1:num <- shift-left 3, -1
383 ]
384 +error: main: second ingredient can't be negative in '1:num <- shift-left 3, -1'
385 
386 :(scenario shift_left_ignores_fractional_part)
387 def main [
388   1:num <- divide 3, 2
389   2:num <- shift-left 1:num, 1
390 ]
391 +mem: storing 2 in location 2
392 
393 :(before "End Primitive Recipe Declarations")
394 SHIFT_RIGHT,
395 :(before "End Primitive Recipe Numbers")
396 put(Recipe_ordinal, "shift-right", SHIFT_RIGHT);
397 :(before "End Primitive Recipe Checks")
398 case SHIFT_RIGHT: {
399   if (SIZE(inst.ingredients) != 2) {
400     raise << maybe(get(Recipe, r).name) << "'shift-right' requires exactly two ingredients, but got '" << to_original_string(inst) << "'\n" << end();
401     break;
402   }
403   if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
404     raise << maybe(get(Recipe, r).name) << "'shift-right' requires number ingredients, but got '" << to_original_string(inst) << "'\n" << end();
405     break;
406   }
407   if (SIZE(inst.products) > 1) {
408     raise << maybe(get(Recipe, r).name) << "'shift-right' yields one product in '" << to_original_string(inst) << "'\n" << end();
409     break;
410   }
411   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
412     raise << maybe(get(Recipe, r).name) << "'shift-right' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
413     goto finish_checking_instruction;
414   }
415   break;
416 }
417 :(before "End Primitive Recipe Implementations")
418 case SHIFT_RIGHT: {
419   // ingredients must be integers
420   int a = static_cast<int>(ingredients.at(0).at(0));
421   int b = static_cast<int>(ingredients.at(1).at(0));
422   products.resize(1);
423   if (b < 0) {
424     raise << maybe(current_recipe_name()) << "second ingredient can't be negative in '" << to_original_string(current_instruction()) << "'\n" << end();
425     products.at(0).push_back(0);
426     break;
427   }
428   products.at(0).push_back(a>>b);
429   break;
430 }
431 
432 :(scenario shift_right_by_zero)
433 def main [
434   1:num <- shift-right 1, 0
435 ]
436 +mem: storing 1 in location 1
437 
438 :(scenario shift_right_1)
439 def main [
440   1:num <- shift-right 1024, 1
441 ]
442 +mem: storing 512 in location 1
443 
444 :(scenario shift_right_2)
445 def main [
446   1:num <- shift-right 3, 1
447 ]
448 +mem: storing 1 in location 1
449 
450 :(scenario shift_right_by_negative)
451 % Hide_errors = true;
452 def main [
453   1:num <- shift-right 4, -1
454 ]
455 +error: main: second ingredient can't be negative in '1:num <- shift-right 4, -1'
456 
457 :(scenario shift_right_ignores_fractional_part)
458 def main [
459   1:num <- divide 3, 2
460   2:num <- shift-right 1:num, 1
461 ]
462 +mem: storing 0 in location 2
463 
464 :(before "End Primitive Recipe Declarations")
465 AND_BITS,
466 :(before "End Primitive Recipe Numbers")
467 put(Recipe_ordinal, "and-bits", AND_BITS);
468 :(before "End Primitive Recipe Checks")
469 case AND_BITS: {
470   if (SIZE(inst.ingredients) != 2) {
471     raise << maybe(get(Recipe, r).name) << "'and-bits' requires exactly two ingredients, but got '" << to_original_string(inst) << "'\n" << end();
472     break;
473   }
474   if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
475     raise << maybe(get(Recipe, r).name) << "'and-bits' requires number ingredients, but got '" << to_original_string(inst) << "'\n" << end();
476     break;
477   }
478   if (SIZE(inst.products) > 1) {
479     raise << maybe(get(Recipe, r).name) << "'and-bits' yields one product in '" << to_original_string(inst) << "'\n" << end();
480     break;
481   }
482   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
483     raise << maybe(get(Recipe, r).name) << "'and-bits' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
484     goto finish_checking_instruction;
485   }
486   break;
487 }
488 :(before "End Primitive Recipe Implementations")
489 case AND_BITS: {
490   // ingredients must be integers
491   int a = static_cast<int>(ingredients.at(0).at(0));
492   int b = static_cast<int>(ingredients.at(1).at(0));
493   products.resize(1);
494   products.at(0).push_back(a&b);
495   break;
496 }
497 
498 :(scenario and_bits_1)
499 def main [
500   1:num <- and-bits 8, 3
501 ]
502 +mem: storing 0 in location 1
503 
504 :(scenario and_bits_2)
505 def main [
506   1:num <- and-bits 3, 2
507 ]
508 +mem: storing 2 in location 1
509 
510 :(scenario and_bits_3)
511 def main [
512   1:num <- and-bits 14, 3
513 ]
514 +mem: storing 2 in location 1
515 
516 :(scenario and_bits_negative)
517 def main [
518   1:num <- and-bits -3, 4
519 ]
520 +mem: storing 4 in location 1
521 
522 :(before "End Primitive Recipe Declarations")
523 OR_BITS,
524 :(before "End Primitive Recipe Numbers")
525 put(Recipe_ordinal, "or-bits", OR_BITS);
526 :(before "End Primitive Recipe Checks")
527 case OR_BITS: {
528   if (SIZE(inst.ingredients) != 2) {
529     raise << maybe(get(Recipe, r).name) << "'or-bits' requires exactly two ingredients, but got '" << to_original_string(inst) << "'\n" << end();
530     break;
531   }
532   if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
533     raise << maybe(get(Recipe, r).name) << "'or-bits' requires number ingredients, but got '" << to_original_string(inst) << "'\n" << end();
534     break;
535   }
536   if (SIZE(inst.products) > 1) {
537     raise << maybe(get(Recipe, r).name) << "'or-bits' yields one product in '" << to_original_string(inst) << "'\n" << end();
538     break;
539   }
540   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
541     raise << maybe(get(Recipe, r).name) << "'or-bits' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
542     goto finish_checking_instruction;
543   }
544   break;
545 }
546 :(before "End Primitive Recipe Implementations")
547 case OR_BITS: {
548   // ingredients must be integers
549   int a = static_cast<int>(ingredients.at(0).at(0));
550   int b = static_cast<int>(ingredients.at(1).at(0));
551   products.resize(1);
552   products.at(0).push_back(a|b);
553   break;
554 }
555 
556 :(scenario or_bits_1)
557 def main [
558   1:num <- or-bits 3, 8
559 ]
560 +mem: storing 11 in location 1
561 
562 :(scenario or_bits_2)
563 def main [
564   1:num <- or-bits 3, 10
565 ]
566 +mem: storing 11 in location 1
567 
568 :(scenario or_bits_3)
569 def main [
570   1:num <- or-bits 4, 6
571 ]
572 +mem: storing 6 in location 1
573 
574 :(before "End Primitive Recipe Declarations")
575 XOR_BITS,
576 :(before "End Primitive Recipe Numbers")
577 put(Recipe_ordinal, "xor-bits", XOR_BITS);
578 :(before "End Primitive Recipe Checks")
579 case XOR_BITS: {
580   if (SIZE(inst.ingredients) != 2) {
581     raise << maybe(get(Recipe, r).name) << "'xor-bits' requires exactly two ingredients, but got '" << to_original_string(inst) << "'\n" << end();
582     break;
583   }
584   if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
585     raise << maybe(get(Recipe, r).name) << "'xor-bits' requires number ingredients, but got '" << to_original_string(inst) << "'\n" << end();
586     break;
587   }
588   if (SIZE(inst.products) > 1) {
589     raise << maybe(get(Recipe, r).name) << "'xor-bits' yields one product in '" << to_original_string(inst) << "'\n" << end();
590     break;
591   }
592   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
593     raise << maybe(get(Recipe, r).name) << "'xor-bits' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
594     goto finish_checking_instruction;
595   }
596   break;
597 }
598 :(before "End Primitive Recipe Implementations")
599 case XOR_BITS: {
600   // ingredients must be integers
601   int a = static_cast<int>(ingredients.at(0).at(0));
602   int b = static_cast<int>(ingredients.at(1).at(0));
603   products.resize(1);
604   products.at(0).push_back(a^b);
605   break;
606 }
607 
608 :(scenario xor_bits_1)
609 def main [
610   1:num <- xor-bits 3, 8
611 ]
612 +mem: storing 11 in location 1
613 
614 :(scenario xor_bits_2)
615 def main [
616   1:num <- xor-bits 3, 10
617 ]
618 +mem: storing 9 in location 1
619 
620 :(scenario xor_bits_3)
621 def main [
622   1:num <- xor-bits 4, 6
623 ]
624 +mem: storing 2 in location 1
625 
626 :(before "End Primitive Recipe Declarations")
627 FLIP_BITS,
628 :(before "End Primitive Recipe Numbers")
629 put(Recipe_ordinal, "flip-bits", FLIP_BITS);
630 :(before "End Primitive Recipe Checks")
631 case FLIP_BITS: {
632   if (SIZE(inst.ingredients) != 1) {
633     raise << maybe(get(Recipe, r).name) << "'flip-bits' requires exactly one ingredient, but got '" << to_original_string(inst) << "'\n" << end();
634     break;
635   }
636   if (!is_mu_number(inst.ingredients.at(0))) {
637     raise << maybe(get(Recipe, r).name) << "'flip-bits' requires a number ingredient, but got '" << to_original_string(inst) << "'\n" << end();
638     break;
639   }
640   if (SIZE(inst.products) > 1) {
641     raise << maybe(get(Recipe, r).name) << "'flip-bits' yields one product in '" << to_original_string(inst) << "'\n" << end();
642     break;
643   }
644   if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
645     raise << maybe(get(Recipe, r).name) << "'flip-bits' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
646     goto finish_checking_instruction;
647   }
648   break;
649 }
650 :(before "End Primitive Recipe Implementations")
651 case FLIP_BITS: {
652   // ingredient must be integer
653   int a = static_cast<int>(ingredients.at(0).at(0));
654   products.resize(1);
655   products.at(0).push_back(~a);
656   break;
657 }
658 
659 :(scenario flip_bits_zero)
660 def main [
661   1:num <- flip-bits 0
662 ]
663 +mem: storing -1 in location 1
664 
665 :(scenario flip_bits_negative)
666 def main [
667   1:num <- flip-bits -1
668 ]
669 +mem: storing 0 in location 1
670 
671 :(scenario flip_bits_1)
672 def main [
673   1:num <- flip-bits 3
674 ]
675 +mem: storing -4 in location 1
676 
677 :(scenario flip_bits_2)
678 def main [
679   1:num <- flip-bits 12
680 ]
681 +mem: storing -13 in location 1
682 
683 :(before "End Primitive Recipe Declarations")
684 ROUND,
685 :(before "End Primitive Recipe Numbers")
686 put(Recipe_ordinal, "round", ROUND);
687 :(before "End Primitive Recipe Checks")
688 case ROUND: {
689   if (SIZE(inst.ingredients) != 1) {
690     raise << maybe(get(Recipe, r).name) << "'round' requires exactly one ingredient, but got '" << to_original_string(inst) << "'\n" << end();
691     break;
692   }
693   if (!is_mu_number(inst.ingredients.at(0))) {
694     raise << maybe(get(Recipe, r).name) << "first ingredient of 'round' should be a number, but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
695     break;
696   }
697   break;
698 }
699 :(before "End Primitive Recipe Implementations")
700 case ROUND: {
701   products.resize(1);
702   products.at(0).push_back(rint(ingredients.at(0).at(0)));
703   break;
704 }
705 
706 :(scenario round_to_nearest_integer)
707 def main [
708   1:num <- round 12.2
709 ]
710 +mem: storing 12 in location 1
711 
712 :(scenario round_halves_toward_zero)
713 def main [
714   1:num <- round 12.5
715 ]
716 +mem: storing 12 in location 1
717 
718 :(scenario round_halves_toward_zero_2)
719 def main [
720   1:num <- round -12.5
721 ]
722 +mem: storing -12 in location 1
723 
724 :(before "End Primitive Recipe Declarations")
725 TRUNCATE,
726 :(before "End Primitive Recipe Numbers")
727 put(Recipe_ordinal, "truncate", TRUNCATE);
728 :(before "End Primitive Recipe Checks")
729 case TRUNCATE: {
730   if (SIZE(inst.ingredients) != 1) {
731     raise << maybe(get(Recipe, r).name) << "'truncate' requires exactly one ingredient, but got '" << to_original_string(inst) << "'\n" << end();
732     break;
733   }
734   if (!is_mu_number(inst.ingredients.at(0))) {
735     raise << maybe(get(Recipe, r).name) << "first ingredient of 'truncate' should be a number, but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
736     break;
737   }
738   break;
739 }
740 :(before "End Primitive Recipe Implementations")
741 case TRUNCATE: {
742   products.resize(1);
743   products.at(0).push_back(trunc(ingredients.at(0).at(0)));
744   break;
745 }
746 
747 :(scenario truncate_to_nearest_integer)
748 def main [
749   1:num <- truncate 12.2
750 ]
751 +mem: storing 12 in location 1
752 
753 :(scenario truncate_negative)
754 def main [
755   1:num <- truncate -12.2
756 ]
757 +mem: storing -12 in location 1
758 
759 :(before "End Primitive Recipe Declarations")
760 SQUARE_ROOT,
761 :(before "End Primitive Recipe Numbers")
762 put(Recipe_ordinal, "square-root", SQUARE_ROOT);
763 :(before "End Primitive Recipe Checks")
764 case SQUARE_ROOT: {
765   if (SIZE(inst.ingredients) != 1) {
766     raise << maybe(get(Recipe, r).name) << "'square-root' requires exactly one ingredient, but got '" << to_original_string(inst) << "'\n" << end();
767     break;
768   }
769   if (!is_mu_number(inst.ingredients.at(0))) {
770     raise << maybe(get(Recipe, r).name) << "first ingredient of 'square-root' should be a number, but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
771     break;
772   }
773   break;
774 }
775 :(before "End Primitive Recipe Implementations")
776 case SQUARE_ROOT: {
777   products.resize(1);
778   products.at(0).push_back(sqrt(ingredients.at(0).at(0)));
779   break;
780 }
781 
782 :(before "End Primitive Recipe Declarations")
783 CHARACTER_TO_CODE,
784 :(before "End Primitive Recipe Numbers")
785 put(Recipe_ordinal, "character-to-code", CHARACTER_TO_CODE);
786 :(before "End Primitive Recipe Checks")
787 case CHARACTER_TO_CODE: {
788   if (SIZE(inst.ingredients) != 1) {
789     raise << maybe(get(Recipe, r).name) << "'character-to-code' requires exactly one ingredient, but got '" << to_original_string(inst) << "'\n" << end();
790     break;
791   }
792   if (!is_mu_character(inst.ingredients.at(0))) {
793     raise << maybe(get(Recipe, r).name) << "first ingredient of 'character-to-code' should be a character, but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
794     break;
795   }
796   if (SIZE(inst.products) != 1) {
797     raise << maybe(get(Recipe, r).name) << "'character-to-code' requires exactly one product, but got '" << to_original_string(inst) << "'\n" << end();
798     break;
799   }
800   if (!is_mu_number(inst.products.at(0))) {
801     raise << maybe(get(Recipe, r).name) << "first product of 'character-to-code' should be a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
802     break;
803   }
804   break;
805 }
806 :(before "End Primitive Recipe Implementations")
807 case CHARACTER_TO_CODE: {
808   double result = 0;
809   for (int i = 0;  i < SIZE(ingredients);  ++i) {
810     result += ingredients.at(i).at(0);
811   }
812   products.resize(1);
813   products.at(0).push_back(result);
814   break;
815 }
816 
817 :(before "End Includes")
818 #include <math.h>