about summary refs log blame commit diff stats
path: root/309stream.subx
blob: 61da00ae54c7973a0c2d015bcb538b5cac237c5f (plain) (tree) 
bae22d72 ^



5462619d ^


30012350 ^

















































bae22d72 ^














































0e9503d7 ^

bae22d72 ^


30012350 ^

bae22d72 ^














































0e9503d7 ^

bae22d72 ^

8a6ad45d ^
























































c54b7e96 ^


9d7d99fe ^

c54b7e96 ^






















































































9d7d99fe ^


















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
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297

298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315



                                                                            

       
















































                                                               













































                                                   
                                          

                     
                                                                 













































                                                  
                                            
                     























































                                                          

                                                                 
                                                                                          





















































































                                                    

















                                                                                                 
# Some unsafe methods not intended to be used directly in SubX, only through
# Mu after proper type-checking.

== code

stream-empty?:  # s: (addr stream _) -> result/eax: boolean
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    51/push-ecx
    56/push-esi
    # result = false
    b8/copy-to-eax 0/imm32/false
    # esi = s
    8b/-> *(ebp+8) 6/r32/esi
    # return s->read >= s->write
    8b/-> *esi 1/r32/ecx
    39/compare-with *(esi+4) 1/r32/ecx
    0f 9d/set-if->= %al
$stream-empty?:end:
    # . restore registers
    5e/pop-to-esi
    59/pop-to-ecx
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

stream-full?:  # s: (addr stream _) -> result/eax: boolean
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    51/push-ecx
    56/push-esi
    # result = false
    b8/copy-to-eax 0/imm32/false
    # esi = s
    8b/-> *(ebp+8) 6/r32/esi
    # return s->write >= s->size
    8b/-> *(esi+8) 1/r32/ecx
    39/compare-with *esi 1/r32/ecx
    0f 9d/set-if->= %al
$stream-full?:end:
    # . restore registers
    5e/pop-to-esi
    59/pop-to-ecx
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

write-to-stream:  # s: (addr stream _), in: (addr byte), n: int
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    50/push-eax
    51/push-ecx
    52/push-edx
    53/push-ebx
    57/push-edi
    # edi = s
    8b/-> *(ebp+8) 7/r32/edi
    # var swrite/edx: int = s->write
    8b/-> *edi 2/r32/edx
    # if (swrite + n > s->size) abort
    8b/-> *(ebp+0x10) 1/r32/ecx
    01/add-to %ecx 2/r32/edx
    3b/compare 1/r32/ecx *(edi+8)
    0f 8f/jump-if-> $write-to-stream:abort/disp32
    # var out/edx: (addr byte) = s->data + s->write
    8d/copy-address *(edi+edx+0xc) 2/r32/edx
    # var outend/ebx: (addr byte) = out + n
    8b/-> *(ebp+0x10) 3/r32/ebx
    8d/copy-address *(edx+ebx) 3/r32/ebx
    # eax = in
    8b/-> *(ebp+0xc) 0/r32/eax
    # var inend/ecx: (addr byte) = in + n
    8b/-> *(ebp+0x10) 1/r32/ecx
    8d/copy-address *(eax+ecx) 1/r32/ecx
    #
    (_append-4  %edx %ebx  %eax %ecx)  # => eax
    # s->write += n
    8b/-> *(ebp+0x10) 1/r32/ecx
    01/add-to *edi 1/r32/ecx
$write-to-stream:end:
    # . restore registers
    5f/pop-to-edi
    5b/pop-to-ebx
    5a/pop-to-edx
    59/pop-to-ecx
    58/pop-to-eax
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

$write-to-stream:abort:
    (abort "write-to-stream: stream full")
    # never gets here

