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
|
//: So far we've been calling a fixed recipe in each instruction, but we'd
//: also like to make the recipe a variable, pass recipes to "higher-order"
//: recipes, return recipes from recipes and so on.
//:
//: todo: support storing shape-shifting recipes into recipe variables and calling them
:(scenario call_literal_recipe)
def main [
1:number <- call f, 34
]
def f x:number -> y:number [
local-scope
load-ingredients
y <- copy x
]
+mem: storing 34 in location 1
:(scenario call_variable)
def main [
{1: (recipe number -> number)} <- copy f
2:number <- call {1: (recipe number -> number)}, 34
]
def f x:number -> y:number [
local-scope
load-ingredients
y <- copy x
]
+mem: storing 34 in location 2
:(before "End Mu Types Initialization")
put(Type_ordinal, "recipe-literal", 0);
// 'recipe' variables can store recipe-literal
type_ordinal recipe = put(Type_ordinal, "recipe", Next_type_ordinal++);
get_or_insert(Type, recipe).name = "recipe";
:(before "End Null-type is_disqualified Exceptions")
if (!x.type && contains_key(Recipe_ordinal, x.name)) {
x.type = new type_tree("recipe-literal", get(Type_ordinal, "recipe-literal"));
x.set_value(get(Recipe_ordinal, x.name));
return true;
}
:(before "End Primitive Recipe Declarations")
CALL,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "call", CALL);
:(before "End Primitive Recipe Checks")
case CALL: {
if (inst.ingredients.empty()) {
raise << maybe(get(Recipe, r).name) << "'call' requires at least one ingredient (the recipe to call)\n" << end();
break;
}
if (!is_mu_recipe(inst.ingredients.at(0))) {
raise << maybe(get(Recipe, r).name) << "first ingredient of 'call' should be a recipe, but got " << inst.ingredients.at(0).original_string << '\n' << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case CALL: {
// Begin Call
if (Trace_stream) {
++Trace_stream->callstack_depth;
trace("trace") << "indirect 'call': incrementing callstack depth to " << Trace_stream->callstack_depth << end();
assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion
}
const instruction& caller_instruction = current_instruction();
Current_routine->calls.push_front(call(ingredients.at(0).at(0)));
ingredients.erase(ingredients.begin()); // drop the callee
finish_call_housekeeping(caller_instruction, ingredients);
continue;
}
//:: check types for 'call' instructions
:(scenario call_check_literal_recipe)
% Hide_errors = true;
def main [
1:number <- call f, 34
]
def f x:point -> y:point [
local-scope
load-ingredients
y <- copy x
]
+error: main: ingredient 0 has the wrong type at '1:number <- call f, 34'
+error: main: product 0 has the wrong type at '1:number <- call f, 34'
:(scenario call_check_variable_recipe)
% Hide_errors = true;
def main [
{1: (recipe point -> point)} <- copy f
2:number <- call {1: (recipe point -> point)}, 34
]
def f x:point -> y:point [
local-scope
load-ingredients
y <- copy x
]
+error: main: ingredient 0 has the wrong type at '2:number <- call {1: (recipe point -> point)}, 34'
+error: main: product 0 has the wrong type at '2:number <- call {1: (recipe point -> point)}, 34'
:(after "Transform.push_back(check_instruction)")
Transform.push_back(check_indirect_calls_against_header); // idempotent
:(code)
void check_indirect_calls_against_header(const recipe_ordinal r) {
trace(9991, "transform") << "--- type-check 'call' instructions inside recipe " << get(Recipe, r).name << end();
const recipe& caller = get(Recipe, r);
for (int i = 0; i < SIZE(caller.steps); ++i) {
const instruction& inst = caller.steps.at(i);
if (inst.operation != CALL) continue;
if (inst.ingredients.empty()) continue; // error raised above
const reagent& callee = inst.ingredients.at(0);
if (!is_mu_recipe(callee)) continue; // error raised above
const recipe callee_header = is_literal(callee) ? get(Recipe, callee.value) : from_reagent(inst.ingredients.at(0));
if (!callee_header.has_header) continue;
for (long int i = /*skip callee*/1; i < min(SIZE(inst.ingredients), SIZE(callee_header.ingredients)+/*skip callee*/1); ++i) {
if (!types_coercible(callee_header.ingredients.at(i-/*skip callee*/1), inst.ingredients.at(i)))
raise << maybe(caller.name) << "ingredient " << i-/*skip callee*/1 << " has the wrong type at '" << to_original_string(inst) << "'\n" << end();
}
for (long int i = 0; i < min(SIZE(inst.products), SIZE(callee_header.products)); ++i) {
if (is_dummy(inst.products.at(i))) continue;
if (!types_coercible(callee_header.products.at(i), inst.products.at(i)))
raise << maybe(caller.name) << "product " << i << " has the wrong type at '" << to_original_string(inst) << "'\n" << end();
}
}
}
recipe from_reagent(const reagent& r) {
assert(r.type->name == "recipe");
recipe result_header; // will contain only ingredients and products, nothing else
result_header.has_header = true;
const type_tree* curr = r.type->right;
for (; curr; curr=curr->right) {
if (curr->name == "->") {
curr = curr->right; // skip delimiter
break;
}
result_header.ingredients.push_back("recipe:"+curr->name);
}
for (; curr; curr=curr->right)
result_header.products.push_back("recipe:"+curr->name);
return result_header;
}
bool is_mu_recipe(reagent r) {
if (!r.type) return false;
if (r.type->name == "recipe") return true;
if (r.type->name == "recipe-literal") return true;
// End is_mu_recipe Cases
return false;
}
:(scenario copy_typecheck_recipe_variable)
% Hide_errors = true;
def main [
3:number <- copy 34 # abc def
{1: (recipe number -> number)} <- copy f # store literal in a matching variable
{2: (recipe boolean -> boolean)} <- copy {1: (recipe number -> number)} # mismatch between recipe variables
]
def f x:number -> y:number [
local-scope
load-ingredients
y <- copy x
]
+error: main: can't copy {1: (recipe number -> number)} to {2: (recipe boolean -> boolean)}; types don't match
:(scenario copy_typecheck_recipe_variable_2)
% Hide_errors = true;
def main [
{1: (recipe number -> number)} <- copy f # mismatch with a recipe literal
]
def f x:boolean -> y:boolean [
local-scope
load-ingredients
y <- copy x
]
+error: main: can't copy f to {1: (recipe number -> number)}; types don't match
:(before "End Matching Types For Literal(to)")
if (is_mu_recipe(to)) {
if (!contains_key(Recipe, from.value)) {
raise << "trying to store recipe " << from.name << " into " << to_string(to) << " but there's no such recipe\n" << end();
return false;
}
const recipe& rrhs = get(Recipe, from.value);
const recipe& rlhs = from_reagent(to);
for (long int i = 0; i < min(SIZE(rlhs.ingredients), SIZE(rrhs.ingredients)); ++i) {
if (!types_match(rlhs.ingredients.at(i), rrhs.ingredients.at(i)))
return false;
}
for (long int i = 0; i < min(SIZE(rlhs.products), SIZE(rrhs.products)); ++i) {
if (!types_match(rlhs.products.at(i), rrhs.products.at(i)))
return false;
}
return true;
}
//: make sure we don't accidentally break on a function literal
:(scenario jump_forbidden_on_recipe_literals)
% Hide_errors = true;
def foo [
local-scope
]
def main [
local-scope
{
break-if foo
}
]
# error should be as if foo is not a recipe
+error: main: missing type for foo in 'break-if {foo: ()}'
:(before "End JUMP_IF Checks")
check_for_recipe_literals(inst, get(Recipe, r));
:(before "End JUMP_UNLESS Checks")
check_for_recipe_literals(inst, get(Recipe, r));
:(code)
void check_for_recipe_literals(const instruction& inst, const recipe& caller) {
for (int i = 0; i < SIZE(inst.ingredients); ++i) {
if (is_mu_recipe(inst.ingredients.at(i)))
raise << maybe(caller.name) << "missing type for " << inst.ingredients.at(i).original_string << " in '" << inst.original_string << "'\n" << end();
}
}
|