:(scenario new)
def main [
1:address:number/raw <- new number:type
2:address:number/raw <- new number:type
3:boolean/raw <- equal 1:address:number/raw, 2:address:number/raw
]
+mem: storing 0 in location 3
:(before "End Mu Types Initialization")
put(Type_ordinal, "type", 0);
:(code)
bool is_mu_type_literal(reagent r) {
return is_literal(r) && r.type && r.type->name == "type";
}
:(before "End Primitive Recipe Declarations")
NEW,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "new", NEW);
:(before "End Primitive Recipe Checks")
case NEW: {
const recipe& caller = get(Recipe, r);
if (inst.ingredients.empty() || SIZE(inst.ingredients) > 2) {
raise << maybe(caller.name) << "'new' requires one or two ingredients, but got " << to_original_string(inst) << '\n' << end();
break;
}
reagent type = inst.ingredients.at(0);
if (!is_mu_type_literal(type)) {
raise << maybe(caller.name) << "first ingredient of 'new' should be a type, but got " << type.original_string << '\n' << end();
break;
}
if (inst.products.empty()) {
raise << maybe(caller.name) << "result of 'new' should never be ignored\n" << end();
break;
}
if (!product_of_new_is_valid(inst)) {
raise << maybe(caller.name) << "product of 'new' has incorrect type: " << to_original_string(inst) << '\n' << end();
break;
}
break;
}
:(code)
bool product_of_new_is_valid(const instruction& inst) {
reagent product = inst.products.at(0);
canonize_type(product);
if (!product.type || product.type->value != get(Type_ordinal, "address"))
return false;
drop_from_type(product, "address");
if (SIZE(inst.ingredients) > 1) {
if (!product.type || product.type->value != get(Type_ordinal, "array")) return false;
drop_from_type(product, "array");
}
reagent expected_product("x:"+inst.ingredients.at(0).name);
return types_strictly_match(product, expected_product);
}
:(before "End Primitive Recipe Checks")
case ALLOCATE: {
raise << "never call 'allocate' directly'; always use 'new'\n" << end();
break;
}
:(before "End Primitive Recipe Implementations")
case NEW: {
raise << "no implementation for 'new'; why wasn't it translated to 'allocate'? Please save a copy of your program and send it to Kartik.\n" << end();
break;
}
:(after "Transform.push_back(check_instruction)")
Transform.push_back(transform_new_to_allocate);
:(code)
void transform_new_to_allocate(const recipe_ordinal r) {
trace(9991, "transform") << "--- convert 'new' to 'allocate' for recipe " << get(Recipe, r).name << end();
for (int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
instruction& inst = get(Recipe, r).steps.at(i);
if (inst.name == "new") {
inst.operation = ALLOCATE;
string_tree* type_name = new string_tree(inst.ingredients.at(0).name);
type_tree* type = new_type_tree(type_name);
inst.ingredients.at(0).set_value(size_of(type));
trace(9992, "new") << "size of " << to_string(type_name) << " is " << inst.ingredients.at(0).value << end();
delete type;
delete type_name;
}
}
}
:(before "End Globals")
const int Reserved_for_tests = 1000;
int Memory_allocated_until = Reserved_for_tests;
int Initial_memory_per_routine = 100000;
:(before "End Setup")
Memory_allocated_until = Reserved_for_tests;
Initial_memory_per_routine = 100000;
:(before "End routine Fields")
int alloc, alloc_max;
:(before "End routine Constructor")
alloc = Memory_allocated_until;
Memory_allocated_until += Initial_memory_per_routine;
alloc_max = Memory_allocated_until;
trace(9999, "new") << "routine allocated memory from " << alloc << " to " << alloc_max << end();
:(before "End Primitive Recipe Declarations")
ALLOCATE,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "allocate", ALLOCATE);
:(before "End Primitive Recipe Implementations")
case ALLOCATE: {
int size = ingredients.at(0).at(0);
if (SIZE(ingredients) > 1) {
trace(9999, "mem") << "array size is " << ingredients.at(1).at(0) << end();
size = 1 + size*ingredients.at(1).at(0);
}
size++;
trace(9999, "mem") << "allocating size " << size << end();
ensure_space(size);
const int result = Current_routine->alloc;
trace(9999, "mem") << "new alloc: " << result << end();
products.resize(1);
products.at(0).push_back(result);
for (int address = result; address < result+size; ++address)
put(Memory, address, 0);
if (SIZE(current_instruction().ingredients) > 1) {
trace(9999, "mem") << "storing " << ingredients.at(1).at(0) << " in location " << result+1 << end();
put(Memory, result+1, ingredients.at(1).at(0));
}
Current_routine->alloc += size;
assert(Current_routine->alloc <= Current_routine->alloc_max);
break;
}
:(code)
void ensure_space(int size) {
if (size > Initial_memory_per_routine) {
tb_shutdown();
cerr << "can't allocate " << size << " locations, that's too much compared to " << Initial_memory_per_routine << ".\n";
exit(0);
}
if (Current_routine->alloc + size > Current_routine->alloc_max) {
Current_routine->alloc = Memory_allocated_until;
Memory_allocated_until += Initial_memory_per_routine;
Current_routine->alloc_max = Memory_allocated_until;
trace(9999, "new") << "routine allocated memory from " << Current_routine->alloc << " to " << Current_routine->alloc_max << end();
}
}
:(scenario new_initializes)
% Memory_allocated_until = 10;
% put(Memory, Memory_allocated_until, 1);
def main [
1:address:number <- new number:type
2:number <- copy 1:address:number/lookup
]
+mem: storing 0 in location 2
:(scenario new_error)
% Hide_errors = true;
def main [
1:number/raw <- new number:type
]
+error: main: product of 'new' has incorrect type: 1:number/raw <- new number:type
:(scenario new_array)
def main [
1:address:array:number/raw <- new number:type, 5
2:address:number/raw <- new number:type
3:number/raw <- subtract 2:address:number/raw, 1:address:array:number/raw
]
+run: {1: ("address" "array" "number"), "raw": ()} <- new {number: "type"}, {5: "literal"}
+mem: array size is 5
+mem: storing 7 in location 3
:(scenario new_empty_array)
def main [
1:address:array:number/raw <- new number:type, 0
2:address:number/raw <- new number:type
3:number/raw <- subtract 2:address:number/raw, 1:address:array:number/raw
]
+run: {1: ("address" "array" "number"), "raw": ()} <- new {number: "type"}, {0: "literal"}
+mem: array size is 0
+mem: storing 2 in location 3
:(scenario new_overflow)
% Initial_memory_per_routine = 3; // barely enough room for point allocation below
def main [
1:address:number/raw <- new number:type
2:address:point/raw <- new point:type
]
+new: routine allocated memory from 1000 to 1003
+new: routine allocated memory from 1003 to 1006
:(scenario copy_indirect)
def main [
1:address:number <- copy 10/unsafe
11:number <- copy 34
2:number <- copy 1:address:number/lookup
]
+mem: storing 34 in location 2
:(before "End Preprocess read_memory(x)")
canonize(x);
:(scenario store_indirect)
def main [
1:address:number <- copy 10/unsafe
1:address:number/lookup <- copy 34
]
+mem: storing 34 in location 11
:(before "End Preprocess write_memory(x)")
canonize(x);
if (x.value == 0) {
raise << "can't write to location 0 in '" << to_original_string(current_instruction()) << "'\n" << end();
return;
}
:(scenario store_to_0_fails)
% Hide_errors = true;
def main [
1:address:number <- copy 0
1:address:number/lookup <- copy 34
]
-mem: storing 34 in location 0
+error: can't write to location 0 in '1:address:number/lookup <- copy 34'
:(code)
void canonize(reagent& x) {
if (is_literal(x)) return;
while (has_property(x, "lookup"))
lookup_memory(x);
}
void lookup_memory(reagent& x) {
if (!x.type || x.type->value != get(Type_ordinal, "address")) {
raise << maybe(current_recipe_name()) << "tried to /lookup " << x.original_string << " but it isn't an address\n" << end();
return;
}
if (x.value == 0) {
raise << maybe(current_recipe_name()) << "tried to /lookup 0\n" << end();
return;
}
trace(9999, "mem") << "location " << x.value << " is " << no_scientific(get_or_insert(Memory, x.value)) << end();
x.set_value(get_or_insert(Memory, x.value));
drop_from_type(x, "address");
if (x.value != 0) {
trace(9999, "mem") << "skipping refcount at " << x.value << end();
x.set_value(x.value+1);
}
drop_one_lookup(x);
}
void test_lookup_address_skips_refcount() {
reagent x("*x:address:number");
x.set_value(34);
put(Memory, 34, 1000);
lookup_memory(x);
CHECK_TRACE_CONTENTS("mem: skipping refcount at 1000");
CHECK_EQ(x.value, 1001);
}
void test_lookup_zero_address_does_not_skip_refcount() {
reagent x("*x:address:number");
x.set_value(34);
put(Memory, 34, 0);
lookup_memory(x);
CHECK_TRACE_DOESNT_CONTAIN("mem: skipping refcount at 0");
CHECK_EQ(x.value, 0);
}
:(after "bool types_strictly_match(reagent to, reagent from)")
if (!canonize_type(to)) return false;
if (!canonize_type(from)) return false;
:(after "bool is_mu_array(reagent r)")
if (!canonize_type(r)) return false;
:(after "bool is_mu_address(reagent r)")
if (!canonize_type(r)) return false;
:(after "bool is_mu_number(reagent r)")
if (!canonize_type(r)) return false;
:(after "bool is_mu_boolean(reagent r)")
if (!canonize_type(r)) return false;
:(after "Update product While Type-checking Merge")
if (!canonize_type(product)) continue;
:(before "End Compute Call Ingredient")
canonize_type(ingredient);
:(before "End Preprocess NEXT_INGREDIENT product")
canonize_type(product);
:(before "End Check REPLY Copy(lhs, rhs)
canonize_type(lhs);
canonize_type(rhs);
:(code)
bool canonize_type(reagent& r) {
while (has_property(r, "lookup")) {
if (!r.type || r.type->value != get(Type_ordinal, "address")) {
raise << "can't lookup non-address: " << to_string(r) << ": " << to_string(r.type) << '\n' << end();
return false;
}
drop_from_type(r, "address");
drop_one_lookup(r);
}
return true;
}
void drop_from_type(reagent& r, string expected_type) {
if (r.type->name != expected_type) {
raise << "can't drop2 " << expected_type << " from " << to_string(r) << '\n' << end();
return;
}
type_tree* tmp = r.type;
r.type = tmp->right;
tmp->right = NULL;
delete tmp;
}
void drop_one_lookup(reagent& r) {
for (vector<pair<string, string_tree*> >::iterator p = r.properties.begin(); p != r.properties.end(); ++p) {
if (p->first == "lookup") {
r.properties.erase(p);
return;
}
}
assert(false);
}
:(scenario get_indirect)
def main [
1:address:point <- copy 10/unsafe
11:number <- copy 34
12:number <- copy 35
2:number <- get 1:address:point/lookup, 0:offset
]
+mem: storing 34 in location 2
:(scenario get_indirect2)
def main [
1:address:point <- copy 10/unsafe
11:number <- copy 34
12:number <- copy 35
2:address:number <- copy 20/unsafe
2:address:number/lookup <- get 1:address:point/lookup, 0:offset
]
+mem: storing 34 in location 21
:(scenario include_nonlookup_properties)
def main [
1:address:point <- copy 10/unsafe
11:number <- copy 34
12:number <- copy 35
2:number <- get 1:address:point/lookup/foo, 0:offset
]
+mem: storing 34 in location 2
:(after "Update GET base in Check")
if (!canonize_type(base)) break;
:(after "Update GET product in Check")
if (!canonize_type(product)) break;
:(after "Update GET base in Run")
canonize(base);
:(scenario put_indirect)
def main [
1:address:point <- copy 10/unsafe
11:number <- copy 34
12:number <- copy 35
1:address:point/lookup <- put 1:address:point/lookup, 0:offset, 36
]
+mem: storing 36 in location 11
:(after "Update PUT base in Check")
if (!canonize_type(base)) break;
:(after "Update PUT offset in Check")
if (!canonize_type(offset)) break;
:(after "Update PUT base in Run")
canonize(base);
:(scenario copy_array_indirect)
def main [
11:array:number:3 <- create-array
12:number <- copy 14
13:number <- copy 15
14:number <- copy 16
1:address:array:number <- copy 10/unsafe
2:array:number <- copy 1:address:array:number/lookup
]
+mem: storing 3 in location 2
+mem: storing 14 in location 3
+mem: storing 15 in location 4
+mem: storing 16 in location 5
:(before "Update CREATE_ARRAY product in Check")
assert(!has_property(product, "lookup"));
:(before "Update CREATE_ARRAY product in Run")
assert(!has_property(product, "lookup"));
:(scenario index_indirect)
def main [
11:array:number:3 <- create-array
12:number <- copy 14
13:number <- copy 15
14:number <- copy 16
1:address:array:number <- copy 10/unsafe
2:number <- index 1:address:array:number/lookup, 1
]
+mem: storing 15 in location 2
:(before "Update INDEX base in Check")
if (!canonize_type(base)) break;
:(before "Update INDEX index in Check")
if (!canonize_type(index)) break;
:(before "Update INDEX product in Check")
if (!canonize_type(product)) break;
:(before "Update INDEX base in Run")
canonize(base);
:(before "Update INDEX index in Run")
canonize(index);
:(scenario put_index_indirect)
def main [
11:array:number:3 <- create-array
12:number <- copy 14
13:number <- copy 15
14:number <- copy 16
1:address:array:number <- copy 10/unsafe
1:address:array:number/lookup <- put-index 1:address:array:number/lookup, 1, 34
]
+mem: storing 34 in location 13
:(scenario put_index_indirect_2)
def main [
1:array:number:3 <- create-array
2:number <- copy 14
3:number <- copy 15
4:number <- copy 16
5:address:number <- copy 10/unsafe
11:number <- copy 1
5:address:array:number/lookup <- put-index 1:array:number:3, 5:address:number/lookup, 34
]
+mem: storing 34 in location 3
:(before "Update PUT_INDEX base in Check")
if (!canonize_type(base)) break;
:(before "Update PUT_INDEX index in Check")
if (!canonize_type(index)) break;
:(before "Update PUT_INDEX value in Check")
if (!canonize_type(value)) break;
:(before "Update PUT_INDEX base in Run")
canonize(base);
:(before "Update PUT_INDEX index in Run")
canonize(index);
:(scenario length_indirect)
def main [
11:array:number:3 <- create-array
12:number <- copy 14
13:number <- copy 15
14:number <- copy 16
1:address:array:number <- copy 10/unsafe
2:number <- length 1:address:array:number/lookup
]
+mem: storing 3 in location 2
:(before "Update LENGTH array in Check")
if (!canonize_type(array)) break;
:(before "Update LENGTH array in Run")
canonize(array);
:(scenario maybe_convert_indirect)
def main [
11:number-or-point <- merge 0/number, 34
1:address:number-or-point <- copy 10/unsafe
2:number, 3:boolean <- maybe-convert 1:address:number-or-point/lookup, i:variant
]
+mem: storing 34 in location 2
+mem: storing 1 in location 3
:(scenario maybe_convert_indirect_2)
def main [
11:number-or-point <- merge 0/number, 34
1:address:number-or-point <- copy 10/unsafe
2:address:number <- copy 20/unsafe
2:address:number/lookup, 3:boolean <- maybe-convert 1:address:number-or-point/lookup, i:variant
]
+mem: storing 34 in location 21
+mem: storing 1 in location 3
:(scenario maybe_convert_indirect_3)
def main [
11:number-or-point <- merge 0/number, 34
1:address:number-or-point <- copy 10/unsafe
2:address:boolean <- copy 20/unsafe
3:number, 2:address:boolean/lookup <- maybe-convert 1:address:number-or-point/lookup, i:variant
]
+mem: storing 34 in location 3
+mem: storing 1 in location 21
:(before "Update MAYBE_CONVERT base in Check")
if (!canonize_type(base)) break;
:(before "Update MAYBE_CONVERT product in Check")
if (!canonize_type(product)) break;
:(before "Update MAYBE_CONVERT status in Check")
if (!canonize_type(status)) break;
:(before "Update MAYBE_CONVERT base in Run")
canonize(base);
:(before "Update MAYBE_CONVERT product in Run")
canonize(product);
:(before "Update MAYBE_CONVERT status in Run")
canonize(status);
:(scenario merge_exclusive_container_indirect)
def main [
1:address:number-or-point <- copy 10/unsafe
1:address:number-or-point/lookup <- merge 0/number, 34
]
+mem: storing 0 in location 11
+mem: storing 34 in location 12
:(before "Update size_mismatch Check for MERGE(x)
canonize(x);
:(scenario lookup_abbreviation)
def main [
1:address:number <- copy 10/unsafe
11:number <- copy 34
3:number <- copy *1:address:number
]
+parse: ingredient: {1: ("address" "number"), "lookup": ()}
+mem: storing 34 in location 3
:(before "End Parsing reagent")
{
while (!name.empty() && name.at(0) == '*') {
name.erase(0, 1);
properties.push_back(pair<string, string_tree*>("lookup", NULL));
}
if (name.empty())
raise << "illegal name " << original_string << '\n' << end();
}
:(scenario refcounts)
def main [
1:address:number <- copy 1000/unsafe
2:address:number <- copy 1:address:number
1:address:number <- copy 0
2:address:number <- copy 0
]
+run: {1: ("address" "number")} <- copy {1000: "literal", "unsafe": ()}
+mem: incrementing refcount of 1000: 0 -> 1
+run: {2: ("address" "number")} <- copy {1: ("address" "number")}
+mem: incrementing refcount of 1000: 1 -> 2
+run: {1: ("address" "number")} <- copy {0: "literal"}
+mem: decrementing refcount of 1000: 2 -> 1
+run: {2: ("address" "number")} <- copy {0: "literal"}
+mem: decrementing refcount of 1000: 1 -> 0
+mem: automatically abandoning 1000
:(before "End write_memory(reagent x) Special-cases")
if (x.type->value == get(Type_ordinal, "address")) {
int old_address = get_or_insert(Memory, x.value);
assert(scalar(data));
int new_address = data.at(0);
if (old_address) {
int old_refcount = get_or_insert(Memory, old_address);
trace(9999, "mem") << "decrementing refcount of " << old_address << ": " << old_refcount << " -> " << (old_refcount-1) << end();
put(Memory, old_address, old_refcount-1);
}
trace(9999, "mem") << "storing " << no_scientific(data.at(0)) << " in location " << x.value << end();
put(Memory, x.value, new_address);
if (new_address) {
int new_refcount = get_or_insert(Memory, new_address);
assert(new_refcount >= 0);
trace(9999, "mem") << "incrementing refcount of " << new_address << ": " << new_refcount << " -> " << (new_refcount+1) << end();
put(Memory, new_address, new_refcount+1);
}
assert(old_address >= 0);
if (old_address == 0) return;
if (get_or_insert(Memory, old_address) < 0) {
DUMP("");
cerr << old_address << ' ' << get_or_insert(Memory, old_address) << '\n';
}
assert(get_or_insert(Memory, old_address) >= 0);
if (get_or_insert(Memory, old_address) > 0) return;
trace(9999, "mem") << "automatically abandoning " << old_address << end();
trace(9999, "mem") << "computing size to abandon at " << x.value << end();
x.set_value(old_address+1);
drop_from_type(x, "address");
abandon(old_address, size_of(x)+1);
return;
}
:(scenario refcounts_2)
def main [
1:address:number <- new number:type
1:address:number <- new number:type
1:address:number <- copy 0
]
+run: {1: ("address" "number")} <- new {number: "type"}
+mem: incrementing refcount of 1000: 0 -> 1
+run: {1: ("address" "number")} <- new {number: "type"}
+mem: automatically abandoning 1000
:(scenario refcounts_3)
def main [
1:address:number <- new number:type
foo 1:address:number
1:address:number <- copy 0
]
def foo [
2:address:number <- next-ingredient
2:address:number <- copy 0
]
+run: {1: ("address" "number")} <- new {number: "type"}
+mem: incrementing refcount of 1000: 0 -> 1
+run: {2: ("address" "number")} <- next-ingredient
+mem: incrementing refcount of 1000: 1 -> 2
+run: {2: ("address" "number")} <- copy {0: "literal"}
+mem: decrementing refcount of 1000: 2 -> 1
+run: {1: ("address" "number")} <- copy {0: "literal"}
+mem: decrementing refcount of 1000: 1 -> 0
+mem: automatically abandoning 1000
:(scenario refcounts_4)
def main [
1:address:number <- new number:type
1:address:number <- copy 1:address:number
]
+run: {1: ("address" "number")} <- new {number: "type"}
+mem: incrementing refcount of 1000: 0 -> 1
+run: {1: ("address" "number")} <- copy {1: ("address" "number")}
+mem: decrementing refcount of 1000: 1 -> 0
+mem: incrementing refcount of 1000: 0 -> 1
:(scenario refcounts_5)
def main [
1:address:number <- new number:type
foo 1:address:number
1:address:number <- new number:type
]
def foo [
2:address:number <- next-ingredient
]
+run: {1: ("address" "number")} <- new {number: "type"}
+mem: incrementing refcount of 1000: 0 -> 1
+run: {2: ("address" "number")} <- next-ingredient
+mem: incrementing refcount of 1000: 1 -> 2
+run: {1: ("address" "number")} <- new {number: "type"}
+mem: decrementing refcount of 1000: 2 -> 1
:(scenario refcounts_array)
def main [
1:number <- copy 30
10:address:array:number <- new number:type, 20
11:number <- copy 10:address:array:number
10:address:array:number <- new number:type, 25
]
+run: {10: ("address" "array" "number")} <- new {number: "type"}, {20: "literal"}
+abandon: saving in free-list of size 22
:(scenario new_reclaim)
def main [
1:address:number <- new number:type
2:number <- copy 1:address:number
1:address:number <- copy 0
3:address:number <- new number:type
4:boolean <- equal 2:number, 3:address:number
]
+mem: storing 1 in location 4
:(before "End routine Fields")
map<int, int> free_list;
:(code)
void abandon(int address, int size) {
trace(9999, "abandon") << "saving in free-list of size " << size << end();
for (int curr = address; curr < address+size; ++curr)
put(Memory, curr, 0);
put(Memory, address, get_or_insert(Current_routine->free_list, size));
put(Current_routine->free_list, size, address);
}
:(before "ensure_space(size)" following "case ALLOCATE")
if (get_or_insert(Current_routine->free_list, size)) {
trace(9999, "abandon") << "picking up space from free-list of size " << size << end();
int result = get_or_insert(Current_routine->free_list, size);
trace(9999, "mem") << "new alloc from free list: " << result << end();
put(Current_routine->free_list, size, get_or_insert(Memory, result));
for (int curr = result+1; curr < result+size; ++curr) {
if (get_or_insert(Memory, curr) != 0) {
raise << maybe(current_recipe_name()) << "memory in free list was not zeroed out: " << curr << '/' << result << "; somebody wrote to us after free!!!\n" << end();
break;
}
}
if (SIZE(current_instruction().ingredients) > 1)
put(Memory, result+1, ingredients.at(1).at(0));
else
put(Memory, result, 0);
products.resize(1);
products.at(0).push_back(result);
break;
}
:(scenario new_differing_size_no_reclaim)
def main [
1:address:number <- new number:type
2:number <- copy 1:address:number
1:address:number <- copy 0
3:address:array:number <- new number:type, 2
4:boolean <- equal 2:number, 3:address:array:number
]
+mem: storing 0 in location 4
:(scenario new_reclaim_array)
def main [
1:address:array:number <- new number:type, 2
2:number <- copy 1:address:array:number
1:address:array:number <- copy 0
3:address:array:number <- new number:type, 2
4:boolean <- equal 2:number, 3:address:array:number
]
+mem: storing 1 in location 4
:(before "End Primitive Recipe Declarations")
_DUMP,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "$dump", _DUMP);
:(before "End Primitive Recipe Implementations")
case _DUMP: {
reagent after_canonize = current_instruction().ingredients.at(0);
canonize(after_canonize);
cerr << maybe(current_recipe_name()) << current_instruction().ingredients.at(0).name << ' ' << no_scientific(current_instruction().ingredients.at(0).value) << " => " << no_scientific(after_canonize.value) << " => " << no_scientific(get_or_insert(Memory, after_canonize.value)) << '\n';
break;
}
:(before "End Globals")
int Bar = -1;
:(before "End Primitive Recipe Declarations")
_BAR,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "$bar", _BAR);
:(before "End Primitive Recipe Implementations")
case _BAR: {
if (current_instruction().ingredients.empty()) {
if (Bar != -1) cerr << Bar << ": " << no_scientific(get_or_insert(Memory, Bar)) << '\n';
else cerr << '\n';
}
else {
reagent tmp = current_instruction().ingredients.at(0);
canonize(tmp);
Bar = tmp.value;
}
break;
}