1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
//: So far the recipes we define can't run each other. Let's fix that.
:(scenario calling_recipe)
def main [
f
]
def f [
3:num <- add 2, 2
]
+mem: storing 4 in location 3
:(scenario return_on_fallthrough)
def main [
f
1:num <- copy 0
2:num <- copy 0
3:num <- copy 0
]
def f [
4:num <- copy 0
5:num <- copy 0
]
+run: f
# running f
+run: {4: "number"} <- copy {0: "literal"}
+run: {5: "number"} <- copy {0: "literal"}
# back out to main
+run: {1: "number"} <- copy {0: "literal"}
+run: {2: "number"} <- copy {0: "literal"}
+run: {3: "number"} <- copy {0: "literal"}
:(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 {
recipe_ordinal running_recipe;
int running_step_index;
// End call Fields
call(recipe_ordinal r) { clear(r, 0); }
call(recipe_ordinal r, int index) { clear(r, index); }
void clear(recipe_ordinal r, int index) {
running_recipe = r;
running_step_index = index;
// End call Constructor
}
~call() {
// End call Destructor
}
};
typedef list<call> call_stack;
:(replace{} "struct routine")
struct routine {
call_stack calls;
// End routine Fields
routine(recipe_ordinal r);
bool completed() const;
const vector<instruction>& steps() const;
};
:(code)
routine::routine(recipe_ordinal r) {
if (Trace_stream) {
++Trace_stream->callstack_depth;
trace("trace") << "new routine; incrementing callstack depth to " << Trace_stream->callstack_depth << end();
assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion
}
calls.push_front(call(r));
// End routine Constructor
}
//:: now update routine's helpers
//: macro versions for a slight speedup
:(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())
//: 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);
//? }
:(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();
}
:(after "Defined Recipe Checks")
// not a primitive; check that it's present in the book of recipes
if (!contains_key(Recipe, inst.operation)) {
raise << maybe(get(Recipe, r).name) << "undefined operation in '" << to_original_string(inst) << "'\n" << end();
break;
}
:(replace{} "default:" following "End Primitive Recipe Implementations")
default: {
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;
trace("trace") << "incrementing callstack depth to " << Trace_stream->callstack_depth << end();
assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion
}
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);
// not done with caller
write_products = false;
fall_through_to_next_instruction = false;
// End Non-primitive Call(caller_frame)
}
}
:(code)
void finish_call_housekeeping(const instruction& call_instruction, const vector<vector<double> >& ingredients) {
// End Call Housekeeping
}
:(scenario calling_undefined_recipe_fails)
% Hide_errors = true;
def main [
foo
]
+error: main: undefined operation in 'foo'
:(scenario calling_undefined_recipe_handles_missing_result)
% Hide_errors = true;
def main [
x:num <- foo
]
+error: main: undefined operation in 'x:num <- foo'
//:: finally, we need to fix the termination conditions for the run loop
:(replace{} "bool routine::completed() const")
bool routine::completed() const {
return calls.empty();
}
:(replace{} "const vector<instruction>& routine::steps() const")
const vector<instruction>& routine::steps() const {
assert(!calls.empty());
return get(Recipe, calls.front().running_recipe).steps;
}
:(after "Running One Instruction")
// 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
while (current_step_index() >= SIZE(Current_routine->steps())) {
// Falling Through End Of Recipe
if (Trace_stream) {
trace("trace") << "fall-through: exiting " << current_recipe_name() << "; decrementing callstack depth from " << Trace_stream->callstack_depth << end();
--Trace_stream->callstack_depth;
assert(Trace_stream->callstack_depth >= 0);
}
Current_routine->calls.pop_front();
if (Current_routine->calls.empty()) goto stop_running_current_routine;
// Complete Call Fallthrough
// todo: fail if no products returned
++current_step_index();
}
:(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: {
dump(Current_routine->calls);
break;
}
:(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';
}
|