1 //: Introduce a new transform to perform various checks in instructions before
  2 //: we start running them. It'll be extensible, so that we can add checks for
  3 //: new recipes as we extend 'run' to support them.
  4 //:
  5 //: Doing checking in a separate part complicates things, because the values
  6 //: of variables in memory and the processor (current_recipe_name,
  7 //: current_instruction) aren't available at checking time. If I had a more
  8 //: sophisticated layer system I'd introduce the simpler version first and
  9 //: transform it in a separate layer or set of layers.
 10 
 11 :(before "End Checks")
 12 Transform.push_back(check_instruction);  // idempotent
 13 
 14 :(code)
 15 void check_instruction(const recipe_ordinal r) {
 16   trace(9991, "transform") << "--- perform checks for recipe " << get(Recipe, r).name << end();
 17   map<string, vector<type_ordinal> > metadata;
 18   for (int i = 0;  i < SIZE(get(Recipe, r).steps);  ++i) {
 19   ¦ instruction& inst = get(Recipe, r).steps.at(i);
 20   ¦ if (inst.is_label) continue;
 21   ¦ switch (inst.operation) {
 22   ¦ ¦ // Primitive Recipe Checks
 23   ¦ ¦ case COPY: {
 24   ¦ ¦ ¦ if (SIZE(inst.products) > SIZE(inst.ingredients)) {
 25   ¦ ¦ ¦ ¦ raise << maybe(get(Recipe, r).name) << "too many products in '" << to_original_string(inst) << "'\n" << end();
 26   ¦ ¦ ¦ ¦ break;
 27   ¦ ¦ ¦ }
 28   ¦ ¦ ¦ for (int i = 0;  i < SIZE(inst.products);  ++i) {
 29   ¦ ¦ ¦ ¦ if (!types_coercible(inst.products.at(i), inst.ingredients.at(i))) {
 30   ¦ ¦ ¦ ¦ ¦ raise << maybe(get(Recipe, r).name) << "can't copy '" << inst.ingredients.at(i).original_string << "' to '" << inst.products.at(i).original_string << "'; types don't match\n" << end();
 31   ¦ ¦ ¦ ¦ ¦ goto finish_checking_instruction;
 32   ¦ ¦ ¦ ¦ }
 33   ¦ ¦ ¦ }
 34   ¦ ¦ ¦ break;
 35   ¦ ¦ }
 36   ¦ ¦ // End Primitive Recipe Checks
 37   ¦ ¦ default: {
 38   ¦ ¦ ¦ // Defined Recipe Checks
 39   ¦ ¦ ¦ // End Defined Recipe Checks
 40   ¦ ¦ }
 41   ¦ }
 42   ¦ finish_checking_instruction:;
 43   }
 44 }
 45 
 46 :(scenario copy_checks_reagent_count)
 47 % Hide_errors = true;
 48 def main [
 49   1:num, 2:num <- copy 34
 50 ]
 51 +error: main: too many products in '1:num, 2:num <- copy 34'
 52 
 53 :(scenario write_scalar_to_array_disallowed)
 54 % Hide_errors = true;
 55 def main [
 56   1:array:num <- copy 34
 57 ]
 58 +error: main: can't copy '34' to '1:array:num'; types don't match
 59 
 60 :(scenario write_scalar_to_array_disallowed_2)
 61 % Hide_errors = true;
 62 def main [
 63   1:num, 2:array:num <- copy 34, 35
 64 ]
 65 +error: main: can't copy '35' to '2:array:num'; types don't match
 66 
 67 :(scenario write_scalar_to_address_disallowed)
 68 % Hide_errors = true;
 69 def main [
 70   1:address:num <- copy 34
 71 ]
 72 +error: main: can't copy '34' to '1:address:num'; types don't match
 73 
 74 :(scenario write_address_to_number_allowed)
 75 def main [
 76   1:address:num <- copy 12/unsafe
 77   2:num <- copy 1:address:num
 78 ]
 79 +mem: storing 12 in location 2
 80 $error: 0
 81 
 82 :(scenario write_address_to_character_disallowed)
 83 % Hide_errors = true;
 84 def main [
 85   1:address:num <- copy 12/unsafe
 86   2:char <- copy 1:address:num
 87 ]
 88 +error: main: can't copy '1:address:num' to '2:char'; types don't match
 89 
 90 :(scenario write_number_to_character_allowed)
 91 def main [
 92   1:num <- copy 97
 93   2:char <- copy 1:num
 94 ]
 95 $error: 0
 96 
 97 :(scenario write_boolean_to_number_allowed)
 98 def main [
 99   1:bool <- copy 1/true
100   2:num <- copy 1:bool
101 ]
102 +mem: storing 1 in location 2
103 $error: 0
104 
105 :(scenario write_number_to_boolean_disallowed)
106 % Hide_errors = true;
107 def main [
108   1:num <- copy 34
109   2:bool <- copy 1:num
110 ]
111 +error: main: can't copy '1:num' to '2:bool'; types don't match
112 
113 :(code)
114 // types_match with some leniency
115 bool types_coercible(const reagent& to, const reagent& from) {
116   if (types_match(to, from)) return true;
117   if (is_mu_address(from) && is_real_mu_number(to)) return true;
118   if (is_mu_boolean(from) && is_real_mu_number(to)) return true;
119   if (is_real_mu_number(from) && is_mu_character(to)) return true;
120   // End types_coercible Special-cases
121   return false;
122 }
123 
124 bool types_match(const reagent& to, const reagent& from) {
125   // to sidestep type-checking, use /unsafe in the source.
126   // this will be highlighted in red inside vim. just for setting up some tests.
127   if (is_unsafe(from)) return true;
128   if (is_literal(from)) {
129   ¦ if