read-from-stream:  # s: (addr stream _), out: (addr byte), n: int
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    50/push-eax
    51/push-ecx
    52/push-edx
    53/push-ebx
    56/push-esi
    # esi = s
    8b/-> *(ebp+8) 6/r32/esi
    # var sread/edx: int = s->read
    8b/-> *(esi+4) 2/r32/edx
    # if (sread + n > s->write) abort
    8b/-> *(ebp+0x10) 1/r32/ecx
    01/add-to %ecx 2/r32/edx
    3b/compare 1/r32/ecx *esi
    0f 8f/jump-if-> $read-from-stream:abort/disp32
    # var in/edx: (addr byte) = s->data + s->read
    8d/copy-address *(esi+edx+0xc) 2/r32/edx
    # var inend/ebx: (addr byte) = in + n
    8b/-> *(ebp+0x10) 3/r32/ebx
    8d/copy-address *(edx+ebx) 3/r32/ebx
    # eax = out
    8b/-> *(ebp+0xc) 0/r32/eax
    # var outend/ecx: (addr byte) = out + n
    8b/-> *(ebp+0x10) 1/r32/ecx
    8d/copy-address *(eax+ecx) 1/r32/ecx
    #
    (_append-4  %eax %ecx  %edx %ebx)  # => eax
    # s->read += n
    8b/-> *(ebp+0x10) 1/r32/ecx
    01/add-to *(esi+4) 1/r32/ecx
$read-from-stream:end:
    # . restore registers
    5e/pop-to-esi
    5b/pop-to-ebx
    5a/pop-to-edx
    59/pop-to-ecx
    58/pop-to-eax
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

$read-from-stream:abort:
    (abort "read-from-stream: stream empty")
    # never gets here

stream-first:  # s: (addr stream byte) -> result/eax: byte
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    51/push-ecx
    56/push-esi
    # result = false
    b8/copy-to-eax 0/imm32
    # esi = s
    8b/-> *(ebp+8) 6/r32/esi
    # var idx/ecx: int = s->read
    8b/-> *(esi+4) 1/r32/ecx
    # if idx >= s->write return 0
    3b/compare-with 1/r32/ecx *esi
    7d/jump-if->= $stream-first:end/disp8
    # result = s->data[idx]
    8a/byte-> *(esi+ecx+0xc) 0/r32/AL
$stream-first:end:
    # . restore registers
    5e/pop-to-esi
    59/pop-to-ecx
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

stream-final:  # s: (addr stream byte) -> result/eax: byte
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    51/push-ecx
    56/push-esi
    # result = false
    b8/copy-to-eax 0/imm32
    # esi = s
    8b/-> *(ebp+8) 6/r32/esi
    # var max/ecx: int = s->write
    8b/-> *esi 1/r32/ecx
    # if s->read >= max return 0
    39/compare-with *(esi+4) 1/r32/ecx
    7d/jump-if->= $stream-final:end/disp8
    # var idx/ecx: int = max - 1
    49/decrement-ecx
    # result = s->data[idx]
    8a/byte-> *(esi+ecx+0xc) 0/r32/AL
$stream-final:end:
    # . restore registers
    5e/pop-to-esi
    59/pop-to-ecx
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

# compare all the data in two streams (ignoring the read pointer)
streams-data-equal?:  # a: (addr stream byte), b: (addr array byte) -> result/eax: boolean
    # pseudocode:
    #   awrite = a->write
    #   if (awrite != b->write) return false
    #   i = 0
    #   curra = a->data
    #   currb = b->data
    #   while i < awrite
    #     i1 = *curra
    #     i2 = *currb
    #     if (c1 != c2) return false
    #     i+=4, curra+=4, currb+=4
    #   return true
    #
    # registers:
    #   i: ecx
    #   awrite: edx
    #   curra: esi
    #   currb: edi
    #   i1: eax
    #   i2: ebx
    #
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    51/push-ecx
    52/push-edx
    53/push-ebx
    56/push-esi
    57/push-edi
    # esi = a
    8b/-> *(ebp+8) 6/r32/esi
    # edi = b
    8b/-> *(ebp+0xc) 7/r32/edi
    # var awrite/edx: int = a->write
    8b/-> *esi 2/r32/edx
$streams-data-equal?:sizes:
    # if (awrite != b->write) return false
    39/compare *edi 2/r32/edx
    75/jump-if-!= $streams-data-equal?:false/disp8
    # var curra/esi: (addr byte) = a->data
    81 0/subop/add %esi 0xc/imm32
    # var currb/edi: (addr byte) = b->data
    81 0/subop/add %edi 0xc/imm32
    # var i/ecx: int = 0
    31/xor-with %ecx 1/r32/ecx
    # var vala/eax: int
    31/xor-with %eax 0/r32/eax
    # var valb/ebx: int
    31/xor-with %ebx 3/r32/ebx
