1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 :(scenario copy_literal)
16 def main [
17 1:num <- copy 23
18 ]
19 +run: {1: "number"} <- copy {23: "literal"}
20 +mem: storing 23 in location 1
21
22 :(scenario copy)
23 def main [
24 1:num <- copy 23
25 2:num <- copy 1:num
26 ]
27 +run: {2: "number"} <- copy {1: "number"}
28 +mem: location 1 is 23
29 +mem: storing 23 in location 2
30
31 :(scenario copy_multiple)
32 def main [
33 1:num, 2:num <- copy 23, 24
34 ]
35 +mem: storing 23 in location 1
36 +mem: storing 24 in location 2
37
38 :(before "End Types")
39
40
41 struct routine {
42 recipe_ordinal running_recipe;
43 int running_step_index;
44 routine(recipe_ordinal r) :running_recipe(r), running_step_index(0) {}
45 bool completed() const;
46 const vector<instruction>& steps() const;
47 };
48
49 :(before "End Globals")
50 routine* Current_routine = NULL;
51 map<string, int> Instructions_running;
52 map<string, int> Locations_read;
53 map<string, int> Locations_read_by_instruction;
54 :(before "End Setup")
55 Current_routine = NULL;
56
57 :(code)
58 void run(const recipe_ordinal r) {
59 routine rr(r);
60 Current_routine = &rr;
61 run_current_routine();
62 Current_routine = NULL;
63 }
64
65 void run_current_routine() {
66 while (should_continue_running(Current_routine)) {
67 ¦
68
69 ¦ if (current_instruction().is_label) { ++current_step_index(); continue; }
70 ¦ trace(Initial_callstack_depth + Trace_stream->callstack_depth, "run") << to_string(current_instruction()) << end();
71 ¦ if (get_or_insert(Memory, 0) != 0) {
72 ¦ ¦ raise << "something wrote to location 0; this should never happen\n" << end();
73 ¦ ¦ put(Memory, 0, 0);
74 ¦ }
75 ¦
76 ¦ vector<vector<double> > ingredients;
77 ¦ if (should_copy_ingredients()) {
78 ¦ ¦ for (int i = 0; i < SIZE(current_instruction().ingredients); ++i)
79 ¦ ¦ ¦ ingredients.push_back(read_memory(current_instruction().ingredients.at(i)));
80 ¦ }
81 ¦
82 ¦ vector<vector<double> > products;
83 ¦ switch (current_instruction().operation) {
84 ¦ ¦
85 ¦ ¦ case COPY: {
86 ¦ ¦ ¦ copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin()));
87 ¦ ¦ ¦ break;
88 ¦ ¦ }
89 ¦ ¦
90 ¦ ¦ default: {
91 ¦ ¦ ¦ cout << "not a primitive op: " << current_instruction().operation << '\n';
92 ¦ ¦ }
93 ¦ }
94 ¦
95 ¦ Writing_products_of_instruction = true;
96 ¦ if (SIZE(products) < SIZE(current_instruction().products)) {
97 ¦ ¦ raise << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products in '" << to_original_string(current_instruction()) << "'\n" << end();
98 ¦ }
99 ¦ else {
100 ¦ ¦ for (int i = 0; i < SIZE(current_instruction().products); ++i)
101 ¦ ¦ ¦ write_memory(current_instruction().products.at(i), products.at(i));
102 ¦ }
103 ¦ Writing_products_of_instruction = false;
104 ¦
105 ¦ finish_instruction:;
106 ¦ ++current_step_index();
107 }
108 stop_running_current_routine:;
109 }
110 :(before "End Globals")
111 bool Writing_products_of_instruction = false;
112
113
114 bool should_continue_running(const routine* current_routine) {
115 assert(current_routine == Current_routine);
116 return !Current_routine->completed();
117 }
118
119 bool should_copy_ingredients() {
120
121 return true;
122 }
123
124
125
126
127
128 int& current_step_index() {
129 return Current_routine->running_step_index;
130 }
131
132
133 const string& current_recipe_name() {
134 return get(Recipe, Current_routine->running_recipe).name;
135 }
136
137
138 const recipe& current_recipe() {
139 return get(Recipe, Current_routine->running_recipe);
140 }
141
142
143 const instruction& current_instruction() {
144 return get(Recipe, Current_routine->running_recipe).steps.at(Current_routine->running_step_index);
145 }
146
147
148 bool routine::completed() const {
149 return running_step_index >= SIZE(get(Recipe, running_recipe).steps);
150 }
151
152
153 const vector<instruction>& routine::steps() const {
154 return get(Recipe, running_recipe).steps;
155 }
156
157
158
159
160 :(before "End Load Recipes")
161
162
163
164 load_file_or_directory("core.mu");
165
166
167
168
169 :(before "End Commandline Parsing")
170
171
172
173 if (argc > 1) {
174
175 ++argv;
176 --argc;
177 while (argc > 0) {
178 ¦
179 ¦ if (string(*argv) == "--") break;
180 ¦ if (starts_with(*argv, "--"))
181 ¦ ¦ cerr << "treating " << *argv << " as a file rather than an option\n";
182 ¦ load_file_or_directory(*argv);
183 ¦ --argc;
184 ¦ ++argv;
185 }
186 if (Run_tests) Recipe.erase(get(Recipe_ordinal, "main"));
187 }
188 transform_all();
189
190
191 if (trace_contains_errors()) return 1;
192 save_snapshots();
193
194
195
196 :(before "End Main")
197 if (!Run_tests && contains_key(Recipe_ordinal, "main") && contains_key(Recipe, get(Recipe_ordinal, "main"))) {
198
199 setup();
200 if (Start_tracing) {
201 ¦ Trace_stream = new trace_stream;
202 ¦ Save_trace = true;
203 }
204 trace(2, "run") << "=== Starting to run" << end();
205 assert(Num_calls_to_transform_all == 1);
206 run_main(argc, argv);
207 teardown();
208 }
209 :(code)
210 void run_main(int argc, char* argv[]) {
211 recipe_ordinal r = get(Recipe_ordinal, "main");
212 if (r) run(r);
213 }
214
215
216
217 :(before "End Globals")
218 bool Start_tracing = false;
219 :(before "End Commandline Options(*arg)")
220 else if (is_equal(*arg, "--trace")) {
221 Start_tracing = true;
222 }
223
224 :(code)
225 void dump_profile() {
226 for (map<string, int>::iterator p = Instructions_running.begin(); p != Instructions_running.end(); ++p) {
227 ¦ cerr << p->first << ": " << p->second << '\n';
228 }
229 cerr << "== locations read\n";
230 for (map<string, int>::iterator p = Locations_read.begin(); p != Locations_read.end(); ++p) {
231 ¦ cerr << p->first << ": " << p->second << '\n';
232 }
233 cerr << "== locations read by instruction\n";
234 for (map<string, int>::iterator p = Locations_read_by_instruction.begin(); p != Locations_read_by_instruction.end(); ++p) {
235 ¦ cerr << p->first << ": " << p->second << '\n';
236 }
237 }
238 :(before "End One-time Setup")
239
240
241 :(code)
242 void cleanup_main() {
243 if (Save_trace && Trace_stream) {
244 ¦ cerr << "writing trace to 'last_run'\n";
245 ¦ ofstream fout("last_run");
246 ¦ fout << Trace_stream->readable_contents("");
247 ¦ fout.close();
248 }
249 if (Trace_stream) delete Trace_stream, Trace_stream = NULL;
250 }
251 :(before "End One-time Setup")
252 atexit(cleanup_main);
253
254 :(code)
255 void load_file_or_directory(string filename) {
256 if (is_directory(filename)) {
257 ¦ load_all(filename);
258 ¦ return;
259 }
260 ifstream fin(filename.c_str());
261 if (!fin) {
262 ¦ cerr << "no such file '" << filename << "'\n" << end();
263 ¦ return;
264 }
265 trace(9990, "load") << "=== " << filename << end();
266 load(fin);
267 fin.close();
268 }
269
270 bool is_directory(string path) {
271 struct stat info;
272 if (stat(path.c_str(), &info)) return false;
273 return info.st_mode & S_IFDIR;
274 }
275
276 void load_all(string dir) {
277 dirent** files;
278 int num_files = scandir(dir.c_str(), &files, NULL, alphasort);
279 for (int i = 0; i < num_files; ++i) {
280 ¦ string curr_file = files[i]->d_name;
281 ¦ if (isdigit(curr_file.at(0)))
282 ¦ ¦ load_file_or_directory(dir+'/'+curr_file);
283 ¦ free(files[i]);
284 ¦ files[i] = NULL;
285 }
286 free(files);
287 }
288 :(before "End Includes")
289 #include <dirent.h>
290 #include <sys/stat.h>
291
292
293
294 :(code)
295 vector<double> read_memory(reagent x) {
296
297 vector<double> result;
298 if (is_literal(x)) {
299 ¦ result.push_back(x.value);
300 ¦ return result;
301 }
302
303 int size = size_of(x);
304 for (int offset = 0; offset < size; ++offset) {
305 ¦ double val = get_or_insert(Memory, x.value+offset);
306 ¦ trace(9999, "mem") << "location " << x.value+offset << " is " << no_scientific(val) << end();
307 ¦ result.push_back(val);
308 }
309 return result;
310 }
311
312 void write_memory(reagent x, const vector<double>& data) {
313 assert(Current_routine);
314
315 if (!x.type) {
316 ¦ raise << "can't write to '" << to_string(x) << "'; no type\n" << end();
317 ¦ return;
318 }
319 if (is_dummy(x)) return;
320 if (is_literal(x)) return;
321
322 if (x.value == 0) {
323 ¦ raise << "can't write to location 0 in '" << to_original_string(current_instruction()) << "'\n" << end();
324 ¦ return;
325 }
326 if (size_mismatch(x, data)) {
327 ¦ raise << maybe(current_recipe_name()) << "size mismatch in storing to '" << x.original_string << "' (" << size_of(x) << " vs " << SIZE(data) << ") at '" << to_original_string(current_instruction()) << "'\n" << end();
328 ¦ return;
329 }
330
331 for (int offset = 0; offset < SIZE(data); ++offset) {
332 ¦ assert(x.value+offset > 0);
333 ¦ trace(9999, "mem") << "storing " << no_scientific(data.at(offset)) << " in location " << x.value+offset << end();
334 ¦ put(Memory, x.value+offset, data.at(offset));
335 }
336 }
337
338 :(code)
339 int size_of(const reagent& r) {
340 if (!r.type) return 0;
341
342 return size_of(r.type);
343 }
344 int size_of(const type_tree* type) {
345 if (!type) return 0;
346 if (type->atom) {
347 ¦ if (type->value == -1) return 1;
348 ¦ if (type->value == 0) return 1;
349 ¦
350 }
351 else {
352 ¦ if (!type->left->atom) {
353 ¦ ¦ raise << "invalid type " << to_string(type) << '\n' << end();
354 ¦ ¦ return 0;
355 ¦ }
356 ¦ if (type->left->value == get(Type_ordinal, "address")) return 1;
357 ¦
358 }
359
360 return 1;
361 }
362
363 bool size_mismatch(const reagent& x, const vector<double>& data) {
364 if (!x.type) return true;
365
366
367 return size_of(x) != SIZE(data);
368 }
369
370 bool is_literal(const reagent& r) {
371 return is_literal(r.type);
372 }
373 bool is_literal(const type_tree* type) {
374 if (!type) return false;
375 if (!type->atom) return false;
376 return type->value == 0;
377 }
378
379 bool scalar(const vector<int>& x) {
380 return SIZE(x) == 1;
381 }
382 bool scalar(const vector<double>& x) {
383 return SIZE(x) == 1;
384 }
385
386
387 void run(const string& form) {
388 vector<recipe_ordinal> tmp = load(form);
389 transform_all();
390 if (tmp.empty()) return;
391 if (trace_contains_errors()) return;
392
393
394 if (contains_key(Recipe, get(Recipe_ordinal, "main")))
395 ¦ run(get(Recipe_ordinal, "main"));
396 else
397 ¦ run(tmp.front());
398 }
399
400 :(scenario run_label)
401 def main [
402 +foo
403 1:num <- copy 23
404 2:num <- copy 1:num
405 ]
406 +run: {1: "number"} <- copy {23: "literal"}
407 +run: {2: "number"} <- copy {1: "number"}
408 -run: +foo
409
410 :(scenario run_dummy)
411 def main [
412 _ <- copy 0
413 ]
414 +run: _ <- copy {0: "literal"}
415
416 :(scenario write_to_0_disallowed)
417 % Hide_errors = true;
418 def main [
419 0:num <- copy 34
420 ]
421 -mem: storing 34 in location 0
422
423
424
425
426 :(scenario comma_without_space)
427 def main [
428 1:num, 2:num <- copy 2,2
429 ]
430 +mem: storing 2 in location 1
431
432 :(scenario space_without_comma)
433 def main [
434 1:num, 2:num <- copy 2 2
435 ]
436 +mem: storing 2 in location 1
437
438 :(scenario comma_before_space)
439 def main [
440 1:num, 2:num <- copy 2, 2
441 ]
442 +mem: storing 2 in location 1
443
444 :(scenario comma_after_space)
445 def main [
446 1:num, 2:num <- copy 2 ,2
447 ]
448 +mem: storing 2 in location 1