# Mu - 033exclusive_container.cc

      1 //: Exclusive containers contain exactly one of a fixed number of 'variants'
      2 //: of different types.
      3 //:
      4 //: They also implicitly contain a tag describing precisely which variant is
      5 //: currently stored in them.
      6
      7 :(before "End Mu Types Initialization")
      8 //: We'll use this container as a running example, with two number elements.
      9 {
     10 type_ordinal tmp = put(Type_ordinal, "number-or-point", Next_type_ordinal++);
     11 get_or_insert(Type, tmp);  // initialize
     12 get(Type, tmp).kind = EXCLUSIVE_CONTAINER;
     13 get(Type, tmp).name = "number-or-point";
     14 get(Type, tmp).elements.push_back(reagent("i:number"));
     15 get(Type, tmp).elements.push_back(reagent("p:point"));
     16 }
     17
     18 //: Tests in this layer often explicitly set up memory before reading it as a
     19 //: container. Don't do this in general. I'm tagging such cases with /unsafe;
     20 //: they'll be exceptions to later checks.
     21 :(scenario copy_exclusive_container)
     22 # Copying exclusive containers copies all their contents and an extra location for the tag.
     23 def main [
     24   1:num <- copy 1  # 'point' variant
     25   2:num <- copy 34
     26   3:num <- copy 35
     27   4:number-or-point <- copy 1:number-or-point/unsafe
     28 ]
     29 +mem: storing 1 in location 4
     30 +mem: storing 34 in location 5
     31 +mem: storing 35 in location 6
     32
     33 :(before "End size_of(type) Special-cases")
     34 if (t.kind == EXCLUSIVE_CONTAINER) {
     35   // size of an exclusive container is the size of its largest variant
     36   // (So like containers, it can't contain arrays.)
     37   int result = 0;
     38   for (int i = 0; i < SIZE(t.elements); ++i) {
     39     reagent tmp;
     40     tmp.type = new type_tree(*type);
     41     int size = size_of(variant_type(tmp, i));
     42     if (size > result) result = size;
     43   }
     44   // ...+1 for its tag.
     45   return result+1;
     46 }
     47
     48 //:: To access variants of an exclusive container, use 'maybe-convert'.
     49 //: It always returns an address (so that you can modify it) or null (to
     50 //: signal that the conversion failed (because the container contains a
     51 //: different variant).
     52
     53 //: 'maybe-convert' requires a literal in ingredient 1. We'll use a synonym
     54 //: called 'variant'.
     55 :(before "End Mu Types Initialization")
     56 put(Type_ordinal, "variant", 0);
     57
     58 :(scenario maybe_convert)
     59 def main [
     60   12:num <- copy 1
     61   13:num <- copy 35
     62   14:num <- copy 36
     63   20:point, 22:bool <- maybe-convert 12:number-or-point/unsafe, 1:variant
     64 ]
     65 # boolean
     66 +mem: storing 1 in location 22
     67 # point
     68 +mem: storing 35 in location 20
     69 +mem: storing 36 in location 21
     70
     71 :(scenario maybe_convert_fail)
     72 def main [
     73   12:num <- copy 1
     74   13:num <- copy 35
     75   14:num <- copy 36
     76   20:num, 21:bool <- maybe-convert 12:number-or-point/unsafe, 0:variant
     77 ]
     78 # boolean
     79 +mem: storing 0 in location 21
     80 # number: no write
     81
     82 :(before "End Primitive Recipe Declarations")
     83 MAYBE_CONVERT,
     84 :(before "End Primitive Recipe Numbers")
     85 put(Recipe_ordinal, "maybe-convert", MAYBE_CONVERT);
     86 :(before "End Primitive Recipe Checks")
     87 case MAYBE_CONVERT: {
     88   const recipe& caller = get(Recipe, r);
     89   if (SIZE(inst.ingredients) != 2) {
     90     raise << maybe(caller.name) << "'maybe-convert' expects exactly 2 ingredients in '" << to_original_string(inst) << "'\n" << end();
     91     break;
     92   }
     93   reagent/*copy*/ base = inst.ingredients.at(0);
     94   // Update MAYBE_CONVERT base in Check
     95   if (!base.type) {
     96     raise << maybe(caller.name) << "first ingredient of 'maybe-convert' should be an exclusive-container, but got '" << base.original_string << "'\n" << end();
     97     break;
     98   }
     99   const type_tree* base_type = base.type;
    100   // Update MAYBE_CONVERT base_type in Check
    101   if (!base_type->atom || base_type->value == 0 || !contains_key(Type, base_type->value) || get(Type, base_type->value).kind != EXCLUSIVE_CONTAINER) {
    102     raise << maybe(caller.name) << "first ingredient of 'maybe-convert' should be an exclusive-container, but got '" << base.original_string << "'\n" << end();
    103     break;
    104   }
    105   if (!is_literal(inst.ingredients.at(1))) {
    106     raise << maybe(caller.name) << "second ingredient of 'maybe-convert' should have type 'variant', but got '" << inst.ingredients.at(1).original_string << "'\n" << end();
    107     break;
    108   }
    109   if (inst.products.empty()) break;
    110   if (SIZE(inst.products) != 2) {
    111     raise << maybe(caller.name) << "'maybe-convert' expects exactly 2 products in '" << to_original_string(inst) << "'\n" << end();
    112     break;
    113   }
    114   reagent/*copy*/ product = inst.products.at(0);
    115   // Update MAYBE_CONVERT product in Check
    116   reagent& offset = inst.ingredients.at(1);
    117   populate_value(offset);
    118   if (offset.value >= SIZE(get(Type, base_type->value).elements)) {
    119     raise << maybe(caller.name) << "invalid tag " << offset.value << " in '" << to_original_string(inst) << '\n' << end();
    120     break;
    121   }
    122   const reagent& variant = variant_type(base, offset.value);
    123   if (!types_coercible(product, variant)) {
    124     raise << maybe(caller.name) << "'maybe-convert " << base.original_string << ", " << inst.ingredients.at(1).original_string << "' should write to " << to_string(variant.type) << " but '" << product.name << "' has type " << to_string(product.type) << '\n' << end();
    125     break;
    126   }
    127   reagent/*copy*/ status = inst.products.at(1);
    128   // Update MAYBE_CONVERT status in Check
    129   if (!is_mu_boolean(status)) {
    130     raise << maybe(get(Recipe, r).name) << "second product yielded by 'maybe-convert' should be a boolean, but tried to write to '" << inst.products.at(1).original_string << "'\n" << end();
    131     break;
    132   }
    133   break;
    134 }
    135 :(before "End Primitive Recipe Implementations")
    136 case MAYBE_CONVERT: {
    137   reagent/*copy*/ base = current_instruction().ingredients.at(0);
    138   // Update MAYBE_CONVERT base in Run
    139   int base_address = base.value;
    140   if (base_address == 0) {
    141     raise << maybe(current_recipe_name()) << "tried to access location 0 in '" << to_original_string(current_instruction()) << "'\n" << end();
    142     break;
    143   }
    144   int tag = current_instruction().ingredients.at(1).value;
    145   reagent/*copy*/ product = current_instruction().products.at(0);
    146   // Update MAYBE_CONVERT product in Run
    147   reagent/*copy*/ status = current_instruction().products.at(1);
    148   // Update MAYBE_CONVERT status in Run
    149   // optimization: directly write results to only update first product when necessary
    150   write_products = false;
    151   if (tag == static_cast<int>(get_or_insert(Memory, base_address))) {
    152     const reagent& variant = variant_type(base, tag);
    153     trace("mem") << "storing 1 in location " << status.value << end();
    154     put(Memory, status.value, 1);
    155     if (!is_dummy(product)) {
    156       // Write Memory in Successful MAYBE_CONVERT in Run
    157       for (int i = 0;  i < size_of(variant);  ++i) {
    158         double val = get_or_insert(Memory, base_address+/*skip tag*/1+i);
    159         trace("mem") << "storing " << no_scientific(val) << " in location " << product.value+i << end();
    160         put(Memory, product.value+i, val);
    161       }
    162     }
    163   }
    164   else {
    165     trace("mem") << "storing 0 in location " << status.value << end();
    166     put(Memory, status.value, 0);
    167   }
    168   break;
    169 }
    170
    171 :(code)
    172 const reagent variant_type(const reagent& base, int tag) {
    173   return variant_type(base.type, tag);
    174 }
    175
    176 const reagent variant_type(const type_tree* type, int tag) {
    177   assert(tag >= 0);
    178   const type_tree* root_type = type->atom ? type : type->left;
    179   assert(contains_key(Type, root_type->value));
    180   assert(!get(Type, root_type->value).name.empty());
    181   const type_info& info = get(Type, root_type->value);
    182   assert(info.kind == EXCLUSIVE_CONTAINER);
    183   reagent/*copy*/ element = info.elements.at(tag);
    184   // End variant_type Special-cases
    185   return element;
    186 }
    187
    188 :(scenario maybe_convert_product_type_mismatch)
    189 % Hide_errors = true;
    190 def main [
    191   12:num <- copy 1
    192   13:num <- copy 35
    193   14:num <- copy 36
    194   20:num, 21:bool <- maybe-convert 12:number-or-point/unsafe, 1:variant
    195 ]
    196 +error: main: 'maybe-convert 12:number-or-point/unsafe, 1:variant' should write to point but '20' has type number
    197
    198 :(scenario maybe_convert_dummy_product)
    199 def main [
    200   12:num <- copy 1
    201   13:num <- copy 35
    202   14:num <- copy 36
    203   _, 21:bool <- maybe-convert 12:number-or-point/unsafe, 1:variant
    204 ]
    205 $error: 0
    206
    207 //:: Allow exclusive containers to be defined in Mu code.
    208
    209 :(scenario exclusive_container)
    210 exclusive-container foo [
    211   x:num
    212   y:num
    213 ]
    214 +parse: --- defining exclusive-container foo
    215 +parse: element: {x: "number"}
    216 +parse: element: {y: "number"}
    217
    218 :(before "End Command Handlers")
    219 else if (command == "exclusive-container") {
    220   insert_container(command, EXCLUSIVE_CONTAINER, in);
    221 }
    222
    223 //: arrays are disallowed inside exclusive containers unless their length is
    224 //: fixed in advance
    225
    226 :(scenario exclusive_container_contains_array)
    227 exclusive-container foo [
    228   x:@:num:3
    229 ]
    230 $error: 0
    231
    232 :(scenario exclusive_container_disallows_dynamic_array_element)
    233 % Hide_errors = true;
    234 exclusive-container foo [
    235   x:@:num
    236 ]
    237 +error: container 'foo' cannot determine size of element 'x'
    238
    239 //:: To construct exclusive containers out of variant types, use 'merge'.
    240 :(scenario lift_to_exclusive_container)
    241 exclusive-container foo [
    242   x:num
    243   y:num
    244 ]
    245 def main [
    246   1:num <- copy 34
    247   2:foo <- merge 0/x, 1:num  # tag must be a literal when merging exclusive containers
    248   4:foo <- merge 1/y, 1:num
    249 ]
    250 +mem: storing 0 in location 2
    251 +mem: storing 34 in location 3
    252 +mem: storing 1 in location 4
    253 +mem: storing 34 in location 5
    254
    255 //: type-checking for 'merge' on exclusive containers
    256
    257 :(scenario merge_handles_exclusive_container)
    258 exclusive-container foo [
    259   x:num
    260   y:bar
    261 ]
    262 container bar [
    263   z:num
    264 ]
    265 def main [
    266   1:foo <- merge 0/x, 34
    267 ]
    268 +mem: storing 0 in location 1
    269 +mem: storing 34 in location 2
    270 $error: 0
    271
    272 :(scenario merge_requires_literal_tag_for_exclusive_container)
    273 % Hide_errors = true;
    274 exclusive-container foo [
    275   x:num
    276   y:bar
    277 ]
    278 container bar [
    279   z:num
    280 ]
    281 def main [
    282   1:num <- copy 0
    283   2:foo <- merge 1:num, 34
    284 ]
    285 +error: main: ingredient 0 of 'merge' should be a literal, for the tag of exclusive-container 'foo' in '2:foo <- merge 1:num, 34'
    286
    287 :(scenario merge_handles_exclusive_container_inside_exclusive_container)
    288 exclusive-container foo [
    289   x:num
    290   y:bar
    291 ]
    292 exclusive-container bar [
    293   a:num
    294   b:num
    295 ]
    296 def main [
    297   1:num <- copy 0
    298   2:bar <- merge 0/a, 34
    299   4:foo <- merge 1/y, 2:bar
    300 ]
    301 +mem: storing 0 in location 5
    302 +mem: storing 34 in location 6
    303 $error: 0
    304
    305 :(before "End check_merge_call Special-cases")
    306 case EXCLUSIVE_CONTAINER: {
    307   assert(state.data.top().container_element_index == 0);
    308   trace("transform") << "checking exclusive container " << to_string(container) << " vs ingredient " << ingredient_index << end();
    309   // easy case: exact match
    310   if (types_strictly_match(container, inst.ingredients.at(ingredient_index)))
    311     return;
    312   if (!is_literal(ingredients.at(ingredient_index))) {
    313     raise << maybe(caller.name) << "ingredient " << ingredient_index << " of 'merge' should be a literal, for the tag of exclusive-container '" << container_info.name << "' in '" << to_original_string(inst) << "'\n" << end();
    314     return;
    315   }
    316   reagent/*copy*/ ingredient = ingredients.at(ingredient_index);  // unnecessary copy just to keep this function from modifying caller
    317   populate_value(ingredient);
    318   if (ingredient.value >= SIZE(container_info.elements)) {
    319     raise << maybe(caller.name) << "invalid tag at " << ingredient_index << " for '" << container_info.name << "' in '" << to_original_string(inst) << "'\n" << end();
    320     return;
    321   }
    322   const reagent& variant = variant_type(container, ingredient.value);
    323   trace("transform") << "tag: " << ingredient.value << end();
    324   // replace union with its variant
    325   state.data.pop();
    326   state.data.push(merge_check_point(variant, 0));
    327   ++ingredient_index;
    328   break;
    329 }
    330
    331 :(scenario merge_check_container_containing_exclusive_container)
    332 container foo [
    333   x:num
    334   y:bar
    335 ]
    336 exclusive-container bar [
    337   x:num
    338   y:num
    339 ]
    340 def main [
    341   1:foo <- merge 23, 1/y, 34
    342 ]
    343 +mem: storing 23 in location 1
    344 +mem: storing 1 in location 2
    345 +mem: storing 34 in location 3
    346 $error: 0
    347
    348 :(scenario merge_check_container_containing_exclusive_container_2)
    349 % Hide_errors = true;
    350 container foo [
    351   x:num
    352   y:bar
    353 ]
    354 exclusive-container bar [
    355   x:num
    356   y:num
    357 ]
    358 def main [
    359   1:foo <- merge 23, 1/y, 34, 35
    360 ]
    361 +error: main: too many ingredients in '1:foo <- merge 23, 1/y, 34, 35'
    362
    363 :(scenario merge_check_exclusive_container_containing_container)
    364 exclusive-container foo [
    365   x:num
    366   y:bar
    367 ]
    368 container bar [
    369   x:num
    370   y:num
    371 ]
    372 def main [
    373   1:foo <- merge 1/y, 23, 34
    374 ]
    375 +mem: storing 1 in location 1
    376 +mem: storing 23 in location 2
    377 +mem: storing 34 in location 3
    378 $error: 0
    379
    380 :(scenario merge_check_exclusive_container_containing_container_2)
    381 exclusive-container foo [
    382   x:num
    383   y:bar
    384 ]
    385 container bar [
    386   x:num
    387   y:num
    388 ]
    389 def main [
    390   1:foo <- merge 0/x, 23
    391 ]
    392 $error: 0
    393
    394 :(scenario merge_check_exclusive_container_containing_container_3)
    395 % Hide_errors = true;
    396 exclusive-container foo [
    397   x:num
    398   y:bar
    399 ]
    400 container bar [
    401   x:num
    402   y:num
    403 ]
    404 def main [
    405   1:foo <- merge 1/y, 23
    406 ]
    407 +error: main: too few ingredients in '1:foo <- merge 1/y, 23'
    408
    409 :(scenario merge_check_exclusive_container_containing_container_4)
    410 exclusive-container foo [
    411   x:num
    412   y:bar
    413 ]
    414 container bar [
    415   a:num
    416   b:num
    417 ]
    418 def main [
    419   1:bar <- merge 23, 24
    420   3:foo <- merge 1/y, 1:bar
    421 ]
    422 $error: 0
    423
    424 //: Since the different variants of an exclusive-container might have
    425 //: different sizes, relax the size mismatch check for 'merge' instructions.
    426 :(before "End size_mismatch(x) Special-cases")
    427 if (current_step_index() < SIZE(Current_routine->steps())
    428     && current_instruction().operation == MERGE
    429     && !current_instruction().products.empty()
    430     && current_instruction().products.at(0).type) {
    431   reagent/*copy*/ x = current_instruction().products.at(0);
    432   // Update size_mismatch Check for MERGE(x)
    433   const type_tree* root_type = x.type->atom ? x.type : x.type->left;
    434   assert(root_type->atom);
    435   if (get(Type, root_type->value).kind == EXCLUSIVE_CONTAINER)
    436     return size_of(x) < SIZE(data);
    437 }
    438
    439 :(scenario merge_exclusive_container_with_mismatched_sizes)
    440 container foo [
    441   x:num
    442   y:num
    443 ]
    444 exclusive-container bar [
    445   x:num
    446   y:foo
    447 ]
    448 def main [
    449   1:num <- copy 34
    450   2:num <- copy 35
    451   3:bar <- merge 0/x, 1:num
    452   6:bar <- merge 1/foo, 1:num, 2:num
    453 ]
    454 +mem: storing 0 in location 3
    455 +mem: storing 34 in location 4
    456 # bar is always 3 large so location 5 is skipped
    457 +mem: storing 1 in location 6
    458 +mem: storing 34 in location 7
    459 +mem: storing 35 in location 8