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)
|
2015-03-29 17:21:15 +00:00
|
|
|
# if default-space is 10, and if an array of 5 locals lies from location 11 to 15 (inclusive),
|
|
|
|
# then location 0 is really location 11, location 1 is really location 12, and so on.
|
2015-03-22 00:53:20 +00:00
|
|
|
recipe main [
|
2015-05-13 17:03:26 +00:00
|
|
|
10:number <- copy 5:literal # pretend array; in practice we'll use new
|
2015-04-19 07:21:24 +00:00
|
|
|
default-space:address:array:location <- copy 10:literal
|
2015-05-13 17:03:26 +00:00
|
|
|
1:number <- copy 23:literal
|
2015-03-22 00:53:20 +00:00
|
|
|
]
|
2015-03-29 03:50:23 +00:00
|
|
|
+mem: storing 23 in location 12
|
2015-03-22 00:53:20 +00:00
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario deref_sidesteps_default_space)
|
2015-04-03 18:42:50 +00:00
|
|
|
recipe main [
|
|
|
|
# pretend pointer from outside
|
2015-05-13 17:03:26 +00:00
|
|
|
3:number <- copy 34:literal
|
2015-04-03 18:42:50 +00:00
|
|
|
# pretend array
|
2015-05-13 17:03:26 +00:00
|
|
|
1000:number <- copy 5:literal
|
2015-05-19 17:38:23 +00:00
|
|
|
# actual start of this recipe
|
2015-04-19 07:21:24 +00:00
|
|
|
default-space:address:array:location <- copy 1000:literal
|
2015-05-13 17:03:26 +00:00
|
|
|
1:address:number <- copy 3:literal
|
|
|
|
8:number/raw <- copy 1:address:number/deref
|
2015-04-03 18:42:50 +00:00
|
|
|
]
|
|
|
|
+mem: storing 34 in location 8
|
|
|
|
|
2015-04-13 03:56:45 +00:00
|
|
|
:(before "End call Fields")
|
2015-05-17 09:22:41 +00:00
|
|
|
long long int default_space;
|
2015-03-22 00:53:20 +00:00
|
|
|
:(replace "call(recipe_number r) :running_recipe(r)")
|
2015-04-25 03:41:37 +00:00
|
|
|
call(recipe_number r) :running_recipe(r), running_step_index(0), next_ingredient_to_process(0), default_space(0) {}
|
2015-03-22 00:53:20 +00:00
|
|
|
|
|
|
|
:(replace "reagent r = x" following "reagent canonize(reagent x)")
|
|
|
|
reagent r = absolutize(x);
|
|
|
|
:(code)
|
|
|
|
reagent absolutize(reagent x) {
|
2015-04-15 02:06:57 +00:00
|
|
|
//? if (Recipe_number.find("increment-counter") != Recipe_number.end()) //? 1
|
2015-05-07 22:06:53 +00:00
|
|
|
//? cout << "AAA " << "increment-counter/2: " << Recipe[Recipe_number["increment-counter"]].steps.at(2).products.at(0).to_string() << '\n'; //? 1
|
2015-04-18 04:51:13 +00:00
|
|
|
//? cout << "absolutize " << x.to_string() << '\n'; //? 4
|
2015-04-03 18:42:50 +00:00
|
|
|
//? cout << is_raw(x) << '\n'; //? 1
|
2015-03-22 00:53:20 +00:00
|
|
|
if (is_raw(x) || is_dummy(x)) return x;
|
|
|
|
//? cout << "not raw: " << x.to_string() << '\n'; //? 1
|
|
|
|
assert(x.initialized);
|
|
|
|
reagent r = x;
|
2015-05-13 00:00:56 +00:00
|
|
|
r.set_value(address(r.value, space_base(r)));
|
2015-03-22 00:53:20 +00:00
|
|
|
//? cout << "after absolutize: " << r.value << '\n'; //? 1
|
|
|
|
r.properties.push_back(pair<string, vector<string> >("raw", vector<string>()));
|
|
|
|
assert(is_raw(r));
|
|
|
|
return r;
|
|
|
|
}
|
2015-04-03 18:42:50 +00:00
|
|
|
:(before "return result" following "reagent deref(reagent x)")
|
|
|
|
result.properties.push_back(pair<string, vector<string> >("raw", vector<string>()));
|
2015-03-22 00:53:20 +00:00
|
|
|
|
2015-04-18 06:24:52 +00:00
|
|
|
//:: fix 'get'
|
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario deref_sidesteps_default_space_in_get)
|
2015-04-18 04:51:13 +00:00
|
|
|
recipe main [
|
|
|
|
# pretend pointer to container from outside
|
2015-05-13 17:03:26 +00:00
|
|
|
12:number <- copy 34:literal
|
|
|
|
13:number <- copy 35:literal
|
2015-04-18 04:51:13 +00:00
|
|
|
# pretend array
|
2015-05-13 17:03:26 +00:00
|
|
|
1000:number <- copy 5:literal
|
2015-05-19 17:38:23 +00:00
|
|
|
# actual start of this recipe
|
2015-04-19 07:21:24 +00:00
|
|
|
default-space:address:array:location <- copy 1000:literal
|
2015-04-18 04:51:13 +00:00
|
|
|
1:address:point <- copy 12:literal
|
2015-05-13 17:03:26 +00:00
|
|
|
9:number/raw <- get 1:address:point/deref, 1:offset
|
2015-04-18 04:51:13 +00:00
|
|
|
]
|
|
|
|
+mem: storing 35 in location 9
|
|
|
|
|
|
|
|
:(after "reagent tmp" following "case GET:")
|
|
|
|
tmp.properties.push_back(pair<string, vector<string> >("raw", vector<string>()));
|
|
|
|
|
2015-04-18 06:24:52 +00:00
|
|
|
//:: fix 'index'
|
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario deref_sidesteps_default_space_in_index)
|
2015-04-18 04:51:13 +00:00
|
|
|
recipe main [
|
|
|
|
# pretend pointer to array from outside
|
2015-05-13 17:03:26 +00:00
|
|
|
12:number <- copy 2:literal
|
|
|
|
13:number <- copy 34:literal
|
|
|
|
14:number <- copy 35:literal
|
2015-04-18 04:51:13 +00:00
|
|
|
# pretend array
|
2015-05-13 17:03:26 +00:00
|
|
|
1000:number <- copy 5:literal
|
2015-05-19 17:38:23 +00:00
|
|
|
# actual start of this recipe
|
2015-04-19 07:21:24 +00:00
|
|
|
default-space:address:array:location <- copy 1000:literal
|
2015-05-13 17:03:26 +00:00
|
|
|
1:address:array:number <- copy 12:literal
|
|
|
|
9:number/raw <- index 1:address:array:number/deref, 1:literal
|
2015-04-18 04:51:13 +00:00
|
|
|
]
|
|
|
|
+mem: storing 35 in location 9
|
|
|
|
|
|
|
|
:(after "reagent tmp" following "case INDEX:")
|
|
|
|
tmp.properties.push_back(pair<string, vector<string> >("raw", vector<string>()));
|
|
|
|
|
2015-04-18 06:24:52 +00:00
|
|
|
//:: helpers
|
|
|
|
|
2015-04-03 18:42:50 +00:00
|
|
|
:(code)
|
2015-05-17 09:22:41 +00:00
|
|
|
long long int space_base(const reagent& x) {
|
2015-05-13 23:33:40 +00:00
|
|
|
return Current_routine->calls.front().default_space;
|
2015-03-29 03:57:21 +00:00
|
|
|
}
|
|
|
|
|
2015-05-17 09:22:41 +00:00
|
|
|
long long int address(long long int offset, long long int base) {
|
2015-03-29 03:50:23 +00:00
|
|
|
if (base == 0) return offset; // raw
|
2015-04-30 07:02:54 +00:00
|
|
|
//? cout << base << '\n'; //? 2
|
2015-05-17 09:22:41 +00:00
|
|
|
if (offset >= static_cast<long long int>(Memory[base])) {
|
2015-03-29 17:21:15 +00:00
|
|
|
// todo: test
|
2015-05-13 00:00:56 +00:00
|
|
|
raise << "location " << offset << " is out of bounds " << Memory[base] << '\n';
|
2015-03-29 17:21:15 +00:00
|
|
|
}
|
2015-05-13 00:00:56 +00:00
|
|
|
return base+1 + offset;
|
2015-03-29 03:50:23 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 01:08:47 +00:00
|
|
|
:(after "void write_memory(reagent x, vector<double> data)")
|
2015-03-22 00:53:20 +00:00
|
|
|
if (x.name == "default-space") {
|
2015-05-17 09:22:41 +00:00
|
|
|
assert(scalar(data));
|
2015-05-13 23:33:40 +00:00
|
|
|
Current_routine->calls.front().default_space = data.at(0);
|
|
|
|
//? cout << "AAA " << Current_routine->calls.front().default_space << '\n'; //? 1
|
2015-03-22 00:53:20 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-04-15 00:46:43 +00:00
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario get_default_space)
|
2015-04-15 00:46:43 +00:00
|
|
|
recipe main [
|
2015-04-19 07:21:24 +00:00
|
|
|
default-space:address:array:location <- copy 10:literal
|
2015-05-13 17:03:26 +00:00
|
|
|
1:number/raw <- copy default-space:address:array:location
|
2015-04-15 00:46:43 +00:00
|
|
|
]
|
|
|
|
+mem: storing 10 in location 1
|
|
|
|
|
2015-05-13 01:08:47 +00:00
|
|
|
:(after "vector<double> read_memory(reagent x)")
|
2015-04-15 00:46:43 +00:00
|
|
|
if (x.name == "default-space") {
|
2015-05-13 01:08:47 +00:00
|
|
|
vector<double> result;
|
2015-05-13 23:33:40 +00:00
|
|
|
result.push_back(Current_routine->calls.front().default_space);
|
2015-04-15 00:46:43 +00:00
|
|
|
return result;
|
|
|
|
}
|