diff options
| author | Kartik K. Agaram <vc@akkartik.com> | 2015-01-09 00:44:24 -0800 |
|---|---|---|
| committer | Kartik K. Agaram <vc@akkartik.com> | 2015-01-09 00:44:24 -0800 |
| commit | 4dc3d13ef6b84914cc823a6df1e1e52ac13d56fd (patch) | |
| tree | 3e47f8083f62d5a1769734ada41a4522dfbd6e03 | |
| parent | bc3c3618d4a3dc97d100aace0baed024ad4074ed (diff) | |
| download | mu-4dc3d13ef6b84914cc823a6df1e1e52ac13d56fd.tar.gz | |
512 - update html rendering
| -rw-r--r-- | mu.arc.t | 418 | ||||
| -rw-r--r-- | mu.arc.t.html | 4015 | ||||
| -rw-r--r-- | scratch.vim | 24 |
3 files changed, 3096 insertions, 1361 deletions
diff --git a/mu.arc.t b/mu.arc.t index 6661f06d..9b6885d3 100644 --- a/mu.arc.t +++ b/mu.arc.t @@ -3148,9 +3148,10 @@ (reset) (new-trace "before") (= traces* (queue)) -(add-code '((before label1 [ - (2:integer <- copy 0:literal) - ]))) +(add-code + '((before label1 [ + (2:integer <- copy 0:literal) + ]))) (if (~iso (as cons before*!label1) '(; fragment ( @@ -3170,12 +3171,13 @@ (reset) (new-trace "before-multiple") (= traces* (queue)) -(add-code '((before label1 [ - (2:integer <- copy 0:literal) - ]) - (before label1 [ - (3:integer <- copy 0:literal) - ]))) +(add-code + '((before label1 [ + (2:integer <- copy 0:literal) + ]) + (before label1 [ + (3:integer <- copy 0:literal) + ]))) (if (~iso (as cons before*!label1) '(; fragment ( @@ -3198,9 +3200,10 @@ (reset) (new-trace "before-scoped") (= traces* (queue)) -(add-code '((before f/label1 [ ; label1 only inside function f - (2:integer <- copy 0:literal) - ]))) +(add-code + '((before f/label1 [ ; label1 only inside function f + (2:integer <- copy 0:literal) + ]))) (if (~iso (insert-code '((1:integer <- copy 0:literal) label1 @@ -3215,9 +3218,10 @@ (reset) (new-trace "before-scoped2") (= traces* (queue)) -(add-code '((before f/label1 [ ; label1 only inside function f - (2:integer <- copy 0:literal) - ]))) +(add-code + '((before f/label1 [ ; label1 only inside function f + (2:integer <- copy 0:literal) + ]))) (if (~iso (insert-code '((1:integer <- copy 0:literal) label1 @@ -3230,9 +3234,10 @@ (reset) (new-trace "after") (= traces* (queue)) -(add-code '((after label1 [ - (2:integer <- copy 0:literal) - ]))) +(add-code + '((after label1 [ + (2:integer <- copy 0:literal) + ]))) (if (~iso (as cons after*!label1) '(; fragment ( @@ -3252,12 +3257,13 @@ (reset) (new-trace "after-multiple") (= traces* (queue)) -(add-code '((after label1 [ - (2:integer <- copy 0:literal) - ]) - (after label1 [ - (3:integer <- copy 0:literal) - ]))) +(add-code + '((after label1 [ + (2:integer <- copy 0:literal) + ]) + (after label1 [ + (3:integer <- copy 0:literal) + ]))) (if (~iso (as cons after*!label1) '(; fragment ( @@ -3280,12 +3286,13 @@ (reset) (new-trace "before-after") (= traces* (queue)) -(add-code '((before label1 [ - (2:integer <- copy 0:literal) - ]) - (after label1 [ - (3:integer <- copy 0:literal) - ]))) +(add-code + '((before label1 [ + (2:integer <- copy 0:literal) + ]) + (after label1 [ + (3:integer <- copy 0:literal) + ]))) (if (and (~iso (as cons before*!label1) '(; fragment ( @@ -3310,20 +3317,21 @@ (reset) (new-trace "before-after-multiple") (= traces* (queue)) -(add-code '((before label1 [ - (2:integer <- copy 0:literal) - (3:integer <- copy 0:literal) - ]) - (after label1 [ - (4:integer <- copy 0:literal) - ]) - (before label1 [ - (5:integer <- copy 0:literal) - ]) - (after label1 [ - (6:integer <- copy 0:literal) - (7:integer <- copy 0:literal) - ]))) +(add-code + '((before label1 [ + (2:integer <- copy 0:literal) + (3:integer <- copy 0:literal) + ]) + (after label1 [ + (4:integer <- copy 0:literal) + ]) + (before label1 [ + (5:integer <- copy 0:literal) + ]) + (after label1 [ + (6:integer <- copy 0:literal) + (7:integer <- copy 0:literal) + ]))) (if (or (~iso (as cons before*!label1) '(; fragment ( @@ -3360,33 +3368,35 @@ (= traces* (queue)) (if (~iso (do (reset) - (add-code '((before label1 [ - (2:integer <- copy 0:literal) - ]) - (after label1 [ - (3:integer <- copy 0:literal) - ]) - (before label1 [ - (4:integer <- copy 0:literal) - ]) - (after label1 [ - (5:integer <- copy 0:literal) - ]))) + (add-code + '((before label1 [ + (2:integer <- copy 0:literal) + ]) + (after label1 [ + (3:integer <- copy 0:literal) + ]) + (before label1 [ + (4:integer <- copy 0:literal) + ]) + (after label1 [ + (5:integer <- copy 0:literal) + ]))) (list before*!label1 after*!label1)) (do (reset) - (add-code '((before label1 [ - (2:integer <- copy 0:literal) - ]) - (before label1 [ - (4:integer <- copy 0:literal) - ]) - (after label1 [ - (3:integer <- copy 0:literal) - ]) - (after label1 [ - (5:integer <- copy 0:literal) - ]))) + (add-code + '((before label1 [ + (2:integer <- copy 0:literal) + ]) + (before label1 [ + (4:integer <- copy 0:literal) + ]) + (after label1 [ + (3:integer <- copy 0:literal) + ]) + (after label1 [ + (5:integer <- copy 0:literal) + ]))) (list before*!label1 after*!label1))) (prn "F - order matters between 'before' and between 'after' fragments, but not *across* 'before' and 'after' fragments")) @@ -3394,14 +3404,15 @@ (new-trace "before-after-braces") (= traces* (queue)) (= function* (table)) -(add-code '((after label1 [ - (1:integer <- copy 0:literal) - ]) - (function f1 [ - { begin - label1 - } - ]))) +(add-code + '((after label1 [ + (1:integer <- copy 0:literal) + ]) + (function f1 [ + { begin + label1 + } + ]))) ;? (= dump-trace* (obj whitelist '("cn0"))) (freeze function*) (if (~iso function*!f1 @@ -3413,14 +3424,15 @@ (new-trace "before-after-any-order") (= traces* (queue)) (= function* (table)) -(add-code '((function f1 [ - { begin - label1 - } - ]) - (after label1 [ - (1:integer <- copy 0:literal) - ]))) +(add-code + '((function f1 [ + { begin + label1 + } + ]) + (after label1 [ + (1:integer <- copy 0:literal) + ]))) (freeze function*) (if (~iso function*!f1 '(label1 @@ -3432,12 +3444,13 @@ (new-trace "multiple-defs") (= traces* (queue)) (= function* (table)) -(add-code '((function f1 [ - (1:integer <- copy 0:literal) - ]) - (function f1 [ - (2:integer <- copy 0:literal) - ]))) +(add-code + '((function f1 [ + (1:integer <- copy 0:literal) + ]) + (function f1 [ + (2:integer <- copy 0:literal) + ]))) (freeze function*) (if (~iso function*!f1 '((((2 integer)) <- ((copy)) ((0 literal))) @@ -3448,12 +3461,13 @@ (new-trace "def!") (= traces* (queue)) (= function* (table)) -(add-code '((function f1 [ - (1:integer <- copy 0:literal) - ]) - (function! f1 [ - (2:integer <- copy 0:literal) - ]))) +(add-code + '((function f1 [ + (1:integer <- copy 0:literal) + ]) + (function! f1 [ + (2:integer <- copy 0:literal) + ]))) (freeze function*) (if (~iso function*!f1 '((((2 integer)) <- ((copy)) ((0 literal))))) @@ -3467,9 +3481,10 @@ (reset) (new-trace "string-new") -(add-code '((function main [ - (1:string-address <- new string:literal 5:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new string:literal 5:literal) + ]))) (let routine make-routine!main (enq routine running-routines*) (let before rep.routine!alloc @@ -3480,9 +3495,10 @@ ; Convenience: initialize strings using string literals (reset) (new-trace "string-literal") -(add-code '((function main [ - (1:string-address <- new "hello") - ]))) +(add-code + '((function main [ + (1:string-address <- new "hello") + ]))) (let routine make-routine!main (enq routine running-routines*) (let before rep.routine!alloc @@ -3496,22 +3512,24 @@ (reset) (new-trace "strcat") -(add-code '((function main [ - (1:string-address <- new "hello,") - (2:string-address <- new " world!") - (3:string-address <- strcat 1:string-address 2:string-address) - ]))) +(add-code + '((function main [ + (1:string-address <- new "hello,") + (2:string-address <- new " world!") + (3:string-address <- strcat 1:string-address 2:string-address) + ]))) (run 'main) (if (~memory-contains-array memory*.3 "hello, world!") (prn "F - 'strcat' concatenates strings")) (reset) (new-trace "interpolate") -(add-code '((function main [ - (1:string-address <- new "hello, _!") - (2:string-address <- new "abc") - (3:string-address <- interpolate 1:string-address 2:string-address) - ]))) +(add-code + '((function main [ + (1:string-address <- new "hello, _!") + (2:string-address <- new "abc") + (3:string-address <- interpolate 1:string-address 2:string-address) + ]))) ;? (= dump-trace* (obj whitelist '("run"))) (run 'main) (if (~memory-contains-array memory*.3 "hello, abc!") @@ -3519,11 +3537,12 @@ (reset) (new-trace "interpolate-empty") -(add-code '((function main [ - (1:string-address <- new "hello!") - (2:string-address <- new "abc") - (3:string-address <- interpolate 1:string-address 2:string-address) - ]))) +(add-code + '((function main [ + (1:string-address <- new "hello!") + (2:string-address <- new "abc") + (3:string-address <- interpolate 1:string-address 2:string-address) + ]))) ;? (= dump-trace* (obj whitelist '("run"))) (run 'main) (if (~memory-contains-array memory*.3 "hello!") @@ -3531,11 +3550,12 @@ (reset) (new-trace "interpolate-at-start") -(add-code '((function main [ - (1:string-address <- new "_, hello!") - (2:string-address <- new "abc") - (3:string-address <- interpolate 1:string-address 2:string-address) - ]))) +(add-code + '((function main [ + (1:string-address <- new "_, hello!") + (2:string-address <- new "abc") + (3:string-address <- interpolate 1:string-address 2:string-address) + ]))) ;? (= dump-trace* (obj whitelist '("run"))) (run 'main) (if (~memory-contains-array memory*.3 "abc, hello") @@ -3543,11 +3563,12 @@ (reset) (new-trace "interpolate-at-end") -(add-code '((function main [ - (1:string-address <- new "hello, _") - (2:string-address <- new "abc") - (3:string-address <- interpolate 1:string-address 2:string-address) - ]))) +(add-code + '((function main [ + (1:string-address <- new "hello, _") + (2:string-address <- new "abc") + (3:string-address <- interpolate 1:string-address 2:string-address) + ]))) ;? (= dump-trace* (obj whitelist '("run"))) (run 'main) (if (~memory-contains-array memory*.3 "hello, abc") @@ -3555,13 +3576,14 @@ (reset) (new-trace "interpolate-varargs") -(add-code '((function main [ - (1:string-address <- new "hello, _, _, and _!") - (2:string-address <- new "abc") - (3:string-address <- new "def") - (4:string-address <- new "ghi") - (5:string-address <- interpolate 1:string-address 2:string-address 3:string-address 4:string-address) - ]))) +(add-code + '((function main [ + (1:string-address <- new "hello, _, _, and _!") + (2:string-address <- new "abc") + (3:string-address <- new "def") + (4:string-address <- new "ghi") + (5:string-address <- interpolate 1:string-address 2:string-address 3:string-address 4:string-address) + ]))) ;? (= dump-trace* (obj whitelist '("run"))) ;? (= dump-trace* (obj whitelist '("run" "array-info"))) ;? (set dump-trace*) @@ -3574,20 +3596,22 @@ (reset) (new-trace "string-find-next") -(add-code '((function main [ - (1:string-address <- new "a/b") - (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new "a/b") + (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) + ]))) (run 'main) (if (~is memory*.2 1) (prn "F - 'find-next' finds first location of a character")) (reset) (new-trace "string-find-next-empty") -(add-code '((function main [ - (1:string-address <- new "") - (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new "") + (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) + ]))) (run 'main) (each routine completed-routines* (aif rep.routine!error (prn "error - " it))) @@ -3596,20 +3620,22 @@ (reset) (new-trace "string-find-next-initial") -(add-code '((function main [ - (1:string-address <- new "/abc") - (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new "/abc") + (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) + ]))) (run 'main) (if (~is memory*.2 0) (prn "F - 'find-next' handles prefix match")) (reset) (new-trace "string-find-next-final") -(add-code '((function main [ - (1:string-address <- new "abc/") - (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new "abc/") + (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) + ]))) (run 'main) ;? (prn memory*.2) (if (~is memory*.2 3) @@ -3617,10 +3643,11 @@ (reset) (new-trace "string-find-next-missing") -(add-code '((function main [ - (1:string-address <- new "abc") - (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new "abc") + (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) + ]))) (run 'main) ;? (prn memory*.2) (if (~is memory*.2 3) @@ -3628,10 +3655,11 @@ (reset) (new-trace "string-find-next-invalid-index") -(add-code '((function main [ - (1:string-address <- new "abc") - (2:integer <- find-next 1:string-address ((#\/ literal)) 4:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new "abc") + (2:integer <- find-next 1:string-address ((#\/ literal)) 4:literal) + ]))) ;? (= dump-trace* (obj whitelist '("run"))) (run 'main) (each routine completed-routines* @@ -3642,30 +3670,33 @@ (reset) (new-trace "string-find-next-first") -(add-code '((function main [ - (1:string-address <- new "ab/c/") - (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new "ab/c/") + (2:integer <- find-next 1:string-address ((#\/ literal)) 0:literal) + ]))) (run 'main) (if (~is memory*.2 2) (prn "F - 'find-next' finds first of multiple options")) (reset) (new-trace "string-find-next-second") -(add-code '((function main [ - (1:string-address <- new "ab/c/") - (2:integer <- find-next 1:string-address ((#\/ literal)) 3:literal) - ]))) +(add-code + '((function main [ + (1:string-address <- new "ab/c/") + (2:integer <- find-next 1:string-address ((#\/ literal)) 3:literal) + ]))) (run 'main) (if (~is memory*.2 4) (prn "F - 'find-next' finds second of multiple options")) (reset) (new-trace "string-split") -(add-code '((function main [ - (1:string-address <- new "a/b") - (2:string-address-array-address <- split 1:string-address ((#\/ literal))) - ]))) +(add-code + '((function main [ + (1:string-address <- new "a/b") + (2:string-address-array-address <- split 1:string-address ((#\/ literal))) + ]))) ;? (set dump-trace*) (run 'main) (each routine completed-routines* @@ -3681,10 +3712,11 @@ (reset) (new-trace "string-split2") -(add-code '((function main [ - (1:string-address <- new "a/b/c") - (2:string-address-array-address <- split 1:string-address ((#\/ literal))) - ]))) +(add-code + '((function main [ + (1:string-address <- new "a/b/c") + (2:string-address-array-address <- split 1:string-address ((#\/ literal))) + ]))) ;? (set dump-trace*) (run 'main) (each routine completed-routines* @@ -3702,10 +3734,11 @@ (reset) (new-trace "string-split-missing") -(add-code '((function main [ - (1:string-address <- new "abc") - (2:string-address-array-address <- split 1:string-address ((#\/ literal))) - ]))) +(add-code + '((function main [ + (1:string-address <- new "abc") + (2:string-address-array-address <- split 1:string-address ((#\/ literal))) + ]))) (run 'main) (each routine completed-routines* (aif rep.routine!error (prn "error - " it))) @@ -3716,10 +3749,11 @@ (reset) (new-trace "string-split-empty") -(add-code '((function main [ - (1:string-address <- new "") - (2:string-address-array-address <- split 1:string-address ((#\/ literal))) - ]))) +(add-code + '((function main [ + (1:string-address <- new "") + (2:string-address-array-address <- split 1:string-address ((#\/ literal))) + ]))) ;? (= dump-trace* (obj whitelist '("run"))) (run 'main) (each routine completed-routines* @@ -3731,10 +3765,11 @@ (reset) (new-trace "string-split-empty-piece") -(add-code '((function main [ - (1:string-address <- new "a/b//c") - (2:string-address-array-address <- split 1:string-address ((#\/ literal))) - ]))) +(add-code + '((function main [ + (1:string-address <- new "a/b//c") + (2:string-address-array-address <- split 1:string-address ((#\/ literal))) + ]))) (run 'main) (each routine completed-routines* (aif rep.routine!error (prn "error - " it))) @@ -3750,11 +3785,12 @@ (reset) (new-trace "parse-and-record") -(add-code '((and-record foo [ - x:string - y:integer - z:boolean - ]))) +(add-code + '((and-record foo [ + x:string + y:integer + z:boolean + ]))) (if (~iso type*!foo (obj size 3 and-record t elems '((string) (integer) (boolean)) fields '(x y z))) (prn "F - 'add-code' can add new and-records")) diff --git a/mu.arc.t.html b/mu.arc.t.html index defc42d1..943742c0 100644 --- a/mu.arc.t.html +++ b/mu.arc.t.html @@ -150,13 +150,16 @@ a { color:#4444ff; } <span class="Comment">; Other than that, we'll say no more about the code, and focus in the rest of</span> <span class="Comment">; this file on the scenarios the code cares about.</span> -<span class="Delimiter">(</span>load <span class="Constant">"mu.arc"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>selective-load <span class="Constant">"mu.arc"</span> section-level<span class="Delimiter">)</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>section <span class="Constant">20</span> <span class="Comment">; Our language is assembly-like in that functions consist of series of</span> <span class="Comment">; statements, and statements consist of an operation and its arguments (input</span> <span class="Comment">; and output).</span> <span class="Comment">;</span> -<span class="Mu"><span class="Comment">; oarg1, oarg2, ... <span class="Op"><-</span> op arg1, arg2, ...</span></span> +<span class="Comment">; oarg1, oarg2, ... <span class="Op"><-</span> op arg1, arg2, ...</span> <span class="Comment">;</span> <span class="Comment">; Args must be atomic, like an integer or a memory address, they can't be</span> <span class="Comment">; expressions doing arithmetic or function calls. But we can have any number</span> @@ -166,7 +169,7 @@ a { color:#4444ff; } <span class="Comment">; idealized syntax above. For now they will be lists of lists:</span> <span class="Comment">;</span> <span class="Comment">; (function-name</span> -<span class="Mu"><span class="Comment">; ((oarg1 oarg2 ... <span class="Op"><-</span> op arg1 arg2 ...)</span></span> +<span class="Comment">; ((oarg1 oarg2 ... <span class="Op"><-</span> op arg1 arg2 ...)</span> <span class="Comment">; ...</span> <span class="Comment">; ...))</span> <span class="Comment">;</span> @@ -180,15 +183,16 @@ a { color:#4444ff; } <span class="Comment">; lightweight tools that can be combined in various ways, say for using</span> <span class="Comment">; different typecheckers in different subsystems.</span> <span class="Comment">;</span> -<span class="Comment">; In our tests we'll define such mu functions using a call to 'add-fns', so</span> -<span class="Comment">; look for it. Everything outside 'add-fns' is just test-harness details.</span> +<span class="Comment">; In our tests we'll define such mu functions using a call to 'add-code', so</span> +<span class="Comment">; look for it. Everything outside 'add-code' is just test-harness details.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> @@ -201,70 +205,79 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"add"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> add <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span> <span class="Constant">3</span> <span class="Constant">4</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'add' operates on two addresses"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"add-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> add <span class="MuConstant">2</span>:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Constant">5</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - ops can take 'literal' operands (but not return them)"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"sub-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> sub <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> subtract <span class="MuConstant">1</span>:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Constant">-2</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sub' subtracts the second arg from the first"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'subtract'"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"mul-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> mul <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> multiply <span class="MuConstant">2</span>:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Constant">6</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'mul' multiplies like 'add' adds"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'multiply'"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"div-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> div <span class="Delimiter">(</span><span class="MuConstant">8</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> divide <span class="MuConstant">8</span>:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Delimiter">(</span><span class="Identifier">/</span> real.8 <span class="Constant">3</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'div' divides like 'sub' subtracts"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Delimiter">(</span>/ real.8 <span class="Constant">3</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'divide'"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"idiv-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> idiv <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">6</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Constant">2</span>:integer <span class="Op"><-</span> divide-with-remainder <span class="MuConstant">23</span>:literal <span class="MuConstant">6</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">3</span> <span class="Constant">2</span> <span class="Constant">5</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'idiv' performs integer division, returning quotient and remainder"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'divide-with-remainder' performs integer division"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"dummy-oarg"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">(</span>_ <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> idiv <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">6</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>_ <span class="Constant">2</span>:integer <span class="Op"><-</span> divide-with-remainder <span class="MuConstant">23</span>:literal <span class="MuConstant">6</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">2</span> <span class="Constant">5</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - '_' oarg can ignore some results"</span><span class="Delimiter">))</span> @@ -276,55 +289,61 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"and-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> and <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> and <span class="MuConstant">t</span>:literal <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> nil<span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - logical 'and' for booleans"</span><span class="Delimiter">))</span> -<span class="Comment">; Basic comparison operations: lt, le, gt, ge, eq, neq</span> +<span class="Comment">; Basic comparison operations</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"lt-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> lt <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> less-than <span class="MuConstant">4</span>:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> nil<span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'lt' is the less-than inequality operator"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'less-than' inequality operator"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"le-literal-false"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> le <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> lesser-or-equal <span class="MuConstant">4</span>:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> nil<span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'le' is the <= inequality operator"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'lesser-or-equal'"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"le-literal-true"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> le <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> lesser-or-equal <span class="MuConstant">4</span>:literal <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> t<span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'le' returns true for equal operands"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'lesser-or-equal' returns true for equal operands"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"le-literal-true-2"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> le <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> lesser-or-equal <span class="MuConstant">4</span>:literal <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> t<span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - le is the <= inequality operator - 2"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'lesser-or-equal' - 2"</span><span class="Delimiter">))</span> <span class="Comment">; Control flow operations: jump, jump-if, jump-unless</span> <span class="Comment">; These introduce a new type -- 'offset' -- for literals that refer to memory</span> @@ -332,26 +351,30 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"jump-skip"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">8</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span> <span class="Comment">; should be skipped</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">8</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; should be skipped</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">8</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'jump' skips some instructions"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"jump-target"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">8</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span> <span class="Comment">; should be skipped</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">8</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; should be skipped</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))))</span> <span class="Comment">; never reached</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Comment">; never reached</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">8</span><span class="Delimiter">))</span> @@ -360,14 +383,15 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"jump-if-skip"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> eq <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Delimiter">(</span><span class="Constant">1</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> equal <span class="MuConstant">1</span>:literal <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Constant">1</span>:boolean <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> t <span class="Constant">2</span> <span class="Constant">1</span><span class="Delimiter">))</span> @@ -375,13 +399,14 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"jump-if-fallthrough"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> eq <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Delimiter">(</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> equal <span class="MuConstant">1</span>:literal <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Constant">3</span>:boolean <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> nil <span class="Constant">2</span> <span class="Constant">3</span><span class="Delimiter">))</span> @@ -389,21 +414,44 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"jump-if-backward"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Comment">; loop</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> eq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Delimiter">(</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">-3</span> offset<span class="Delimiter">))</span> <span class="Comment">; to loop</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Comment">; loop</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> add <span class="Constant">2</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> equal <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Constant">3</span>:boolean <span class="MuConstant">-3</span>:offset<span class="Delimiter">)</span> <span class="Comment">; to loop</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">4</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">3</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'jump-if' can take a negative offset to make backward jumps"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"jump-label"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Identifier">loop</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> add <span class="Constant">2</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> equal <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Constant">3</span>:boolean <span class="Identifier">loop</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("-")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">4</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">3</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'jump-if' can take a negative offset to make backward jumps"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> <span class="Comment">; Data movement relies on addressing modes:</span> <span class="Comment">; 'direct' - refers to a memory location; default for most types.</span> @@ -411,10 +459,11 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"direct-addressing"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="Constant">1</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> <span class="Constant">34</span><span class="Delimiter">))</span> @@ -427,11 +476,12 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"indirect-addressing"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span> <span class="Comment">; unsafe; can't do this in general</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="Constant">1</span> integer-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer-address <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe; can't do this in general</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="Constant">1</span>:integer-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">34</span> <span class="Constant">3</span> <span class="Constant">34</span><span class="Delimiter">))</span> @@ -442,11 +492,12 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"indirect-addressing-oarg"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer-address <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer-address/deref <span class="Op"><-</span> add <span class="Constant">2</span>:integer <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">36</span><span class="Delimiter">))</span> @@ -456,61 +507,82 @@ a { color:#4444ff; } <span class="Comment">;</span> <span class="Comment">; Until now we've dealt with scalar types like integers and booleans and</span> <span class="Comment">; addresses, where mu looks like other assembly languages. In addition, mu</span> -<span class="Comment">; provides first-class support for compound types: arrays and records.</span> +<span class="Comment">; provides first-class support for compound types: arrays and and-records.</span> <span class="Comment">;</span> -<span class="Comment">; 'get' accesses fields in records</span> +<span class="Comment">; 'get' accesses fields in and-records</span> <span class="Comment">; 'index' accesses indices in arrays</span> <span class="Comment">;</span> <span class="Comment">; Both operations require knowledge about the types being worked on, so all</span> <span class="Comment">; types used in mu programs are defined in a single global system-wide table</span> -<span class="Comment">; (see types* in mu.arc for the complete list of types; we'll add to it over</span> +<span class="Comment">; (see type* in mu.arc for the complete list of types; we'll add to it over</span> <span class="Comment">; time).</span> <span class="Comment">; first a sanity check that the table of types is consistent</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>each <span class="Delimiter">(</span>typ typeinfo<span class="Delimiter">)</span> <span class="Global">types*</span> - <span class="Delimiter">(</span>when typeinfo!record +<span class="Delimiter">(</span>each <span class="Delimiter">(</span>typ typeinfo<span class="Delimiter">)</span> <span class="Global">type*</span> + <span class="Delimiter">(</span>when typeinfo!and-record <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is typeinfo!size <span class="Delimiter">(</span>len typeinfo!elems<span class="Delimiter">)))</span> <span class="Delimiter">(</span>when typeinfo!fields <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is typeinfo!size <span class="Delimiter">(</span>len typeinfo!fields<span class="Delimiter">))))))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"get-record"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">0</span> offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> get <span class="Constant">1</span>:integer-boolean-pair <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:integer-boolean-pair <span class="MuConstant">0</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> nil <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">34</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get' accesses fields of records"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get' accesses fields of and-records"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"get-indirect"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">3</span> integer-boolean-pair-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">3</span> integer-boolean-pair-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">0</span> offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer-boolean-pair-address <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:boolean <span class="Op"><-</span> get <span class="Constant">3</span>:integer-boolean-pair-address/deref <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> get <span class="Constant">3</span>:integer-boolean-pair-address/deref <span class="MuConstant">0</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> nil <span class="Constant">3</span> <span class="Constant">1</span> <span class="Constant">4</span> nil <span class="Constant">5</span> <span class="Constant">34</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get' accesses fields of record address"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get' accesses fields of and-record address"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"get-indirect-repeated"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">35</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">36</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer-point-pair-address <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer-point-pair-address-address <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer-integer-pair <span class="Op"><-</span> get <span class="Constant">5</span>:integer-point-pair-address-address/deref/deref <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer <span class="Op"><-</span> get <span class="Constant">5</span>:integer-point-pair-address-address/deref/deref <span class="MuConstant">0</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains <span class="Constant">6</span> <span class="Delimiter">'(</span><span class="Constant">35</span> <span class="Constant">36</span> <span class="Constant">34</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get' can deref multiple times"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"get-compound-field"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">35</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">36</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer-integer-pair<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> integer-point-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">35</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">36</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer-integer-pair <span class="Op"><-</span> get <span class="Constant">1</span>:integer-point-pair <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> <span class="Constant">35</span> <span class="Constant">3</span> <span class="Constant">36</span> <span class="Constant">4</span> <span class="Constant">35</span> <span class="Constant">5</span> <span class="Constant">36</span><span class="Delimiter">))</span> @@ -518,39 +590,42 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"get-address"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean-address<span class="Delimiter">)</span> <span class="Op"><-</span> get-address <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean-address <span class="Op"><-</span> get-address <span class="Constant">1</span>:integer-boolean-pair <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> t <span class="Constant">3</span> <span class="Constant">2</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get-address' returns address of fields of records"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get-address' returns address of fields of and-records"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"get-address-indirect"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean-address<span class="Delimiter">)</span> <span class="Op"><-</span> get-address <span class="Delimiter">(</span><span class="Constant">3</span> integer-boolean-pair-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer-boolean-pair-address <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:boolean-address <span class="Op"><-</span> get-address <span class="Constant">3</span>:integer-boolean-pair-address/deref <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> t <span class="Constant">3</span> <span class="Constant">1</span> <span class="Constant">4</span> <span class="Constant">2</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get-address' accesses fields of record address"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'get-address' accesses fields of and-record address"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"index-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Op"><-</span> index <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair-array<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer-boolean-pair <span class="Op"><-</span> index <span class="Constant">1</span>:integer-boolean-pair-array <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">23</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">24</span> <span class="Constant">5</span> t <span class="Constant">6</span> <span class="Constant">24</span> <span class="Constant">7</span> t<span class="Delimiter">))</span> @@ -559,15 +634,16 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"index-direct"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">7</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Op"><-</span> index <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair-array<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">6</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer-boolean-pair <span class="Op"><-</span> index <span class="Constant">1</span>:integer-boolean-pair-array <span class="Constant">6</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">23</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">24</span> <span class="Constant">5</span> t <span class="Constant">6</span> <span class="Constant">1</span> <span class="Constant">7</span> <span class="Constant">24</span> <span class="Constant">8</span> t<span class="Delimiter">))</span> @@ -576,16 +652,17 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"index-indirect"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">7</span> integer-boolean-pair-array-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">8</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Op"><-</span> index <span class="Delimiter">(</span><span class="Constant">7</span> integer-boolean-pair-array-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">6</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer-boolean-pair-array-address <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer-boolean-pair <span class="Op"><-</span> index <span class="Constant">7</span>:integer-boolean-pair-array-address/deref <span class="Constant">6</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "cvt0" "cvt1")))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> @@ -595,16 +672,34 @@ a { color:#4444ff; } <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"index-indirect-multiple"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">25</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">26</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer-array-address <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer-array-address-address <span class="Op"><-</span> copy <span class="MuConstant">6</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer <span class="Op"><-</span> index <span class="Constant">7</span>:integer-array-address-address/deref/deref <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.8</span> <span class="Constant">24</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'index' can deref multiple times"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"index-address"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">7</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Op"><-</span> index-address <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair-array<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">6</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer-boolean-pair-address <span class="Op"><-</span> index-address <span class="Constant">1</span>:integer-boolean-pair-array <span class="Constant">6</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">23</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">24</span> <span class="Constant">5</span> t <span class="Constant">6</span> <span class="Constant">1</span> <span class="Constant">7</span> <span class="Constant">4</span><span class="Delimiter">))</span> @@ -612,16 +707,17 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"index-address-indirect"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">7</span> integer-boolean-pair-array-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">8</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Op"><-</span> index-address <span class="Delimiter">(</span><span class="Constant">7</span> integer-boolean-pair-array-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">6</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer-boolean-pair-array-address <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer-boolean-pair-address <span class="Op"><-</span> index-address <span class="Constant">7</span>:integer-boolean-pair-array-address/deref <span class="Constant">6</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">23</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">24</span> <span class="Constant">5</span> t <span class="Constant">6</span> <span class="Constant">1</span> <span class="Constant">7</span> <span class="Constant">1</span> <span class="Constant">8</span> <span class="Constant">4</span><span class="Delimiter">))</span> @@ -631,44 +727,48 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"len-array"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> len <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair-array<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> length <span class="Constant">1</span>:integer-boolean-pair-array<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">23</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">24</span> <span class="Constant">5</span> t <span class="Constant">6</span> <span class="Constant">2</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'len' accesses length of array"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.6</span> <span class="Constant">2</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'length' of array"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"len-array-indirect"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">7</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> len <span class="Delimiter">(</span><span class="Constant">6</span> integer-boolean-pair-array-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer-address <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> length <span class="Constant">6</span>:integer-boolean-pair-array-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "cvt0" "cvt1")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">2</span> <span class="Constant">23</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">24</span> <span class="Constant">5</span> t <span class="Constant">6</span> <span class="Constant">1</span> <span class="Constant">7</span> <span class="Constant">2</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'len' accesses length of array address"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.7</span> <span class="Constant">2</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'length' of array address"</span><span class="Delimiter">))</span> <span class="Comment">; 'sizeof' is a helper to determine the amount of memory required by a type.</span> +<span class="Comment">; Only for non-arrays.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"sizeof-record"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> sizeof <span class="Delimiter">(</span>integer-boolean-pair literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> sizeof integer-boolean-pair:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Constant">2</span><span class="Delimiter">)</span> @@ -676,57 +776,54 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"sizeof-record-not-len"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> sizeof <span class="Delimiter">(</span>integer-point-pair literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> sizeof integer-point-pair:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Constant">3</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>is <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' is different from number of elems"</span><span class="Delimiter">))</span> <span class="Comment">; Regardless of a type's length, you can move it around just like a primitive.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"compound-operand-copy"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"copy-record"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer-boolean-pair <span class="Op"><-</span> copy <span class="Constant">1</span>:integer-boolean-pair<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> nil <span class="Constant">3</span> <span class="Constant">34</span> <span class="Constant">4</span> nil<span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - ops can operate on records spanning multiple locations"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"compound-arg"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)))))</span></span> -<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> nil <span class="Constant">4</span> <span class="Constant">34</span> <span class="Constant">5</span> nil<span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'arg' can copy records spanning multiple locations"</span><span class="Delimiter">))</span> - -<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"compound-arg-indirect"</span><span class="Delimiter">)</span> -<span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="Constant">3</span> integer-boolean-pair-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"copy-record2"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">35</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">36</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer-point-pair <span class="Op"><-</span> copy <span class="Constant">1</span>:integer-point-pair<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "sizeof")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> nil <span class="Constant">3</span> <span class="Constant">1</span> <span class="Constant">4</span> <span class="Constant">34</span> <span class="Constant">5</span> nil<span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'arg' can copy records spanning multiple locations in indirect mode"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> <span class="Constant">35</span> <span class="Constant">3</span> <span class="Constant">36</span> + <span class="Comment">; result</span> + <span class="Constant">4</span> <span class="Constant">34</span> <span class="Constant">5</span> <span class="Constant">35</span> <span class="Constant">6</span> <span class="Constant">36</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - ops can operate on records with fields spanning multiple locations"</span><span class="Delimiter">))</span> + +<span class="Delimiter">)</span> <span class="Comment">; section 20</span> + +<span class="Delimiter">(</span>section <span class="Constant">100</span> <span class="Comment">; A special kind of record is the 'tagged type'. It lets us represent</span> <span class="Comment">; dynamically typed values, which save type information in memory rather than</span> @@ -736,138 +833,165 @@ a { color:#4444ff; } <span class="Comment">;</span> <span class="Comment">; 'save-type' - turns a regular value into a tagged-value of the appropriate type</span> <span class="Comment">; 'maybe-coerce' - turns a tagged value into a regular value if the type matches</span> +<span class="Comment">;</span> +<span class="Comment">; The payload of a tagged value must occupy just one location. Save pointers</span> +<span class="Comment">; to records.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"tagged-value"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "cvt0" "cvt1")))</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> type<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span> <span class="Comment">; pointer to nowhere</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span class="Constant">1</span> tagged-value<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:type <span class="Op"><-</span> copy integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Constant">4</span>:boolean <span class="Op"><-</span> maybe-coerce <span class="Constant">1</span>:tagged-value integer:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> <span class="CommentedCode">;? (prn completed-routines*)</span> <span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">34</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.4</span> t<span class="Delimiter">))</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">34</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.4</span> t<span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'maybe-coerce' copies value only if type tag matches"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"tagged-value-2"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> type<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span> <span class="Comment">; pointer to nowhere</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span class="Constant">1</span> tagged-value<span class="Delimiter">)</span> <span class="Delimiter">(</span>boolean-address literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:type <span class="Op"><-</span> copy integer-address:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Constant">4</span>:boolean <span class="Op"><-</span> maybe-coerce <span class="Constant">1</span>:tagged-value boolean:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.4</span> nil<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">0</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.4</span> nil<span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'maybe-coerce' doesn't copy value when type tag doesn't match"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"save-type"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span> <span class="Comment">; pointer to nowhere</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> tagged-value<span class="Delimiter">)</span> <span class="Op"><-</span> save-type <span class="Delimiter">(</span><span class="Constant">1</span> integer-address<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">1</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> <span class="Delimiter">'</span>integer-address <span class="Constant">3</span> <span class="Constant">34</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> <span class="Delimiter">'</span>integer <span class="Constant">3</span> <span class="Constant">34</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'save-type' saves the type of a value at runtime, turning it into a tagged-value"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"new-tagged-value"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span> <span class="Comment">; pointer to nowhere</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">1</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span class="Constant">2</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"init-tagged-value"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value integer:literal <span class="Constant">1</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Constant">4</span>:boolean <span class="Op"><-</span> maybe-coerce <span class="Constant">2</span>:tagged-value-address/deref integer:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "cvt0" "cvt1" "sizeof")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">34</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.4</span> t<span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new-tagged-value' is the converse of 'maybe-coerce'"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">34</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.4</span> t<span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'init-tagged-value' is the converse of 'maybe-coerce'"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> -<span class="Comment">; Now that we can record types for values we can construct a dynamically typed</span> -<span class="Comment">; list.</span> +<span class="Comment">; Now that we can package values together with their types, we can construct a</span> +<span class="Comment">; dynamically typed list.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"list"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> <span class="Comment">; 1 points at first node: tagged-value (int 34)</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> list-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>list literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> list-value-address <span class="Delimiter">(</span><span class="Constant">1</span> list-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> type-address<span class="Delimiter">)</span> <span class="Op"><-</span> get-address <span class="Delimiter">(</span><span class="Constant">2</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">0</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> type-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> location<span class="Delimiter">)</span> <span class="Op"><-</span> get-address <span class="Delimiter">(</span><span class="Constant">2</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> location deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> list-address-address<span class="Delimiter">)</span> <span class="Op"><-</span> get-address <span class="Delimiter">(</span><span class="Constant">1</span> list-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> list-address-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>list literal<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:list-address <span class="Op"><-</span> new list:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:tagged-value-address <span class="Op"><-</span> list-value-address <span class="Constant">1</span>:list-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:type-address <span class="Op"><-</span> get-address <span class="Constant">2</span>:tagged-value-address/deref type:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:type-address/deref <span class="Op"><-</span> copy integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:location <span class="Op"><-</span> get-address <span class="Constant">2</span>:tagged-value-address/deref payload:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:location/deref <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:list-address-address <span class="Op"><-</span> get-address <span class="Constant">1</span>:list-address/deref cdr:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:list-address-address/deref <span class="Op"><-</span> new list:literal<span class="Delimiter">)</span></span> <span class="Comment">; 6 points at second node: tagged-value (boolean t)</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> list-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="Constant">5</span> list-address-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">7</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> list-value-address <span class="Delimiter">(</span><span class="Constant">6</span> list-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">8</span> type-address<span class="Delimiter">)</span> <span class="Op"><-</span> get-address <span class="Delimiter">(</span><span class="Constant">7</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">0</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">8</span> type-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span>boolean literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">9</span> location<span class="Delimiter">)</span> <span class="Op"><-</span> get-address <span class="Delimiter">(</span><span class="Constant">7</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">9</span> location deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">10</span> list-address<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">6</span> list-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Delimiter">)))</span> -<span class="Delimiter">(</span><span class="Normal">let</span> first Memory-in-use-until - <span class="Delimiter">(</span>run <span class="Delimiter">'</span>test1<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~all first <span class="Delimiter">(</span><span class="Identifier">map</span> <span class="Global">memory*</span> <span class="Delimiter">'(</span><span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span><span class="Delimiter">)))</span> - <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Error">.first</span> <span class="Delimiter">'</span>integer<span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.4</span> <span class="Delimiter">(</span><span class="Identifier">+</span> first <span class="Constant">1</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> first <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">34</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.5</span> <span class="Delimiter">(</span><span class="Identifier">+</span> first <span class="Constant">2</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span><span class="Normal">let</span> second <span class="Global">memory*</span><span class="Constant">.6</span> - <span class="Delimiter">(</span><span class="Normal">or</span> - <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> first <span class="Constant">2</span><span class="Delimiter">))</span> second<span class="Delimiter">)</span> - <span class="Delimiter">(</span>~all second <span class="Delimiter">(</span><span class="Identifier">map</span> <span class="Global">memory*</span> <span class="Delimiter">'(</span><span class="Constant">6</span> <span class="Constant">7</span> <span class="Constant">8</span><span class="Delimiter">)))</span> - <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Error">.second</span> <span class="Delimiter">'</span>boolean<span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.9</span> <span class="Delimiter">(</span><span class="Identifier">+</span> second <span class="Constant">1</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> second <span class="Constant">1</span><span class="Delimiter">))</span> t<span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.10</span> nil<span class="Delimiter">))))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - lists can contain elements of different types"</span><span class="Delimiter">)))</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">10</span> list-address<span class="Delimiter">)</span> <span class="Op"><-</span> list-next <span class="Delimiter">(</span><span class="Constant">1</span> list-address<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:list-address <span class="Op"><-</span> copy <span class="Constant">5</span>:list-address-address/deref<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:tagged-value-address <span class="Op"><-</span> list-value-address <span class="Constant">6</span>:list-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:type-address <span class="Op"><-</span> get-address <span class="Constant">7</span>:tagged-value-address/deref type:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:type-address/deref <span class="Op"><-</span> copy boolean:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">9</span>:location <span class="Op"><-</span> get-address <span class="Constant">7</span>:tagged-value-address/deref payload:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">9</span>:location/deref <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">10</span>:list-address <span class="Op"><-</span> get <span class="Constant">6</span>:list-address/deref <span class="MuConstant">1</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> first rep.routine!alloc +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> + <span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~all first <span class="Delimiter">(</span>map <span class="Global">memory*</span> <span class="Delimiter">'(</span><span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span><span class="Delimiter">)))</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.first <span class="Delimiter">'</span>integer<span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.4</span> <span class="Delimiter">(</span>+ first <span class="Constant">1</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ first <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">34</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.5</span> <span class="Delimiter">(</span>+ first <span class="Constant">2</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span><span class="Normal">let</span> second <span class="Global">memory*</span><span class="Constant">.6</span> + <span class="Delimiter">(</span><span class="Normal">or</span> + <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ first <span class="Constant">2</span><span class="Delimiter">))</span> second<span class="Delimiter">)</span> + <span class="Delimiter">(</span>~all second <span class="Delimiter">(</span>map <span class="Global">memory*</span> <span class="Delimiter">'(</span><span class="Constant">6</span> <span class="Constant">7</span> <span class="Constant">8</span><span class="Delimiter">)))</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.second <span class="Delimiter">'</span>boolean<span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.9</span> <span class="Delimiter">(</span>+ second <span class="Constant">1</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ second <span class="Constant">1</span><span class="Delimiter">))</span> t<span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.10</span> nil<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - lists can contain elements of different types"</span><span class="Delimiter">))))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">10</span>:list-address <span class="Op"><-</span> list-next <span class="Constant">1</span>:list-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>test2<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.10</span> <span class="Global">memory*</span><span class="Constant">.6</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'list-next can move a list pointer to the next node"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> -<span class="Comment">; 'new-list' takes a variable number of args and constructs a list containing</span> -<span class="Comment">; them.</span> +<span class="Comment">; 'init-list' takes a variable number of args and constructs a list containing</span> +<span class="Comment">; them. Just integers for now.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"new-list"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> new-list <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"init-list"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> init-list <span class="MuConstant">3</span>:literal <span class="MuConstant">4</span>:literal <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "cvt0" "cvt1" "sizeof")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">let</span> first <span class="Global">memory*</span><span class="Constant">.1</span> <span class="CommentedCode">;? (prn first)</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Error">.first</span> <span class="Delimiter">'</span>integer<span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> first <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">3</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span><span class="Normal">let</span> second <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> first <span class="Constant">2</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.first <span class="Delimiter">'</span>integer<span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ first <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">3</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> second <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ first <span class="Constant">2</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (prn second)</span> - <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Error">.second</span> <span class="Delimiter">'</span>integer<span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> second <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">4</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span><span class="Normal">let</span> third <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> second <span class="Constant">2</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.second <span class="Delimiter">'</span>integer<span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ second <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> third <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ second <span class="Constant">2</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (prn third)</span> - <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Error">.third</span> <span class="Delimiter">'</span>integer<span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> third <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">5</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> third <span class="Constant">2</span><span class="Delimiter">)</span> nil<span class="Delimiter">)))))))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new-list' can construct a list of integers"</span><span class="Delimiter">)))</span> + <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.third <span class="Delimiter">'</span>integer<span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ third <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">5</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ third <span class="Constant">2</span><span class="Delimiter">)</span> nil<span class="Delimiter">)))))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'init-list' can construct a list of integers"</span><span class="Delimiter">)))</span> + +<span class="Delimiter">)</span> <span class="Comment">; section 100</span> + +<span class="Delimiter">(</span>section <span class="Constant">20</span> <span class="SalientComment">;; Functions</span> <span class="Comment">;</span> @@ -877,13 +1001,15 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> add <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span> <span class="Constant">3</span> <span class="Constant">4</span><span class="Delimiter">))</span> @@ -892,11 +1018,13 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-once"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">2</span> <span class="Global">curr-cycle*</span><span class="Delimiter">)</span> @@ -911,15 +1039,17 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-reply"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> add <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span> <span class="Constant">3</span> <span class="Constant">4</span><span class="Delimiter">))</span> @@ -928,14 +1058,17 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-reply-nested"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> test2<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test2</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> test2<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function test2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">2</span> <span class="Constant">34</span> <span class="Constant">3</span> <span class="Constant">34</span><span class="Delimiter">))</span> @@ -944,15 +1077,17 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-reply-once"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> add <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">5</span> <span class="Global">curr-cycle*</span><span class="Delimiter">)</span> @@ -960,23 +1095,42 @@ a { color:#4444ff; } <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"reply-increments-caller-pc"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function callee <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function caller <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>freeze <span class="Global">function*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">routine*</span> <span class="Delimiter">(</span>make-routine <span class="Delimiter">'</span>caller<span class="Delimiter">))</span> +<span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is <span class="Constant">0</span> pc.routine*<span class="Delimiter">))</span> +<span class="Delimiter">(</span>push-stack <span class="Global">routine*</span> <span class="Delimiter">'</span>callee<span class="Delimiter">)</span> <span class="Comment">; pretend call was at first instruction of caller</span> +<span class="Delimiter">(</span>run-for-time-slice <span class="Constant">1</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> pc.routine*<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'reply' should increment pc in caller (to move past calling instruction)"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-sequential"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> integer<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> add <span class="Constant">4</span>:integer <span class="Constant">5</span>:integer<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Delimiter">)))</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span> <span class="Constant">3</span> <span class="Constant">4</span> - <span class="Comment">; add-fn's temporaries</span> + <span class="Comment">; test1's temporaries</span> <span class="Constant">4</span> <span class="Constant">1</span> <span class="Constant">5</span> <span class="Constant">3</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'arg' accesses in order the operands of the most recent function call (the caller)"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> @@ -984,34 +1138,53 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-random-access"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span> <span class="Delimiter">(</span><span class="MuConstant">0</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> integer<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> <span class="Identifier">input</span> <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">input</span> <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> add <span class="Constant">4</span>:integer <span class="Constant">5</span>:integer<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))</span> <span class="Comment">; should never run</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Delimiter">)))</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span> <span class="Comment">; should never run</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span> <span class="Constant">3</span> <span class="Constant">4</span> - <span class="Comment">; add-fn's temporaries</span> + <span class="Comment">; test's temporaries</span> <span class="Constant">4</span> <span class="Constant">1</span> <span class="Constant">5</span> <span class="Constant">3</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'arg' with index can access function call arguments out of order"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-random-then-sequential"</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>_ <span class="Op"><-</span> <span class="Identifier">input</span> <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span> <span class="Comment">; takes next arg after index 1</span></span> + <span class="Delimiter">])</span> <span class="Comment">; should never run</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="MuConstant">1</span>:literal <span class="MuConstant">2</span>:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">3</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'arg' with index resets index for later calls"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-status"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Delimiter">)))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Constant">5</span>:boolean <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">4</span> <span class="Constant">1</span> <span class="Constant">5</span> t<span class="Delimiter">))</span> @@ -1020,13 +1193,14 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-missing"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Delimiter">)))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">4</span> <span class="Constant">1</span><span class="Delimiter">))</span> @@ -1035,13 +1209,14 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-missing-2"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">6</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Delimiter">)))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Constant">6</span>:boolean <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">4</span> <span class="Constant">1</span> <span class="Constant">6</span> nil<span class="Delimiter">))</span> @@ -1050,14 +1225,15 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-missing-3"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">6</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Delimiter">)))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Constant">6</span>:boolean <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">4</span> <span class="Constant">1</span> <span class="Constant">6</span> nil<span class="Delimiter">))</span> @@ -1066,19 +1242,21 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-missing-4"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> <span class="Comment">; if given two args, adds them; if given one arg, increments</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">6</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-if</span> <span class="Delimiter">(</span><span class="Constant">6</span> boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">7</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> integer<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Delimiter">)))</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Constant">6</span>:boolean <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-if</span> <span class="Constant">6</span>:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + } + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> add <span class="Constant">4</span>:integer <span class="Constant">5</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">4</span> <span class="Constant">34</span> <span class="Constant">5</span> <span class="Constant">1</span> <span class="Constant">6</span> nil <span class="Constant">7</span> <span class="Constant">35</span><span class="Delimiter">))</span> @@ -1087,79 +1265,124 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-arg-by-value"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">0</span> literal<span class="Delimiter">))</span> <span class="Comment">; overwrite caller memory</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))</span> <span class="Comment">; arg not clobbered</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span> <span class="Comment">; overwrite caller memory</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> <span class="Comment">; arg not clobbered</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Constant">1</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">0</span> <span class="Constant">2</span> <span class="Constant">34</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'arg' passes by value"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"arg-record"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer-boolean-pair <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Constant">1</span>:integer-boolean-pair<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> nil <span class="Constant">4</span> <span class="Constant">34</span> <span class="Constant">5</span> nil<span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'arg' can copy records spanning multiple locations"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"arg-record-indirect"</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer-boolean-pair <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer-boolean-pair-address <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>test1 <span class="Constant">3</span>:integer-boolean-pair-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">34</span> <span class="Constant">2</span> nil <span class="Constant">3</span> <span class="Constant">1</span> <span class="Constant">4</span> <span class="Constant">34</span> <span class="Constant">5</span> nil<span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'arg' can copy records spanning multiple locations in indirect mode"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-reply-oarg"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span class="Constant">6</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> test1 <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> add <span class="Constant">4</span>:integer <span class="Constant">5</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">6</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> test1 <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span> <span class="Constant">3</span> <span class="Constant">4</span> - <span class="Comment">; add-fn's temporaries</span> + <span class="Comment">; test1's temporaries</span> <span class="Constant">4</span> <span class="Constant">1</span> <span class="Constant">5</span> <span class="Constant">3</span> <span class="Constant">6</span> <span class="Constant">4</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'reply' can take aguments that are returned, or written back into output args of caller"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-reply-oarg-multiple"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">7</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> test1 <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> add <span class="Constant">4</span>:integer <span class="Constant">5</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">6</span>:integer <span class="Constant">5</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Constant">7</span>:integer <span class="Op"><-</span> test1 <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span> <span class="Constant">3</span> <span class="Constant">4</span> <span class="Constant">7</span> <span class="Constant">3</span> - <span class="Comment">; add-fn's temporaries</span> + <span class="Comment">; test1's temporaries</span> <span class="Constant">4</span> <span class="Constant">1</span> <span class="Constant">5</span> <span class="Constant">3</span> <span class="Constant">6</span> <span class="Constant">4</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'reply' permits a function to return multiple values at once"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-fn-prepare-reply"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>prepare-reply <span class="Delimiter">(</span><span class="Constant">6</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">5</span> integer<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> add <span class="Constant">4</span>:integer <span class="Constant">5</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>prepare-reply <span class="Constant">6</span>:integer <span class="Constant">5</span>:integer<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">7</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> test1 <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Constant">7</span>:integer <span class="Op"><-</span> test1 <span class="Constant">1</span>:integer <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">1</span> <span class="Constant">2</span> <span class="Constant">3</span> <span class="Constant">3</span> <span class="Constant">4</span> <span class="Constant">7</span> <span class="Constant">3</span> - <span class="Comment">; add-fn's temporaries</span> + <span class="Comment">; test1's temporaries</span> <span class="Constant">4</span> <span class="Constant">1</span> <span class="Constant">5</span> <span class="Constant">3</span> <span class="Constant">6</span> <span class="Constant">4</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - without args, 'reply' returns values from previous 'prepare-reply'."</span><span class="Delimiter">))</span> +<span class="Delimiter">)</span> <span class="Comment">; section 20</span> + +<span class="Delimiter">(</span>section <span class="Constant">11</span> + <span class="SalientComment">;; Structured programming</span> <span class="Comment">;</span> <span class="Comment">; Our jump operators are quite inconvenient to use, so mu provides a</span> @@ -1173,244 +1396,283 @@ a { color:#4444ff; } <span class="Comment">; }</span> <span class="Comment">; }</span> <span class="Comment">;</span> -<span class="Comment">; Braces are just labels, they require no special parsing. The operations</span> -<span class="Comment">; 'break' and 'continue' jump to just after the enclosing '}' and '{'</span> -<span class="Comment">; respectively.</span> +<span class="Comment">; Braces are like labels in assembly language, they require no special</span> +<span class="Comment">; parsing. The operations 'loop' and 'break' jump to just after the enclosing</span> +<span class="Comment">; '{' and '}' respectively.</span> <span class="Comment">;</span> -<span class="Comment">; Conditional and unconditional 'break' and 'continue' should give us 80% of</span> -<span class="Comment">; the benefits of the control-flow primitives we're used to in other</span> -<span class="Comment">; languages, like 'if', 'while', 'for', etc.</span> +<span class="Comment">; Conditional and unconditional 'loop' and 'break' should give us 80% of the</span> +<span class="Comment">; benefits of the control-flow primitives we're used to in other languages,</span> +<span class="Comment">; like 'if', 'while', 'for', etc.</span> +<span class="Comment">;</span> +<span class="Comment">; Compare 'unquoted blocks' using {} with 'quoted blocks' using [] that we've</span> +<span class="Comment">; gotten used to seeing. Quoted blocks are used by top-level instructions to</span> +<span class="Comment">; provide code without running it.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("c{0" "c{1")))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span> <span class="Comment">; 'begin' is just a hack because racket turns curlies into parens</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-if</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)))</span></span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces replaces break-if with a jump-if to after the next close-curly"</span><span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> <span class="Comment">; 'begin' is just a hack because racket turns braces into parens</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>not-equal<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break-if</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">reply</span><span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>not-equal<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump-if</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">reply</span><span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces replaces break-if with a jump-if to after the next close-brace"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces-empty-block"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("c{0" "c{1")))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break</span><span class="Delimiter">)</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="Delimiter">(</span><span class="MuConstant">0</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break</span><span class="Delimiter">)))</span></span> + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">reply</span><span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">reply</span><span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces works for degenerate blocks"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces-nested-break"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-if</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)))</span></span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces balances curlies when converting break"</span><span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>not-equal<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break-if</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + } + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">reply</span><span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>not-equal<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump-if</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">reply</span><span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces balances braces when converting break"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces-repeated-jump"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("c{0" "c{1")))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">6</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">7</span> literal<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">6</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">7</span> literal<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break</span><span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + } + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break</span><span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces handles jumps on jumps"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces-nested-continue"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces-nested-loop"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Delimiter">(</span><span class="Identifier">continue-if</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump-if</span> <span class="Delimiter">(</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">-3</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)))</span></span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces balances curlies when converting continue"</span><span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>not-equal<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)))</span></span> + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">loop-if</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">reply</span><span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>not-equal<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump-if</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">-3</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">reply</span><span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces balances braces when converting 'loop'"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces-label"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">foo</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">foo</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + foo + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + foo + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces skips past labels"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces-label-increments-offset"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break</span><span class="Delimiter">)</span></span> - <span class="Mu">foo</span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu">foo</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break</span><span class="Delimiter">)))</span></span> + foo + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))</span> + foo + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces treats labels as instructions"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-braces-label-increments-offset2"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("c{0" "c{1")))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break</span><span class="Delimiter">)</span></span> - <span class="Mu">foo</span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">6</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">7</span> literal<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu">foo</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">jump</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">6</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">7</span> literal<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break</span><span class="Delimiter">)))</span></span> + foo + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break</span><span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))</span></span> + foo + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-braces treats labels as instructions - 2"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"continue"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"break-multiple"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("-")))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">break</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">2</span> blocks<span class="Delimiter">)))</span></span> + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + }<span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">4</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'break' can take an extra arg with number of nested blocks to exit"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"loop"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">continue-if</span> <span class="Delimiter">(</span><span class="Constant">3</span> boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">))))</span></span> -<span class="CommentedCode">;? (each stmt function*!main</span> -<span class="CommentedCode">;? (prn stmt))</span> -<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">4</span> <span class="Constant">2</span> <span class="Constant">4</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">34</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - continue correctly loops"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">loop</span><span class="Delimiter">)))</span></span> + }<span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">-2</span> offset<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'loop' jumps to start of containing block"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> <span class="Comment">; todo: fuzz-test invariant: convert-braces offsets should be robust to any</span> -<span class="Comment">; number of inner blocks inside but not around the continue block.</span> +<span class="Comment">; number of inner blocks inside but not around the loop block.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"continue-nested"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"loop-nested"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">continue-if</span> <span class="Delimiter">(</span><span class="Constant">3</span> boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">))))</span></span> -<span class="CommentedCode">;? (each stmt function*!main</span> -<span class="CommentedCode">;? (prn stmt))</span> -<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">4</span> <span class="Constant">2</span> <span class="Constant">4</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">34</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - continue correctly loops"</span><span class="Delimiter">))</span> - -<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"continue-fail"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> neq <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">continue-if</span> <span class="Delimiter">(</span><span class="Constant">3</span> boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">))))</span></span> -<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span> <span class="Delimiter">(</span>obj <span class="Constant">1</span> <span class="Constant">4</span> <span class="Constant">2</span> <span class="Constant">4</span> <span class="Constant">3</span> nil <span class="Constant">4</span> <span class="Constant">34</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - continue might never trigger"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + } + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">loop</span><span class="Delimiter">)))</span></span> + }<span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">-3</span> offset<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'loop' correctly jumps back past nested braces"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"loop-multiple"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("-")))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-braces + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">loop</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">2</span> blocks<span class="Delimiter">)))</span></span> + } + }<span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">-3</span> offset<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'loop' can take an extra arg with number of nested blocks to exit"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-labels"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-labels + <span class="Mu"><span class="Delimiter">'(</span><span class="Identifier">loop</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Identifier">loop</span> offset<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'(</span><span class="Identifier">loop</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Identifier">jump</span><span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">-2</span> offset<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'convert-labels' rewrites jumps to labels"</span><span class="Delimiter">))</span> <span class="SalientComment">;; Variables</span> <span class="Comment">;</span> @@ -1420,106 +1682,152 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>y integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>z integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span>x integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>y integer<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>y integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>z integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names renames symbolic names to integer locations"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-compound"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer-boolean-pair<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>y integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))))</span></span> + <span class="Comment">; copying 0 into pair is meaningless; just for testing</span> + <span class="Mu"><span class="Delimiter">'((((</span>x integer-boolean-pair<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>y integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names increments integer locations by the size of the type of the previous var"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-nil"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>y integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>nil integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span>x integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>y integer<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>nil integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>y integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Comment">; nil location is meaningless; just for testing</span> + <span class="Mu"><span class="Delimiter">(((</span>nil integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>nil integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames nil"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-global"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-string"</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer-address<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>new<span class="Delimiter">))</span> <span class="Constant">"foo"</span><span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer-address<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>new<span class="Delimiter">))</span> <span class="Constant">"foo"</span><span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"convert-names passes through raw strings (just a convenience arg for 'new')"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-raw"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names + <span class="Mu"><span class="Delimiter">'((((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>y integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>raw<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>y integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>raw<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames raw operands"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-literal"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names + <span class="Comment">; meaningless; just for testing</span> + <span class="Mu"><span class="Delimiter">'((((</span>x literal<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span>x literal<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames literals"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-literal-2"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>y integer global<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span>x integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>y integer global<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>y integer global<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>y integer global<span class="Delimiter">))))</span></span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames global operands"</span><span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span>x boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span>x literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span>x literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames literals, even when the name matches a variable"</span><span class="Delimiter">))</span> <span class="Comment">; kludgy support for 'fork' below</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-functions"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>y integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>z fn<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span>x integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>y integer<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>z fn<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))))</span></span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames nil"</span><span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>y integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Comment">; meaningless; just for testing</span> + <span class="Mu"><span class="Delimiter">(((</span>z fn<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>z fn<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames fns"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-record-fields"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("cn0")))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span>bool offset<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Delimiter">((</span>bool offset<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names replaces record field offsets"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-record-fields-ambiguous"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>errsafe <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>bool boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span>bool offset<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span>bool boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">t</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Delimiter">((</span>bool offset<span class="Delimiter">))))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names doesn't allow offsets and variables with the same name in a function"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-record-fields-ambiguous-2"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>errsafe <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span>bool offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>bool boolean<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Delimiter">((</span>bool offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>bool boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">t</span> literal<span class="Delimiter">))))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names doesn't allow offsets and variables with the same name in a function - 2"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-record-fields-indirect"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("cn0")))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">34</span> integer-boolean-pair-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>bool offset<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">34</span> integer-boolean-pair-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">34</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))</span> <span class="Delimiter">((</span>bool offset<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">34</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names replaces field offsets for record addresses"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-record-fields-multiple"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span>bool offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span>bool offset<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> offset<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">2</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Delimiter">((</span>bool offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Delimiter">((</span>bool offset<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">2</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">3</span> boolean<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>get<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer-boolean-pair<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">1</span> offset<span class="Delimiter">)))))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names replaces field offsets with multiple mentions"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-label"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">foo<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu">foo<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + foo<span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + foo<span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names skips past labels"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> +<span class="Delimiter">)</span> <span class="Comment">; section 11</span> + +<span class="Delimiter">(</span>section <span class="Constant">20</span> + <span class="Comment">; A rudimentary memory allocator. Eventually we want to write this in mu.</span> <span class="Comment">;</span> <span class="Comment">; No deallocation yet; let's see how much code we can build in mu before we</span> @@ -1527,107 +1835,127 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-primitive"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">)))))</span></span> -<span class="Delimiter">(</span><span class="Normal">let</span> before Memory-in-use-until - <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.1</span> before<span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' returns current high-water mark"</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso Memory-in-use-until <span class="Delimiter">(</span><span class="Identifier">+</span> before <span class="Constant">1</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on primitive types increments high-water mark by their size"</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer-address <span class="Op"><-</span> new integer:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> before rep.routine!alloc +<span class="CommentedCode">;? (set dump-trace*)</span> + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.1</span> before<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' returns current high-water mark"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso rep.routine!alloc <span class="Delimiter">(</span>+ before <span class="Constant">1</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on primitive types increments high-water mark by their size"</span><span class="Delimiter">))))</span> +<span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-array-literal"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> type-array-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>type-array literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">)))))</span></span> -<span class="Delimiter">(</span><span class="Normal">let</span> before Memory-in-use-until - <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.1</span> before<span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on array with literal size returns current high-water mark"</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso Memory-in-use-until <span class="Delimiter">(</span><span class="Identifier">+</span> before <span class="Constant">6</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on primitive arrays increments high-water mark by their size"</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:type-array-address <span class="Op"><-</span> new type-array:literal <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> before rep.routine!alloc + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.1</span> before<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on array with literal size returns current high-water mark"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso rep.routine!alloc <span class="Delimiter">(</span>+ before <span class="Constant">6</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on primitive arrays increments high-water mark by their size"</span><span class="Delimiter">))))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"new-array-direct"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> type-array-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>type-array literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)))))</span></span> -<span class="Delimiter">(</span><span class="Normal">let</span> before Memory-in-use-until - <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.2</span> before<span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on array with variable size returns current high-water mark"</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso Memory-in-use-until <span class="Delimiter">(</span><span class="Identifier">+</span> before <span class="Constant">6</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on primitive arrays increments high-water mark by their (variable) size"</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:type-array-address <span class="Op"><-</span> new type-array:literal <span class="Constant">1</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> before rep.routine!alloc + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.2</span> before<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on array with variable size returns current high-water mark"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso rep.routine!alloc <span class="Delimiter">(</span>+ before <span class="Constant">6</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' on primitive arrays increments high-water mark by their (variable) size"</span><span class="Delimiter">))))</span> <span class="Comment">; Even though our memory locations can now have names, the names are all</span> <span class="Comment">; globals, accessible from any function. To isolate functions from their</span> <span class="Comment">; callers we need local variables, and mu provides them using a special</span> -<span class="Comment">; variable called <span style='color:#00af87'>default-scope</span>. When you initialize such a variable (likely</span> +<span class="Comment">; variable called default-space. When you initialize such a variable (likely</span> <span class="Comment">; with a call to our just-defined memory allocator) mu interprets memory</span> -<span class="Comment">; locations as offsets from its value. If <span style='color:#00af87'>default-scope</span> is set to 1000, for</span> +<span class="Comment">; locations as offsets from its value. If default-space is set to 1000, for</span> <span class="Comment">; example, reads and writes to memory location 1 will really go to 1001.</span> <span class="Comment">;</span> -<span class="Comment">; '<span style='color:#00af87'>default-scope</span>' is itself hard-coded to be function-local; it's nil in a new</span> +<span class="Comment">; 'default-space' is itself hard-coded to be function-local; it's nil in a new</span> <span class="Comment">; function, and it's restored when functions return to their callers. But the</span> -<span class="Comment">; actual scope allocation is independent. So you can define closures, or do</span> +<span class="Comment">; actual space allocation is independent. So you can define closures, or do</span> <span class="Comment">; even more funky things like share locals between two coroutines.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"set-default-scope"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">)))))</span></span> -<span class="Delimiter">(</span><span class="Normal">let</span> before Memory-in-use-until -<span class="CommentedCode">;? (set dump-trace*)</span> - <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~and <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Global">memory*</span><span class="Constant">.1</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>is <span class="Constant">23</span> <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> before <span class="Constant">1</span><span class="Delimiter">))))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - <span style='color:#00af87'>default-scope</span> implicitly modifies variable locations"</span><span class="Delimiter">)))</span> - -<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"set-default-scope-skips-offset"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> offset<span class="Delimiter">)))))</span></span> -<span class="Delimiter">(</span><span class="Normal">let</span> before Memory-in-use-until -<span class="CommentedCode">;? (set dump-trace*)</span> - <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~and <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Global">memory*</span><span class="Constant">.1</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>is <span class="Constant">23</span> <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> before <span class="Constant">1</span><span class="Delimiter">))))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - <span style='color:#00af87'>default-scope</span> skips 'offset' types just like literals"</span><span class="Delimiter">)))</span> - -<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"default-scope-bounds-check"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"set-default-space"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> before rep.routine!alloc +<span class="CommentedCode">;? (set dump-trace*)</span> + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~and <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Global">memory*</span><span class="Constant">.1</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>is <span class="Constant">23</span> <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ before <span class="Constant">2</span><span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - default-space implicitly modifies variable locations"</span><span class="Delimiter">))))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"set-default-space-skips-offset"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> before rep.routine!alloc +<span class="CommentedCode">;? (set dump-trace*)</span> + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~and <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Global">memory*</span><span class="Constant">.1</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>is <span class="Constant">23</span> <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ before <span class="Constant">2</span><span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - default-space skips 'offset' types just like literals"</span><span class="Delimiter">))))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"default-space-bounds-check"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">let</span> routine <span class="Delimiter">(</span><span class="Identifier">car</span> <span class="Global">completed-routines*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine <span class="Delimiter">(</span>car <span class="Global">completed-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>no rep.routine!error<span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - <span style='color:#00af87'>default-scope</span> checks bounds"</span><span class="Delimiter">)))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - default-space checks bounds"</span><span class="Delimiter">)))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"default-scope-and-get-indirect"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer-boolean-pair literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> get-address <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">0</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer global<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> integer-boolean-pair-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">0</span> offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"default-space-and-get-indirect"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer-boolean-pair-address <span class="Op"><-</span> new integer-boolean-pair:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer-address <span class="Op"><-</span> get-address <span class="Constant">1</span>:integer-boolean-pair-address/deref <span class="MuConstant">0</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer-address/deref <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer/raw <span class="Op"><-</span> get <span class="Constant">1</span>:integer-boolean-pair-address/deref <span class="MuConstant">0</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "cvt0" "cvt1")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> @@ -1635,53 +1963,196 @@ a { color:#4444ff; } <span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">34</span> <span class="Global">memory*</span><span class="Constant">.3</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - indirect 'get' works in the presence of <span style='color:#00af87'>default-scope</span>"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - indirect 'get' works in the presence of default-space"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"default-scope-and-index-indirect"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer-array-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer-array literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> index-address <span class="Delimiter">(</span><span class="Constant">1</span> integer-array-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer global<span class="Delimiter">)</span> <span class="Op"><-</span> index <span class="Delimiter">(</span><span class="Constant">1</span> integer-array-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> offset<span class="Delimiter">)))))</span></span> -<span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "cvt0" "cvt1")))</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"default-space-and-index-indirect"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer-array-address <span class="Op"><-</span> new integer-array:literal <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer-address <span class="Op"><-</span> index-address <span class="Constant">1</span>:integer-array-address/deref <span class="MuConstant">2</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer-address/deref <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer/raw <span class="Op"><-</span> index <span class="Constant">1</span>:integer-array-address/deref <span class="MuConstant">2</span>:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "array-info")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="CommentedCode">;? (prn completed-routines*)</span> <span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">34</span> <span class="Global">memory*</span><span class="Constant">.3</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - indirect 'index' works in the presence of <span style='color:#00af87'>default-scope</span>"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - indirect 'index' works in the presence of default-space"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="CommentedCode">;? (new-trace "convert-names-default-scope")</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-names-default-space"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-names - <span class="Mu"><span class="Delimiter">'(((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>y integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Comment">; unsafe in general; don't write random values to '<span style='color:#00af87'>default-scope</span>'</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span>x integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>y integer<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer<span class="Delimiter">))))</span></span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames <span style='color:#00af87'>default-scope</span>"</span><span class="Delimiter">))</span> - -<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="Delimiter">(</span>new-trace <span class="Constant">"suppress-default-scope"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer global<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">)))))</span></span> -<span class="Delimiter">(</span><span class="Normal">let</span> before Memory-in-use-until -<span class="CommentedCode">;? (set dump-trace*)</span> - <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> -<span class="CommentedCode">;? (prn memory*)</span> - <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~and <span class="Delimiter">(</span>is <span class="Constant">23</span> <span class="Global">memory*</span><span class="Constant">.1</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span><span class="Identifier">+</span> before <span class="Constant">1</span><span class="Delimiter">))))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - <span style='color:#00af87'>default-scope</span> skipped for locations with metadata 'global'"</span><span class="Delimiter">)))</span> + <span class="Mu"><span class="Delimiter">'((((</span>x integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>y integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">2</span> literal<span class="Delimiter">)))</span></span> + <span class="Comment">; unsafe in general; don't write random values to 'default-space'</span> + <span class="Mu"><span class="Delimiter">(((</span>default-space integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>add<span class="Delimiter">))</span> <span class="Delimiter">((</span>x integer<span class="Delimiter">))</span> <span class="Delimiter">((</span>y integer<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">2</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span>default-space integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>add<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-names never renames default-space"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"suppress-default-space"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer/raw <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> before rep.routine!alloc +<span class="CommentedCode">;? (set dump-trace*)</span> + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~and <span class="Delimiter">(</span>is <span class="Constant">23</span> <span class="Global">memory*</span><span class="Constant">.1</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ before <span class="Constant">1</span><span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - default-space skipped for locations with metadata 'raw'"</span><span class="Delimiter">))))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"array-copy-indirect-scoped"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">10</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span> <span class="Comment">; pretend allocation</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> copy <span class="MuConstant">10</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span> <span class="Comment">; raw location 12</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer-boolean-pair-array-address <span class="Op"><-</span> copy <span class="MuConstant">12</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer-boolean-pair-array <span class="Op"><-</span> copy <span class="Constant">6</span>:integer-boolean-pair-array-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "m" "sizeof")))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.18</span> <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Comment">; variable 7</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - indirect array copy in the presence of 'default-space'"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"len-array-indirect-scoped"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">10</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span> <span class="Comment">; pretend allocation</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> copy <span class="MuConstant">10</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span> <span class="Comment">; raw location 12</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> copy <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer-address <span class="Op"><-</span> copy <span class="MuConstant">12</span>:literal<span class="Delimiter">)</span> <span class="Comment">; unsafe</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> length <span class="Constant">6</span>:integer-boolean-pair-array-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "addr" "sz" "array-len")))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.18</span> <span class="Constant">2</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'len' accesses length of array address"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"default-space-shared"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function init-counter <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; initialize to 3</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> default-space:space-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function increment-counter <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> add <span class="Constant">1</span>:integer <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span> <span class="Comment">; increment</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">1</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:space-address <span class="Op"><-</span> init-counter<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> increment-counter <span class="Constant">1</span>:space-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> increment-counter <span class="Constant">1</span>:space-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">5</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - multiple calls to a function can share locals"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"default-space-closure"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function init-counter <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; initialize to 3</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> default-space:space-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function increment-counter <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">0</span>:space-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span> <span class="Comment">; share outer space</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer/space:1 <span class="Op"><-</span> add <span class="Constant">1</span>:integer/space:1 <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span> <span class="Comment">; increment</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span> <span class="Comment">; dummy</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">1</span>:integer/space:1<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:space-address <span class="Op"><-</span> init-counter<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> increment-counter <span class="Constant">1</span>:space-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> increment-counter <span class="Constant">1</span>:space-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">5</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - multiple calls to a function can share locals"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"default-space-closure-with-names"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function init-counter <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>x:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>y:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; correct copy of y</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> default-space:space-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function increment-counter <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">0</span>:space-address/names:init-counter <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span> <span class="Comment">; outer space must be created by 'init-counter' above</span></span> + <span class="Mu"><span class="Delimiter">(</span>y:integer/space:1 <span class="Op"><-</span> add y:integer/space:1 <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span> <span class="Comment">; increment</span></span> + <span class="Mu"><span class="Delimiter">(</span>y:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span> <span class="Comment">; dummy</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> y:integer/space:1<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:space-address/names:init-counter <span class="Op"><-</span> init-counter<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> increment-counter <span class="Constant">1</span>:space-address/names:init-counter<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> increment-counter <span class="Constant">1</span>:space-address/names:init-counter<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">5</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - multiple calls to a function can share locals"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">)</span> <span class="Comment">; section 20</span> + +<span class="Delimiter">(</span>section <span class="Constant">100</span> <span class="SalientComment">;; Dynamic dispatch</span> <span class="Comment">;</span> @@ -1691,65 +2162,67 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"dispatch-clause"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> <span class="Comment">; doesn't matter too much how many locals you allocate space for (here 20)</span> <span class="Comment">; if it's slightly too many -- memory is plentiful</span> <span class="Comment">; if it's too few -- mu will raise an error</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">20</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff8700'>first-arg-box</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">20</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>first-arg-box:tagged-value-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> <span class="Comment">; if given integers, add them</span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff8700'>first-arg</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#af005f'>result</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span style='color:#af005f'>result</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> test1 <span class="Delimiter">(</span><span class="Constant">1</span> tagged-value-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> tagged-value-address<span class="Delimiter">)))))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span>first-arg:integer match?:boolean <span class="Op"><-</span> maybe-coerce first-arg-box:tagged-value-address/deref integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> match?:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg-box:tagged-value-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg:integer <span class="Op"><-</span> maybe-coerce second-arg-box:tagged-value-address/deref integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>result:integer <span class="Op"><-</span> add first-arg:integer second-arg:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> result:integer<span class="Delimiter">)</span></span> + } + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value integer:literal <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value integer:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> test1 <span class="Constant">1</span>:tagged-value-address <span class="Constant">2</span>:tagged-value-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">37</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - an example function that checks that its oarg is an integer"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> -<span class="Comment">; todo - test that reply increments pc for caller frame after popping current frame</span> - <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"dispatch-multiple-clauses"</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">20</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff8700'>first-arg-box</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">20</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>first-arg-box:tagged-value-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> <span class="Comment">; if given integers, add them</span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff8700'>first-arg</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#af005f'>result</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span style='color:#af005f'>result</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">}</span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span>first-arg:integer match?:boolean <span class="Op"><-</span> maybe-coerce first-arg-box:tagged-value-address/deref integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> match?:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg-box:tagged-value-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg:integer <span class="Op"><-</span> maybe-coerce second-arg-box:tagged-value-address/deref integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>result:integer <span class="Op"><-</span> add first-arg:integer second-arg:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> result:integer<span class="Delimiter">)</span></span> + } <span class="Comment">; if given booleans, or them (it's a silly kind of generic function)</span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff8700'>first-arg</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>boolean literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>boolean literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#af005f'>result</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> or <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg</span> boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span style='color:#af005f'>result</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>boolean literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>boolean literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> test1 <span class="Delimiter">(</span><span class="Constant">1</span> tagged-value-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> tagged-value-address<span class="Delimiter">)))))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span>first-arg:boolean match?:boolean <span class="Op"><-</span> maybe-coerce first-arg-box:tagged-value-address/deref boolean:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> match?:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg-box:tagged-value-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg:boolean <span class="Op"><-</span> maybe-coerce second-arg-box:tagged-value-address/deref boolean:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>result:boolean <span class="Op"><-</span> or first-arg:boolean second-arg:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> result:integer<span class="Delimiter">)</span></span> + } + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value boolean:literal <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value boolean:literal <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> test1 <span class="Constant">1</span>:tagged-value-address <span class="Constant">2</span>:tagged-value-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (each stmt function*!test-fn</span> <span class="CommentedCode">;? (prn " " stmt))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> @@ -1761,41 +2234,139 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"dispatch-multiple-calls"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>test1</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">20</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff8700'>first-arg-box</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">20</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>first-arg-box:tagged-value-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> <span class="Comment">; if given integers, add them</span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff8700'>first-arg</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#af005f'>result</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span style='color:#af005f'>result</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">}</span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span>first-arg:integer match?:boolean <span class="Op"><-</span> maybe-coerce first-arg-box:tagged-value-address/deref integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> match?:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg-box:tagged-value-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg:integer <span class="Op"><-</span> maybe-coerce second-arg-box:tagged-value-address/deref integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>result:integer <span class="Op"><-</span> add first-arg:integer second-arg:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> result:integer<span class="Delimiter">)</span></span> + } <span class="Comment">; if given booleans, or them (it's a silly kind of generic function)</span> - <span class="Mu">{ <span class="CommentedCode">begin</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff8700'>first-arg</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>boolean literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Delimiter">(</span>match? boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ffd700'>second-arg</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg-box</span> tagged-value-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>boolean literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#af005f'>result</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> or <span class="Delimiter">(</span><span style='color:#ff8700'>first-arg</span> boolean<span class="Delimiter">)</span> <span class="Delimiter">(</span><span style='color:#ffd700'>second-arg</span> boolean<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span style='color:#af005f'>result</span> integer<span class="Delimiter">))</span></span> - <span class="Mu">}</span> - <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>boolean literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>boolean literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">t</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> test1 <span class="Delimiter">(</span><span class="Constant">1</span> tagged-value-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> tagged-value-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">10</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">11</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">12</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> test1 <span class="Delimiter">(</span><span class="Constant">10</span> tagged-value-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">11</span> tagged-value-address<span class="Delimiter">)))))</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span>first-arg:boolean match?:boolean <span class="Op"><-</span> maybe-coerce first-arg-box:tagged-value-address/deref boolean:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> match?:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg-box:tagged-value-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>second-arg:boolean <span class="Op"><-</span> maybe-coerce second-arg-box:tagged-value-address/deref boolean:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>result:boolean <span class="Op"><-</span> or first-arg:boolean second-arg:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> result:integer<span class="Delimiter">)</span></span> + } + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value boolean:literal <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value boolean:literal <span class="MuConstant">nil</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> test1 <span class="Constant">1</span>:tagged-value-address <span class="Constant">2</span>:tagged-value-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">10</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value integer:literal <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">11</span>:tagged-value-address <span class="Op"><-</span> init-tagged-value integer:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">12</span>:integer <span class="Op"><-</span> test1 <span class="Constant">10</span>:tagged-value-address <span class="Constant">11</span>:tagged-value-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~and <span class="Delimiter">(</span>is <span class="Global">memory*</span><span class="Constant">.3</span> t<span class="Delimiter">)</span> <span class="Delimiter">(</span>is <span class="Global">memory*</span><span class="Constant">.12</span> <span class="Constant">37</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - different calls can exercise different clauses of the same function"</span><span class="Delimiter">))</span> +<span class="Comment">; We can also dispatch based on the type of the operands or results at the</span> +<span class="Comment">; caller.</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"dispatch-otype"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:type <span class="Op"><-</span> otype <span class="MuConstant">0</span>:offset<span class="Delimiter">)</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> equal <span class="Constant">4</span>:type integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Constant">5</span>:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer <span class="Op"><-</span> add <span class="Constant">6</span>:integer <span class="Constant">7</span>:integer<span class="Delimiter">)</span></span> + } + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">8</span>:integer<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> test1 <span class="MuConstant">1</span>:literal <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - an example function that checks that its oarg is an integer"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"dispatch-otype-multiple-clauses"</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:type <span class="Op"><-</span> otype <span class="MuConstant">0</span>:offset<span class="Delimiter">)</span></span> + { <span class="CommentedCode">begin</span> + <span class="Comment">; integer needed? add args</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> equal <span class="Constant">4</span>:type integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Constant">5</span>:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer <span class="Op"><-</span> add <span class="Constant">6</span>:integer <span class="Constant">7</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">8</span>:integer<span class="Delimiter">)</span></span> + } + { <span class="CommentedCode">begin</span> + <span class="Comment">; boolean needed? 'or' args</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> equal <span class="Constant">4</span>:type boolean:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Constant">5</span>:boolean <span class="MuConstant">4</span>:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:boolean <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:boolean <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:boolean <span class="Op"><-</span> or <span class="Constant">6</span>:boolean <span class="Constant">7</span>:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">8</span>:boolean<span class="Delimiter">)</span></span> + }<span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> test1 <span class="MuConstant">t</span>:literal <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (each stmt function*!test1</span> +<span class="CommentedCode">;? (prn " " stmt))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (wipe dump-trace*)</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.1</span> t<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - an example function that can do different things (dispatch) based on the type of its args or oargs"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"dispatch-otype-multiple-calls"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function test1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:type <span class="Op"><-</span> otype <span class="MuConstant">0</span>:offset<span class="Delimiter">)</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> equal <span class="Constant">4</span>:type integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Constant">5</span>:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer <span class="Op"><-</span> add <span class="Constant">6</span>:integer <span class="Constant">7</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">8</span>:integer<span class="Delimiter">)</span></span> + } + { <span class="CommentedCode">begin</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> equal <span class="Constant">4</span>:type boolean:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">break-unless</span> <span class="Constant">5</span>:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:boolean <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:boolean <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:boolean <span class="Op"><-</span> or <span class="Constant">6</span>:boolean <span class="Constant">7</span>:boolean<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="Constant">8</span>:boolean<span class="Delimiter">)</span></span> + }<span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:boolean <span class="Op"><-</span> test1 <span class="MuConstant">t</span>:literal <span class="MuConstant">t</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> test1 <span class="MuConstant">3</span>:literal <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~and <span class="Delimiter">(</span>is <span class="Global">memory*</span><span class="Constant">.1</span> t<span class="Delimiter">)</span> <span class="Delimiter">(</span>is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">7</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - different calls can exercise different clauses of the same function"</span><span class="Delimiter">))</span> + +<span class="Delimiter">)</span> <span class="Comment">; section 100</span> + +<span class="Delimiter">(</span>section <span class="Constant">20</span> + <span class="SalientComment">;; Concurrency</span> <span class="Comment">;</span> <span class="Comment">; A rudimentary process scheduler. You can 'run' multiple functions at once,</span> @@ -1809,11 +2380,14 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1 <span class="Delimiter">'</span>f2<span class="Delimiter">)</span> <span class="Delimiter">(</span>when <span class="Delimiter">(</span>~iso <span class="Constant">2</span> <span class="Global">curr-cycle*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - scheduler didn't run the right number of instructions: "</span> <span class="Global">curr-cycle*</span><span class="Delimiter">))</span> @@ -1832,14 +2406,17 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler-alternate"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>f1 - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))</span></span> - <span class="Delimiter">(</span>f2 - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> -<span class="Delimiter">(</span><span class="Identifier">=</span> <span class="Global">scheduling-interval*</span> <span class="Constant">1</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>= <span class="Global">scheduling-interval*</span> <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1 <span class="Delimiter">'</span>f2<span class="Delimiter">)</span> <span class="Delimiter">(</span>check-trace-contents <span class="Constant">"scheduler alternates between routines"</span> <span class="Delimiter">'((</span><span class="Constant">"run"</span> <span class="Constant">"f1 0"</span><span class="Delimiter">)</span> @@ -1850,20 +2427,23 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler-sleep"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Comment">; add one baseline routine to run (empty running-routines* handled below)</span> <span class="Delimiter">(</span>enq make-routine!f1 <span class="Global">running-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is <span class="Constant">1</span> len.running-routines*<span class="Delimiter">))</span> <span class="Comment">; sleeping routine</span> <span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!f2 - <span class="Delimiter">(</span><span class="Identifier">=</span> rep.routine!sleep <span class="Delimiter">'(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span> - <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span><span class="Error">.routine</span><span class="Delimiter">))</span> + <span class="Mu"><span class="Delimiter">(</span>= rep.routine!sleep <span class="Delimiter">'(</span>for-some-cycles <span class="Constant">23</span><span class="Delimiter">))</span></span> + <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span>.routine<span class="Delimiter">))</span> <span class="Comment">; not yet time for it to wake up</span> -<span class="Delimiter">(</span><span class="Identifier">=</span> <span class="Global">curr-cycle*</span> <span class="Constant">23</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">curr-cycle*</span> <span class="Constant">23</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "schedule")))</span> <span class="Delimiter">(</span>update-scheduler-state<span class="Delimiter">)</span> @@ -1872,40 +2452,46 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler-wakeup"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Comment">; add one baseline routine to run (empty running-routines* handled below)</span> <span class="Delimiter">(</span>enq make-routine!f1 <span class="Global">running-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is <span class="Constant">1</span> len.running-routines*<span class="Delimiter">))</span> <span class="Comment">; sleeping routine</span> <span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!f2 - <span class="Delimiter">(</span><span class="Identifier">=</span> rep.routine!sleep <span class="Delimiter">'(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span> - <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span><span class="Error">.routine</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>= rep.routine!sleep <span class="Delimiter">'(</span>for-some-cycles <span class="Constant">23</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span>.routine<span class="Delimiter">))</span> <span class="Comment">; time for it to wake up</span> -<span class="Delimiter">(</span><span class="Identifier">=</span> <span class="Global">curr-cycle*</span> <span class="Constant">24</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">curr-cycle*</span> <span class="Constant">24</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>update-scheduler-state<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">2</span> len.running-routines*<span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - scheduler wakes up sleeping routines at the right time"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler-sleep-location"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Comment">; add one baseline routine to run (empty running-routines* handled below)</span> <span class="Delimiter">(</span>enq make-routine!f1 <span class="Global">running-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is <span class="Constant">1</span> len.running-routines*<span class="Delimiter">))</span> <span class="Comment">; blocked routine waiting for location 23 to change</span> <span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!f2 - <span class="Delimiter">(</span><span class="Identifier">=</span> rep.routine!sleep <span class="Delimiter">'(</span><span class="Constant">23</span> <span class="Constant">0</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span><span class="Error">.routine</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>= rep.routine!sleep <span class="Delimiter">'(</span>until-location-changes <span class="Constant">23</span> <span class="Constant">0</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span>.routine<span class="Delimiter">))</span> <span class="Comment">; leave memory location 23 unchanged</span> -<span class="Delimiter">(</span><span class="Identifier">=</span> <span class="Global">memory*</span><span class="Constant">.23</span> <span class="Constant">0</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.23</span> <span class="Constant">0</span><span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="CommentedCode">;? (prn running-routines*)</span> <span class="CommentedCode">;? (prn sleeping-routines*)</span> @@ -1921,20 +2507,23 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler-wakeup-location"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Comment">; add one baseline routine to run (empty running-routines* handled below)</span> <span class="Delimiter">(</span>enq make-routine!f1 <span class="Global">running-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is <span class="Constant">1</span> len.running-routines*<span class="Delimiter">))</span> <span class="Comment">; blocked routine waiting for location 23 to change</span> <span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!f2 - <span class="Delimiter">(</span><span class="Identifier">=</span> rep.routine!sleep <span class="Delimiter">'(</span><span class="Constant">23</span> <span class="Constant">0</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span><span class="Error">.routine</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>= rep.routine!sleep <span class="Delimiter">'(</span>until-location-changes <span class="Constant">23</span> <span class="Constant">0</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span>.routine<span class="Delimiter">))</span> <span class="Comment">; change memory location 23</span> -<span class="Delimiter">(</span><span class="Identifier">=</span> <span class="Global">memory*</span><span class="Constant">.23</span> <span class="Constant">1</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.23</span> <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>update-scheduler-state<span class="Delimiter">)</span> <span class="Comment">; routine unblocked</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">2</span> len.running-routines*<span class="Delimiter">)</span> @@ -1942,35 +2531,39 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler-skip"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Comment">; running-routines* is empty</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>empty <span class="Global">running-routines*</span><span class="Delimiter">))</span> <span class="Comment">; sleeping routine</span> <span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!f1 - <span class="Delimiter">(</span><span class="Identifier">=</span> rep.routine!sleep <span class="Delimiter">'(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span> - <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span><span class="Error">.routine</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>= rep.routine!sleep <span class="Delimiter">'(</span>for-some-cycles <span class="Constant">34</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span>.routine<span class="Delimiter">))</span> <span class="Comment">; long time left for it to wake up</span> -<span class="Delimiter">(</span><span class="Identifier">=</span> <span class="Global">curr-cycle*</span> <span class="Constant">0</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">curr-cycle*</span> <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>update-scheduler-state<span class="Delimiter">)</span> -<span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is <span class="Global">curr-cycle*</span> <span class="Constant">24</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is <span class="Global">curr-cycle*</span> <span class="Constant">35</span><span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> len.running-routines*<span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - scheduler skips ahead to earliest sleeping routines when nothing to run"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler-deadlock"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>empty <span class="Global">running-routines*</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>empty <span class="Global">completed-routines*</span><span class="Delimiter">))</span> <span class="Comment">; blocked routine</span> <span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!f1 - <span class="Delimiter">(</span><span class="Identifier">=</span> rep.routine!sleep <span class="Delimiter">'(</span><span class="Constant">23</span> <span class="Constant">0</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span><span class="Error">.routine</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>= rep.routine!sleep <span class="Delimiter">'(</span>until-location-changes <span class="Constant">23</span> <span class="Constant">0</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span>.routine<span class="Delimiter">))</span> <span class="Comment">; location it's waiting on is 'unchanged'</span> -<span class="Delimiter">(</span><span class="Identifier">=</span> <span class="Global">memory*</span><span class="Constant">.23</span> <span class="Constant">0</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.23</span> <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>update-scheduler-state<span class="Delimiter">)</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>~empty <span class="Global">completed-routines*</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (prn completed-routines*)</span> @@ -1981,31 +2574,35 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"scheduler-deadlock2"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Comment">; running-routines* is empty</span> <span class="Delimiter">(</span>assert <span class="Delimiter">(</span>empty <span class="Global">running-routines*</span><span class="Delimiter">))</span> <span class="Comment">; blocked routine</span> <span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!f1 - <span class="Delimiter">(</span><span class="Identifier">=</span> rep.routine!sleep <span class="Delimiter">'(</span><span class="Constant">23</span> <span class="Constant">0</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span><span class="Error">.routine</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>= rep.routine!sleep <span class="Delimiter">'(</span>until-location-changes <span class="Constant">23</span> <span class="Constant">0</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>set <span class="Global">sleeping-routines*</span>.routine<span class="Delimiter">))</span> <span class="Comment">; but is about to become ready</span> -<span class="Delimiter">(</span><span class="Identifier">=</span> <span class="Global">memory*</span><span class="Constant">.23</span> <span class="Constant">1</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.23</span> <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>update-scheduler-state<span class="Delimiter">)</span> <span class="Delimiter">(</span>when <span class="Delimiter">(</span>~empty <span class="Global">completed-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - scheduler ignores sleeping but ready threads when detecting deadlock"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"sleep"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>f1 - <span class="Mu"><span class="Delimiter">(</span>sleep <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))</span></span> - <span class="Delimiter">(</span>f2 - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>sleep for-some-cycles:literal <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "schedule")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1 <span class="Delimiter">'</span>f2<span class="Delimiter">)</span> <span class="Delimiter">(</span>check-trace-contents <span class="Constant">"scheduler handles sleeping routines"</span> @@ -2021,14 +2618,16 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"sleep-long"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>f1 - <span class="Mu"><span class="Delimiter">(</span>sleep <span class="Delimiter">(</span><span class="MuConstant">20</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))</span></span> - <span class="Delimiter">(</span>f2 - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>sleep for-some-cycles:literal <span class="MuConstant">20</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "schedule")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1 <span class="Delimiter">'</span>f2<span class="Delimiter">)</span> <span class="Delimiter">(</span>check-trace-contents <span class="Constant">"scheduler progresses sleeping routines when there are no routines left to run"</span> @@ -2044,15 +2643,17 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"sleep-location"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>f1 +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> <span class="Comment">; waits for memory location 1 to be set, before computing its successor</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">0</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>sleep <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">)))</span></span> - <span class="Delimiter">(</span>f2 - <span class="Mu"><span class="Delimiter">(</span>sleep <span class="Delimiter">(</span><span class="MuConstant">30</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span> <span class="Comment">; set to value</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>sleep until-location-changes:literal <span class="Constant">1</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> add <span class="Constant">1</span>:integer <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>sleep for-some-cycles:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; set to value</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "schedule")))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1 <span class="Delimiter">'</span>f2<span class="Delimiter">)</span> @@ -2065,59 +2666,84 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"sleep-scoped-location"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> <span class="Comment">; waits for memory location 1 to be changed, before computing its successor</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">10</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span> <span class="Comment">; array of locals</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">10</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span> <span class="Comment">; really location 11</span></span> - <span class="Mu"><span class="Delimiter">(</span>sleep <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> add <span class="Delimiter">(</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Delimiter">(</span>sleep <span class="Delimiter">(</span><span class="MuConstant">30</span> literal<span class="Delimiter">))</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">11</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">)))))</span> <span class="Comment">; set to value</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">10</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span> <span class="Comment">; array of locals</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> copy <span class="MuConstant">10</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span> <span class="Comment">; really location 12</span></span> + <span class="Mu"><span class="Delimiter">(</span>sleep until-location-changes:literal <span class="Constant">1</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> add <span class="Constant">1</span>:integer <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>sleep for-some-cycles:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">12</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; set to value</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "schedule")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1 <span class="Delimiter">'</span>f2<span class="Delimiter">)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.12</span> <span class="Constant">4</span><span class="Delimiter">)</span> <span class="Comment">; successor of value</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.13</span> <span class="Constant">4</span><span class="Delimiter">)</span> <span class="Comment">; successor of value</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - sleep can block on a scoped memory location"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"fork"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Delimiter">(</span>fork <span class="Delimiter">(</span>f2 fn<span class="Delimiter">)))</span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>fork f2:fn<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">4</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - fork works"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"fork-with-args"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Delimiter">(</span>fork <span class="Delimiter">(</span>f2 fn<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">)))</span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>fork f2:fn <span class="MuConstant">nil</span>:literal <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">4</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - fork can pass args"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"fork-copies-args"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>fork <span class="Delimiter">(</span>f2 fn<span class="Delimiter">)</span> <span class="Delimiter">(</span>x integer<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>x integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span> <span class="Comment">; should be ignored</span></span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>x:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>fork f2:fn <span class="MuConstant">nil</span>:literal x:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>x:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span> <span class="Comment">; should be ignored</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f2 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">4</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - fork passes args by value"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"fork-global"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer/raw <span class="Op"><-</span> copy <span class="Constant">2</span>:integer/space:global<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>fork f1:fn default-space:space-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>awhen rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">memory*</span><span class="Constant">.1</span> <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - fork can take a space of global variables to access"</span><span class="Delimiter">))</span> + <span class="Comment">; The scheduler needs to keep track of the call stack for each routine.</span> <span class="Comment">; Eventually we'll want to save this information in mu's address space itself,</span> <span class="Comment">; along with the types array, the magic buffers for args and oargs, and so on.</span> @@ -2128,19 +2754,24 @@ a { color:#4444ff; } <span class="Comment">; Routines can throw errors.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"array-bounds-check"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>main</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">23</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> index <span class="Delimiter">(</span><span class="Constant">1</span> integer-array<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">2</span> literal<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">23</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> index <span class="Constant">1</span>:integer-array <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">let</span> routine <span class="Delimiter">(</span><span class="Identifier">car</span> <span class="Global">completed-routines*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine <span class="Delimiter">(</span>car <span class="Global">completed-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>no rep.routine!error<span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'index' throws an error if out of bounds"</span><span class="Delimiter">)))</span> +<span class="Delimiter">)</span> <span class="Comment">; section 20</span> + +<span class="Delimiter">(</span>section <span class="Constant">100</span> + <span class="SalientComment">;; Synchronization</span> <span class="Comment">;</span> <span class="Comment">; Mu synchronizes using channels rather than locks, like Erlang and Go.</span> @@ -2158,224 +2789,231 @@ a { color:#4444ff; } <span class="Comment">; first-full, while the writer always modifies it at first-empty.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-new"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-full offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-free offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-full:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-free:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">0</span> <span class="Global">memory*</span><span class="Constant">.2</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>~is <span class="Constant">0</span> <span class="Global">memory*</span><span class="Constant">.3</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new-channel' initializes 'first-full and 'first-free to 0"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'init-channel' initializes 'first-full and 'first-free to 0"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-write"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-full offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-free offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-full:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-free:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (prn function*!write)</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "array-len" "cvt0" "cvt1")))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("jump")))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "reply")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> <span class="CommentedCode">;? (prn canon.memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">0</span> <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">0</span> <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.6</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'write' enqueues item to channel"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-read"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> tagged-value<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> read <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">6</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> maybe-coerce <span class="Delimiter">(</span><span class="Constant">4</span> tagged-value<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">7</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-full offset<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">8</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-free offset<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:tagged-value <span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> read <span class="Constant">1</span>:channel-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> maybe-coerce <span class="Constant">5</span>:tagged-value integer:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-full:offset<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">9</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-free:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "array-len" "cvt0" "cvt1")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn int-canon.memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.6</span> <span class="Global">memory*</span><span class="Constant">.2</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.7</span> <span class="Constant">34</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'read' returns written value"</span><span class="Delimiter">))</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.7</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.8</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.8</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.9</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'read' dequeues item from channel"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-write-wrap"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> <span class="Comment">; channel with 1 slot</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> <span class="Comment">; write a value</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> <span class="Comment">; first-free will now be 1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-free offset<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-free:offset<span class="Delimiter">)</span></span> <span class="Comment">; read one value</span> - <span class="Mu"><span class="Delimiter">(</span>_ <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> read <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span>_ <span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> read <span class="Constant">1</span>:channel-address<span class="Delimiter">)</span></span> <span class="Comment">; write a second value; verify that first-free wraps around to 0.</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-free offset<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-free:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "array-len" "cvt0" "cvt1")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn canon.memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Constant">0</span> <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Constant">0</span> <span class="Global">memory*</span><span class="Constant">.6</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'write' can wrap pointer back to start"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-read-wrap"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> <span class="Comment">; channel with 1 slot</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> <span class="Comment">; write a value</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> <span class="Comment">; read one value</span> - <span class="Mu"><span class="Delimiter">(</span>_ <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> read <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span>_ <span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> read <span class="Constant">1</span>:channel-address<span class="Delimiter">)</span></span> <span class="Comment">; first-full will now be 1</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-full offset<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-full:offset<span class="Delimiter">)</span></span> <span class="Comment">; write a second value</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> <span class="Comment">; read second value; verify that first-full wraps around to 0.</span> - <span class="Mu"><span class="Delimiter">(</span>_ <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> read <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> get <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>first-full offset<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span>_ <span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> read <span class="Constant">1</span>:channel-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> get <span class="Constant">1</span>:channel-address/deref first-full:offset<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="CommentedCode">;? (= dump-trace* (obj blacklist '("sz" "m" "setm" "addr" "array-len" "cvt0" "cvt1")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn canon.memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is <span class="Constant">0</span> <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is <span class="Constant">0</span> <span class="Global">memory*</span><span class="Constant">.6</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - 'read' can wrap pointer back to start"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-new-empty-not-full"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> empty? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> full? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:boolean <span class="Op"><-</span> empty? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:boolean <span class="Op"><-</span> full? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is t <span class="Global">memory*</span><span class="Constant">.2</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.3</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - a new channel is always empty, never <span style='color:#5f00af'>full</span>"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - a new channel is always empty, never full"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-write-not-empty"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> empty? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> full? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> empty? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:boolean <span class="Op"><-</span> full? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.6</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - a channel after writing is never empty"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-write-full"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> empty? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> full? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> empty? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:boolean <span class="Op"><-</span> full? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is t <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - a channel after writing may be <span style='color:#5f00af'>full</span>"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is t <span class="Global">memory*</span><span class="Constant">.6</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - a channel after writing may be full"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-read-not-full"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>_ <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> read <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> empty? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> full? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>_ <span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> read <span class="Constant">1</span>:channel-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> empty? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:boolean <span class="Op"><-</span> full? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - a channel after reading is never <span style='color:#5f00af'>full</span>"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.6</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - a channel after reading is never full"</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-read-empty"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>_ <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> read <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">4</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> empty? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">5</span> boolean<span class="Delimiter">)</span> <span class="Op"><-</span> full? <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>_ <span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> read <span class="Constant">1</span>:channel-address<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:boolean <span class="Op"><-</span> empty? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:boolean <span class="Op"><-</span> full? <span class="Constant">1</span>:channel-address/deref<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is t <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> - <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is t <span class="Global">memory*</span><span class="Constant">.5</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~is nil <span class="Global">memory*</span><span class="Constant">.6</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - a channel after reading may be empty"</span><span class="Delimiter">))</span> -<span class="Comment">; The key property of channels; writing to a <span style='color:#5f00af'>full</span> channel blocks the current</span> +<span class="Comment">; The key property of channels; writing to a full channel blocks the current</span> <span class="Comment">; routine until it creates space. Ditto reading from an empty channel.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-read-block"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> <span class="Comment">; channel is empty, but receives a read</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> tagged-value<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> read <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:tagged-value <span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> read <span class="Constant">1</span>:channel-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> -<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "schedule")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn int-canon.memory*)</span> <span class="CommentedCode">;? (prn sleeping-routines*)</span> <span class="CommentedCode">;? (prn completed-routines*)</span> <span class="Comment">; read should cause the routine to sleep, and</span> <span class="Comment">; the sole sleeping routine should trigger the deadlock detector</span> -<span class="Delimiter">(</span><span class="Normal">let</span> routine <span class="Delimiter">(</span><span class="Identifier">car</span> <span class="Global">completed-routines*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine <span class="Delimiter">(</span>car <span class="Global">completed-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>when <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>no routine<span class="Delimiter">)</span> <span class="Delimiter">(</span>no rep.routine!error<span class="Delimiter">)</span> <span class="Delimiter">(</span>~posmatch <span class="Constant">"deadlock"</span> rep.routine!error<span class="Delimiter">))</span> @@ -2384,15 +3022,15 @@ a { color:#4444ff; } <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-write-block"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Delimiter">'((</span>main - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">1</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">34</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">2</span> integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">1</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">34</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:tagged-value <span class="Op"><-</span> save-type <span class="Constant">2</span>:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> <span class="Comment">; channel has capacity 1, but receives a second write</span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span><span class="Constant">1</span> channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">3</span> tagged-value-address deref<span class="Delimiter">)))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address <span class="Constant">3</span>:tagged-value<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "schedule" "addr")))</span> <span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> @@ -2402,39 +3040,65 @@ a { color:#4444ff; } <span class="CommentedCode">;? (prn completed-routines*)</span> <span class="Comment">; second write should cause the routine to sleep, and</span> <span class="Comment">; the sole sleeping routine should trigger the deadlock detector</span> -<span class="Delimiter">(</span><span class="Normal">let</span> routine <span class="Delimiter">(</span><span class="Identifier">car</span> <span class="Global">completed-routines*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine <span class="Delimiter">(</span>car <span class="Global">completed-routines*</span><span class="Delimiter">)</span> <span class="Delimiter">(</span>when <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>no routine<span class="Delimiter">)</span> <span class="Delimiter">(</span>no rep.routine!error<span class="Delimiter">)</span> <span class="Delimiter">(</span>~posmatch <span class="Constant">"deadlock"</span> rep.routine!error<span class="Delimiter">))</span> - <span class="Delimiter">(</span>prn <span class="Constant">"F - 'write' on <span style='color:#5f00af'>full</span> channel blocks (puts the routine to sleep until the channel gets data)"</span><span class="Delimiter">)))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'write' on full channel blocks (puts the routine to sleep until the channel gets data)"</span><span class="Delimiter">)))</span> <span class="CommentedCode">;? (quit)</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Delimiter">(</span>new-trace <span class="Constant">"channel-handoff"</span><span class="Delimiter">)</span> -<span class="Delimiter">(</span>add-fns - <span class="Mu"><span class="Delimiter">'((</span>f1</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">30</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#ff87af'>chan</span> channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-channel <span class="Delimiter">(</span><span class="MuConstant">3</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">(</span>fork <span class="Delimiter">(</span>f2 fn<span class="Delimiter">)</span> <span class="Delimiter">(</span><span style='color:#ff87af'>chan</span> channel-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">1</span> tagged-value global<span class="Delimiter">)</span> <span class="Op"><-</span> read <span class="Delimiter">(</span><span style='color:#ff87af'>chan</span> channel-address<span class="Delimiter">)))</span></span> - <span class="Mu"><span class="Delimiter">(</span>f2</span> - <span class="Mu"><span class="Delimiter">((</span><span style='color:#00af87'>default-scope</span> scope-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>scope literal<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="MuConstant">30</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>n integer-address<span class="Delimiter">)</span> <span class="Op"><-</span> new <span class="Delimiter">(</span>integer literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>n integer-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">24</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>ochan channel-address<span class="Delimiter">)</span> <span class="Op"><-</span> <span class="Identifier">arg</span><span class="Delimiter">)</span></span> - <span class="Mu"><span class="Delimiter">((</span>x tagged-value-address<span class="Delimiter">)</span> <span class="Op"><-</span> new-tagged-value <span class="Delimiter">(</span>integer-address literal<span class="Delimiter">)</span> <span class="Delimiter">(</span>n integer-address<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span>ochan channel-address deref<span class="Delimiter">)</span> <span class="Op"><-</span> write <span class="Delimiter">(</span>ochan channel-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>x tagged-value-address deref<span class="Delimiter">)))))</span></span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function consumer <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>chan:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; create a channel</span></span> + <span class="Mu"><span class="Delimiter">(</span>fork producer:fn <span class="MuConstant">nil</span>:literal chan:channel-address<span class="Delimiter">)</span> <span class="Comment">; fork a routine to produce a value in it</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:tagged-value/raw <span class="Op"><-</span> read chan:channel-address<span class="Delimiter">)</span> <span class="Comment">; wait for input on channel</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function producer <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>n:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>ochan:channel-address <span class="Op"><-</span> <span class="Identifier">next-input</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>x:tagged-value <span class="Op"><-</span> save-type n:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>ochan:channel-address/deref <span class="Op"><-</span> write ochan:channel-address x:tagged-value<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> <span class="CommentedCode">;? (set dump-trace*)</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("schedule" "run" "addr")))</span> <span class="CommentedCode">;? (= dump-trace* (obj whitelist '("-")))</span> -<span class="Delimiter">(</span>run <span class="Delimiter">'</span>f1<span class="Delimiter">)</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>consumer<span class="Delimiter">)</span> <span class="CommentedCode">;? (prn memory*)</span> <span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> -<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">24</span> <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Global">memory*</span><span class="Constant">.2</span><span class="Delimiter">))</span> <span class="Comment">; location 1 contains tagged-value *x above</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">24</span> <span class="Global">memory*</span><span class="Constant">.2</span><span class="Delimiter">)</span> <span class="Comment">; location 1 contains tagged-value x above</span> <span class="Delimiter">(</span>prn <span class="Constant">"F - channels are meant to be shared between routines"</span><span class="Delimiter">))</span> <span class="CommentedCode">;? (quit)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"channel-handoff-routine"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function consumer <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address <span class="Op"><-</span> init-channel <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span> <span class="Comment">; create a channel</span></span> + <span class="Mu"><span class="Delimiter">(</span>fork producer:fn default-space:space-address<span class="Delimiter">)</span> <span class="Comment">; pass it as a global to another routine</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:tagged-value/raw <span class="Op"><-</span> read <span class="Constant">1</span>:channel-address<span class="Delimiter">)</span> <span class="Comment">; wait for input on channel</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function producer <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>n:integer <span class="Op"><-</span> copy <span class="MuConstant">24</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>x:tagged-value <span class="Op"><-</span> save-type n:integer<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:channel-address/space:global/deref <span class="Op"><-</span> write <span class="Constant">1</span>:channel-address/space:global x:tagged-value<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>consumer<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">24</span> <span class="Global">memory*</span><span class="Constant">.2</span><span class="Delimiter">)</span> <span class="Comment">; location 1 contains tagged-value x above</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - channels are meant to be shared between routines"</span><span class="Delimiter">))</span> + +<span class="Delimiter">)</span> <span class="Comment">; section 100</span> + +<span class="Delimiter">(</span>section <span class="Constant">10</span> + <span class="SalientComment">;; Separating concerns</span> <span class="Comment">;</span> <span class="Comment">; Lightweight tools can also operate on quoted lists of statements surrounded</span> @@ -2450,18 +3114,1037 @@ a { color:#4444ff; } <span class="Comment">; code is that we can naturally name 'join points' wherever we want.</span> <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> -<span class="CommentedCode">;? (new-trace "convert-quotes-defer")</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-quotes-defer"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-quotes - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> <span class="Mu"><span class="Delimiter">(</span>defer <span class="Delimiter">[</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">6</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">])</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))))</span></span> - <span class="Mu"><span class="Delimiter">'(((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">4</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">2</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">5</span> literal<span class="Delimiter">))</span></span> - <span class="Mu"><span class="Delimiter">((</span><span class="Constant">3</span> integer<span class="Delimiter">)</span> <span class="Op"><-</span> copy <span class="Delimiter">(</span><span class="MuConstant">6</span> literal<span class="Delimiter">))))</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">6</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">5</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">6</span>:literal<span class="Delimiter">)))</span></span> <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-quotes can handle 'defer'"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-quotes-defer-reply"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-quotes + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>defer <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-quotes inserts code at early exits"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-quotes-defer-reply-arg"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-quotes + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>defer <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span> <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span>prepare-reply <span class="MuConstant">2</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Identifier">reply</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-quotes inserts code at early exits"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"convert-quotes-label"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>convert-quotes + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + foo + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">5</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + foo + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">5</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - convert-quotes can handle labels"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>as cons <span class="Global">before*</span>!label1<span class="Delimiter">)</span> + <span class="Delimiter">'(</span><span class="Comment">; fragment</span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'before' records fragments of code to insert before labels"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>insert-code + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'insert-code' can insert fragments before labels"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before-multiple"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>as cons <span class="Global">before*</span>!label1<span class="Delimiter">)</span> + <span class="Delimiter">'(</span><span class="Comment">; fragment</span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))</span></span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'before' records fragments in order"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>insert-code + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'insert-code' can insert multiple fragments in order before label"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before-scoped"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>before f/label1 <span class="Delimiter">[</span> <span class="Comment">; label1 only inside function f</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>insert-code + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))</span></span> + <span class="Delimiter">'</span>f<span class="Delimiter">)</span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'insert-code' can insert fragments before labels just in specified functions"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before-scoped2"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>before f/label1 <span class="Delimiter">[</span> <span class="Comment">; label1 only inside function f</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>insert-code + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'insert-code' ignores labels not in specified functions"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"after"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>as cons <span class="Global">after*</span>!label1<span class="Delimiter">)</span> + <span class="Delimiter">'(</span><span class="Comment">; fragment</span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'after' records fragments of code to insert after labels"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>insert-code + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'insert-code' can insert fragments after labels"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"after-multiple"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>as cons <span class="Global">after*</span>!label1<span class="Delimiter">)</span> + <span class="Delimiter">'(</span><span class="Comment">; fragment</span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))</span></span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'after' records fragments in *reverse* order"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>insert-code + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'insert-code' can insert multiple fragments in order after label"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before-after"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">and</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>as cons <span class="Global">before*</span>!label1<span class="Delimiter">)</span> + <span class="Delimiter">'(</span><span class="Comment">; fragment</span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))))</span></span> + <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>as cons <span class="Global">after*</span>!label1<span class="Delimiter">)</span> + <span class="Delimiter">'(</span><span class="Comment">; fragment</span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'before' and 'after' fragments work together"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>insert-code + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'insert-code' can insert multiple fragments around label"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before-after-multiple"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>as cons <span class="Global">before*</span>!label1<span class="Delimiter">)</span> + <span class="Delimiter">'(</span><span class="Comment">; fragment</span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))</span></span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))))</span></span> + <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>as cons <span class="Global">after*</span>!label1<span class="Delimiter">)</span> + <span class="Delimiter">'(</span><span class="Comment">; fragment</span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">))</span></span> + <span class="Delimiter">(</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - multiple 'before' and 'after' fragments at once"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>insert-code + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">'((</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu">label1</span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">6</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">7</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">8</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'insert-code' can insert multiple fragments around label - 2"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before-after-independent"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span><span class="Normal">do</span> + <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> + <span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> + <span class="Delimiter">(</span>list <span class="Global">before*</span>!label1 <span class="Global">after*</span>!label1<span class="Delimiter">))</span> + <span class="Delimiter">(</span><span class="Normal">do</span> + <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> + <span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>before label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> + <span class="Delimiter">(</span>list <span class="Global">before*</span>!label1 <span class="Global">after*</span>!label1<span class="Delimiter">)))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - order matters between 'before' and between 'after' fragments, but not *across* 'before' and 'after' fragments"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before-after-braces"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">function*</span> <span class="Delimiter">(</span>table<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f1 <span class="Delimiter">[</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu">label1</span> + } + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("cn0")))</span> +<span class="Delimiter">(</span>freeze <span class="Global">function*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">function*</span>!f1 + <span class="Mu"><span class="Delimiter">'(</span>label1</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - before/after works inside blocks"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"before-after-any-order"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">function*</span> <span class="Delimiter">(</span>table<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + { <span class="CommentedCode">begin</span> + <span class="Mu">label1</span> + } + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>after label1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>freeze <span class="Global">function*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">function*</span>!f1 + <span class="Mu"><span class="Delimiter">'(</span>label1</span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - before/after can come after the function they need to modify"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"multiple-defs"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">function*</span> <span class="Delimiter">(</span>table<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>freeze <span class="Global">function*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">function*</span>!f1 + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))</span></span> + <span class="Mu"><span class="Delimiter">(((</span><span class="Constant">1</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - multiple 'def' of the same function add clauses"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"def!"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">traces*</span> <span class="Delimiter">(</span>queue<span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">function*</span> <span class="Delimiter">(</span>table<span class="Delimiter">))</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])</span> + <span class="Mu"><span class="Delimiter">(</span>function! f1 <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> copy <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>freeze <span class="Global">function*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">function*</span>!f1 + <span class="Mu"><span class="Delimiter">'((((</span><span class="Constant">2</span> integer<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>copy<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">0</span> literal<span class="Delimiter">)))))</span></span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'def!' clears all previous clauses"</span><span class="Delimiter">))</span> + +<span class="Delimiter">)</span> <span class="Comment">; section 10</span> + +<span class="SalientComment">;; ---</span> + +<span class="Delimiter">(</span>section <span class="Constant">100</span> <span class="Comment">; string utilities</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-new"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new string:literal <span class="MuConstant">5</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> before rep.routine!alloc + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso rep.routine!alloc <span class="Delimiter">(</span>+ before <span class="Constant">5</span> <span class="Constant">1</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' allocates arrays of bytes for strings"</span><span class="Delimiter">))))</span> + +<span class="Comment">; Convenience: initialize strings using string literals</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-literal"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"hello"</span><span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> routine make-routine!main + <span class="Delimiter">(</span>enq routine <span class="Global">running-routines*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">let</span> before rep.routine!alloc +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("schedule" "run" "addr")))</span> + <span class="Delimiter">(</span>run<span class="Delimiter">)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso rep.routine!alloc <span class="Delimiter">(</span>+ before <span class="Constant">5</span> <span class="Constant">1</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' allocates arrays of bytes for string literals"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains-array before <span class="Constant">"hello"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'new' initializes allocated memory to string literal"</span><span class="Delimiter">))))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"strcat"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"hello,"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address <span class="Op"><-</span> new <span class="Constant">" world!"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:string-address <span class="Op"><-</span> strcat <span class="Constant">1</span>:string-address <span class="Constant">2</span>:string-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains-array <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">"hello, world!"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'strcat' concatenates strings"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"interpolate"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"hello, _!"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:string-address <span class="Op"><-</span> interpolate <span class="Constant">1</span>:string-address <span class="Constant">2</span>:string-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains-array <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">"hello, abc!"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'interpolate' splices strings"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"interpolate-empty"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"hello!"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:string-address <span class="Op"><-</span> interpolate <span class="Constant">1</span>:string-address <span class="Constant">2</span>:string-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains-array <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">"hello!"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'interpolate' without underscore returns template"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"interpolate-at-start"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"_, hello!"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:string-address <span class="Op"><-</span> interpolate <span class="Constant">1</span>:string-address <span class="Constant">2</span>:string-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains-array <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">"abc, hello"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'interpolate' splices strings at start"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"interpolate-at-end"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"hello, _"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:string-address <span class="Op"><-</span> interpolate <span class="Constant">1</span>:string-address <span class="Constant">2</span>:string-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains-array <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">"hello, abc"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'interpolate' splices strings at start"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"interpolate-varargs"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"hello, _, _, and _!"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">3</span>:string-address <span class="Op"><-</span> new <span class="Constant">"def"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">4</span>:string-address <span class="Op"><-</span> new <span class="Constant">"ghi"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">5</span>:string-address <span class="Op"><-</span> interpolate <span class="Constant">1</span>:string-address <span class="Constant">2</span>:string-address <span class="Constant">3</span>:string-address <span class="Constant">4</span>:string-address<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run" "array-info")))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (quit)</span> +<span class="CommentedCode">;? (up i 1 (+ 1 (memory* memory*.5))</span> +<span class="CommentedCode">;? (prn (memory* (+ memory*.5 i))))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains-array <span class="Global">memory*</span><span class="Constant">.5</span> <span class="Constant">"hello, abc, def, and ghi!"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'interpolate' splices in any number of strings"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-find-next"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"a/b"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> find-next <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">))</span> <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">1</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'find-next' finds first location of a character"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-find-next-empty"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">""</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> find-next <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">))</span> <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">0</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'find-next' finds first location of a character"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-find-next-initial"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"/abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> find-next <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">))</span> <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">0</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'find-next' handles prefix match"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-find-next-final"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc/"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> find-next <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">))</span> <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*.2)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">3</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'find-next' handles suffix match"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-find-next-missing"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> find-next <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">))</span> <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn memory*.2)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">3</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'find-next' handles no match"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-find-next-invalid-index"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> find-next <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">))</span> <span class="MuConstant">4</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="CommentedCode">;? (prn memory*.2)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'find-next' skips invalid index (past end of string)"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-find-next-first"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"ab/c/"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> find-next <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">))</span> <span class="MuConstant">0</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">2</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'find-next' finds first of multiple options"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-find-next-second"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"ab/c/"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:integer <span class="Op"><-</span> find-next <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">))</span> <span class="MuConstant">3</span>:literal<span class="Delimiter">)</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'find-next' finds second of multiple options"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-split"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"a/b"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address-array-address <span class="Op"><-</span> split <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> base <span class="Global">memory*</span><span class="Constant">.2</span> +<span class="CommentedCode">;? (prn base " " memory*.base)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.base <span class="Constant">2</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (do1 nil prn.111)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">"a"</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (do1 nil prn.111)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">2</span><span class="Delimiter">))</span> <span class="Constant">"b"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'split' cuts string at delimiter"</span><span class="Delimiter">)))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-split2"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"a/b/c"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address-array-address <span class="Op"><-</span> split <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> base <span class="Global">memory*</span><span class="Constant">.2</span> +<span class="CommentedCode">;? (prn base " " memory*.base)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.base <span class="Constant">3</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (do1 nil prn.111)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">"a"</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (do1 nil prn.111)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">2</span><span class="Delimiter">))</span> <span class="Constant">"b"</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (do1 nil prn.111)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">3</span><span class="Delimiter">))</span> <span class="Constant">"c"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'split' cuts string at two delimiters"</span><span class="Delimiter">)))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-split-missing"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"abc"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address-array-address <span class="Op"><-</span> split <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> base <span class="Global">memory*</span><span class="Constant">.2</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.base <span class="Constant">1</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">"abc"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'split' handles missing delimiter"</span><span class="Delimiter">)))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-split-empty"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">""</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address-array-address <span class="Op"><-</span> split <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">])))</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("run")))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> base <span class="Global">memory*</span><span class="Constant">.2</span> +<span class="CommentedCode">;? (prn base " " memory*.base)</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.base <span class="Constant">0</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'split' handles empty string"</span><span class="Delimiter">)))</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"string-split-empty-piece"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Mu"><span class="Delimiter">'((</span>function main <span class="Delimiter">[</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">1</span>:string-address <span class="Op"><-</span> new <span class="Constant">"a/b//c"</span><span class="Delimiter">)</span></span> + <span class="Mu"><span class="Delimiter">(</span><span class="Constant">2</span>:string-address-array-address <span class="Op"><-</span> split <span class="Constant">1</span>:string-address <span class="Delimiter">((</span><span class="MuConstant">#\/</span> literal<span class="Delimiter">)))</span></span> + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span>run <span class="Delimiter">'</span>main<span class="Delimiter">)</span> +<span class="Delimiter">(</span>each routine <span class="Global">completed-routines*</span> + <span class="Delimiter">(</span>aif rep.routine!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">let</span> base <span class="Global">memory*</span><span class="Constant">.2</span> + <span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span><span class="Normal">or</span> <span class="Delimiter">(</span>~is <span class="Global">memory*</span>.base <span class="Constant">4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">1</span><span class="Delimiter">))</span> <span class="Constant">"a"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">2</span><span class="Delimiter">))</span> <span class="Constant">"b"</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">3</span><span class="Delimiter">))</span> <span class="Constant">""</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>~memory-contains-array <span class="Delimiter">(</span><span class="Global">memory*</span> <span class="Delimiter">(</span>+ base <span class="Constant">4</span><span class="Delimiter">))</span> <span class="Constant">"c"</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'split' cuts string at two delimiters"</span><span class="Delimiter">)))</span> + +<span class="Delimiter">)</span> <span class="Comment">; section 100 for string utilities</span> + +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>new-trace <span class="Constant">"parse-and-record"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>add-code + <span class="Delimiter">'((</span>and-record foo <span class="Delimiter">[</span> + x:string + y:integer + z:boolean + <span class="Delimiter">])))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Global">type*</span>!foo <span class="Delimiter">(</span>obj size <span class="Constant">3</span> and-record t elems <span class="Delimiter">'((</span>string<span class="Delimiter">)</span> <span class="Delimiter">(</span>integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>boolean<span class="Delimiter">))</span> <span class="Normal">fields</span> <span class="Delimiter">'(</span>x y z<span class="Delimiter">)))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'add-code' can add new and-records"</span><span class="Delimiter">))</span> + +<span class="SalientComment">;; unit tests for various helpers</span> + +<span class="Comment">; tokenize-args</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== tokenize-args"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>assert:iso <span class="Delimiter">'((</span>a b<span class="Delimiter">)</span> <span class="Delimiter">(</span>c d<span class="Delimiter">))</span> + <span class="Delimiter">(</span>tokenize-arg <span class="Delimiter">'</span>a:b/c:d<span class="Delimiter">))</span> +<span class="Comment">; numbers are not symbols</span> +<span class="Delimiter">(</span>assert:iso <span class="Delimiter">'((</span>a b<span class="Delimiter">)</span> <span class="Delimiter">(</span><span class="Constant">1</span> d<span class="Delimiter">))</span> + <span class="Delimiter">(</span>tokenize-arg <span class="Delimiter">'</span>a:b/1:d<span class="Delimiter">))</span> +<span class="Comment">; special symbols are skipped</span> +<span class="Mu"><span class="Delimiter">(</span>assert:iso <span class="Delimiter">'</span><span class="Op"><-</span></span> + <span class="Mu"><span class="Delimiter">(</span>tokenize-arg <span class="Delimiter">'</span><span class="Op"><-</span><span class="Delimiter">))</span></span> +<span class="Delimiter">(</span>assert:iso <span class="Delimiter">'</span>_ + <span class="Delimiter">(</span>tokenize-arg <span class="Delimiter">'</span>_<span class="Delimiter">))</span> + +<span class="Comment">; idempotent</span> +<span class="Delimiter">(</span>assert:iso <span class="Delimiter">(</span>tokenize-arg:tokenize-arg <span class="Delimiter">'</span>a:b/c:d<span class="Delimiter">)</span> + <span class="Delimiter">(</span>tokenize-arg <span class="Delimiter">'</span>a:b/c:d<span class="Delimiter">))</span> + +<span class="Comment">; support labels</span> +<span class="Mu"><span class="Delimiter">(</span>assert:iso <span class="Delimiter">'((((</span>default-space space-address<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>new<span class="Delimiter">))</span> <span class="Delimiter">((</span>space literal<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">30</span> literal<span class="Delimiter">)))</span></span> + foo<span class="Delimiter">)</span> + <span class="Delimiter">(</span>tokenize-args + <span class="Mu"><span class="Delimiter">'((</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + foo<span class="Delimiter">)))</span> + +<span class="Comment">; support braces</span> +<span class="Mu"><span class="Delimiter">(</span>assert:iso <span class="Delimiter">'((((</span>default-space space-address<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>new<span class="Delimiter">))</span> <span class="Delimiter">((</span>space literal<span class="Delimiter">))</span> <span class="Delimiter">((</span><span class="MuConstant">30</span> literal<span class="Delimiter">)))</span></span> + foo + { <span class="CommentedCode">begin</span> + bar + <span class="Mu"><span class="Delimiter">(((</span>a b<span class="Delimiter">))</span> <span class="Op"><-</span> <span class="Delimiter">((</span>op<span class="Delimiter">))</span> <span class="Delimiter">((</span>c d<span class="Delimiter">))</span> <span class="Delimiter">((</span>e f<span class="Delimiter">)))</span></span> + }<span class="Delimiter">)</span> + <span class="Delimiter">(</span>tokenize-args + <span class="Mu"><span class="Delimiter">'((</span>default-space:space-address <span class="Op"><-</span> new space:literal <span class="MuConstant">30</span>:literal<span class="Delimiter">)</span></span> + foo + { <span class="CommentedCode">begin</span> + bar + <span class="Mu"><span class="Delimiter">(</span>a:b <span class="Op"><-</span> op c:d e:f<span class="Delimiter">)</span></span> + }<span class="Delimiter">)))</span> + +<span class="Comment">; space</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== space"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Constant">0</span> <span class="Delimiter">(</span>space <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'space' is 0 by default"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Constant">1</span> <span class="Delimiter">(</span>space <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>space <span class="Constant">1</span><span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'space' picks up space when available"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'</span>global <span class="Delimiter">(</span>space <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>space global<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'space' understands routine-global space"</span><span class="Delimiter">))</span> + +<span class="Comment">; absolutize</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== absolutize"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Delimiter">(</span>absolutize <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'absolutize' works without routine"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">routine*</span> make-routine!foo<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Delimiter">(</span>absolutize <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'absolutize' works without default-space"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= rep.routine*!call-stack.0!default-space <span class="Constant">10</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.10</span> <span class="Constant">5</span><span class="Delimiter">)</span> <span class="Comment">; bounds check for default-space</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span><span class="Constant">15</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>raw<span class="Delimiter">))</span> + <span class="Delimiter">(</span>absolutize <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'absolutize' works with default-space"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>absolutize <span class="Delimiter">'((</span><span class="Constant">5</span> integer<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~posmatch <span class="Constant">"no room"</span> rep.routine*!error<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'absolutize' checks against default-space bounds"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span>_ integer<span class="Delimiter">))</span> <span class="Delimiter">(</span>absolutize <span class="Delimiter">'((</span>_ integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'absolutize' passes dummy args right through"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.20</span> <span class="Constant">5</span><span class="Delimiter">)</span> <span class="Comment">; pretend array</span> +<span class="Delimiter">(</span>= rep.routine*!globals <span class="Constant">20</span><span class="Delimiter">)</span> <span class="Comment">; provide it to routine global</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span><span class="Constant">22</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>raw<span class="Delimiter">))</span> + <span class="Delimiter">(</span>absolutize <span class="Delimiter">'((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>space global<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'absolutize' handles variables in the global space"</span><span class="Delimiter">))</span> + +<span class="Comment">; deref</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== deref"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">4</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> + <span class="Delimiter">(</span>deref <span class="Delimiter">'((</span><span class="Constant">3</span> integer-address<span class="Delimiter">)</span> + <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'deref' handles simple addresses"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))</span> + <span class="Delimiter">(</span>deref <span class="Delimiter">'((</span><span class="Constant">3</span> integer-address<span class="Delimiter">)</span> + <span class="Delimiter">(</span>deref<span class="Delimiter">)</span> + <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'deref' deletes just one deref"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.4</span> <span class="Constant">5</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span><span class="Constant">5</span> integer<span class="Delimiter">))</span> + <span class="Delimiter">(</span>deref:deref <span class="Delimiter">'((</span><span class="Constant">3</span> integer-address-address<span class="Delimiter">)</span> + <span class="Delimiter">(</span>deref<span class="Delimiter">)</span> + <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'deref' can be chained"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">'((</span><span class="Constant">5</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>foo<span class="Delimiter">))</span> + <span class="Delimiter">(</span>deref:deref <span class="Delimiter">'((</span><span class="Constant">3</span> integer-address-address<span class="Delimiter">)</span> + <span class="Delimiter">(</span>deref<span class="Delimiter">)</span> + <span class="Delimiter">(</span>foo<span class="Delimiter">)</span> + <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'deref' skips junk"</span><span class="Delimiter">))</span> + +<span class="Comment">; addr</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== addr"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">routine*</span> nil<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn 111)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - directly addressed operands are their own address"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer-address<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - directly addressed operands are their own address - 2"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="MuConstant">4</span> literal<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'addr' doesn't understand literals"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (prn 201)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.4</span> <span class="Constant">23</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn 202)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'addr' works with indirectly-addressed 'deref'"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">4</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">3</span> integer-address-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'addr' works with multiple 'deref'"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>= <span class="Global">routine*</span> make-routine!foo<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - directly addressed operands are their own address inside routines"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer-address<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - directly addressed operands are their own address inside routines - 2"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="MuConstant">4</span> literal<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'addr' doesn't understand literals inside routines"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.4</span> <span class="Constant">23</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'addr' works with indirectly-addressed 'deref' inside routines"</span><span class="Delimiter">))</span> + +<span class="CommentedCode">;? (prn 301)</span> +<span class="Delimiter">(</span>= rep.routine*!call-stack.0!default-space <span class="Constant">10</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn 302)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.10</span> <span class="Constant">5</span><span class="Delimiter">)</span> <span class="Comment">; bounds check for default-space</span> +<span class="CommentedCode">;? (prn 303)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">15</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - directly addressed operands in routines add default-space"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">15</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer-address<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - directly addressed operands in routines add default-space - 2"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">15</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="MuConstant">4</span> literal<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'addr' doesn't understand literals"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.15</span> <span class="Constant">23</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">23</span> <span class="Delimiter">(</span>addr <span class="Delimiter">'((</span><span class="Constant">4</span> integer-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'addr' adds default-space before 'deref', not after"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Comment">; array-len</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== array-len"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.35</span> <span class="Constant">4</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>array-len <span class="Delimiter">'((</span><span class="Constant">35</span> integer-boolean-pair-array<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'array-len'"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.34</span> <span class="Constant">35</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>array-len <span class="Delimiter">'((</span><span class="Constant">34</span> integer-boolean-pair-array-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'array-len'"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Comment">; sizeof</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== sizeof"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="CommentedCode">;? (set dump-trace*)</span> +<span class="CommentedCode">;? (prn 401)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span>_ integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on primitives"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span>_ integer-address<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on addresses"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">2</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span>_ integer-boolean-pair<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on and-records"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">3</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span>_ integer-point-pair<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on and-records with and-record fields"</span><span class="Delimiter">))</span> + +<span class="CommentedCode">;? (prn 410)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">34</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on primitive operands"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">1</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">34</span> integer-address<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on address operands"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">2</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">34</span> integer-boolean-pair<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on and-record operands"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">3</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">34</span> integer-point-pair<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on and-record operands with and-record fields"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">2</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">34</span> integer-boolean-pair-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on pointers to and-records"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.35</span> <span class="Constant">4</span><span class="Delimiter">)</span> <span class="Comment">; size of array</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.34</span> <span class="Constant">35</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("sizeof" "array-len")))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">9</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">34</span> integer-boolean-pair-array-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on pointers to arrays"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="CommentedCode">;? (prn 420)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.4</span> <span class="Constant">23</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">24</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">4</span> integer-array<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' reads array lengths from memory"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">4</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">24</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">3</span> integer-array-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' handles pointers to arrays"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.15</span> <span class="Constant">34</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">routine*</span> make-routine!foo<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">24</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">4</span> integer-array<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' reads array lengths from memory inside routines"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= rep.routine*!call-stack.0!default-space <span class="Constant">10</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.10</span> <span class="Constant">5</span><span class="Delimiter">)</span> <span class="Comment">; bounds check for default-space</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">35</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">4</span> integer-array<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' reads array lengths from memory using default-space"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.35</span> <span class="Constant">4</span><span class="Delimiter">)</span> <span class="Comment">; size of array</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.15</span> <span class="Constant">35</span><span class="Delimiter">)</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("sizeof")))</span> +<span class="Delimiter">(</span>aif rep.routine*!error <span class="Delimiter">(</span>prn <span class="Constant">"error - "</span> it<span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">9</span> <span class="Delimiter">(</span>sizeof <span class="Delimiter">'((</span><span class="Constant">4</span> integer-boolean-pair-array-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'sizeof' works on pointers to arrays using default-space"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (quit)</span> + +<span class="Comment">; m</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== m"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="MuConstant">4</span> literal<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' avoids reading memory for literals"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="MuConstant">4</span> offset<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' avoids reading memory for offsets"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.4</span> <span class="Constant">34</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">34</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' reads memory for simple types"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.3</span> <span class="Constant">4</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">34</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">3</span> integer-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' redirects addresses"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">3</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">34</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">2</span> integer-address-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' multiply redirects addresses"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">34</span> nil<span class="Delimiter">))</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">4</span> integer-boolean-pair<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' supports compound records"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.5</span> <span class="Constant">35</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.6</span> <span class="Constant">36</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">34</span> <span class="Constant">35</span> <span class="Constant">36</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">4</span> integer-point-pair<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' supports records with compound fields"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">34</span> <span class="Constant">35</span> <span class="Constant">36</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">3</span> integer-point-pair-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' supports indirect access to records"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.4</span> <span class="Constant">2</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">35</span> <span class="Constant">36</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">4</span> integer-array<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' supports access to arrays"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">35</span> <span class="Constant">36</span><span class="Delimiter">))</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">3</span> integer-array-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' supports indirect access to arrays"</span><span class="Delimiter">))</span> + +<span class="Delimiter">(</span>= <span class="Global">routine*</span> make-routine!foo<span class="Delimiter">)</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.10</span> <span class="Constant">5</span><span class="Delimiter">)</span> <span class="Comment">; fake array</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.12</span> <span class="Constant">34</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>= rep.routine*!globals <span class="Constant">10</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~iso <span class="Constant">34</span> <span class="Delimiter">(</span>m <span class="Delimiter">'((</span><span class="Constant">1</span> integer<span class="Delimiter">)</span> <span class="Delimiter">(</span>space global<span class="Delimiter">))))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'm' supports access to per-routine globals"</span><span class="Delimiter">))</span> + +<span class="Comment">; setm</span> +<span class="Delimiter">(</span>prn <span class="Constant">"== setm"</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>reset<span class="Delimiter">)</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">4</span> integer<span class="Delimiter">))</span> <span class="Constant">34</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">34</span> <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' writes primitives to memory"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">3</span> integer-address<span class="Delimiter">))</span> <span class="Constant">4</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">4</span> <span class="Global">memory*</span><span class="Constant">.3</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' writes addresses to memory"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">3</span> integer-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))</span> <span class="Constant">35</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">35</span> <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' redirects writes"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">memory*</span><span class="Constant">.2</span> <span class="Constant">3</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">2</span> integer-address-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))</span> <span class="Constant">36</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~is <span class="Constant">36</span> <span class="Global">memory*</span><span class="Constant">.4</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' multiply redirects writes"</span><span class="Delimiter">))</span> +<span class="CommentedCode">;? (prn 505)</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">4</span> integer-integer-pair<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">23</span> <span class="Constant">24</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains <span class="Constant">4</span> <span class="Delimiter">'(</span><span class="Constant">23</span> <span class="Constant">24</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' writes compound records"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>assert <span class="Delimiter">(</span>is <span class="Global">memory*</span><span class="Constant">.7</span> nil<span class="Delimiter">))</span> +<span class="CommentedCode">;? (prn 506)</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">7</span> integer-point-pair<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">23</span> <span class="Constant">24</span> <span class="Constant">25</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains <span class="Constant">7</span> <span class="Delimiter">'(</span><span class="Constant">23</span> <span class="Constant">24</span> <span class="Constant">25</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' writes records with compound fields"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">routine*</span> make-routine!foo<span class="Delimiter">)</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">4</span> integer-point-pair<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">33</span> <span class="Constant">34</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~posmatch <span class="Constant">"incorrect size"</span> rep.routine*!error<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' checks size of target"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>wipe <span class="Global">routine*</span><span class="Delimiter">)</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">3</span> integer-point-pair-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">43</span> <span class="Constant">44</span> <span class="Constant">45</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains <span class="Constant">4</span> <span class="Delimiter">'(</span><span class="Constant">43</span> <span class="Constant">44</span> <span class="Constant">45</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' supports indirect writes to records"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">2</span> integer-point-pair-address-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">53</span> <span class="Constant">54</span> <span class="Constant">55</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains <span class="Constant">4</span> <span class="Delimiter">'(</span><span class="Constant">53</span> <span class="Constant">54</span> <span class="Constant">55</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' supports multiply indirect writes to records"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">4</span> integer-array<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">31</span> <span class="Constant">32</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains <span class="Constant">4</span> <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">31</span> <span class="Constant">32</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' writes arrays"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">3</span> integer-array-address<span class="Delimiter">)</span> <span class="Delimiter">(</span>deref<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">41</span> <span class="Constant">42</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~memory-contains <span class="Constant">4</span> <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">41</span> <span class="Constant">42</span><span class="Delimiter">))</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' supports indirect writes to arrays"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">routine*</span> make-routine!foo<span class="Delimiter">)</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">4</span> integer-array<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">31</span> <span class="Constant">32</span> <span class="Constant">33</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~posmatch <span class="Constant">"invalid array"</span> rep.routine*!error<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' checks that array written is well-formed"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">routine*</span> make-routine!foo<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn 111)</span> +<span class="CommentedCode">;? (= dump-trace* (obj whitelist '("sizeof" "setm")))</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">4</span> integer-boolean-pair-array<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">31</span> nil <span class="Constant">32</span> nil <span class="Constant">33</span><span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>~posmatch <span class="Constant">"invalid array"</span> rep.routine*!error<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' checks that array of records is well-formed"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>= <span class="Global">routine*</span> make-routine!foo<span class="Delimiter">)</span> +<span class="CommentedCode">;? (prn 222)</span> +<span class="Delimiter">(</span>setm <span class="Delimiter">'((</span><span class="Constant">4</span> integer-boolean-pair-array<span class="Delimiter">))</span> <span class="Delimiter">(</span>annotate <span class="Delimiter">'</span>record <span class="Delimiter">'(</span><span class="Constant">2</span> <span class="Constant">31</span> nil <span class="Constant">32</span> nil<span class="Delimiter">)))</span> +<span class="Delimiter">(</span><span class="Normal">if</span> <span class="Delimiter">(</span>posmatch <span class="Constant">"invalid array"</span> rep.routine*!error<span class="Delimiter">)</span> + <span class="Delimiter">(</span>prn <span class="Constant">"F - 'setm' checks that array of records is well-formed - 2"</span><span class="Delimiter">))</span> +<span class="Delimiter">(</span>wipe <span class="Global">routine*</span><span class="Delimiter">)</span> + <span class="Delimiter">(</span>reset<span class="Delimiter">)</span> <span class="Comment">; end file with this to persist the trace for the final test</span> </pre> </body> diff --git a/scratch.vim b/scratch.vim index 72ce7d32..83b05539 100644 --- a/scratch.vim +++ b/scratch.vim @@ -2,13 +2,29 @@ TOhtml %s,<.*<-.*,<span class="Mu">&</span>,gc -%s,<-,<span class="Op">&</span>,g -%s/Constant[^>]*>[^>]*> literal/Mu&/gc -%s/Constant[^>]*>[^>]*> offset/Mu&/gc +%s/Special"></Op">\</g +%s, <-, <span class="Op">&</span>,gc +%s/Constant[^>]*>[^>]*>[: ]literal/Mu&/gc +%s/Constant[^>]*>[^>]*>[: ]offset/Mu&/gc %s,\<nil literal,<span class="MuConstant">t</span> literal,gc %s,\<t literal,<span class="MuConstant">t</span> literal,gc +%s,\<nil:literal\>,<span class="MuConstant">nil</span>:literal,gc +%s,\<t:literal\>,<span class="MuConstant">t</span>:literal,gc -map ` :s,[{}<].*,<span class="Mu">&</span>,<CR> +map ` :s,[^ ].*,<span class="Mu">&</span>,<CR> +/function.*[ +"b = `/<Up><Up><Enter>n +map ; @b +/jump +/break +/reply +/loop +/sleep +/fork +/defer +/label1 +/before.*[ +/after.*[ " supercedes %s,<.*break.*,<span class="Mu">&</span>,gc |