diff options
| -rw-r--r-- | mu.arc | 4 | ||||
| -rw-r--r-- | mu.arc.t | 128 |
2 files changed, 61 insertions, 71 deletions
diff --git a/mu.arc b/mu.arc index fc6f3747..958cda77 100644 --- a/mu.arc +++ b/mu.arc @@ -411,10 +411,6 @@ (if (len> caller-args.context idx) (list (m caller-args.context.idx) t) (list nil nil))) - type - (ty (caller-args.context arg.0)) - otype - (ty (caller-oargs.context arg.0)) reply (do (pop-stack context) (if empty.context (return ninstrs)) diff --git a/mu.arc.t b/mu.arc.t index 4be95dcc..f7b77b28 100644 --- a/mu.arc.t +++ b/mu.arc.t @@ -1137,111 +1137,105 @@ (if (~iso memory* (obj 1 4 2 4 3 nil 4 34)) (prn "F - continue might never trigger")) -; 'type' and 'otype' let us create generic functions that run different code -; based on what args the caller provides, or what oargs the caller expects. -; -; These operations are almost certainly bad ideas; they violate our constraint -; of easily assembling down to native code. We'll eventually switch to dynamic -; typing with tagged-values. +; using tagged-values you can define generic functions that run different code +; based on the types of their args. (reset) -(new-trace "dispatch-otype") +(new-trace "dispatch-clause") +;? (set dump-trace*) (add-fns '((test1 - ((4 type) <- otype 0) + ((4 tagged-value-address) <- arg) { begin - ((5 boolean) <- eq (4 type) (integer literal)) - (break-unless (5 boolean)) - ((6 integer) <- arg) - ((7 integer) <- arg) - ((8 integer) <- add (6 integer) (7 integer)) + ((5 integer) (6 boolean) <- maybe-coerce (4 tagged-value-address deref) (integer literal)) + (break-unless (6 boolean)) + ((7 tagged-value-address) <- arg) + ((8 integer) (9 boolean) <- maybe-coerce (7 tagged-value-address deref) (integer literal)) + ((9 integer) <- add (5 integer) (8 integer)) + (reply (9 integer)) } - (reply (8 integer))) + (reply (nil literal))) (main - ((1 integer) <- test1 (1 literal) (3 literal))))) + ((1 tagged-value-address) <- new-tagged-value (integer literal) (34 literal)) + ((2 tagged-value-address) <- new-tagged-value (integer literal) (3 literal)) + ((3 integer) <- test1 (1 tagged-value-address) (2 tagged-value-address))))) (run 'main) ;? (prn memory*) -(if (~iso memory* (obj 1 4 - ; add-fn's temporaries - 4 'integer 5 t 6 1 7 3 8 4)) +(if (~is memory*.3 37) (prn "F - an example function that checks that its oarg is an integer")) ;? (quit) ; todo - test that reply increments pc for caller frame after popping current frame (reset) -(new-trace "dispatch-otype-multiple-clauses") +(new-trace "dispatch-multiple-clauses") ;? (set dump-trace*) (add-fns - '((test-fn - ((4 type) <- otype 0) + '((test1 + ((4 tagged-value-address) <- arg) { begin - ; integer needed? add args - ((5 boolean) <- eq (4 type) (integer literal)) - (break-unless (5 boolean)) - ((6 integer) <- arg) - ((7 integer) <- arg) - ((8 integer) <- add (6 integer) (7 integer)) - (reply (8 integer)) + ((5 integer) (6 boolean) <- maybe-coerce (4 tagged-value-address deref) (integer literal)) + (break-unless (6 boolean)) + ((7 tagged-value-address) <- arg) + ((8 integer) (9 boolean) <- maybe-coerce (7 tagged-value-address deref) (integer literal)) + ((9 integer) <- add (5 integer) (8 integer)) + (reply (9 integer)) } { begin - ; boolean needed? 'or' args - ((5 boolean) <- eq (4 type) (boolean literal)) - (break-unless (5 boolean) (4 offset)) - ((6 boolean) <- arg) - ((7 boolean) <- arg) - ((8 boolean) <- or (6 boolean) (7 boolean)) - (reply (8 boolean)) - }) + ((5 boolean) (6 boolean) <- maybe-coerce (4 tagged-value-address deref) (boolean literal)) + (break-unless (6 boolean)) + ((7 tagged-value-address) <- arg) + ((8 boolean) (9 boolean) <- maybe-coerce (7 tagged-value-address deref) (boolean literal)) + ((9 boolean) <- or (5 boolean) (8 boolean)) + (reply (9 boolean)) + } + (reply (nil literal))) (main - ((1 boolean) <- test-fn (t literal) (t literal))))) + ((1 tagged-value-address) <- new-tagged-value (boolean literal) (t literal)) + ((2 tagged-value-address) <- new-tagged-value (boolean literal) (nil literal)) + ((3 boolean) <- test1 (1 tagged-value-address) (2 tagged-value-address))))) ;? (each stmt function*!test-fn ;? (prn " " stmt)) (run 'main) ;? (wipe dump-trace*) ;? (prn memory*) -(if (~is memory*.1 t) +(if (~is memory*.3 t) (prn "F - an example function that can do different things (dispatch) based on the type of its args or oargs")) -(if (~iso memory* (obj 1 t - ; add-fn's temporaries - 4 'boolean 5 t 6 t 7 t 8 t)) - (prn "F - an example function that can do different things (dispatch) based on the type of its args or oargs (internals)")) ;? (quit) (reset) -(new-trace "dispatch-otype-multiple-calls") +(new-trace "dispatch-multiple-calls") (add-fns - '((test-fn - ((4 type) <- otype 0) + '((test1 + ((4 tagged-value-address) <- arg) { begin - ((5 boolean) <- eq (4 type) (integer literal)) - (break-unless (5 boolean)) - ((6 integer) <- arg) - ((7 integer) <- arg) - ((8 integer) <- add (6 integer) (7 integer)) - (reply (8 integer)) + ((5 integer) (6 boolean) <- maybe-coerce (4 tagged-value-address deref) (integer literal)) + (break-unless (6 boolean)) + ((7 tagged-value-address) <- arg) + ((8 integer) (9 boolean) <- maybe-coerce (7 tagged-value-address deref) (integer literal)) + ((9 integer) <- add (5 integer) (8 integer)) + (reply (9 integer)) } { begin - ((5 boolean) <- eq (4 type) (boolean literal)) - (break-unless (5 boolean)) - ((6 boolean) <- arg) - ((7 boolean) <- arg) - ((8 boolean) <- or (6 boolean) (7 boolean)) - (reply (8 boolean)) - }) + ((5 boolean) (6 boolean) <- maybe-coerce (4 tagged-value-address deref) (boolean literal)) + (break-unless (6 boolean)) + ((7 tagged-value-address) <- arg) + ((8 boolean) (9 boolean) <- maybe-coerce (7 tagged-value-address deref) (boolean literal)) + ((9 boolean) <- or (5 boolean) (8 boolean)) + (reply (9 boolean)) + } + (reply (nil literal))) (main - ((1 boolean) <- test-fn (t literal) (t literal)) - ((2 integer) <- test-fn (3 literal) (4 literal))))) + ((1 tagged-value-address) <- new-tagged-value (boolean literal) (t literal)) + ((2 tagged-value-address) <- new-tagged-value (boolean literal) (nil literal)) + ((3 boolean) <- test1 (1 tagged-value-address) (2 tagged-value-address)) + ((10 tagged-value-address) <- new-tagged-value (integer literal) (34 literal)) + ((11 tagged-value-address) <- new-tagged-value (integer literal) (3 literal)) + ((12 integer) <- test1 (10 tagged-value-address) (11 tagged-value-address))))) (run 'main) ;? (prn memory*) -(if (~and (is memory*.1 t) (is memory*.2 7)) +(if (~and (is memory*.3 t) (is memory*.12 37)) (prn "F - different calls can exercise different clauses of the same function")) -(if (~iso memory* (obj ; results of first and second calls to test-fn - 1 t 2 7 - ; temporaries for most recent call to test-fn - 4 'integer 5 t 6 3 7 4 8 7)) - (prn "F - different calls can exercise different clauses of the same function (internals)")) - ; A rudimentary memory allocator. Eventually we want to write this in mu. |