2015-04-17 18:22:59 +00:00
|
|
|
//: So far the recipes we define can't run each other. Let's fix that.
|
|
|
|
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
void test_calling_recipe() {
|
|
|
|
run(
|
|
|
|
"def main [\n"
|
|
|
|
" f\n"
|
|
|
|
"]\n"
|
|
|
|
"def f [\n"
|
|
|
|
" 3:num <- add 2, 2\n"
|
|
|
|
"]\n"
|
|
|
|
);
|
|
|
|
CHECK_TRACE_CONTENTS(
|
|
|
|
"mem: storing 4 in location 3\n"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
void test_return_on_fallthrough() {
|
|
|
|
run(
|
|
|
|
"def main [\n"
|
|
|
|
" f\n"
|
|
|
|
" 1:num <- copy 0\n"
|
|
|
|
" 2:num <- copy 0\n"
|
|
|
|
" 3:num <- copy 0\n"
|
|
|
|
"]\n"
|
|
|
|
"def f [\n"
|
|
|
|
" 4:num <- copy 0\n"
|
|
|
|
" 5:num <- copy 0\n"
|
|
|
|
"]\n"
|
|
|
|
);
|
|
|
|
CHECK_TRACE_CONTENTS(
|
|
|
|
"run: f\n"
|
|
|
|
"run: {4: \"number\"} <- copy {0: \"literal\"}\n"
|
|
|
|
"run: {5: \"number\"} <- copy {0: \"literal\"}\n"
|
|
|
|
"run: {1: \"number\"} <- copy {0: \"literal\"}\n"
|
|
|
|
"run: {2: \"number\"} <- copy {0: \"literal\"}\n"
|
|
|
|
"run: {3: \"number\"} <- copy {0: \"literal\"}\n"
|
|
|
|
);
|
|
|
|
}
|
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) {
|
2019-02-25 08:17:46 +00:00
|
|
|
++Callstack_depth;
|
|
|
|
trace(Callstack_depth+1, "trace") << "new routine; incrementing callstack depth to " << Callstack_depth << end();
|
|
|
|
assert(Callstack_depth < Max_depth);
|
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
|
2019-02-25 08:17:46 +00:00
|
|
|
++Callstack_depth;
|
|
|
|
trace(Callstack_depth+1, "trace") << "incrementing callstack depth to " << Callstack_depth << end();
|
|
|
|
assert(Callstack_depth < Max_depth);
|
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
|
|
|
|
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
|
|
|
void test_calling_undefined_recipe_fails() {
|
|
|
|
Hide_errors = true;
|
|
|
|
run(
|
|
|
|
"def main [\n"
|
|
|
|
" foo\n"
|
|
|
|
"]\n"
|
|
|
|
);
|
|
|
|
CHECK_TRACE_CONTENTS(
|
|
|
|
"error: main: undefined operation in 'foo'\n"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
void test_calling_undefined_recipe_handles_missing_result() {
|
|
|
|
Hide_errors = true;
|
|
|
|
run(
|
|
|
|
"def main [\n"
|
|
|
|
" x:num <- foo\n"
|
|
|
|
"]\n"
|
|
|
|
);
|
|
|
|
CHECK_TRACE_CONTENTS(
|
|
|
|
"error: main: undefined operation in 'x:num <- foo'\n"
|
|
|
|
);
|
|
|
|
}
|
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
|
2019-02-25 08:17:46 +00:00
|
|
|
trace(Callstack_depth+1, "trace") << "fall-through: exiting " << current_recipe_name() << "; decrementing callstack depth from " << Callstack_depth << end();
|
|
|
|
--Callstack_depth;
|
|
|
|
assert(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';
|
|
|
|
}
|