2015-05-19 17:38:23 +00:00
|
|
|
//: Spaces help isolate recipes from each other. You can create them at will,
|
2015-03-22 00:53:20 +00:00
|
|
|
//: and all addresses in arguments are implicitly based on the 'default-space'
|
|
|
|
//: (unless they have the /raw property)
|
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario set_default_space)
|
2016-01-21 04:47:54 +00:00
|
|
|
# if default-space is 10, and if an array of 5 locals lies from location 12 to 16 (inclusive),
|
|
|
|
# then local 0 is really location 12, local 1 is really location 13, and so on.
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2016-04-24 18:54:30 +00:00
|
|
|
# pretend address:array:location; in practice we'll use new
|
2016-01-21 04:47:54 +00:00
|
|
|
10:number <- copy 0 # refcount
|
|
|
|
11:number <- copy 5 # length
|
2016-04-24 18:54:30 +00:00
|
|
|
default-space:address:array:location <- copy 10/unsafe
|
2015-07-28 21:33:22 +00:00
|
|
|
1:number <- copy 23
|
2015-03-22 00:53:20 +00:00
|
|
|
]
|
2016-01-21 04:47:54 +00:00
|
|
|
+mem: storing 23 in location 13
|
2015-03-22 00:53:20 +00:00
|
|
|
|
2015-07-28 22:03:46 +00:00
|
|
|
:(scenario lookup_sidesteps_default_space)
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2016-04-24 18:54:30 +00:00
|
|
|
# pretend pointer from outside (2000 reserved for refcount)
|
|
|
|
2001:number <- copy 34
|
|
|
|
# pretend address:array:location; in practice we'll use new
|
2016-01-21 04:47:54 +00:00
|
|
|
1000:number <- copy 0 # refcount
|
|
|
|
1001:number <- copy 5 # length
|
2015-05-19 17:38:23 +00:00
|
|
|
# actual start of this recipe
|
2016-04-24 18:54:30 +00:00
|
|
|
default-space:address:array:location <- copy 1000/unsafe
|
|
|
|
1:address:number <- copy 2000/unsafe # even local variables always contain raw addresses
|
2015-07-29 08:35:06 +00:00
|
|
|
8:number/raw <- copy *1:address:number
|
2015-04-03 18:42:50 +00:00
|
|
|
]
|
|
|
|
+mem: storing 34 in location 8
|
|
|
|
|
2015-05-23 19:30:58 +00:00
|
|
|
//:: first disable name conversion for 'default-space'
|
|
|
|
:(scenario convert_names_passes_default_space)
|
2015-10-07 07:22:49 +00:00
|
|
|
% Hide_errors = true;
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2015-07-28 21:33:22 +00:00
|
|
|
default-space:number, x:number <- copy 0, 1
|
2015-05-23 19:30:58 +00:00
|
|
|
]
|
|
|
|
+name: assign x 1
|
|
|
|
-name: assign default-space 1
|
|
|
|
|
2016-01-30 05:58:00 +00:00
|
|
|
:(before "End is_disqualified Cases")
|
2015-05-23 19:30:58 +00:00
|
|
|
if (x.name == "default-space")
|
|
|
|
x.initialized = true;
|
|
|
|
:(before "End is_special_name Cases")
|
|
|
|
if (s == "default-space") return true;
|
|
|
|
|
|
|
|
//:: now implement space support
|
2015-04-13 03:56:45 +00:00
|
|
|
:(before "End call Fields")
|
2016-03-14 03:26:47 +00:00
|
|
|
int default_space;
|
2015-05-24 00:58:10 +00:00
|
|
|
:(before "End call Constructor")
|
|
|
|
default_space = 0;
|
2015-03-22 00:53:20 +00:00
|
|
|
|
2015-10-26 04:42:18 +00:00
|
|
|
:(before "End canonize(x) Special-cases")
|
2016-04-20 16:54:10 +00:00
|
|
|
absolutize(x);
|
2015-03-22 00:53:20 +00:00
|
|
|
:(code)
|
2015-10-26 04:42:18 +00:00
|
|
|
void absolutize(reagent& x) {
|
|
|
|
if (is_raw(x) || is_dummy(x)) return;
|
|
|
|
if (x.name == "default-space") return;
|
2015-07-25 07:02:20 +00:00
|
|
|
if (!x.initialized) {
|
2016-05-21 05:09:06 +00:00
|
|
|
raise << to_original_string(current_instruction()) << ": reagent not initialized: '" << x.original_string << "'\n" << end();
|
2015-07-25 07:02:20 +00:00
|
|
|
}
|
2015-10-26 04:42:18 +00:00
|
|
|
x.set_value(address(x.value, space_base(x)));
|
2015-10-27 03:00:38 +00:00
|
|
|
x.properties.push_back(pair<string, string_tree*>("raw", NULL));
|
2015-10-26 04:42:18 +00:00
|
|
|
assert(is_raw(x));
|
2015-03-22 00:53:20 +00:00
|
|
|
}
|
|
|
|
|
2016-03-14 03:26:47 +00:00
|
|
|
int space_base(const reagent& x) {
|
2016-01-20 21:41:19 +00:00
|
|
|
// temporary stub; will be replaced in a later layer
|
2016-01-21 04:47:54 +00:00
|
|
|
return current_call().default_space ? (current_call().default_space+/*skip refcount*/1) : 0;
|
2016-01-20 21:41:19 +00:00
|
|
|
}
|
|
|
|
|
2016-03-14 03:26:47 +00:00
|
|
|
int address(int offset, int base) {
|
2016-02-27 05:50:54 +00:00
|
|
|
assert(offset >= 0);
|
2016-01-20 21:41:19 +00:00
|
|
|
if (base == 0) return offset; // raw
|
2016-03-14 03:26:47 +00:00
|
|
|
int size = get_or_insert(Memory, base);
|
2016-01-20 21:41:19 +00:00
|
|
|
if (offset >= size) {
|
|
|
|
// todo: test
|
2016-02-26 21:04:55 +00:00
|
|
|
raise << "location " << offset << " is out of bounds " << size << " at " << base << '\n' << end();
|
2016-01-20 21:41:19 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return base + /*skip length*/1 + offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
//:: reads and writes to the 'default-space' variable have special behavior
|
|
|
|
|
2016-05-06 15:33:15 +00:00
|
|
|
:(after "Begin Preprocess write_memory(x, data)")
|
2016-05-06 07:46:39 +00:00
|
|
|
if (x.name == "default-space") {
|
|
|
|
if (!scalar(data)
|
|
|
|
|| !x.type
|
|
|
|
|| x.type->value != get(Type_ordinal, "address")
|
|
|
|
|| !x.type->right
|
|
|
|
|| x.type->right->value != get(Type_ordinal, "array")
|
|
|
|
|| !x.type->right->right
|
|
|
|
|| x.type->right->right->value != get(Type_ordinal, "location")
|
|
|
|
|| x.type->right->right->right) {
|
2016-05-21 05:09:06 +00:00
|
|
|
raise << maybe(current_recipe_name()) << "'default-space' should be of type address:array:location, but is " << to_string(x.type) << '\n' << end();
|
2016-01-20 21:41:19 +00:00
|
|
|
}
|
2016-05-06 07:46:39 +00:00
|
|
|
current_call().default_space = data.at(0);
|
|
|
|
return;
|
|
|
|
}
|
2016-01-20 21:41:19 +00:00
|
|
|
|
|
|
|
:(scenario get_default_space)
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2016-04-24 18:54:30 +00:00
|
|
|
default-space:address:array:location <- copy 10/unsafe
|
|
|
|
1:address:array:location/raw <- copy default-space:address:array:location
|
2016-01-20 21:41:19 +00:00
|
|
|
]
|
|
|
|
+mem: storing 10 in location 1
|
|
|
|
|
2016-05-06 15:33:15 +00:00
|
|
|
:(after "Begin Preprocess read_memory(x)")
|
2016-05-06 07:46:39 +00:00
|
|
|
if (x.name == "default-space") {
|
|
|
|
vector<double> result;
|
|
|
|
result.push_back(current_call().default_space);
|
|
|
|
return result;
|
|
|
|
}
|
2016-01-20 21:41:19 +00:00
|
|
|
|
2015-04-18 06:24:52 +00:00
|
|
|
//:: fix 'get'
|
|
|
|
|
2015-07-28 22:03:46 +00:00
|
|
|
:(scenario lookup_sidesteps_default_space_in_get)
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2016-04-24 18:54:30 +00:00
|
|
|
# pretend pointer to container from outside (2000 reserved for refcount)
|
|
|
|
2001:number <- copy 34
|
|
|
|
2002:number <- copy 35
|
|
|
|
# pretend address:array:location; in practice we'll use new
|
2016-01-21 04:47:54 +00:00
|
|
|
1000:number <- copy 0 # refcount
|
|
|
|
1001:number <- copy 5 # length
|
2015-05-19 17:38:23 +00:00
|
|
|
# actual start of this recipe
|
2016-04-24 18:54:30 +00:00
|
|
|
default-space:address:array:location <- copy 1000/unsafe
|
|
|
|
1:address:point <- copy 2000/unsafe
|
2015-07-29 08:35:06 +00:00
|
|
|
9:number/raw <- get *1:address:point, 1:offset
|
2015-04-18 04:51:13 +00:00
|
|
|
]
|
|
|
|
+mem: storing 35 in location 9
|
|
|
|
|
2016-04-20 16:58:07 +00:00
|
|
|
:(before "Read element" following "case GET:")
|
|
|
|
element.properties.push_back(pair<string, string_tree*>("raw", NULL));
|
2015-04-18 04:51:13 +00:00
|
|
|
|
2015-04-18 06:24:52 +00:00
|
|
|
//:: fix 'index'
|
|
|
|
|
2015-07-28 22:03:46 +00:00
|
|
|
:(scenario lookup_sidesteps_default_space_in_index)
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2016-04-24 18:54:30 +00:00
|
|
|
# pretend pointer to array from outside (2000 reserved for refcount)
|
|
|
|
2001:number <- copy 2 # length
|
|
|
|
2002:number <- copy 34
|
|
|
|
2003:number <- copy 35
|
|
|
|
# pretend address:array:location; in practice we'll use new
|
2016-01-21 04:47:54 +00:00
|
|
|
1000:number <- copy 0 # refcount
|
|
|
|
1001:number <- copy 5 # length
|
2015-05-19 17:38:23 +00:00
|
|
|
# actual start of this recipe
|
2016-04-24 18:54:30 +00:00
|
|
|
default-space:address:array:location <- copy 1000/unsafe
|
|
|
|
1:address:array:number <- copy 2000/unsafe
|
2015-07-29 08:35:06 +00:00
|
|
|
9:number/raw <- index *1:address:array:number, 1
|
2015-04-18 04:51:13 +00:00
|
|
|
]
|
|
|
|
+mem: storing 35 in location 9
|
|
|
|
|
2016-04-20 16:58:07 +00:00
|
|
|
:(before "Read element" following "case INDEX:")
|
|
|
|
element.properties.push_back(pair<string, string_tree*>("raw", NULL));
|
2015-04-18 04:51:13 +00:00
|
|
|
|
2015-07-14 02:59:27 +00:00
|
|
|
//:: convenience operation to automatically deduce the amount of space to
|
|
|
|
//:: allocate in a default space with names
|
|
|
|
|
|
|
|
:(scenario new_default_space)
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2015-07-14 02:59:27 +00:00
|
|
|
new-default-space
|
2015-07-28 21:33:22 +00:00
|
|
|
x:number <- copy 0
|
|
|
|
y:number <- copy 3
|
2015-07-14 02:59:27 +00:00
|
|
|
]
|
|
|
|
# allocate space for x and y, as well as the chaining slot at 0
|
|
|
|
+mem: array size is 3
|
|
|
|
|
2016-01-30 05:58:00 +00:00
|
|
|
:(before "End is_disqualified Cases")
|
2015-07-14 02:59:27 +00:00
|
|
|
if (x.name == "number-of-locals")
|
|
|
|
x.initialized = true;
|
|
|
|
:(before "End is_special_name Cases")
|
|
|
|
if (s == "number-of-locals") return true;
|
|
|
|
|
2015-10-29 01:19:41 +00:00
|
|
|
:(before "End Rewrite Instruction(curr, recipe result)")
|
2015-07-14 02:59:27 +00:00
|
|
|
// rewrite `new-default-space` to
|
2016-04-24 18:54:30 +00:00
|
|
|
// `default-space:address:array:location <- new location:type, number-of-locals:literal`
|
2015-07-14 02:59:27 +00:00
|
|
|
// where N is Name[recipe][""]
|
|
|
|
if (curr.name == "new-default-space") {
|
2015-07-14 05:43:16 +00:00
|
|
|
rewrite_default_space_instruction(curr);
|
2015-07-14 02:59:27 +00:00
|
|
|
}
|
2016-05-06 15:33:15 +00:00
|
|
|
:(after "Begin Preprocess read_memory(x)")
|
2016-05-06 07:46:39 +00:00
|
|
|
if (x.name == "number-of-locals") {
|
|
|
|
vector<double> result;
|
|
|
|
result.push_back(Name[get(Recipe_ordinal, current_recipe_name())][""]);
|
|
|
|
if (result.back() == 0)
|
|
|
|
raise << "no space allocated for default-space in recipe " << current_recipe_name() << "; are you using names?\n" << end();
|
|
|
|
return result;
|
|
|
|
}
|
2016-05-06 15:33:15 +00:00
|
|
|
:(after "Begin Preprocess write_memory(x, data)")
|
2016-05-06 07:46:39 +00:00
|
|
|
if (x.name == "number-of-locals") {
|
|
|
|
raise << maybe(current_recipe_name()) << "can't write to special name 'number-of-locals'\n" << end();
|
|
|
|
return;
|
|
|
|
}
|
2015-07-14 02:59:27 +00:00
|
|
|
|
2016-05-18 23:45:32 +00:00
|
|
|
//:: 'local-scope' is like 'new-default-space' except that we'll reclaim the
|
|
|
|
//:: default-space when the routine exits
|
2015-07-14 05:43:16 +00:00
|
|
|
|
|
|
|
:(scenario local_scope)
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2015-07-14 05:43:16 +00:00
|
|
|
1:address <- foo
|
|
|
|
2:address <- foo
|
|
|
|
3:boolean <- equal 1:address, 2:address
|
|
|
|
]
|
2016-03-08 09:30:14 +00:00
|
|
|
def foo [
|
2015-07-14 05:43:16 +00:00
|
|
|
local-scope
|
2015-07-28 21:33:22 +00:00
|
|
|
x:number <- copy 34
|
2016-04-24 18:54:30 +00:00
|
|
|
return default-space:address:array:location
|
2015-07-14 05:43:16 +00:00
|
|
|
]
|
|
|
|
# both calls to foo should have received the same default-space
|
|
|
|
+mem: storing 1 in location 3
|
|
|
|
|
2016-05-18 23:45:32 +00:00
|
|
|
:(scenario local_scope_frees_up_addresses)
|
|
|
|
def main [
|
|
|
|
local-scope
|
|
|
|
x:address:array:character <- new [abc]
|
|
|
|
]
|
|
|
|
+mem: clearing x:address:array:character
|
|
|
|
|
|
|
|
:(before "End Rewrite Instruction(curr, recipe result)")
|
|
|
|
if (curr.name == "local-scope") {
|
|
|
|
rewrite_default_space_instruction(curr);
|
|
|
|
}
|
2016-03-13 04:41:35 +00:00
|
|
|
|
|
|
|
//: todo: do this in a transform, rather than magically in the reply instruction
|
2015-07-14 05:43:16 +00:00
|
|
|
:(after "Falling Through End Of Recipe")
|
|
|
|
try_reclaim_locals();
|
|
|
|
:(after "Starting Reply")
|
|
|
|
try_reclaim_locals();
|
|
|
|
|
|
|
|
:(code)
|
|
|
|
void try_reclaim_locals() {
|
|
|
|
// only reclaim routines starting with 'local-scope'
|
2015-11-06 19:06:58 +00:00
|
|
|
const recipe_ordinal r = get(Recipe_ordinal, current_recipe_name());
|
2016-03-13 03:24:38 +00:00
|
|
|
const recipe& exiting_recipe = get(Recipe, r);
|
|
|
|
if (exiting_recipe.steps.empty()) return;
|
|
|
|
const instruction& inst = exiting_recipe.steps.at(0);
|
2015-10-30 00:15:09 +00:00
|
|
|
if (inst.old_name != "local-scope") return;
|
2016-03-13 04:41:35 +00:00
|
|
|
// reclaim any local variables unless they're being returned
|
2016-05-18 23:45:32 +00:00
|
|
|
vector<double> zeros;
|
|
|
|
for (int i = /*leave default space for last*/1; i < SIZE(exiting_recipe.steps); ++i) {
|
|
|
|
const instruction& inst = exiting_recipe.steps.at(i);
|
|
|
|
for (int i = 0; i < SIZE(inst.products); ++i) {
|
|
|
|
// local variables only
|
|
|
|
if (has_property(inst.products.at(i), "space")) continue;
|
|
|
|
if (has_property(inst.products.at(i), "lookup")) continue;
|
|
|
|
if (has_property(inst.products.at(i), "raw")) continue; // tests often want to check such locations after they run
|
|
|
|
if (escaping(inst.products.at(i))) continue;
|
|
|
|
trace(9999, "mem") << "clearing " << inst.products.at(i).original_string << end();
|
|
|
|
zeros.resize(size_of(inst.products.at(i)));
|
2016-08-16 21:52:05 +00:00
|
|
|
write_memory(inst.products.at(i), zeros);
|
2016-05-18 23:45:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
trace(9999, "mem") << "automatically abandoning " << current_call().default_space << end();
|
2015-10-28 13:27:01 +00:00
|
|
|
abandon(current_call().default_space,
|
2016-05-18 01:32:41 +00:00
|
|
|
inst.products.at(0).type->right,
|
2016-01-21 04:47:54 +00:00
|
|
|
/*refcount*/1 + /*array length*/1 + /*number-of-locals*/Name[r][""]);
|
2015-07-14 05:43:16 +00:00
|
|
|
}
|
|
|
|
|
2016-08-16 21:41:49 +00:00
|
|
|
:(code)
|
|
|
|
// is this reagent one of the values returned by the current (reply) instruction?
|
|
|
|
// is the corresponding ingredient saved in the caller?
|
|
|
|
bool escaping(const reagent& r) {
|
|
|
|
assert(Current_routine); // run-time only
|
|
|
|
// nothing escapes when you fall through past end of recipe
|
|
|
|
if (current_step_index() >= SIZE(Current_routine->steps())) return false;
|
|
|
|
for (long long i = 0; i < SIZE(current_instruction().ingredients); ++i) {
|
|
|
|
if (r == current_instruction().ingredients.at(i)) {
|
|
|
|
if (caller_uses_product(i))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-05-18 23:45:32 +00:00
|
|
|
//: since we don't decrement refcounts for escaping values above, make sure we
|
|
|
|
//: don't increment them when the caller saves them either
|
|
|
|
|
2016-08-16 21:52:05 +00:00
|
|
|
:(after "Write Products of Instruction")
|
|
|
|
Update_refcounts_in_write_memory = should_update_refcounts_in_write_memory();
|
|
|
|
:(before "End Write Products of Instruction")
|
|
|
|
Update_refcounts_in_write_memory = true;
|
|
|
|
:(code)
|
|
|
|
bool should_update_refcounts_in_write_memory() {
|
2016-05-18 23:45:32 +00:00
|
|
|
const instruction& inst = current_instruction();
|
2016-08-17 00:03:27 +00:00
|
|
|
// End should_update_refcounts_in_write_memory Special-cases For Primitives
|
2016-05-18 23:45:32 +00:00
|
|
|
if (inst.operation < MAX_PRIMITIVE_RECIPES) return true;
|
|
|
|
if (!contains_key(Recipe, inst.operation)) return true;
|
|
|
|
const recipe& caller = get(Recipe, inst.operation);
|
|
|
|
if (caller.steps.empty()) return true;
|
2016-08-17 00:03:27 +00:00
|
|
|
return caller.steps.at(0).old_name != "local-scope"; // callees that call local-scope are already dealt with before return
|
2016-05-18 23:45:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool caller_uses_product(int product_index) {
|
|
|
|
assert(Current_routine); // run-time only
|
|
|
|
assert(!Current_routine->calls.empty());
|
|
|
|
if (Current_routine->calls.size() == 1) return false;
|
|
|
|
const call& caller = *++Current_routine->calls.begin();
|
|
|
|
const instruction& caller_inst = to_instruction(caller);
|
|
|
|
if (product_index >= SIZE(caller_inst.products)) return false;
|
|
|
|
return !is_dummy(caller_inst.products.at(product_index));
|
|
|
|
}
|
|
|
|
|
2015-07-14 05:43:16 +00:00
|
|
|
void rewrite_default_space_instruction(instruction& curr) {
|
|
|
|
if (!curr.ingredients.empty())
|
2016-03-21 09:25:52 +00:00
|
|
|
raise << to_original_string(curr) << " can't take any ingredients\n" << end();
|
2015-10-30 00:15:09 +00:00
|
|
|
curr.name = "new";
|
2015-07-14 05:43:16 +00:00
|
|
|
curr.ingredients.push_back(reagent("location:type"));
|
|
|
|
curr.ingredients.push_back(reagent("number-of-locals:literal"));
|
|
|
|
if (!curr.products.empty())
|
2016-02-26 21:04:55 +00:00
|
|
|
raise << "new-default-space can't take any results\n" << end();
|
2016-04-24 18:54:30 +00:00
|
|
|
curr.products.push_back(reagent("default-space:address:array:location"));
|
2015-07-14 05:43:16 +00:00
|
|
|
}
|
2016-01-28 03:59:29 +00:00
|
|
|
|
2016-05-18 23:45:32 +00:00
|
|
|
:(scenario local_scope_frees_up_addresses_inside_containers)
|
|
|
|
container foo [
|
|
|
|
x:number
|
|
|
|
y:address:number
|
|
|
|
]
|
|
|
|
def main [
|
|
|
|
local-scope
|
|
|
|
x:address:number <- new number:type
|
2016-05-19 00:05:22 +00:00
|
|
|
y:foo <- merge 34, x:address:number
|
2016-05-18 23:45:32 +00:00
|
|
|
# x and y are both cleared when main returns
|
|
|
|
]
|
|
|
|
+mem: clearing x:address:number
|
|
|
|
+mem: decrementing refcount of 1006: 2 -> 1
|
|
|
|
+mem: clearing y:foo
|
|
|
|
+mem: decrementing refcount of 1006: 1 -> 0
|
|
|
|
+mem: automatically abandoning 1006
|
|
|
|
|
|
|
|
:(scenario local_scope_returns_addresses_inside_containers)
|
|
|
|
container foo [
|
|
|
|
x:number
|
|
|
|
y:address:number
|
|
|
|
]
|
|
|
|
def f [
|
|
|
|
local-scope
|
|
|
|
x:address:number <- new number:type
|
2016-05-19 00:05:22 +00:00
|
|
|
*x:address:number <- copy 12
|
|
|
|
y:foo <- merge 34, x:address:number
|
2016-05-18 23:45:32 +00:00
|
|
|
# since y is 'escaping' f, it should not be cleared
|
2016-05-19 00:05:22 +00:00
|
|
|
return y:foo
|
2016-05-18 23:45:32 +00:00
|
|
|
]
|
|
|
|
def main [
|
|
|
|
1:foo <- f
|
|
|
|
3:number <- get 1:foo, x:offset
|
|
|
|
4:address:number <- get 1:foo, y:offset
|
|
|
|
5:number <- copy *4:address:number
|
|
|
|
1:foo <- put 1:foo, y:offset, 0
|
|
|
|
4:address:number <- copy 0
|
|
|
|
]
|
|
|
|
+mem: storing 34 in location 1
|
|
|
|
+mem: storing 1006 in location 2
|
|
|
|
+mem: storing 34 in location 3
|
|
|
|
# refcount of 1:foo shouldn't include any stray ones from f
|
|
|
|
+run: {4: ("address" "number")} <- get {1: "foo"}, {y: "offset"}
|
|
|
|
+mem: incrementing refcount of 1006: 1 -> 2
|
|
|
|
# 1:foo wasn't abandoned/cleared
|
|
|
|
+run: {5: "number"} <- copy {4: ("address" "number"), "lookup": ()}
|
|
|
|
+mem: storing 12 in location 5
|
|
|
|
+run: {1: "foo"} <- put {1: "foo"}, {y: "offset"}, {0: "literal"}
|
|
|
|
+mem: decrementing refcount of 1006: 2 -> 1
|
|
|
|
+run: {4: ("address" "number")} <- copy {0: "literal"}
|
|
|
|
+mem: decrementing refcount of 1006: 1 -> 0
|
|
|
|
+mem: automatically abandoning 1006
|
|
|
|
|
|
|
|
:(scenario local_scope_claims_return_values_when_not_saved)
|
|
|
|
def f [
|
|
|
|
local-scope
|
|
|
|
x:address:number <- new number:type
|
|
|
|
reply x:address:number
|
|
|
|
]
|
|
|
|
def main [
|
|
|
|
f # doesn't save result
|
|
|
|
]
|
|
|
|
# x reclaimed
|
|
|
|
+mem: automatically abandoning 1004
|
|
|
|
# f's local scope reclaimed
|
|
|
|
+mem: automatically abandoning 1000
|
|
|
|
|
2016-01-28 03:59:29 +00:00
|
|
|
//:: all recipes must set default-space one way or another
|
|
|
|
|
|
|
|
:(before "End Globals")
|
2016-02-25 16:24:14 +00:00
|
|
|
bool Hide_missing_default_space_errors = true;
|
2016-01-28 03:59:29 +00:00
|
|
|
:(before "End Checks")
|
|
|
|
Transform.push_back(check_default_space); // idempotent
|
|
|
|
:(code)
|
|
|
|
void check_default_space(const recipe_ordinal r) {
|
2016-02-25 16:24:14 +00:00
|
|
|
if (Hide_missing_default_space_errors) return; // skip previous core tests; this is only for mu code
|
2016-01-28 03:59:29 +00:00
|
|
|
const recipe& caller = get(Recipe, r);
|
|
|
|
// skip scenarios (later layer)
|
|
|
|
// user code should never create recipes with underscores in their names
|
|
|
|
if (caller.name.find("scenario_") == 0) return; // skip mu scenarios which will use raw memory locations
|
|
|
|
if (caller.name.find("run_") == 0) return; // skip calls to 'run', which should be in scenarios and will also use raw memory locations
|
|
|
|
// assume recipes with only numeric addresses know what they're doing (usually tests)
|
|
|
|
if (!contains_non_special_name(r)) return;
|
|
|
|
trace(9991, "transform") << "--- check that recipe " << caller.name << " sets default-space" << end();
|
|
|
|
if (caller.steps.empty()) return;
|
|
|
|
if (caller.steps.at(0).products.empty()
|
|
|
|
|| caller.steps.at(0).products.at(0).name != "default-space") {
|
2016-05-21 05:09:06 +00:00
|
|
|
raise << caller.name << " does not seem to start with default-space or local-scope\n" << end();
|
2016-01-28 03:59:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
:(after "Load .mu Core")
|
2016-02-25 16:24:14 +00:00
|
|
|
Hide_missing_default_space_errors = false;
|
2016-01-28 03:59:29 +00:00
|
|
|
:(after "Test Runs")
|
2016-02-25 16:24:14 +00:00
|
|
|
Hide_missing_default_space_errors = true;
|
2016-01-28 03:59:29 +00:00
|
|
|
:(after "Running Main")
|
2016-02-25 16:24:14 +00:00
|
|
|
Hide_missing_default_space_errors = false;
|
2016-01-28 03:59:29 +00:00
|
|
|
|
|
|
|
:(code)
|
|
|
|
bool contains_non_special_name(const recipe_ordinal r) {
|
2016-03-14 03:26:47 +00:00
|
|
|
for (map<string, int>::iterator p = Name[r].begin(); p != Name[r].end(); ++p) {
|
2016-01-28 03:59:29 +00:00
|
|
|
if (p->first.empty()) continue;
|
2016-02-10 23:46:50 +00:00
|
|
|
if (p->first.find("stash_") == 0) continue; // generated by rewrite_stashes_to_text (cross-layer)
|
2016-02-26 04:47:42 +00:00
|
|
|
if (!is_special_name(p->first))
|
2016-01-28 03:59:29 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2016-03-05 03:22:09 +00:00
|
|
|
|
|
|
|
// reagent comparison -- only between reagents in a single recipe
|
|
|
|
bool operator==(const reagent& a, const reagent& b) {
|
|
|
|
if (a.name != b.name) return false;
|
|
|
|
if (property(a, "space") != property(b, "space")) return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator<(const reagent& a, const reagent& b) {
|
2016-03-14 03:26:47 +00:00
|
|
|
int aspace = 0, bspace = 0;
|
2016-03-05 03:22:09 +00:00
|
|
|
if (has_property(a, "space")) aspace = to_integer(property(a, "space")->value);
|
|
|
|
if (has_property(b, "space")) bspace = to_integer(property(b, "space")->value);
|
|
|
|
if (aspace != bspace) return aspace < bspace;
|
|
|
|
return a.name < b.name;
|
|
|
|
}
|