$streams-data-equal?:loop:
    {
      # if (i >= awrite) return true
      39/compare %ecx 2/r32/edx
      7d/jump-if->= $streams-data-equal?:true/disp8
      # var vala/eax: int = *curra
      8a/byte-> *esi 0/r32/eax
      # var valb/ebx: int = *currb
      8a/byte-> *edi 3/r32/ebx
      # if (vala != valb) return false
      39/compare %eax 3/r32/ebx
      75/jump-if-!= $streams-data-equal?:false/disp8
      # i++
      41/increment-ecx
      # curra++
      46/increment-esi
      # currb++
      47/increment-edi
      eb/jump loop/disp8
    }
$streams-data-equal?:true:
    b8/copy-to-eax 1/imm32
    eb/jump $streams-data-equal?:end/disp8
$streams-data-equal?:false:
    b8/copy-to-eax 0/imm32
$streams-data-equal?:end:
    # . restore registers
    5f/pop-to-edi
    5e/pop-to-esi
    5b/pop-to-ebx
    5a/pop-to-edx
    59/pop-to-ecx
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

# helper for tests
check-streams-data-equal:  # s: (addr stream _), expected: (addr array _), msg: (addr array byte)
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    50/push-eax
    #
    (streams-data-equal? *(ebp+8) *(ebp+0xc))  # => eax
    (check-ints-equal %eax 1 *(ebp+0x10))
