2015-04-17 18:22:59 +00:00
|
|
|
//: So far the recipes we define can't run each other. Let's fix that.
|
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario calling_recipe)
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2015-03-14 00:39:32 +00:00
|
|
|
f
|
|
|
|
]
|
2016-03-08 09:30:14 +00:00
|
|
|
def f [
|
2016-09-17 07:43:13 +00:00
|
|
|
3:num <- add 2, 2
|
2015-03-14 00:39:32 +00:00
|
|
|
]
|
2015-03-24 06:59:59 +00:00
|
|
|
+mem: storing 4 in location 3
|
2015-03-14 07:07:44 +00:00
|
|
|
|
2015-04-24 17:19:03 +00:00
|
|
|
:(scenario return_on_fallthrough)
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2015-04-23 05:34:34 +00:00
|
|
|
f
|
2016-09-17 07:43:13 +00:00
|
|
|
1:num <- copy 0
|
|
|
|
2:num <- copy 0
|
|
|
|
3:num <- copy 0
|
2015-04-23 05:34:34 +00:00
|
|
|
]
|
2016-03-08 09:30:14 +00:00
|
|
|
def f [
|
2016-09-17 07:43:13 +00:00
|
|
|
4:num <- copy 0
|
|
|
|
5:num <- copy 0
|
2015-04-23 05:34:34 +00:00
|
|
|
]
|
2015-05-21 19:36:59 +00:00
|
|
|
+run: f
|
|
|
|
# running f
|
2016-03-21 09:25:52 +00:00
|
|
|
+run: {4: "number"} <- copy {0: "literal"}
|
|
|
|
+run: {5: "number"} <- copy {0: "literal"}
|
2015-05-21 19:36:59 +00:00
|
|
|
# back out to main
|
2016-03-21 09:25:52 +00:00
|
|
|
+run: {1: "number"} <- copy {0: "literal"}
|
|
|
|
+run: {2: "number"} <- copy {0: "literal"}
|
|
|
|
+run: {3: "number"} <- copy {0: "literal"}
|
2015-04-23 05:34:34 +00:00
|
|
|
|
2015-03-15 16:43:05 +00:00
|
|
|
:(before "struct routine {")
|
|
|
|
// Everytime a recipe runs another, we interrupt it and start running the new
|
|
|
|
// recipe. When that finishes, we continue this one where we left off.
|
|
|
|
// This requires maintaining a 'stack' of interrupted recipes or 'calls'.
|
|
|
|
struct call {
|
2015-07-04 16:40:50 +00:00
|
|
|
recipe_ordinal running_recipe;
|
2016-03-14 03:26:47 +00:00
|
|
|
int running_step_index;
|
2015-04-13 03:56:45 +00:00
|
|
|
// End call Fields
|
2017-12-04 08:08:02 +00:00
|
|
|
call(recipe_ordinal r) { clear(r, 0); }
|
|
|
|
call(recipe_ordinal r, int index) { clear(r, index); }
|
|
|
|
void clear(recipe_ordinal r, int index) {
|
2015-05-24 00:58:10 +00:00
|
|
|
running_recipe = r;
|
2017-12-04 08:08:02 +00:00
|
|
|
running_step_index = index;
|
2015-05-24 00:58:10 +00:00
|
|
|
// End call Constructor
|
|
|
|
}
|
2015-10-28 20:08:26 +00:00
|
|
|
~call() {
|
|
|
|
// End call Destructor
|
|
|
|
}
|
2015-03-15 16:43:05 +00:00
|
|
|
};
|
2015-05-13 23:33:40 +00:00
|
|
|
typedef list<call> call_stack;
|
2015-03-15 16:43:05 +00:00
|
|
|
|
|
|
|
:(replace{} "struct routine")
|
|
|
|
struct routine {
|
|
|
|
call_stack calls;
|
2015-04-13 03:56:45 +00:00
|
|
|
// End routine Fields
|
2015-07-04 16:40:50 +00:00
|
|
|
routine(recipe_ordinal r);
|
2015-04-25 03:00:56 +00:00
|
|
|
bool completed() const;
|
2015-04-25 03:52:06 +00:00
|
|
|
const vector<instruction>& steps() const;
|
2015-03-27 17:51:27 +00:00
|
|
|
};
|
|
|
|
:(code)
|
2015-07-04 16:40:50 +00:00
|
|
|
routine::routine(recipe_ordinal r) {
|
2015-10-19 22:07:54 +00:00
|
|
|
if (Trace_stream) {
|
|
|
|
++Trace_stream->callstack_depth;
|
2017-11-03 08:50:46 +00:00
|
|
|
trace("trace") << "new routine; incrementing callstack depth to " << Trace_stream->callstack_depth << end();
|
2015-10-19 22:07:54 +00:00
|
|
|
assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion
|
|
|
|
}
|
2015-05-13 23:33:40 +00:00
|
|
|
calls.push_front(call(r));
|
2015-04-27 01:17:39 +00:00
|
|
|
// End routine Constructor
|
2015-04-25 05:24:39 +00:00
|
|
|
}
|
2015-04-18 06:24:52 +00:00
|
|
|
|
|
|
|
//:: now update routine's helpers
|
|
|
|
|
2017-11-01 09:46:41 +00:00
|
|
|
//: macro versions for a slight speedup
|
|
|
|
|
3898
There seems to be some chance of speed-up when I inline these functions.
However, it's not a clear enough signal to justify improving the `build`
script to handle the `inline` keyword.
Current timing experiments:
Before After
ubuntu 1GB 9:22,8:48,8:51,9:16,9:17,8:36,9:05 8:55,8:41,8:15,8:27,8:29,8:54,9:29
OS X 8GB 4:05,4:00,4:18,4:09,3:40,3:51,3:56 3:58,3:52,4:01,4:13,4:16,4:31,4:13
2017-05-30 14:34:58 +00:00
|
|
|
:(delete{} "int& current_step_index()")
|
|
|
|
:(delete{} "recipe_ordinal currently_running_recipe()")
|
|
|
|
:(delete{} "const string& current_recipe_name()")
|
|
|
|
:(delete{} "const recipe& current_recipe()")
|
|
|
|
:(delete{} "const instruction& current_instruction()")
|
|
|
|
|
|
|
|
:(before "End Includes")
|
|
|
|
#define current_call() Current_routine->calls.front()
|
|
|
|
#define current_step_index() current_call().running_step_index
|
|
|
|
#define currently_running_recipe() current_call().running_recipe
|
|
|
|
#define current_recipe() get(Recipe, currently_running_recipe())
|
|
|
|
#define current_recipe_name() current_recipe().name
|
|
|
|
#define to_instruction(call) get(Recipe, (call).running_recipe).steps.at((call).running_step_index)
|
|
|
|
#define current_instruction() to_instruction(current_call())
|
2015-03-15 05:25:06 +00:00
|
|
|
|
2017-11-01 09:46:41 +00:00
|
|
|
//: function versions for debugging
|
|
|
|
|
|
|
|
:(code)
|
|
|
|
//? :(before "End Globals")
|
|
|
|
//? bool Foo2 = false;
|
|
|
|
//? :(code)
|
|
|
|
//? call& current_call() {
|
|
|
|
//? if (Foo2) cerr << __FUNCTION__ << '\n';
|
|
|
|
//? return Current_routine->calls.front();
|
|
|
|
//? }
|
|
|
|
//? :(replace{} "int& current_step_index()")
|
|
|
|
//? int& current_step_index() {
|
|
|
|
//? assert(!Current_routine->calls.empty());
|
|
|
|
//? if (Foo2) cerr << __FUNCTION__ << '\n';
|
|
|
|
//? return current_call().running_step_index;
|
|
|
|
//? }
|
|
|
|
//? :(replace{} "recipe_ordinal currently_running_recipe()")
|
|
|
|
//? recipe_ordinal currently_running_recipe() {
|
|
|
|
//? assert(!Current_routine->calls.empty());
|
|
|
|
//? if (Foo2) cerr << __FUNCTION__ << '\n';
|
|
|
|
//? return current_call().running_recipe;
|
|
|
|
//? }
|
|
|
|
//? :(replace{} "const string& current_recipe_name()")
|
|
|
|
//? const string& current_recipe_name() {
|
|
|
|
//? assert(!Current_routine->calls.empty());
|
|
|
|
//? if (Foo2) cerr << __FUNCTION__ << '\n';
|
|
|
|
//? return get(Recipe, current_call().running_recipe).name;
|
|
|
|
//? }
|
|
|
|
//? :(replace{} "const recipe& current_recipe()")
|
|
|
|
//? const recipe& current_recipe() {
|
|
|
|
//? assert(!Current_routine->calls.empty());
|
|
|
|
//? if (Foo2) cerr << __FUNCTION__ << '\n';
|
|
|
|
//? return get(Recipe, current_call().running_recipe);
|
|
|
|
//? }
|
|
|
|
//? :(replace{} "const instruction& current_instruction()")
|
|
|
|
//? const instruction& current_instruction() {
|
|
|
|
//? assert(!Current_routine->calls.empty());
|
|
|
|
//? if (Foo2) cerr << __FUNCTION__ << '\n';
|
|
|
|
//? return to_instruction(current_call());
|
|
|
|
//? }
|
|
|
|
//? :(code)
|
|
|
|
//? const instruction& to_instruction(const call& call) {
|
|
|
|
//? return get(Recipe, call.running_recipe).steps.at(call.running_step_index);
|
|
|
|
//? }
|
|
|
|
|
2018-02-20 09:11:22 +00:00
|
|
|
:(code)
|
|
|
|
void dump_callstack() {
|
|
|
|
if (!Current_routine) return;
|
|
|
|
if (Current_routine->calls.size() <= 1) return;
|
|
|
|
for (call_stack::const_iterator p = ++Current_routine->calls.begin(); p != Current_routine->calls.end(); ++p)
|
|
|
|
raise << " called from " << get(Recipe, p->running_recipe).name << ": " << to_original_string(to_instruction(*p)) << '\n' << end();
|
|
|
|
}
|
|
|
|
|
2015-10-02 06:44:17 +00:00
|
|
|
:(after "Defined Recipe Checks")
|
|
|
|
// not a primitive; check that it's present in the book of recipes
|
2015-11-06 21:22:16 +00:00
|
|
|
if (!contains_key(Recipe, inst.operation)) {
|
2017-05-26 23:43:18 +00:00
|
|
|
raise << maybe(get(Recipe, r).name) << "undefined operation in '" << to_original_string(inst) << "'\n" << end();
|
2015-10-02 06:44:17 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-04-13 03:47:49 +00:00
|
|
|
:(replace{} "default:" following "End Primitive Recipe Implementations")
|
2015-03-15 00:10:33 +00:00
|
|
|
default: {
|
2017-05-28 21:28:07 +00:00
|
|
|
if (contains_key(Recipe, current_instruction().operation)) { // error already raised in Checks above
|
|
|
|
// not a primitive; look up the book of recipes
|
|
|
|
if (Trace_stream) {
|
|
|
|
++Trace_stream->callstack_depth;
|
2017-11-03 08:50:46 +00:00
|
|
|
trace("trace") << "incrementing callstack depth to " << Trace_stream->callstack_depth << end();
|
2017-05-28 21:28:07 +00:00
|
|
|
assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion
|
|
|
|
}
|
2017-05-29 07:02:59 +00:00
|
|
|
const call& caller_frame = current_call();
|
|
|
|
Current_routine->calls.push_front(call(to_instruction(caller_frame).operation));
|
|
|
|
finish_call_housekeeping(to_instruction(caller_frame), ingredients);
|
2017-05-28 21:28:07 +00:00
|
|
|
// not done with caller
|
|
|
|
write_products = false;
|
|
|
|
fall_through_to_next_instruction = false;
|
2017-05-29 07:02:59 +00:00
|
|
|
// End Non-primitive Call(caller_frame)
|
2015-10-05 04:29:58 +00:00
|
|
|
}
|
2016-01-18 17:13:02 +00:00
|
|
|
}
|
|
|
|
:(code)
|
|
|
|
void finish_call_housekeeping(const instruction& call_instruction, const vector<vector<double> >& ingredients) {
|
2015-10-28 12:40:27 +00:00
|
|
|
// End Call Housekeeping
|
|
|
|
}
|
2015-03-15 00:10:33 +00:00
|
|
|
|
2015-10-07 05:15:45 +00:00
|
|
|
:(scenario calling_undefined_recipe_fails)
|
|
|
|
% Hide_errors = true;
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2015-08-01 01:25:08 +00:00
|
|
|
foo
|
|
|
|
]
|
2017-04-04 07:10:47 +00:00
|
|
|
+error: main: undefined operation in 'foo'
|
2015-08-01 01:25:08 +00:00
|
|
|
|
|
|
|
:(scenario calling_undefined_recipe_handles_missing_result)
|
2015-10-07 05:15:45 +00:00
|
|
|
% Hide_errors = true;
|
2016-03-08 09:30:14 +00:00
|
|
|
def main [
|
2016-09-17 07:43:13 +00:00
|
|
|
x:num <- foo
|
2015-08-01 01:25:08 +00:00
|
|
|
]
|
2017-04-04 07:10:47 +00:00
|
|
|
+error: main: undefined operation in 'x:num <- foo'
|
2015-08-01 01:25:08 +00:00
|
|
|
|
2015-04-18 06:24:52 +00:00
|
|
|
//:: finally, we need to fix the termination conditions for the run loop
|
2015-03-17 03:41:12 +00:00
|
|
|
|
2016-08-29 21:58:16 +00:00
|
|
|
:(replace{} "bool routine::completed() const")
|
|
|
|
bool routine::completed() const {
|
2015-04-25 03:00:56 +00:00
|
|
|
return calls.empty();
|
2015-03-14 07:07:44 +00:00
|
|
|
}
|
2015-03-14 08:09:20 +00:00
|
|
|
|
2016-08-29 21:58:16 +00:00
|
|
|
:(replace{} "const vector<instruction>& routine::steps() const")
|
|
|
|
const vector<instruction>& routine::steps() const {
|
2015-05-13 23:33:40 +00:00
|
|
|
assert(!calls.empty());
|
2015-11-06 19:06:58 +00:00
|
|
|
return get(Recipe, calls.front().running_recipe).steps;
|
2015-04-25 03:52:06 +00:00
|
|
|
}
|
|
|
|
|
2017-03-20 23:53:36 +00:00
|
|
|
:(after "Running One Instruction")
|
2015-03-15 16:43:05 +00:00
|
|
|
// when we reach the end of one call, we may reach the end of the one below
|
|
|
|
// it, and the one below that, and so on
|
2015-05-17 09:22:41 +00:00
|
|
|
while (current_step_index() >= SIZE(Current_routine->steps())) {
|
2015-07-08 20:26:02 +00:00
|
|
|
// Falling Through End Of Recipe
|
2015-10-19 22:07:54 +00:00
|
|
|
if (Trace_stream) {
|
2017-11-03 08:50:46 +00:00
|
|
|
trace("trace") << "fall-through: exiting " << current_recipe_name() << "; decrementing callstack depth from " << Trace_stream->callstack_depth << end();
|
2015-10-19 22:07:54 +00:00
|
|
|
--Trace_stream->callstack_depth;
|
|
|
|
assert(Trace_stream->callstack_depth >= 0);
|
|
|
|
}
|
2015-05-13 23:33:40 +00:00
|
|
|
Current_routine->calls.pop_front();
|
2016-07-07 01:47:37 +00:00
|
|
|
if (Current_routine->calls.empty()) goto stop_running_current_routine;
|
2015-07-08 21:47:12 +00:00
|
|
|
// Complete Call Fallthrough
|
2015-10-07 05:15:45 +00:00
|
|
|
// todo: fail if no products returned
|
2015-04-25 03:23:34 +00:00
|
|
|
++current_step_index();
|
2015-03-14 08:09:20 +00:00
|
|
|
}
|
2017-11-19 10:36:35 +00:00
|
|
|
|
|
|
|
:(before "End Primitive Recipe Declarations")
|
|
|
|
_DUMP_CALL_STACK,
|
|
|
|
:(before "End Primitive Recipe Numbers")
|
|
|
|
put(Recipe_ordinal, "$dump-call-stack", _DUMP_CALL_STACK);
|
|
|
|
:(before "End Primitive Recipe Checks")
|
|
|
|
case _DUMP_CALL_STACK: {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
:(before "End Primitive Recipe Implementations")
|
|
|
|
case _DUMP_CALL_STACK: {
|
2017-12-07 21:45:01 +00:00
|
|
|
dump(Current_routine->calls);
|
2017-11-19 10:36:35 +00:00
|
|
|
break;
|
|
|
|
}
|
2017-12-07 21:45:01 +00:00
|
|
|
:(code)
|
|
|
|
void dump(const call_stack& calls) {
|
|
|
|
for (call_stack::const_reverse_iterator p = calls.rbegin(); p != calls.rend(); ++p)
|
|
|
|
cerr << get(Recipe, p->running_recipe).name << ":" << p->running_step_index << " -- " << to_string(to_instruction(*p)) << '\n';
|
|
|
|
}
|