about summary refs log tree commit diff stats
path: root/edit/005-sandbox.mu
diff options
context:
space:
mode:
Diffstat (limited to 'edit/005-sandbox.mu')
-rw-r--r--edit/005-sandbox.mu146
1 files changed, 73 insertions, 73 deletions
diff --git a/edit/005-sandbox.mu b/edit/005-sandbox.mu
index 77d13238..7962aa2a 100644
--- a/edit/005-sandbox.mu
+++ b/edit/005-sandbox.mu
@@ -13,15 +13,15 @@ def! main [
   initial-recipe:text <- restore [recipes.mu]
   initial-sandbox:text <- new []
   hide-screen 0/screen
-  env:&:programming-environment-data <- new-programming-environment 0/screen, initial-recipe, initial-sandbox
+  env:&:environment <- new-programming-environment 0/screen, initial-recipe, initial-sandbox
   env <- restore-sandboxes env
   render-all 0/screen, env, render
   event-loop 0/screen, 0/console, env
   # never gets here
 ]
 
-container programming-environment-data [
-  sandbox:&:sandbox-data  # list of sandboxes, from top to bottom
+container environment [
+  sandbox:&:sandbox  # list of sandboxes, from top to bottom
   render-from:num
   number-of-sandboxes:num
 ]
@@ -30,7 +30,7 @@ after <programming-environment-initialization> [
   *result <- put *result, render-from:offset, -1
 ]
 
-container sandbox-data [
+container sandbox [
   data:text
   response:text
   # coordinates to track clicks
@@ -38,7 +38,7 @@ container sandbox-data [
   starting-row-on-screen:num
   code-ending-row-on-screen:num  # past end of code
   screen:&:screen  # prints in the sandbox go here
-  next-sandbox:&:sandbox-data
+  next-sandbox:&:sandbox
 ]
 
 scenario run-and-show-results [
@@ -48,13 +48,13 @@ scenario run-and-show-results [
   1:text <- new []
   # sandbox editor contains an instruction without storing outputs
   2:text <- new [divide-with-remainder 11, 3]
-  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  3:&:environment <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the code in the editors
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # check that screen prints the results
   screen-should-contain [
@@ -104,7 +104,7 @@ scenario run-and-show-results [
     press F4
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # check that screen prints the results
   screen-should-contain [
@@ -142,23 +142,23 @@ after <global-keypress> [
   }
 ]
 
-def run-sandboxes env:&:programming-environment-data, screen:&:screen -> errors-found?:bool, env:&:programming-environment-data, screen:&:screen [
+def run-sandboxes env:&:environment, screen:&:screen -> errors-found?:bool, env:&:environment, screen:&:screen [
   local-scope
   load-ingredients
   errors-found?:bool, env, screen <- update-recipes env, screen
   return-if errors-found?
   # check contents of right editor (sandbox)
   <run-sandboxes-begin>
-  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor <- get *env, current-sandbox:offset
   {
     sandbox-contents:text <- editor-contents current-sandbox
     break-unless sandbox-contents
     # if contents exist, first save them
-    # run them and turn them into a new sandbox-data
-    new-sandbox:&:sandbox-data <- new sandbox-data:type
+    # run them and turn them into a new sandbox
+    new-sandbox:&:sandbox <- new sandbox:type
     *new-sandbox <- put *new-sandbox, data:offset, sandbox-contents
     # push to head of sandbox list
-    dest:&:sandbox-data <- get *env, sandbox:offset
+    dest:&:sandbox <- get *env, sandbox:offset
     *new-sandbox <- put *new-sandbox, next-sandbox:offset, dest
     *env <- put *env, sandbox:offset, new-sandbox
     # update sandbox count
@@ -173,7 +173,7 @@ def run-sandboxes env:&:programming-environment-data, screen:&:screen -> errors-
   # save all sandboxes before running, just in case we die when running
   save-sandboxes env
   # run all sandboxes
-  curr:&:sandbox-data <- get *env, sandbox:offset
+  curr:&:sandbox <- get *env, sandbox:offset
   idx:num <- copy 0
   {
     break-unless curr
@@ -187,10 +187,10 @@ def run-sandboxes env:&:programming-environment-data, screen:&:screen -> errors-
 
 # copy code from recipe editor, persist, load into mu
 # replaced in a later layer (whereupon errors-found? will actually be set)
-def update-recipes env:&:programming-environment-data, screen:&:screen -> errors-found?:bool, env:&:programming-environment-data, screen:&:screen [
+def update-recipes env:&:environment, screen:&:screen -> errors-found?:bool, env:&:environment, screen:&:screen [
   local-scope
   load-ingredients
-  recipes:&:editor-data <- get *env, recipes:offset
+  recipes:&:editor <- get *env, recipes:offset
   in:text <- editor-contents recipes
   save [recipes.mu], in  # newlayer: persistence
   reload in
@@ -198,7 +198,7 @@ def update-recipes env:&:programming-environment-data, screen:&:screen -> errors
 ]
 
 # replaced in a later layer
-def! update-sandbox sandbox:&:sandbox-data, env:&:programming-environment-data, idx:num -> sandbox:&:sandbox-data, env:&:programming-environment-data [
+def! update-sandbox sandbox:&:sandbox, env:&:environment, idx:num -> sandbox:&:sandbox, env:&:environment [
   local-scope
   load-ingredients
   data:text <- get *sandbox, data:offset
@@ -214,13 +214,13 @@ def update-status screen:&:screen, msg:text, color:num -> screen:&:screen [
   screen <- print screen, msg, color, 238/grey/background
 ]
 
-def save-sandboxes env:&:programming-environment-data [
+def save-sandboxes env:&:environment [
   local-scope
   load-ingredients
-  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor <- get *env, current-sandbox:offset
   # first clear previous versions, in case we deleted some sandbox
   $system [rm lesson/[0-9]* >/dev/null 2>/dev/null]  # some shells can't handle '>&'
-  curr:&:sandbox-data <- get *env, sandbox:offset
+  curr:&:sandbox <- get *env, sandbox:offset
   idx:num <- copy 0
   {
     break-unless curr
@@ -234,11 +234,11 @@ def save-sandboxes env:&:programming-environment-data [
   }
 ]
 
-def! render-sandbox-side screen:&:screen, env:&:programming-environment-data, {render-editor: (recipe (address screen) (address editor-data) -> number number (address screen) (address editor-data))} -> screen:&:screen, env:&:programming-environment-data [
+def! render-sandbox-side screen:&:screen, env:&:environment, {render-editor: (recipe (address screen) (address editor) -> number number (address screen) (address editor))} -> screen:&:screen, env:&:environment [
   local-scope
   load-ingredients
   trace 11, [app], [render sandbox side]
-  current-sandbox:&:editor-data <- get *env, current-sandbox:offset
+  current-sandbox:&:editor <- get *env, current-sandbox:offset
   row:num, column:num <- copy 1, 0
   left:num <- get *current-sandbox, left:offset
   right:num <- get *current-sandbox, right:offset
@@ -253,12 +253,12 @@ def! render-sandbox-side screen:&:screen, env:&:programming-environment-data, {r
   }
   # render sandboxes
   draw-horizontal screen, row, left, right, 9473/horizontal-double
-  sandbox:&:sandbox-data <- get *env, sandbox:offset
+  sandbox:&:sandbox <- get *env, sandbox:offset
   row, screen <- render-sandboxes screen, sandbox, left, right, row, render-from
   clear-rest-of-screen screen, row, left, right
 ]
 
-def render-sandboxes screen:&:screen, sandbox:&:sandbox-data, left:num, right:num, row:num, render-from:num, idx:num -> row:num, screen:&:screen, sandbox:&:sandbox-data [
+def render-sandboxes screen:&:screen, sandbox:&:sandbox, left:num, right:num, row:num, render-from:num, idx:num -> row:num, screen:&:screen, sandbox:&:sandbox [
   local-scope
   load-ingredients
   return-unless sandbox
@@ -308,7 +308,7 @@ def render-sandboxes screen:&:screen, sandbox:&:sandbox-data, left:num, right:nu
     <end-render-sandbox-reset-hidden>
   }
   # draw next sandbox
-  next-sandbox:&:sandbox-data <- get *sandbox, next-sandbox:offset
+  next-sandbox:&:sandbox <- get *sandbox, next-sandbox:offset
   next-idx:num <- add idx, 1
   row, screen <- render-sandboxes screen, next-sandbox, left, right, row, render-from, next-idx
 ]
@@ -416,20 +416,20 @@ def render-text screen:&:screen, s:text, left:num, right:num, color:num, row:num
 ]
 
 # assumes programming environment has no sandboxes; restores them from previous session
-def restore-sandboxes env:&:programming-environment-data -> env:&:programming-environment-data [
+def restore-sandboxes env:&:environment -> env:&:environment [
   local-scope
   load-ingredients
   # read all scenarios, pushing them to end of a list of scenarios
   idx:num <- copy 0
-  curr:&:sandbox-data <- copy 0
-  prev:&:sandbox-data <- copy 0
+  curr:&:sandbox <- copy 0
+  prev:&:sandbox <- copy 0
   {
     filename:text <- to-text idx
     contents:text <- restore filename
     break-unless contents  # stop at first error; assuming file didn't exist
                            # todo: handle empty sandbox
     # create new sandbox for file
-    curr <- new sandbox-data:type
+    curr <- new sandbox:type
     *curr <- put *curr, data:offset, contents
     <end-restore-sandbox>
     {
@@ -527,12 +527,12 @@ reply z
 ]]
   # sandbox editor contains an instruction without storing outputs
   2:text <- new [foo]
-  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  3:&:environment <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the code in the editors
   assume-console [
     press F4
   ]
-  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:environment
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -552,7 +552,7 @@ reply z
     press F4
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # check that screen updates the result on the right
   screen-should-contain [
@@ -575,13 +575,13 @@ scenario run-instruction-manages-screen-per-sandbox [
   1:text <- new []
   # right editor contains an instruction
   2:text <- new [print-integer screen, 4]
-  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
+  3:&:environment <- new-programming-environment screen:&:screen, 1:text, 2:text
   # run the code in the editor
   assume-console [
     press F4
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # check that it prints a little toy screen
   screen-should-contain [
@@ -601,7 +601,7 @@ scenario run-instruction-manages-screen-per-sandbox [
   ]
 ]
 
-def editor-contents editor:&:editor-data -> result:text [
+def editor-contents editor:&:editor -> result:text [
   local-scope
   load-ingredients
   buf:&:buffer <- new-buffer 80
@@ -623,14 +623,14 @@ def editor-contents editor:&:editor-data -> result:text [
 scenario editor-provides-edited-contents [
   assume-screen 10/width, 5/height
   1:text <- new [abc]
-  2:&:editor-data <- new-editor 1:text, screen:&:screen, 0/left, 10/right
+  2:&:editor <- new-editor 1:text, screen:&:screen, 0/left, 10/right
   assume-console [
     left-click 1, 2
     type [def]
   ]
   run [
-    editor-event-loop screen:&:screen, console:&:console, 2:&:editor-data
-    3:text <- editor-contents 2:&:editor-data
+    editor-event-loop screen:&:screen, console:&:console, 2:&:editor
+    3:text <- editor-contents 2:&:editor
     4:@:char <- copy *3:text
   ]
   memory-should-contain [
@@ -644,7 +644,7 @@ scenario scrolling-down-past-bottom-of-recipe-editor [
   local-scope
   trace-until 100/app
   assume-screen 100/width, 10/height
-  env:&:programming-environment-data <- new-programming-environment screen:&:screen, [], []
+  env:&:environment <- new-programming-environment screen:&:screen, [], []
   render-all screen, env, render
   assume-console [
     press enter
@@ -665,7 +665,7 @@ scenario cursor-down-in-recipe-editor [
   local-scope
   trace-until 100/app
   assume-screen 100/width, 10/height
-  env:&:programming-environment-data <- new-programming-environment screen:&:screen, [], []
+  env:&:environment <- new-programming-environment screen:&:screen, [], []
   render-all screen, env, render
   assume-console [
     press enter
@@ -688,7 +688,7 @@ scenario cursor-down-in-recipe-editor [
 # we'll not use the recipe-editor's 'bottom' element directly, because later
 # layers will add other stuff to the left side below the editor (error messages)
 
-container programming-environment-data [
+container environment [
   recipe-bottom:num
 ]
 
@@ -701,7 +701,7 @@ after <global-keypress> [
     break-if sandbox-in-focus?
     down-arrow?:bool <- equal k, 65516/down-arrow
     break-unless down-arrow?
-    recipe-editor:&:editor-data <- get *env, recipes:offset
+    recipe-editor:&:editor <- get *env, recipes:offset
     recipe-cursor-row:num <- get *recipe-editor, cursor-row:offset
     recipe-editor-bottom:num <- get *recipe-editor, bottom:offset
     at-bottom-of-editor?:bool <- greater-or-equal recipe-cursor-row, recipe-editor-bottom
@@ -731,7 +731,7 @@ after <global-type> [
   }
 ]
 
-def more-to-scroll? env:&:programming-environment-data, screen:&:screen -> result:bool [
+def more-to-scroll? env:&:environment, screen:&:screen -> result:bool [
   local-scope
   load-ingredients
   recipe-bottom:num <- get *env, recipe-bottom:offset
@@ -743,7 +743,7 @@ scenario scrolling-down-past-bottom-of-recipe-editor-2 [
   local-scope
   trace-until 100/app
   assume-screen 100/width, 10/height
-  env:&:programming-environment-data <- new-programming-environment screen:&:screen, [], []
+  env:&:environment <- new-programming-environment screen:&:screen, [], []
   render-all screen, env, render
   assume-console [
     # add a line
@@ -768,7 +768,7 @@ scenario scrolling-down-past-bottom-of-recipe-editor-3 [
   local-scope
   trace-until 100/app
   assume-screen 100/width, 10/height
-  env:&:programming-environment-data <- new-programming-environment screen:&:screen, [], [ab
+  env:&:environment <- new-programming-environment screen:&:screen, [], [ab
 cd]
   render-all screen, env, render
   assume-console [
@@ -800,13 +800,13 @@ scenario scrolling-down-past-bottom-of-sandbox-editor [
   # initialize sandbox side
   1:text <- new []
   2:text <- new [add 2, 2]
-  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
-  render-all screen, 3:&:programming-environment-data, render
+  3:&:environment <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:environment, render
   assume-console [
     # create a sandbox
     press F4
   ]
-  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:environment
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -820,7 +820,7 @@ scenario scrolling-down-past-bottom-of-sandbox-editor [
     press page-down
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
     4:char/cursor <- copy 9251/␣
     print screen:&:screen, 4:char/cursor
   ]
@@ -838,7 +838,7 @@ scenario scrolling-down-past-bottom-of-sandbox-editor [
     press page-up
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
     4:char/cursor <- copy 9251/␣
     print screen:&:screen, 4:char/cursor
   ]
@@ -858,7 +858,7 @@ after <global-keypress> [
     break-unless sandbox-in-focus?
     page-down?:bool <- equal k, 65518/page-down
     break-unless page-down?
-    sandbox:&:sandbox-data <- get *env, sandbox:offset
+    sandbox:&:sandbox <- get *env, sandbox:offset
     break-unless sandbox
     # slide down if possible
     {
@@ -910,12 +910,12 @@ after <global-keypress> [
 
 # sandbox belonging to 'env' whose next-sandbox is 'in'
 # return 0 if there's no such sandbox, either because 'in' doesn't exist in 'env', or because it's the first sandbox
-def previous-sandbox env:&:programming-environment-data, in:&:sandbox-data -> out:&:sandbox-data [
+def previous-sandbox env:&:environment, in:&:sandbox -> out:&:sandbox [
   local-scope
   load-ingredients
-  curr:&:sandbox-data <- get *env, sandbox:offset
+  curr:&:sandbox <- get *env, sandbox:offset
   return-unless curr, 0/nil
-  next:&:sandbox-data <- get *curr, next-sandbox:offset
+  next:&:sandbox <- get *curr, next-sandbox:offset
   {
     return-unless next, 0/nil
     found?:bool <- equal next, in
@@ -935,18 +935,18 @@ scenario scrolling-down-on-recipe-side [
 ]
   # create a sandbox
   2:text <- new [add 2, 2]
-  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
-  render-all screen, 3:&:programming-environment-data, render
+  3:&:environment <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:environment, render
   assume-console [
     press F4
   ]
-  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:environment
   # hit 'down' in recipe editor
   assume-console [
     press page-down
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
     4:char/cursor <- copy 9251/␣
     print screen:&:screen, 4:char/cursor
   ]
@@ -966,8 +966,8 @@ scenario scrolling-through-multiple-sandboxes [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
-  render-all screen, 3:&:programming-environment-data, render
+  3:&:environment <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:environment, render
   # create 2 sandboxes
   assume-console [
     press ctrl-n
@@ -976,7 +976,7 @@ scenario scrolling-through-multiple-sandboxes [
     type [add 1, 1]
     press F4
   ]
-  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:environment
   4:char/cursor <- copy 9251/␣
   print screen:&:screen, 4:char/cursor
   screen-should-contain [
@@ -996,7 +996,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-down
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
     4:char/cursor <- copy 9251/␣
     print screen:&:screen, 4:char/cursor
   ]
@@ -1018,7 +1018,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-down
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # just second sandbox displayed
   screen-should-contain [
@@ -1035,7 +1035,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-down
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # no change
   screen-should-contain [
@@ -1052,7 +1052,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-up
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # back to displaying both sandboxes without editor
   screen-should-contain [
@@ -1071,7 +1071,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-up
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
     4:char/cursor <- copy 9251/␣
     print screen:&:screen, 4:char/cursor
   ]
@@ -1093,7 +1093,7 @@ scenario scrolling-through-multiple-sandboxes [
     press page-up
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
     4:char/cursor <- copy 9251/␣
     print screen:&:screen, 4:char/cursor
   ]
@@ -1118,15 +1118,15 @@ scenario scrolling-manages-sandbox-index-correctly [
   # initialize environment
   1:text <- new []
   2:text <- new []
-  3:&:programming-environment-data <- new-programming-environment screen:&:screen, 1:text, 2:text
-  render-all screen, 3:&:programming-environment-data, render
+  3:&:environment <- new-programming-environment screen:&:screen, 1:text, 2:text
+  render-all screen, 3:&:environment, render
   # create a sandbox
   assume-console [
     press ctrl-n
     type [add 1, 1]
     press F4
   ]
-  event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+  event-loop screen:&:screen, console:&:console, 3:&:environment
   screen-should-contain [
     .                                                                                 run (F4)           .
     .                                                  ┊                                                 .
@@ -1142,7 +1142,7 @@ scenario scrolling-manages-sandbox-index-correctly [
     press page-down
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # sandbox editor hidden; first sandbox displayed
   # cursor moves to first sandbox
@@ -1160,7 +1160,7 @@ scenario scrolling-manages-sandbox-index-correctly [
     press page-up
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # back to displaying both sandboxes as well as editor
   screen-should-contain [
@@ -1178,7 +1178,7 @@ scenario scrolling-manages-sandbox-index-correctly [
     press page-down
   ]
   run [
-    event-loop screen:&:screen, console:&:console, 3:&:programming-environment-data
+    event-loop screen:&:screen, console:&:console, 3:&:environment
   ]
   # sandbox editor hidden; first sandbox displayed
   # cursor moves to first sandbox