$check-streams-equal:end:
    # . restore registers
    58/pop-to-eax
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-10-07 02:44:27 +0000
class="n">recipe& caller) { if (x.type) return; if (!contains_key(Recipe_ordinal, x.name)) return; if (contains_reagent_with_non_recipe_literal_type(caller, x.name)) return; x.type = new type_tree("recipe-literal"); x.set_value(get(Recipe_ordinal, x.name)); } bool contains_reagent_with_non_recipe_literal_type(const recipe& caller, const string& name) { for (int i = 0; i < SIZE(caller.steps); ++i) { const instruction& inst = caller.steps.at(i); for (int i = 0; i < SIZE(inst.ingredients); ++i) if (is_matching_non_recipe_literal(inst.ingredients.at(i), name)) return true; for (int i = 0; i < SIZE(inst.products); ++i) if (is_matching_non_recipe_literal(inst.products.at(i), name)) return true; } return false; } bool is_matching_non_recipe_literal(const reagent& x, const string& name) { if (x.name != name) return false; if (!x.type) return false; return !x.type->atom || x.type->name != "recipe-literal"; } //: It's confusing to use variable names that are also recipe names. Always //: assume variable types override recipe literals. void test_error_on_recipe_literal_used_as_a_variable() { Hide_errors = true; run( "def main [\n" " local-scope\n" " a:bool <- equal break 0\n" " break:bool <- copy 0\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: main: missing type for 'break' in 'a:bool <- equal break, 0'\n" ); } :(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 trace(Callstack_depth+1, "trace") << "indirect 'call': incrementing callstack depth to " << Callstack_depth << end(); ++Callstack_depth; assert(Callstack_depth < Max_depth); if (!ingredients.at(0).at(0)) { raise << maybe(current_recipe_name()) << "tried to call empty recipe in '" << to_string(current_instruction()) << "'" << end(); break; } const call& caller_frame = current_call(); instruction/*copy*/ call_instruction = to_instruction(caller_frame); call_instruction.operation = ingredients.at(0).at(0); call_instruction.ingredients.erase(call_instruction.ingredients.begin()); Current_routine->calls.push_front(call(ingredients.at(0).at(0))); ingredients.erase(ingredients.begin()); // drop the callee finish_call_housekeeping(call_instruction, ingredients); // not done with caller write_products = false; fall_through_to_next_instruction = false; break; } :(code) void test_call_variable() { run( "def main [\n" " {1: (recipe number -> number)} <- copy f\n" " 2:num <- call {1: (recipe number -> number)}, 34\n" "]\n" "def f x:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 34 in location 2\n" ); } void test_call_literal_recipe_repeatedly() { run( "def main [\n" " 1:num <- call f, 34\n" " 1:num <- call f, 35\n" "]\n" "def f x:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 34 in location 1\n" "mem: storing 35 in location 1\n" ); } void test_call_shape_shifting_recipe() { run( "def main [\n" " 1:num <- call f, 34\n" "]\n" "def f x:_elem -> y:_elem [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 34 in location 1\n" ); } void test_call_shape_shifting_recipe_inside_shape_shifting_recipe() { run( "def main [\n" " 1:num <- f 34\n" "]\n" "def f x:_elem -> y:_elem [\n" " local-scope\n" " load-ingredients\n" " y <- call g x\n" "]\n" "def g x:_elem -> y:_elem [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 34 in location 1\n" ); } void test_call_shape_shifting_recipe_repeatedly_inside_shape_shifting_recipe() { run( "def main [\n" " 1:num <- f 34\n" "]\n" "def f x:_elem -> y:_elem [\n" " local-scope\n" " load-ingredients\n" " y <- call g x\n" " y <- call g x\n" "]\n" "def g x:_elem -> y:_elem [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 34 in location 1\n" ); } //:: check types for 'call' instructions void test_call_check_literal_recipe() { Hide_errors = true; run( "def main [\n" " 1:num <- call f, 34\n" "]\n" "def f x:point -> y:point [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: main: ingredient 0 has the wrong type at '1:num <- call f, 34'\n" "error: main: product 0 has the wrong type at '1:num <- call f, 34'\n" ); } void test_call_check_variable_recipe() { Hide_errors = true; run( "def main [\n" " {1: (recipe point -> point)} <- copy f\n" " 2:num <- call {1: (recipe point -> point)}, 34\n" "]\n" "def f x:point -> y:point [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: main: ingredient 0 has the wrong type at '2:num <- call {1: (recipe point -> point)}, 34'\n" "error: main: product 0 has the wrong type at '2:num <- call {1: (recipe point -> point)}, 34'\n" ); } :(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases") if (inst.name == "call" && !inst.ingredients.empty() && is_recipe_literal(inst.ingredients.at(0))) { resolve_indirect_ambiguous_call(r, index, inst, caller_recipe); return; } :(code) bool is_recipe_literal(const reagent& x) { return x.type && x.type->atom && x.type->name == "recipe-literal"; } void resolve_indirect_ambiguous_call(const recipe_ordinal r, int index, instruction& inst, const recipe& caller_recipe) { instruction inst2; inst2.name = inst.ingredients.at(0).name; for (int i = /*skip recipe*/1; i < SIZE(inst.ingredients); ++i) inst2.ingredients.push_back(inst.ingredients.at(i)); for (int i = 0; i < SIZE(inst.products); ++i) inst2.products.push_back(inst.products.at(i)); resolve_ambiguous_call(r, index, inst2, caller_recipe); inst.ingredients.at(0).name = inst2.name; inst.ingredients.at(0).set_value(get(Recipe_ordinal, inst2.name)); } :(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(101, "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 (!is_indirect_call(inst.operation)) 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; if (is_indirect_call_with_ingredients(inst.operation)) { 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(); } } if (is_indirect_call_with_products(inst.operation)) { 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(); } } } } bool is_indirect_call(const recipe_ordinal r) { return is_indirect_call_with_ingredients(r) || is_indirect_call_with_products(r); } bool is_indirect_call_with_ingredients(const recipe_ordinal r) { if (r == CALL) return true; // End is_indirect_call_with_ingredients Special-cases return false; } bool is_indirect_call_with_products(const recipe_ordinal r) { if (r == CALL) return true; // End is_indirect_call_with_products Special-cases return false; } recipe from_reagent(const reagent& r) { assert(r.type); recipe result_header; // will contain only ingredients and products, nothing else result_header.has_header = true; // Begin Reagent->Recipe(r, recipe_header) if (r.type->atom) { assert(r.type->name == "recipe"); return result_header; } const type_tree* root_type = r.type->atom ? r.type : r.type->left; assert(root_type->atom); assert(root_type->name == "recipe"); const type_tree* curr = r.type->right; for (/*nada*/; curr && !curr->atom; curr = curr->right) { if (curr->left->atom && curr->left->name == "->") { curr = curr->right; // skip delimiter goto read_products; } result_header.ingredients.push_back(next_recipe_reagent(curr->left)); } if (curr) { assert(curr->atom); result_header.ingredients.push_back(next_recipe_reagent(curr)); return result_header; // no products } read_products: for (/*nada*/; curr && !curr->atom; curr = curr->right) result_header.products.push_back(next_recipe_reagent(curr->left)); if (curr) { assert(curr->atom); result_header.products.push_back(next_recipe_reagent(curr)); } return result_header; } :(before "End Unit Tests") void test_from_reagent_atomic() { reagent a("{f: recipe}"); recipe r_header = from_reagent(a); CHECK(r_header.ingredients.empty()); CHECK(r_header.products.empty()); } void test_from_reagent_non_atomic() { reagent a("{f: (recipe number -> number)}"); recipe r_header = from_reagent(a); CHECK_EQ(SIZE(r_header.ingredients), 1); CHECK_EQ(SIZE(r_header.products), 1); } void test_from_reagent_reads_ingredient_at_end() { reagent a("{f: (recipe number number)}"); recipe r_header = from_reagent(a); CHECK_EQ(SIZE(r_header.ingredients), 2); CHECK(r_header.products.empty()); } void test_from_reagent_reads_sole_ingredient_at_end() { reagent a("{f: (recipe number)}"); recipe r_header = from_reagent(a); CHECK_EQ(SIZE(r_header.ingredients), 1); CHECK(r_header.products.empty()); } :(code) reagent next_recipe_reagent(const type_tree* curr) { if (!curr->left) return reagent("recipe:"+curr->name); return reagent(new type_tree(*curr)); } bool is_mu_recipe(const reagent& r) { if (!r.type) return false; if (r.type->atom) { // End is_mu_recipe Atom Cases(r) return r.type->name == "recipe-literal"; } return r.type->left->atom && r.type->left->name == "recipe"; } void test_copy_typecheck_recipe_variable() { Hide_errors = true; run( "def main [\n" " 3:num <- copy 34\n" " {1: (recipe number -> number)} <- copy f\n" // store literal in a matching variable " {2: (recipe boolean -> boolean)} <- copy {1: (recipe number -> number)}\n" // mismatch between recipe variables "]\n" "def f x:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: main: can't copy '{1: (recipe number -> number)}' to '{2: (recipe boolean -> boolean)}'; types don't match\n" ); } void test_copy_typecheck_recipe_variable_2() { Hide_errors = true; run( "def main [\n" " {1: (recipe number -> number)} <- copy f\n" // mismatch with a recipe literal "]\n" "def f x:bool -> y:bool [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: main: can't copy 'f' to '{1: (recipe number -> number)}'; types don't match\n" ); } :(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; } :(code) void test_call_variable_compound_ingredient() { run( "def main [\n" " {1: (recipe (address number) -> number)} <- copy f\n" " 2:&:num <- copy null\n" " 3:num <- call {1: (recipe (address number) -> number)}, 2:&:num\n" "]\n" "def f x:&:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " y <- deaddress x\n" "]\n" ); CHECK_TRACE_COUNT("error", 0); } //: make sure we don't accidentally break on a recipe literal void test_jump_forbidden_on_recipe_literals() { Hide_errors = true; run( "def foo [\n" " local-scope\n" "]\n" "def main [\n" " local-scope\n" " {\n" " break-if foo\n" " }\n" "]\n" ); // error should be as if foo is not a recipe CHECK_TRACE_CONTENTS( "error: main: missing type for 'foo' in 'break-if foo'\n" ); } :(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 '" << to_original_string(inst) << "'\n" << end(); if (is_present_in_ingredients(caller, inst.ingredients.at(i).name)) raise << " did you forget 'load-ingredients'?\n" << end(); } } } void test_load_ingredients_missing_error_3() { Hide_errors = true; run( "def foo {f: (recipe num -> num)} [\n" " local-scope\n" " b:num <- call f, 1\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: foo: missing type for 'f' in 'b:num <- call f, 1'\n" "error: did you forget 'load-ingredients'?\n" ); } :(before "End Mu Types Initialization") put(Type_abbreviations, "function", new_type_tree("recipe")); put(Type_abbreviations, "fn", new_type_tree("recipe")); //: copying functions to variables :(code) void test_copy_recipe_to_variable() { run( "def main [\n" " {1: (fn number -> number)} <- copy f\n" " 2:num <- call {1: (function number -> number)}, 34\n" "]\n" "def f x:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 34 in location 2\n" ); } void test_copy_overloaded_recipe_to_variable() { run( "def main [\n" " local-scope\n" " {x: (fn num -> num)} <- copy f\n" " 1:num/raw <- call x, 34\n" "]\n" // variant f "def f x:bool -> y:bool [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" // variant f_2 "def f x:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); // x contains f_2 CHECK_TRACE_CONTENTS( "mem: storing 34 in location 1\n" ); } :(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases") if (inst.name == "copy") { for (int i = 0; i < SIZE(inst.ingredients); ++i) { if (!is_recipe_literal(inst.ingredients.at(i))) continue; if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue; // potentially overloaded recipe string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, inst.products.at(i), r, index, caller_recipe); if (new_name == "") continue; inst.ingredients.at(i).name = new_name; inst.ingredients.at(i).value = get(Recipe_ordinal, new_name); } return; } :(code) string resolve_ambiguous_call(const string& recipe_name, const reagent& call_types, const recipe_ordinal r, int index, const recipe& caller_recipe) { instruction inst; inst.name = recipe_name; if (!is_mu_recipe(call_types)) return ""; // error raised elsewhere if (is_recipe_literal(call_types)) return ""; // error raised elsewhere construct_fake_call(call_types, inst); resolve_ambiguous_call(r, index, inst, caller_recipe); return inst.name; } void construct_fake_call(const reagent& recipe_var, instruction& out) { assert(recipe_var.type->left->name == "recipe"); type_tree* stem = NULL; for (stem = recipe_var.type->right; stem && stem->left->name != "->"; stem = stem->right) out.ingredients.push_back(copy(stem->left)); if (stem == NULL) return; for (/*skip '->'*/stem = stem->right; stem; stem = stem->right) out.products.push_back(copy(stem->left)); } void test_copy_shape_shifting_recipe_to_variable() { run( "def main [\n" " local-scope\n" " {x: (fn num -> num)} <- copy f\n" " 1:num/raw <- call x, 34\n" "]\n" "def f x:_elem -> y:_elem [\n" " local-scope\n" " load-inputs\n" " y <- copy x\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 34 in location 1\n" ); } //: passing function literals to (higher-order) functions void test_pass_overloaded_recipe_literal_to_ingredient() { run( // like test_copy_overloaded_recipe_to_variable, except we bind 'x' in // the course of a 'call' rather than 'copy' "def main [\n" " 1:num <- g f\n" "]\n" "def g {x: (fn num -> num)} -> result:num [\n" " local-scope\n" " load-ingredients\n" " result <- call x, 34\n" "]\n" // variant f "def f x:bool -> y:bool [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" // variant f_2 "def f x:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); // x contains f_2 CHECK_TRACE_CONTENTS( "mem: storing 34 in location 1\n" ); } :(after "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases") for (int i = 0; i < SIZE(inst.ingredients); ++i) { if (!is_mu_recipe(inst.ingredients.at(i))) continue; if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue; if (get(Recipe_ordinal, inst.name) < MAX_PRIMITIVE_RECIPES) continue; if (non_ghost_size(get_or_insert(Recipe_variants, inst.name)) > 1) { raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to simultaneously guess which overloads you want for '" << inst.name << "' and '" << inst.ingredients.at(i).name << "'\n" << end(); return; } const recipe& callee = get(Recipe, get(Recipe_ordinal, inst.name)); if (!callee.has_header) { raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to guess which variant of '" << inst.ingredients.at(i).name << "' you want, when the caller '" << inst.name << "' doesn't have a header\n" << end(); return; } string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, callee.ingredients.at(i), r, index, caller_recipe); if (new_name != "") { inst.ingredients.at(i).name = new_name; inst.ingredients.at(i).value = get(Recipe_ordinal, new_name); } } :(code) void test_return_overloaded_recipe_literal_to_caller() { run( "def main [\n" " local-scope\n" " {x: (fn num -> num)} <- g\n" " 1:num/raw <- call x, 34\n" "]\n" "def g -> {x: (fn num -> num)} [\n" " local-scope\n" " return f\n" "]\n" // variant f "def f x:bool -> y:bool [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" // variant f_2 "def f x:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " y <- copy x\n" "]\n" ); // x contains f_2 CHECK_TRACE_CONTENTS( "mem: storing 34 in location 1\n" ); } :(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases") if (inst.name == "return" || inst.name == "reply") { for (int i = 0; i < SIZE(inst.ingredients); ++i) { if (!is_recipe_literal(inst.ingredients.at(i))) continue; if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue; // potentially overloaded recipe if (!caller_recipe.has_header) { raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to guess which variant of '" << inst.ingredients.at(i).name << "' you want, without a recipe header\n" << end(); return; } string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, caller_recipe.products.at(i), r, index, caller_recipe); if (new_name == "") continue; inst.ingredients.at(i).name = new_name; inst.ingredients.at(i).value = get(Recipe_ordinal, new_name); } return; }
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-10-07 02:44:27 +0000