//: Phase 3: Start running a loaded and transformed recipe. //: //: So far we've seen recipes as lists of instructions, and instructions point //: at other recipes. To kick things off mu needs to know how to run certain //: 'primitive' recipes. That will then give the ability to run recipes //: containing these primitives. //: //: This layer defines a skeleton with just two primitive recipes: IDLE which //: does nothing, and COPY, which can copy numbers from one memory location to //: another. Later layers will add more primitives. :(scenario copy_literal) recipe main [ 1:number <- copy 23 ] +run: 1:number <- copy 23 +mem: storing 23 in location 1 :(scenario copy) recipe main [ 1:number <- copy 23 2:number <- copy 1:number ] +run: 2:number <- copy 1:number +mem: location 1 is 23 +mem: storing 23 in location 2 :(scenario copy_multiple) recipe main [ 1:number, 2:number <- copy 23, 24 ] +mem: storing 23 in location 1 +mem: storing 24 in location 2 :(before "End Types") // Book-keeping while running a recipe. //: Later layers will change this. struct routine { recipe_ordinal running_recipe; long long int running_step_index; routine(recipe_ordinal r) :running_recipe(r), running_step_index(0) {} bool completed() const; }; :(before "End Globals") routine* Current_routine = NULL; map Instructions_running; :(code) void run(recipe_ordinal r) { routine rr(r); Current_routine = &rr; run_current_routine(); } void run_current_routine() { // curly on a separate line, because later layers will modify header while (!Current_routine->completed()) // later layers will modify condition { // Running One Instruction Instructions_running[current_recipe_name()]++; if (current_instruction().is_label) { ++current_step_index(); continue; } trace(Initial_callstack_depth+Callstack_depth, "run") << current_instruction().to_string() << end(); if (Memory[0] != 0) { raise << "something wrote to location 0; this should never happen\n" << end(); Memory[0] = 0; } // Read all ingredients from memory. // Each ingredient loads a vector of values rather than a single value; mu // permits operating on reagents spanning multiple locations. vector > ingredients; for (long long int i = 0; i < SIZE(current_instruction().ingredients); ++i) { ingredients.push_back(read_memory(current_instruction().ingredients.at(i))); } // Instructions below will write to 'products'. vector > products; switch (current_instruction().operation) { // Primitive Recipe Implementations case COPY: { if (SIZE(current_instruction().products) != SIZE(ingredients)) { raise << "ingredients and products should match in '" << current_instruction().to_string() << "'\n" << end(); break; } for (long long int i = 0; i < SIZE(ingredients); ++i) { if (!is_mu_array(current_instruction().ingredients.at(i)) && is_mu_array(current_instruction().products.at(i))) { raise << "can't copy " << current_instruction().ingredients.at(i).original_string << " to array " << current_instruction().products.at(i).original_string << "\n" << end(); goto finish_instruction; } if (is_mu_array(current_instruction().ingredients.at(i)) && !is_mu_array(current_instruction().products.at(i))) { raise << "can't copy array " << current_instruction().ingredients.at(i).original_string << " to " << current_instruction().products.at(i).original_string << "\n" << end(); goto finish_instruction; } } copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin())); break; } // End Primitive Recipe Implementations default: { cout << "not a primitive op: " << current_instruction().operation << '\n'; } } finish_instruction: if (SIZE(products) < SIZE(current_instruction().products)) { raise << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products! " << current_instruction().to_string() << end(); } else { for (long long int i = 0; i < SIZE(current_instruction().products); ++i) { write_memory(current_instruction().products.at(i), products.at(i)); } } // End of Instruction ++current_step_index(); } stop_running_current_routine:; } //: Some helpers. //: We'll need to override these later as we change the definition of routine. //: Important that they return referrences into the routine. inline long long int& current_step_index() { return Current_routine->running_step_index; } inline const string& current_recipe_name() { return Recipe[Current_routine->running_recipe].name; } inline const instruction& current_instruction() { return Recipe[Current_routine->running_recipe].steps.at(Current_routine->running_step_index); } inline bool routine::completed() const { return running_step_index >= SIZE(Recipe[running_recipe].steps); } :(before "End Commandline Parsing") // Loading Commandline Files if (argc > 1) { for (int i = 1; i < argc; ++i) { load_permanently(argv[i]); } } :(before "End Main") if (!Run_tests) { setup(); //? Trace_file = "interactive"; //? 2 //? START_TRACING_UNTIL_END_OF_SCOPE; //? 2 //? Trace_stream->collect_layer.insert("app"); //? 1 transform_all(); recipe_ordinal r = Recipe_ordinal[string("main")]; atexit(dump_profile); if (r) run(r); //? dump_memory(); //? 1 teardown(); } :(code) void dump_profile() { for (map::iterator p = Instructions_running.begin(); p != Instructions_running.end(); ++p) { cerr << p->first << ": " << p->second << '\n'; } } :(code) void cleanup_main() { if (!Trace_file.empty() && Trace_stream) { ofstream fout(Trace_file.c_str()); fout << Trace_stream->readable_contents(""); fout.close(); } } :(before "End One-time Setup") atexit(cleanup_main); :(code) void load_permanently(string filename) { ifstream fin(filename.c_str()); fin.peek(); if (!fin) { raise << "no such file " << filename << '\n' << end(); return; } fin >> std::noskipws; load(fin); transform_all(); fin.close(); // freeze everything so it doesn't get cleared by tests recently_added_recipes.clear(); // End load_permanently. } //:: On startup, load everything in core.mu :(before "End Load Recipes") load_permanently("core.mu"); :(code) // helper for tests void run(string form) { //? cerr << form << '\n'; //? 1 vector tmp = load(form); if (tmp.empty()) return; transform_all(); run(tmp.front()); } //:: Reading from memory, writing to memory. vector read_memory(reagent x) { //? cout << "read_memory: " << x.to_string() << '\n'; //? 2 vector result; if (is_literal(x)) { result.push_back(x.value); return result; } long long int base = x.value; long long int size = size_of(x); for (long long int offset = 0; offset < size; ++offset) { double val = Memory[base+offset]; trace(Primitive_recipe_depth, "mem") << "location " << base+offset << " is " << val << end(); result.push_back(val); } return result; } void write_memory(reagent x, vector data) { if (is_dummy(x)) return; if (is_literal(x)) return; long long int base = x.value; if (size_mismatch(x, data)) { raise << current_recipe_name() << ": size mismatch in storing to " << x.original_string << " at '" << current_instruction().to_string() << "'\n" << end(); return; } for (long long int offset = 0; offset < SIZE(data); ++offset) { trace(Primitive_recipe_depth, "mem") << "storing " << data.at(offset) << " in location " << base+offset << end(); Memory[base+offset] = data.at(offset); } } :(code) long long int size_of(const reagent& r) { if (r.types.empty()) return 0; // End size_of(reagent) Cases return size_of(r.types); } long long int size_of(const vector& types) { if (types.empty()) return 0; // End size_of(types) Cases return 1; } bool size_mismatch(const reagent& x, const vector& data) { if (x.types.empty()) return true; // End size_mismatch(x) Cases //? if (size_of(x) != SIZE(data)) cerr << size_of(x) << " vs " << SIZE(data) << '\n'; //? 2 return size_of(x) != SIZE(data); } bool is_dummy(const reagent& x) { return x.name == "_"; } bool is_literal(const reagent& r) { return SIZE(r.types) == 1 && r.types.at(0) == 0; } bool is_mu_array(reagent r) { return !r.types.empty() && r.types.at(0) == Type_ordinal["array"]; } :(scenario run_label) recipe main [ +foo 1:number <- copy 23 2:number <- copy 1:number ] +run: 1:number <- copy 23 +run: 2:number <- copy 1:number -run: +foo :(scenario run_dummy) recipe main [ _ <- copy 0 ] +run: _ <- copy 0 :(scenario write_to_0_disallowed) recipe main [ 0 <- copy 34 ] -mem: storing 34 in location 0 :(scenario copy_checks_reagent_count) % Hide_warnings = true; recipe main [ 1:number <- copy 34, 35 ] +warn: ingredients and products should match in '1:number <- copy 34, 35' :(scenario write_scalar_to_array_disallowed) % Hide_warnings = true; recipe main [ 1:array:number <- copy 34 ] +warn: can't copy 34 to array 1:array:number :(scenario write_scalar_to_array_disallowed_2) % Hide_warnings = true; recipe main [ 1:number, 2:array:number <- copy 34, 35 ] +warn: can't copy 35 to array 2:array:number //: mu is robust to various combinations of commas and spaces. You just have //: to put spaces around the '<-'. :(scenario comma_without_space) recipe main [ 1:number, 2:number <- copy 2,2 ] +mem: storing 2 in location 1 :(scenario space_without_comma) recipe main [ 1:number, 2:number <- copy 2 2 ] +mem: storing 2 in location 1 :(scenario comma_before_space) recipe main [ 1:number, 2:number <- copy 2, 2 ] +mem: storing 2 in location 1 :(scenario comma_after_space) recipe main [ 1:number, 2:number <- copy 2 ,2 ] +mem: storing 2 in location 1