From f182752578c4e5b06b1fe15bfcae007797c1ce2d Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Sat, 8 Nov 2014 09:42:24 -0800 Subject: 261 - render matchadd() to html as well --- mu.arc.t.html | 108 +++++++++++++++++++++++++++++----------------------------- 1 file changed, 54 insertions(+), 54 deletions(-) (limited to 'mu.arc.t.html') diff --git a/mu.arc.t.html b/mu.arc.t.html index 2883aaca..8d8575c7 100644 --- a/mu.arc.t.html +++ b/mu.arc.t.html @@ -92,7 +92,7 @@ a { color:#4444ff; } ; allocation, or write to disk? It requires better, more observable primitives ; than we currently have. Modern operating systems have their roots in the ; 70s. Their interfaces were not designed to be testable. They provide no way -; to simulate a full disk, or a specific sequence of writes from different +; to simulate a full disk, or a specific sequence of writes from different ; threads. We need something better. ; ; This project tries to move, groping, towards that 'something better', a @@ -1370,12 +1370,12 @@ a { color:#4444ff; } ; Even though our memory locations can now have names, the names are all ; globals, accessible from any function. To isolate functions from their ; callers we need local variables, and mu provides them using a special -; variable called default-scope. When you initialize such a variable (likely +; variable called default-scope. When you initialize such a variable (likely ; with a call to our just-defined memory allocator) mu interprets memory -; locations as offsets from its value. If default-scope is set to 1000, for +; locations as offsets from its value. If default-scope is set to 1000, for ; example, reads and writes to memory location 1 will really go to 1001. ; -; 'default-scope' is itself hard-coded to be function-local; it's nil in a new +; 'default-scope' is itself hard-coded to be function-local; it's nil in a new ; function, and it's restored when functions return to their callers. But the ; actual scope allocation is independent. So you can define closures, or do ; even more funky things like share locals between two coroutines. @@ -1384,7 +1384,7 @@ a { color:#4444ff; } (new-trace "set-default-scope") (add-fns '((main - ((default-scope scope-address) <- new (scope literal) (2 literal)) + ((default-scope scope-address) <- new (scope literal) (2 literal)) ((1 integer) <- copy (23 literal))))) (let before Memory-in-use-until ;? (set dump-trace*) @@ -1392,13 +1392,13 @@ a { color:#4444ff; } ;? (prn memory*) (if (~and (~is 23 memory*.1) (is 23 (memory* (+ before 1)))) - (prn "F - default-scope implicitly modifies variable locations"))) + (prn "F - default-scope implicitly modifies variable locations"))) (reset) (new-trace "set-default-scope-skips-offset") (add-fns '((main - ((default-scope scope-address) <- new (scope literal) (2 literal)) + ((default-scope scope-address) <- new (scope literal) (2 literal)) ((1 integer) <- copy (23 offset))))) (let before Memory-in-use-until ;? (set dump-trace*) @@ -1406,26 +1406,26 @@ a { color:#4444ff; } ;? (prn memory*) (if (~and (~is 23 memory*.1) (is 23 (memory* (+ before 1)))) - (prn "F - default-scope skips 'offset' types just like literals"))) + (prn "F - default-scope skips 'offset' types just like literals"))) (reset) (new-trace "default-scope-bounds-check") (add-fns '((main - ((default-scope scope-address) <- new (scope literal) (2 literal)) + ((default-scope scope-address) <- new (scope literal) (2 literal)) ((2 integer) <- copy (23 literal))))) ;? (set dump-trace*) (run 'main) ;? (prn memory*) (let last-routine (deq completed-routines*) (if (no rep.last-routine!error) - (prn "F - default-scope checks bounds"))) + (prn "F - default-scope checks bounds"))) (reset) (new-trace "default-scope-and-get-indirect") (add-fns '((main - ((default-scope scope-address) <- new (scope literal) (5 literal)) + ((default-scope scope-address) <- new (scope literal) (5 literal)) ((1 integer-boolean-pair-address) <- new (integer-boolean-pair literal)) ((2 integer-address) <- get-address (1 integer-boolean-pair-address deref) (0 offset)) ((2 integer-address deref) <- copy (34 literal)) @@ -1437,14 +1437,14 @@ a { color:#4444ff; } (let last-routine (deq completed-routines*) (aif rep.last-routine!error (prn "error - " it))) (if (~is 34 memory*.3) - (prn "F - indirect 'get' works in the presence of default-scope")) + (prn "F - indirect 'get' works in the presence of default-scope")) ;? (quit) (reset) (new-trace "default-scope-and-index-indirect") (add-fns '((main - ((default-scope scope-address) <- new (scope literal) (5 literal)) + ((default-scope scope-address) <- new (scope literal) (5 literal)) ((1 integer-array-address) <- new (integer-array literal) (4 literal)) ((2 integer-address) <- index-address (1 integer-array-address deref) (2 offset)) ((2 integer-address deref) <- copy (34 literal)) @@ -1456,7 +1456,7 @@ a { color:#4444ff; } (let last-routine (deq completed-routines*) (aif rep.last-routine!error (prn "error - " it))) (if (~is 34 memory*.3) - (prn "F - indirect 'index' works in the presence of default-scope")) + (prn "F - indirect 'index' works in the presence of default-scope")) ;? (quit) (reset) @@ -1464,18 +1464,18 @@ a { color:#4444ff; } (if (~iso (convert-names '(((x integer) <- copy (4 literal)) ((y integer) <- copy (2 literal)) - ; unsafe in general; don't write random values to 'default-scope' - ((default-scope integer) <- add (x integer) (y integer)))) + ; unsafe in general; don't write random values to 'default-scope' + ((default-scope integer) <- add (x integer) (y integer)))) '(((1 integer) <- copy (4 literal)) ((2 integer) <- copy (2 literal)) - ((default-scope integer) <- add (1 integer) (2 integer)))) - (prn "F - convert-names never renames default-scope")) + ((default-scope integer) <- add (1 integer) (2 integer)))) + (prn "F - convert-names never renames default-scope")) (reset) (new-trace "suppress-default-scope") (add-fns '((main - ((default-scope scope-address) <- new (scope literal) (2 literal)) + ((default-scope scope-address) <- new (scope literal) (2 literal)) ((1 integer global) <- copy (23 literal))))) (let before Memory-in-use-until ;? (set dump-trace*) @@ -1483,17 +1483,17 @@ a { color:#4444ff; } ;? (prn memory*) (if (~and (is 23 memory*.1) (~is 23 (memory* (+ before 1)))) - (prn "F - default-scope skipped for locations with metadata 'global'"))) + (prn "F - default-scope skipped for locations with metadata 'global'"))) (reset) (new-trace "convert-names-global") (if (~iso (convert-names '(((x integer) <- copy (4 literal)) ((y integer global) <- copy (2 literal)) - ((default-scope integer) <- add (x integer) (y integer global)))) + ((default-scope integer) <- add (x integer) (y integer global)))) '(((1 integer) <- copy (4 literal)) ((y integer global) <- copy (2 literal)) - ((default-scope integer) <- add (1 integer) (y integer global)))) + ((default-scope integer) <- add (1 integer) (y integer global)))) (prn "F - convert-names never renames global operands")) ; Putting it all together, here's how you define generic functions that run @@ -1504,16 +1504,16 @@ a { color:#4444ff; } ;? (set dump-trace*) (add-fns '((test1 - ((default-scope scope-address) <- new (scope literal) (20 literal)) - ((first-arg-box tagged-value-address) <- arg) + ((default-scope scope-address) <- new (scope literal) (20 literal)) + ((first-arg-box tagged-value-address) <- arg) ; if given integers, add them { begin - ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal)) + ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal)) (break-unless (match? boolean)) - ((second-arg-box tagged-value-address) <- arg) - ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal)) - ((result integer) <- add (first-arg integer) (second-arg integer)) - (reply (result integer)) + ((second-arg-box tagged-value-address) <- arg) + ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal)) + ((result integer) <- add (first-arg integer) (second-arg integer)) + (reply (result integer)) } (reply (t literal))) (main @@ -1533,25 +1533,25 @@ a { color:#4444ff; } ;? (set dump-trace*) (add-fns '((test1 - ((default-scope scope-address) <- new (scope literal) (20 literal)) - ((first-arg-box tagged-value-address) <- arg) + ((default-scope scope-address) <- new (scope literal) (20 literal)) + ((first-arg-box tagged-value-address) <- arg) ; if given integers, add them { begin - ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal)) + ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal)) (break-unless (match? boolean)) - ((second-arg-box tagged-value-address) <- arg) - ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal)) - ((result integer) <- add (first-arg integer) (second-arg integer)) - (reply (result integer)) + ((second-arg-box tagged-value-address) <- arg) + ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal)) + ((result integer) <- add (first-arg integer) (second-arg integer)) + (reply (result integer)) } ; if given booleans, or them (it's a silly kind of generic function) { begin - ((first-arg boolean) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (boolean literal)) + ((first-arg boolean) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (boolean literal)) (break-unless (match? boolean)) - ((second-arg-box tagged-value-address) <- arg) - ((second-arg boolean) <- maybe-coerce (second-arg-box tagged-value-address deref) (boolean literal)) - ((result boolean) <- or (first-arg boolean) (second-arg boolean)) - (reply (result integer)) + ((second-arg-box tagged-value-address) <- arg) + ((second-arg boolean) <- maybe-coerce (second-arg-box tagged-value-address deref) (boolean literal)) + ((result boolean) <- or (first-arg boolean) (second-arg boolean)) + (reply (result integer)) } (reply (t literal))) (main @@ -1571,25 +1571,25 @@ a { color:#4444ff; } (new-trace "dispatch-multiple-calls") (add-fns '((test1 - ((default-scope scope-address) <- new (scope literal) (20 literal)) - ((first-arg-box tagged-value-address) <- arg) + ((default-scope scope-address) <- new (scope literal) (20 literal)) + ((first-arg-box tagged-value-address) <- arg) ; if given integers, add them { begin - ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal)) + ((first-arg integer) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (integer literal)) (break-unless (match? boolean)) - ((second-arg-box tagged-value-address) <- arg) - ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal)) - ((result integer) <- add (first-arg integer) (second-arg integer)) - (reply (result integer)) + ((second-arg-box tagged-value-address) <- arg) + ((second-arg integer) <- maybe-coerce (second-arg-box tagged-value-address deref) (integer literal)) + ((result integer) <- add (first-arg integer) (second-arg integer)) + (reply (result integer)) } ; if given booleans, or them (it's a silly kind of generic function) { begin - ((first-arg boolean) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (boolean literal)) + ((first-arg boolean) (match? boolean) <- maybe-coerce (first-arg-box tagged-value-address deref) (boolean literal)) (break-unless (match? boolean)) - ((second-arg-box tagged-value-address) <- arg) - ((second-arg boolean) <- maybe-coerce (second-arg-box tagged-value-address deref) (boolean literal)) - ((result boolean) <- or (first-arg boolean) (second-arg boolean)) - (reply (result integer)) + ((second-arg-box tagged-value-address) <- arg) + ((second-arg boolean) <- maybe-coerce (second-arg-box tagged-value-address deref) (boolean literal)) + ((result boolean) <- or (first-arg boolean) (second-arg boolean)) + (reply (result integer)) } (reply (t literal))) (main @@ -1665,7 +1665,7 @@ a { color:#4444ff; } ; have it run just before the function exits. Great for keeping code to ; reclaim memory or other resources close to the code to allocate it. (C++ ; programmers know this as RAII.) We'll use 'defer' when we build a memory -; deallocation routine like C's 'free'. +; deallocation routine like C's 'free'. ; ; More powerful reorderings are also possible like in Literate Programming or ; Aspect-Oriented Programming; one advantage of prohibiting arbitrarily nested -- cgit 1.4.1-2-gfad0