# Mu - 101run_sandboxed.cc

      1 //: Helper for various programming environments: run arbitrary Mu code and
      2 //: return some result in text form.
      3
      4 :(scenario run_interactive_code)
      5 def main [
      6   1:num <- copy 0  # reserve space for the sandbox
      7   10:text <- new [1:num/raw <- copy 34]
      8 #?   $print 10:num [|] 11:num [: ] 1000:num [|] *10:text [ (] 10:text [)] 10/newline
      9   run-sandboxed 10:text
     10   20:num <- copy 1:num
     11 ]
     12 +mem: storing 34 in location 20
     13
     14 :(scenario run_interactive_empty)
     15 def main [
     16   10:text <- copy null
     17   20:text <- run-sandboxed 10:text
     18 ]
     19 # result is null
     20 +mem: storing 0 in location 20
     21 +mem: storing 0 in location 21
     22
     23 //: As the name suggests, 'run-sandboxed' will prevent certain operations that
     24 //: regular Mu code can perform.
     25 :(before "End Globals")
     26 bool Sandbox_mode = false;
     27 //: for starters, users can't override 'main' when the environment is running
     28 :(before "End Load Recipe Name")
     29 if (Sandbox_mode && result.name == "main") {
     30   slurp_balanced_bracket(in);
     31   return -1;
     32 }
     33
     34 //: run code in 'interactive mode', i.e. with errors off and return:
     35 //:   stringified output in case we want to print it to screen
     36 //:   any errors encountered
     37 //:   simulated screen any prints went to
     38 //:   any 'app' layer traces generated
     39 :(before "End Primitive Recipe Declarations")
     40 RUN_SANDBOXED,
     41 :(before "End Primitive Recipe Numbers")
     42 put(Recipe_ordinal, "run-sandboxed", RUN_SANDBOXED);
     43 :(before "End Primitive Recipe Checks")
     44 case RUN_SANDBOXED: {
     45   if (SIZE(inst.ingredients) != 1) {
     46     raise << maybe(get(Recipe, r).name) << "'run-sandboxed' requires exactly one ingredient, but got '" << inst.original_string << "'\n" << end();
     47     break;
     48   }
     49   if (!is_mu_text(inst.ingredients.at(0))) {
     50     raise << maybe(get(Recipe, r).name) << "first ingredient of 'run-sandboxed' should be a string, but got '" << to_string(inst.ingredients.at(0)) << "'\n" << end();
     51     break;
     52   }
     53   break;
     54 }
     55 :(before "End Primitive Recipe Implementations")
     56 case RUN_SANDBOXED: {
     57   bool new_code_pushed_to_stack = run_interactive(ingredients.at(0).at(/*skip alloc id*/1));
     58   if (!new_code_pushed_to_stack) {
     59     products.resize(5);
     60     products.at(0).push_back(/*alloc id*/0);
     61     products.at(0).push_back(0);
     62     products.at(1).push_back(/*alloc id*/0);
     63     products.at(1).push_back(trace_error_contents());
     64     products.at(2).push_back(/*alloc id*/0);
     65     products.at(2).push_back(0);
     66     products.at(3).push_back(/*alloc id*/0);
     67     products.at(3).push_back(trace_app_contents());
     68     products.at(4).push_back(1);  // completed
     69     run_code_end();
     70     break;  // done with this instruction
     71   }
     72   else {
     73     continue;  // not done with caller; don't increment current_step_index()
     74   }
     75 }
     76
     77 //: To show results in the sandbox Mu uses a hack: it saves the products
     78 //: returned by each instruction while Track_most_recent_products is true, and
     79 //: keeps the most recent such result around so that it can be returned as the
     80 //: result of a sandbox.
     81
     82 :(before "End Globals")
     83 bool Track_most_recent_products = false;
     84 int Call_depth_to_track_most_recent_products_at = 0;
     85 string Most_recent_products;
     86 :(before "End Reset")
     87 Track_most_recent_products = false;
     88 Call_depth_to_track_most_recent_products_at = 0;
     89 Most_recent_products = "";
     90
     91 :(before "End Globals")
     92 trace_stream* Save_trace_stream = NULL;
     93 string Save_trace_file;
     94 :(code)
     95 // reads a string, tries to call it as code (treating it as a test), saving
     96 // all errors.
     97 // returns true if successfully called (no errors found during load and transform)
     98 bool run_interactive(int address) {
     99 //?   cerr << "run_interactive: " << address << '\n';
    100   assert(contains_key(Recipe_ordinal, "interactive") && get(Recipe_ordinal, "interactive") != 0);
    101   // try to sandbox the run as best you can
    102   // todo: test this
    103   if (!Current_scenario) {
    104     for (int i = 1; i < Reserved_for_tests; ++i)
    105       Memory.erase(i);
    106   }
    107   string command = trim(strip_comments(read_mu_text(address)));
    108 //?   cerr << "command: " << command << '\n';
    109   Name[get(Recipe_ordinal, "interactive")].clear();
    110   run_code_begin(/*should_stash_snapshots*/true);
    111   if (command.empty()) return false;
    112   // don't kill the current routine on parse errors
    113   routine* save_current_routine = Current_routine;
    114   Current_routine = NULL;
    115   // call run(string) but without the scheduling
    116   load(string("recipe! interactive [\n") +
    117           "local-scope\n" +
    118           "screen:&:screen <- next-ingredient\n" +
    119           "$start-tracking-products\n" +
    120           command + "\n" +
    121           "$stop-tracking-products\n" +
    122           "return screen\n" +
    123        "]\n");
    124   transform_all();
    125   Current_routine = save_current_routine;
    126   if (trace_count("error") > 0) return false;
    127   // now call 'sandbox' which will run 'interactive' in a separate routine,
    128   // and wait for it
    129   if (Save_trace_stream) {
    130     ++Save_trace_stream->callstack_depth;
    131     trace(9999, "trace") << "run-sandboxed: incrementing callstack depth to " << Save_trace_stream->callstack_depth << end();
    132     assert(Save_trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
    133   }
    134   Current_routine->calls.push_front(call(get(Recipe_ordinal, "sandbox")));
    135   return true;
    136 }
    137
    138 //: Carefully update all state to exactly how it was -- including snapshots.
    139
    140 :(before "End Globals")
    141 bool Run_profiler_stash = false;
    142 map<string, recipe_ordinal> Recipe_ordinal_snapshot_stash;
    143 map<recipe_ordinal, recipe> Recipe_snapshot_stash;
    144 map<string, type_ordinal> Type_ordinal_snapshot_stash;
    145 map<type_ordinal, type_info> Type_snapshot_stash;
    146 map<recipe_ordinal, map<string, int> > Name_snapshot_stash;
    147 map<string, vector<recipe_ordinal> > Recipe_variants_snapshot_stash;
    148 map<string, type_tree*> Type_abbreviations_snapshot_stash;
    149 vector<scenario> Scenarios_snapshot_stash;
    150 set<string> Scenario_names_snapshot_stash;
    151
    152 :(code)
    153 void run_code_begin(bool should_stash_snapshots) {
    154   // stuff to undo later, in run_code_end()
    155   Hide_errors = true;
    156   Disable_redefine_checks = true;
    157   Run_profiler_stash = Run_profiler;
    158   Run_profiler = false;
    159   if (should_stash_snapshots)
    160     stash_snapshots();
    161   Save_trace_stream = Trace_stream;
    162   Trace_stream = new trace_stream;
    163   Trace_stream->collect_depth = App_depth;
    164 }
    165
    166 void run_code_end() {
    167   Hide_errors = false;
    168   Disable_redefine_checks = false;
    169   Run_profiler = Run_profiler_stash;
    170   Run_profiler_stash = false;
    171 //?   ofstream fout("sandbox.log");
    172 //?   fout << Trace_stream->readable_contents("");
    173 //?   fout.close();
    174   delete Trace_stream;
    175   Trace_stream = Save_trace_stream;
    176   Save_trace_stream = NULL;
    177   Save_trace_file.clear();
    178   Recipe.erase(get(Recipe_ordinal, "interactive"));  // keep past sandboxes from inserting errors
    179   if (!Recipe_snapshot_stash.empty())
    180     unstash_snapshots();
    181 }
    182
    183 // keep sync'd with save_snapshots and restore_snapshots
    184 void stash_snapshots() {
    185   assert(Recipe_ordinal_snapshot_stash.empty());
    186   Recipe_ordinal_snapshot_stash = Recipe_ordinal_snapshot;
    187   assert(Recipe_snapshot_stash.empty());
    188   Recipe_snapshot_stash = Recipe_snapshot;
    189   assert(Type_ordinal_snapshot_stash.empty());
    190   Type_ordinal_snapshot_stash = Type_ordinal_snapshot;
    191   assert(Type_snapshot_stash.empty());
    192   Type_snapshot_stash = Type_snapshot;
    193   assert(Name_snapshot_stash.empty());
    194   Name_snapshot_stash = Name_snapshot;
    195   assert(Recipe_variants_snapshot_stash.empty());
    196   Recipe_variants_snapshot_stash = Recipe_variants_snapshot;
    197   assert(Type_abbreviations_snapshot_stash.empty());
    198   Type_abbreviations_snapshot_stash = Type_abbreviations_snapshot;
    199   assert(Scenarios_snapshot_stash.empty());
    200   Scenarios_snapshot_stash = Scenarios_snapshot;
    201   assert(Scenario_names_snapshot_stash.empty());
    202   Scenario_names_snapshot_stash = Scenario_names_snapshot;
    203   save_snapshots();
    204 }
    205 void unstash_snapshots() {
    206   restore_snapshots();
    207   Recipe_ordinal_snapshot = Recipe_ordinal_snapshot_stash;  Recipe_ordinal_snapshot_stash.clear();
    208   Recipe_snapshot = Recipe_snapshot_stash;  Recipe_snapshot_stash.clear();
    209   Type_ordinal_snapshot = Type_ordinal_snapshot_stash;  Type_ordinal_snapshot_stash.clear();
    210   Type_snapshot = Type_snapshot_stash;  Type_snapshot_stash.clear();
    211   Name_snapshot = Name_snapshot_stash;  Name_snapshot_stash.clear();
    212   Recipe_variants_snapshot = Recipe_variants_snapshot_stash;  Recipe_variants_snapshot_stash.clear();
    213   Type_abbreviations_snapshot = Type_abbreviations_snapshot_stash;  Type_abbreviations_snapshot_stash.clear();
    214   Scenarios_snapshot = Scenarios_snapshot_stash;  Scenarios_snapshot_stash.clear();
    215   Scenario_names_snapshot = Scenario_names_snapshot_stash;  Scenario_names_snapshot_stash.clear();
    216 }
    217
    218 :(before "End Mu Prelude")
    219 load(string(
    220 "recipe interactive [\n") +  // just a dummy version to initialize the Recipe_ordinal and so on
    221 "]\n" +
    222 "recipe sandbox [\n" +
    223   "local-scope\n" +
    224 //?   "$print [aaa] 10/newline\n" +
    225   "screen:&:screen <- new-fake-screen 30, 5\n" +
    226   "routine-id:num <- start-running interactive, screen\n" +
    227   "limit-time routine-id, 100000/instructions\n" +
    228   "wait-for-routine routine-id\n" +
    229 //?   "$print [bbb] 10/newline\n" +
    230   "instructions-run:num <- number-of-instructions routine-id\n" +
    231   "stash instructions-run [instructions run]\n" +
    232   "sandbox-state:num <- routine-state routine-id\n" +
    233   "completed?:bool <- equal sandbox-state, 1/completed\n" +
    234 //?   "$print [completed: ] completed? 10/newline\n" +
    235   "output:text <- $most-recent-products\n" +
    236 //?   "$print [zzz] 10/newline\n" +
    237 //?   "$print output\n" +
    238   "errors:text <- save-errors\n" +
    239   "stashes:text <- save-app-trace\n" +
    240   "$cleanup-run-sandboxed\n" +
    241   "return output, errors, screen, stashes, completed?\n" +
    242 "]\n");
    243
    244 //: adjust errors in the sandbox
    245 :(before "End maybe(recipe_name) Special-cases")
    246 if (recipe_name == "interactive") return "";
    247
    248 :(scenario run_interactive_comments)
    249 def main [
    250   1:text <- new [# ab
    251 add 2, 2]
    252   2:text <- run-sandboxed 1:text
    253   3:@:char <- copy *2:text
    254 ]
    255 +mem: storing 52 in location 4
    256
    257 :(before "End Primitive Recipe Declarations")
    258 _START_TRACKING_PRODUCTS,
    259 :(before "End Primitive Recipe Numbers")
    260 put(Recipe_ordinal, "$start-tracking-products", _START_TRACKING_PRODUCTS);
    261 :(before "End Primitive Recipe Checks")
    262 case _START_TRACKING_PRODUCTS: {
    263   break;
    264 }
    265 :(before "End Primitive Recipe Implementations")
    266 case _START_TRACKING_PRODUCTS: {
    267   Track_most_recent_products = true;
    268   Call_depth_to_track_most_recent_products_at = SIZE(Current_routine->calls);
    269   break;
    270 }
    271
    272 :(before "End Primitive Recipe Declarations")
    273 _STOP_TRACKING_PRODUCTS,
    274 :(before "End Primitive Recipe Numbers")
    275 put(Recipe_ordinal, "$stop-tracking-products", _STOP_TRACKING_PRODUCTS);
    276 :(before "End Primitive Recipe Checks")
    277 case _STOP_TRACKING_PRODUCTS: {
    278   break;
    279 }
    280 :(before "End Primitive Recipe Implementations")
    281 case _STOP_TRACKING_PRODUCTS: {
    282   Track_most_recent_products = false;
    283   break;
    284 }
    285
    286 :(before "End Primitive Recipe Declarations")
    287 _MOST_RECENT_PRODUCTS,
    288 :(before "End Primitive Recipe Numbers")
    289 put(Recipe_ordinal, "$most-recent-products", _MOST_RECENT_PRODUCTS);
    290 :(before "End Primitive Recipe Checks")
    291 case _MOST_RECENT_PRODUCTS: {
    292   break;
    293 }
    294 :(before "End Primitive Recipe Implementations")
    295 case _MOST_RECENT_PRODUCTS: {
    296   products.resize(1);
    297   products.at(0).push_back(/*alloc id*/0);
    298   products.at(0).push_back(new_mu_text(Most_recent_products));
    299   break;
    300 }
    301
    302 :(before "End Primitive Recipe Declarations")
    303 SAVE_ERRORS,
    304 :(before "End Primitive Recipe Numbers")
    305 put(Recipe_ordinal, "save-errors", SAVE_ERRORS);
    306 :(before "End Primitive Recipe Checks")
    307 case SAVE_ERRORS: {
    308   break;
    309 }
    310 :(before "End Primitive Recipe Implementations")
    311 case SAVE_ERRORS: {
    312   products.resize(1);
    313   products.at(0).push_back(/*alloc id*/0);
    314   products.at(0).push_back(trace_error_contents());
    315   break;
    316 }
    317
    318 :(before "End Primitive Recipe Declarations")
    319 SAVE_APP_TRACE,
    320 :(before "End Primitive Recipe Numbers")
    321 put(Recipe_ordinal, "save-app-trace", SAVE_APP_TRACE);
    322 :(before "End Primitive Recipe Checks")
    323 case SAVE_APP_TRACE: {
    324   break;
    325 }
    326 :(before "End Primitive Recipe Implementations")
    327 case SAVE_APP_TRACE: {
    328   products.resize(1);
    329   products.at(0).push_back(/*alloc id*/0);
    330   products.at(0).push_back(trace_app_contents());
    331   break;
    332 }
    333
    334 :(before "End Primitive Recipe Declarations")
    335 _CLEANUP_RUN_SANDBOXED,
    336 :(before "End Primitive Recipe Numbers")
    337 put(Recipe_ordinal, "$cleanup-run-sandboxed", _CLEANUP_RUN_SANDBOXED);
    338 :(before "End Primitive Recipe Checks")
    339 case _CLEANUP_RUN_SANDBOXED: {
    340   break;
    341 }
    342 :(before "End Primitive Recipe Implementations")
    343 case _CLEANUP_RUN_SANDBOXED: {
    344   run_code_end();
    345   break;
    346 }
    347
    348 :(scenario "run_interactive_converts_result_to_text")
    349 def main [
    350   # try to interactively add 2 and 2
    351   10:text <- new [add 2, 2]
    352   20:text <- run-sandboxed 10:text
    353   30:@:char <- copy *20:text
    354 ]
    355 # first letter in the output should be '4' in unicode
    356 +mem: storing 52 in location 31
    357
    358 :(scenario "run_interactive_ignores_products_in_nested_functions")
    359 def main [
    360   10:text <- new [foo]
    361   20:text <- run-sandboxed 10:text
    362   30:@:char <- copy *20:text
    363 ]
    364 def foo [
    365   40:num <- copy 1234
    366   {
    367     break
    368     reply 5678
    369   }
    370 ]
    371 # no product should have been tracked
    372 +mem: storing 0 in location 30
    373
    374 :(scenario "run_interactive_ignores_products_in_previous_instructions")
    375 def main [
    376   10:text <- new [
    377     add 1, 1  # generates a product
    378     foo]  # no products
    379   20:text <- run-sandboxed 10:text
    380   30:@:char <- copy *20:text
    381 ]
    382 def foo [
    383   40:num <- copy 1234
    384   {
    385     break
    386     reply 5678
    387   }
    388 ]
    389 # no product should have been tracked
    390 +mem: storing 0 in location 30
    391
    392 :(scenario "run_interactive_remembers_products_before_final_label")
    393 def main [
    394   10:text <- new [
    395     add 1, 1  # generates a product
    396     +foo]  # no products
    397   20:text <- run-sandboxed 10:text
    398   30:@:char <- copy *20:text
    399 ]
    400 def foo [
    401   40:num <- copy 1234
    402   {
    403     break
    404     reply 5678
    405   }
    406 ]
    407 # product tracked
    408 +mem: storing 50 in location 31
    409
    410 :(scenario "run_interactive_returns_text")
    411 def main [
    412   # try to interactively add 2 and 2
    413   1:text <- new [
    414     x:text <- new [a]
    415     y:text <- new [b]
    416     z:text <- append x:text, y:text
    417   ]
    418   10:text <- run-sandboxed 1:text
    419 #?   $print 10:text 10/newline
    420   20:@:char <- copy *10:text
    421 ]
    422 # output contains "ab"
    423 +mem: storing 97 in location 21
    424 +mem: storing 98 in location 22
    425
    426 :(scenario "run_interactive_returns_errors")
    427 def main [
    428   # run a command that generates an error
    429   10:text <- new [x:num <- copy 34
    430 get x:num, foo:offset]
    431   20:text, 30:text <- run-sandboxed 10:text
    432   40:@:char <- copy *30:text
    433 ]
    434 # error should be "unknown element foo in container number"
    435 +mem: storing 117 in location 41
    436 +mem: storing 110 in location 42
    437 +mem: storing 107 in location 43
    438 +mem: storing 110 in location 44
    439 # ...
    440
    441 :(scenario run_interactive_with_comment)
    442 def main [
    443   # 2 instructions, with a comment after the first
    444   10:text <- new [a:num <- copy 0  # abc
    445 b:num <- copy 0
    446 ]
    447   20:text, 30:text <- run-sandboxed 10:text
    448 ]
    449 # no errors
    450 # skip alloc id
    451 +mem: storing 0 in location 30
    452 +mem: storing 0 in location 31
    453
    454 :(after "Running One Instruction")
    455 if (Track_most_recent_products && SIZE(Current_routine->calls) == Call_depth_to_track_most_recent_products_at
    456     && !current_instruction().is_label
    457     && current_instruction().name != "$stop-tracking-products") {
    458   Most_recent_products = "";
    459 }
    460 :(before "End Running One Instruction")
    461 if (Track_most_recent_products && SIZE(Current_routine->calls) == Call_depth_to_track_most_recent_products_at) {
    462   Most_recent_products = track_most_recent_products(current_instruction(), products);
    463 //?   cerr << "most recent products: " << Most_recent_products << '\n';
    464 }
    465 :(code)
    466 string track_most_recent_products(const instruction& instruction, const vector<vector<double> >& products) {
    467   ostringstream out;
    468   for (int i = 0; i < SIZE(products); ++i) {
    469     // A sandbox can print a string result, but only if it is actually saved
    470     // to a variable in the sandbox, because otherwise the results are
    471     // reclaimed before the sandbox sees them. So you get these interactions
    472     // in the sandbox:
    473     //
    474     //    new [abc]
    475     //    => <address>
    476     //
    477     //    x:text <- new [abc]
    478     //    => abc
    479     if (i < SIZE(instruction.products)) {
    480       if (is_mu_text(instruction.products.at(i))) {
    481         if (SIZE(products.at(i)) != 2) continue;  // weak silent check for address
    482         out << read_mu_text(products.at(i).at(/*skip alloc id*/1)) << '\n';
    483         continue;
    484       }
    485     }
    486     for (int j = 0; j < SIZE(products.at(i)); ++j)
    487       out << no_scientific(products.at(i).at(j)) << ' ';
    488     out << '\n';
    489   }
    490   return out.str();
    491 }
    492
    493 :(code)
    494 string strip_comments(string in) {
    495   ostringstream result;
    496   for (int i = 0; i < SIZE(in); ++i) {
    497     if (in.at(i) != '#') {
    498       result << in.at(i);
    499     }
    500     else {
    501       while (i+1 < SIZE(in) && in.at(i+1) != '\n')
    502         ++i;
    503     }
    504   }
    505   return result.str();
    506 }
    507
    508 int stringified_value_of_location(int address) {
    509   // convert to string
    510   ostringstream out;
    511   out << no_scientific(get_or_insert(Memory, address));
    512   return new_mu_text(out.str());
    513 }
    514
    515 int trace_error_contents() {
    516   if (!Trace_stream) return 0;
    517   ostringstream out;
    518   for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
    519     if (p->label != "error") continue;
    520     out << p->contents;
    521     if (*--p->contents.end() != '\n') out << '\n';
    522   }
    523   string result = out.str();
    524   truncate(result);
    525   if (result.empty()) return 0;
    526   return new_mu_text(result);
    527 }
    528
    529 int trace_app_contents() {
    530   if (!Trace_stream) return 0;
    531   ostringstream out;
    532   for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
    533     if (p->depth != App_depth) continue;
    534     out << p->contents;
    535     if (*--p->contents.end() != '\n') out << '\n';
    536   }
    537   string result = out.str();
    538   if (result.empty()) return 0;
    539   truncate(result);
    540   return new_mu_text(result);
    541 }
    542
    543 void truncate(string& x) {
    544   if (SIZE(x) > 1024) {
    545     x.erase(1024);
    546     *x.rbegin() = '\n';
    547     *++x.rbegin() = '.';
    548     *++++x.rbegin() = '.';
    549   }
    550 }
    551
    552 //: simpler version of run-sandboxed: doesn't do any running, just loads
    553 //: recipes and reports errors.
    554
    555 :(before "End Primitive Recipe Declarations")
    556 RELOAD,
    557 :(before "End Primitive Recipe Numbers")
    558 put(Recipe_ordinal, "reload", RELOAD);
    559 :(before "End Primitive Recipe Checks")
    560 case RELOAD: {
    561   if (SIZE(inst.ingredients) != 1) {
    562     raise << maybe(get(Recipe, r).name) << "'reload' requires exactly one ingredient, but got '" << inst.original_string << "'\n" << end();
    563     break;
    564   }
    565   if (!is_mu_text(inst.ingredients.at(0))) {
    566     raise << maybe(get(Recipe, r).name) << "first ingredient of 'reload' should be a string, but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
    567     break;
    568   }
    569   break;
    570 }
    571 :(before "End Primitive Recipe Implementations")
    572 case RELOAD: {
    573   restore_non_recipe_snapshots();
    574   string code = read_mu_text(ingredients.at(0).at(/*skip alloc id*/1));
    575   run_code_begin(/*should_stash_snapshots*/false);
    576   routine* save_current_routine = Current_routine;
    577   Current_routine = NULL;
    578   Sandbox_mode = true;
    579   vector<recipe_ordinal> recipes_reloaded = load(code);
    580   transform_all();
    581   Trace_stream->newline();  // flush trace
    582   Sandbox_mode = false;
    583   Current_routine = save_current_routine;
    584   products.resize(1);
    585   products.at(0).push_back(/*alloc id*/0);
    586   products.at(0).push_back(trace_error_contents());
    587   run_code_end();  // wait until we're done with the trace contents
    588   break;
    589 }
    590
    591 :(scenario reload_loads_function_definitions)
    592 def main [
    593   local-scope
    594   x:text <- new [recipe foo [
    595     1:num/raw <- copy 34
    596   ]]
    597   reload x
    598   run-sandboxed [foo]
    599   2:num/raw <- copy 1:num/raw
    600 ]
    601 +mem: storing 34 in location 2
    602
    603 :(scenario reload_continues_past_error)
    604 def main [
    605   local-scope
    606   x:text <- new [recipe foo [
    607     get 1234:num, foo:offset
    608   ]]
    609   reload x
    610   1:num/raw <- copy 34
    611 ]
    612 +mem: storing 34 in location 1
    613
    614 :(scenario reload_can_repeatedly_load_container_definitions)
    615 # define a container and try to create it (merge requires knowing container size)
    616 def main [
    617   local-scope
    618   x:text <- new [
    619     container foo [
    620       x:num
    621       y:num
    622     ]
    623     recipe bar [
    624       local-scope
    625       x:foo <- merge 34, 35
    626     ]
    627   ]
    628   # save warning addresses in locations of type 'number' to avoid spurious changes to them due to 'abandon'
    629   10:text/raw <- reload x
    630   20:text/raw <- reload x
    631 ]
    632 # no errors on either load
    633 +mem: storing 0 in location 10
    634 +mem: storing 0 in location 11
    635 +mem: storing 0 in location 20
    636 +mem: storing 0 in location 21