fn evaluate functions: (addr handle function), bindings: (addr table), scratch: (addr line), end: (addr word), out: (addr value-stack) { var line/eax: (addr line) <- copy scratch var word-ah/eax: (addr handle word) <- get line, data var curr/eax: (addr word) <- lookup *word-ah var curr-stream-storage: (stream byte 0x10) var curr-stream/edi: (addr stream byte) <- address curr-stream-storage clear-value-stack out $evaluate:loop: { # precondition (should never hit) compare curr, 0 break-if-= # update curr-stream emit-word curr, curr-stream #? print-string-to-real-screen "eval: " #? print-stream-to-real-screen curr-stream #? print-string-to-real-screen "\n" $evaluate:process-word: { ### if curr-stream is an operator, perform it ## numbers { var add?/eax: boolean <- stream-data-equal? curr-stream, "+" compare add?, 0 break-if-= var _b/xmm0: float <- pop-number-from-value-stack out var b/xmm1: float <- copy _b var a/xmm0: float <- pop-number-from-value-stack out a <- add b push-number-to-value-stack out, a break $evaluate:process-word } { var sub?/eax: boolean <- stream-data-equal? curr-stream, "-" compare sub?, 0 break-if-= var _b/xmm0: float <- pop-number-from-value-stack out var b/xmm1: float <- copy _b var a/xmm0: float <- pop-number-from-value-stack out a <- subtract b push-number-to-value-stack out, a break $evaluate:process-word } { var mul?/eax: boolean <- stream-data-equal? curr-stream, "*" compare mul?, 0 break-if-= var _b/xmm0: float <- pop-number-from-value-stack out var b/xmm1: float <- copy _b var a/xmm0: float <- pop-number-from-value-stack out a <- multiply b push-number-to-value-stack out, a break $evaluate:process-word } { var div?/eax: boolean <- stream-data-equal? curr-stream, "/" compare div?, 0 break-if-= var _b/xmm0: float <- pop-number-from-value-stack out var b/xmm1: float <- copy _b var a/xmm0: float <- pop-number-from-value-stack out a <- divide b push-number-to-value-stack out, a break $evaluate:process-word } { var sqrt?/eax: boolean <- stream-data-equal? curr-stream, "sqrt" compare sqrt?, 0 break-if-= var a/xmm0: float <- pop-number-from-value-stack out a <- square-root a push-number-to-value-stack out, a break $evaluate:process-word } ## strings/arrays { var len?/eax: boolean <- stream-data-equal? curr-stream, "len" compare len?, 0 break-if-= #? print-string 0, "is len\n" # pop target-val from out var out2/esi: (addr value-stack) <- copy out var top-addr/ecx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= #? print-string 0, "stack has stuff\n" var data-ah/eax: (addr handle array value) <- get out2, data var data/eax: (addr array value) <- lookup *data-ah var top/edx: int <- copy *top-addr top <- decrement var dest-offset/edx: (offset value) <- compute-offset data, top var target-val/edx: (addr value) <- index data, dest-offset # check target-val is a string or array var target-type-addr/eax: (addr int) <- get target-val, type compare
parse/0: instruction: 18
parse/0:   ingredient: {name: "foo", value: 0, type: 0, properties: ["foo": "literal-string"]}
parse/0:   ingredient: {name: "aaa", value: 0, type: 0, properties: ["aaa": "literal-string"]}
after-brace/0: recipe test-trace_in_mu
after-brace/0: trace ...
run/0: instruction test-trace_in_mu/0
foo/0: aaa
, text-data stream-to-array s-addr, target # save result into target-val var type-addr/eax: (addr int) <- get target-val, type copy-to *type-addr, 1/string var target-file-ah/eax: (addr handle buffered-file) <- get target-val, file-data clear-object target-file-ah break $evaluate:process-word } { var lines?/eax: boolean <- stream-data-equal? curr-stream, "lines" compare lines?, 0 break-if-= # pop target-val from out var out2/esi: (addr value-stack) <- copy out var top-addr/ecx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var data/eax: (addr array value) <- lookup *data-ah var top/edx: int <- copy *top-addr top <- decrement var dest-offset/edx: (offset value) <- compute-offset data, top var target-val/edx: (addr value) <- index data, dest-offset # check target-val is a file var target-type-addr/eax: (addr int) <- get target-val, type compare *target-type-addr, 3/file break-if-!= # read all lines from file and save as an array of strings in target-val # read target-val as a filename and save the handle in target-val var file-ah/eax: (addr handle buffered-file) <- get target-val, file-data var file/eax: (addr buffered-file) <- lookup *file-ah var s: (stream byte 0x100) var s-addr/ecx: (addr stream byte) <- address s slurp file, s-addr var tmp-ah/eax: (addr handle array byte) <- get target-val, text-data stream-to-array s-addr, tmp-ah var tmp/eax: (addr array byte) <- lookup *tmp-ah #? enable-screen-type-mode #? print-string 0, tmp var h: (handle array (handle array byte)) { var ah/edx: (addr handle array (handle array byte)) <- address h split-string tmp, 0xa, ah } var target/eax: (addr handle array value) <- get target-val, array-data save-lines h, target # save result into target-val var type-addr/eax: (addr int) <- get target-val, type copy-to *type-addr, 2/array var target-file-ah/eax: (addr handle buffered-file) <- get target-val, file-data var empty-file: (handle buffered-file) copy-handle empty-file, target-file-ah var target-text-ah/eax: (addr handle array byte) <- get target-val, text-data var empty-text: (handle array byte) copy-handle empty-text, target-text-ah break $evaluate:process-word } ## screens { var fake-screen?/eax: boolean <- stream-data-equal? curr-stream, "fake-screen" compare fake-screen?, 0 break-if-= var out2/esi: (addr value-stack) <- copy out var top-addr/ecx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= # pop width and height from out var nrows-f/xmm0: float <- pop-number-from-value-stack out2 var nrows/edx: int <- convert nrows-f var ncols-f/xmm0: float <- pop-number-from-value-stack out2 var ncols/ebx: int <- convert ncols-f # define a new screen with those dimensions var screen-h: (handle screen) var screen-ah/eax: (addr handle screen) <- address screen-h allocate screen-ah var screen/eax: (addr screen) <- lookup screen-h initialize-screen screen, nrows, ncols # push screen to stack var data-ah/eax: (addr handle array value) <- get out2, data var data/eax: (addr array value) <- lookup *data-ah var top/edx: int <- copy *top-addr increment *top-addr var dest-offset/edx: (offset value) <- compute-offset data, top var target-val/edx: (addr value) <- index data, dest-offset var type/eax: (addr int) <- get target-val, type copy-to *type, 4/screen var dest/eax: (addr handle screen) <- get target-val, screen-data copy-handle screen-h, dest break $evaluate:process-word } { var print?/eax: boolean <- stream-data-equal? curr-stream, "print" compare print?, 0 break-if-= var out2/esi: (addr value-stack) <- copy out var top-addr/ecx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= # pop string from out var top-addr/ecx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= decrement *top-addr var data-ah/eax: (addr handle array value) <- get out2, data var _data/eax: (addr array value) <- lookup *data-ah var data/edi: (addr array value) <- copy _data var top/eax: int <- copy *top-addr var dest-offset/edx: (offset value) <- compute-offset data, top var s/esi: (addr value) <- index data, dest-offset # select target screen from top of out (but don't pop it) compare *top-addr, 0 break-if-<= var top/eax: int <- copy *top-addr top <- decrement var dest-offset/edx: (offset value) <- compute-offset data, top var target-val/edx: (addr value) <- index data, dest-offset var type/eax: (addr int) <- get target-val, type compare *type, 4/screen break-if-!= # print string to target screen var dest-ah/eax: (addr handle screen) <- get target-val, screen-data var dest/eax: (addr screen) <- lookup *dest-ah var r/ecx: (addr int) <- get dest, cursor-row var c/edx: (addr int) <- get dest, cursor-col render-value-at dest, *r, *c, s, 0 break $evaluate:process-word } { var move?/eax: boolean <- stream-data-equal? curr-stream, "move" compare move?, 0 break-if-= var out2/esi: (addr value-stack) <- copy out # pop args var r-f/xmm0: float <- pop-number-from-value-stack out2 var r/ecx: int <- convert r-f var c-f/xmm0: float <- pop-number-from-value-stack out2 var c/edx: int <- convert c-f # select screen from top of out (but don't pop it) var top-addr/ebx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var _data/eax: (addr array value) <- lookup *data-ah var data/edi: (addr array value) <- copy _data var top/eax: int <- copy *top-addr top <- decrement var target-offset/eax: (offset value) <- compute-offset data, top var target-val/ebx: (addr value) <- index data, target-offset var type/eax: (addr int) <- get target-val, type compare *type, 4/screen break-if-!= var target-ah/eax: (addr handle screen) <- get target-val, screen-data var target/eax: (addr screen) <- lookup *target-ah move-cursor target, r, c break $evaluate:process-word } { var up?/eax: boolean <- stream-data-equal? curr-stream, "up" compare up?, 0 break-if-= var out2/esi: (addr value-stack) <- copy out var top-addr/ebx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= # pop args var d-f/xmm0: float <- pop-number-from-value-stack out2 var d/ecx: int <- convert d-f # select screen from top of out (but don't pop it) compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var _data/eax: (addr array value) <- lookup *data-ah var data/edi: (addr array value) <- copy _data var top/eax: int <- copy *top-addr top <- decrement var target-offset/eax: (offset value) <- compute-offset data, top var target-val/ebx: (addr value) <- index data, target-offset var type/eax: (addr int) <- get target-val, type compare *type, 4/screen break-if-!= var target-ah/eax: (addr handle screen) <- get target-val, screen-data var _target/eax: (addr screen) <- lookup *target-ah var target/edi: (addr screen) <- copy _target var r/edx: (addr int) <- get target, cursor-row var c/eax: (addr int) <- get target, cursor-col var col/eax: int <- copy *c { compare d, 0 break-if-<= compare *r, 1 break-if-<= print-string target "│" decrement *r move-cursor target, *r, col d <- decrement loop } break $evaluate:process-word } { var down?/eax: boolean <- stream-data-equal? curr-stream, "down" compare down?, 0 break-if-= var out2/esi: (addr value-stack) <- copy out var top-addr/ebx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= # pop args var d-f/xmm0: float <- pop-number-from-value-stack out2 var d/ecx: int <- convert d-f # select screen from top of out (but don't pop it) compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var _data/eax: (addr array value) <- lookup *data-ah var data/edi: (addr array value) <- copy _data var top/eax: int <- copy *top-addr top <- decrement var target-offset/eax: (offset value) <- compute-offset data, top var target-val/ebx: (addr value) <- index data, target-offset var type/eax: (addr int) <- get target-val, type compare *type, 4/screen break-if-!= var target-ah/eax: (addr handle screen) <- get target-val, screen-data var _target/eax: (addr screen) <- lookup *target-ah var target/edi: (addr screen) <- copy _target var bound-a/ebx: (addr int) <- get target, num-rows var bound/ebx: int <- copy *bound-a var r/edx: (addr int) <- get target, cursor-row var c/eax: (addr int) <- get target, cursor-col var col/eax: int <- copy *c { compare d, 0 break-if-<= compare *r, bound break-if->= print-string target "│" increment *r move-cursor target, *r, col d <- decrement loop } break $evaluate:process-word } { var left?/eax: boolean <- stream-data-equal? curr-stream, "left" compare left?, 0 break-if-= var out2/esi: (addr value-stack) <- copy out var top-addr/ebx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= # pop args var d-f/xmm0: float <- pop-number-from-value-stack out2 var d/ecx: int <- convert d-f # select screen from top of out (but don't pop it) compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var _data/eax: (addr array value) <- lookup *data-ah var data/edi: (addr array value) <- copy _data var top/eax: int <- copy *top-addr top <- decrement var target-offset/eax: (offset value) <- compute-offset data, top var target-val/ebx: (addr value) <- index data, target-offset var type/eax: (addr int) <- get target-val, type compare *type, 4/screen break-if-!= var target-ah/eax: (addr handle screen) <- get target-val, screen-data var _target/eax: (addr screen) <- lookup *target-ah var target/edi: (addr screen) <- copy _target var c/edx: (addr int) <- get target, cursor-col var r/eax: (addr int) <- get target, cursor-row var row/eax: int <- copy *r { compare d, 0 break-if-<= compare *c, 1 break-if-<= print-string target "─" decrement *c decrement *c # second one to undo the print above move-cursor target, row, *c d <- decrement loop } break $evaluate:process-word } { var right?/eax: boolean <- stream-data-equal? curr-stream, "right" compare right?, 0 break-if-= var out2/esi: (addr value-stack) <- copy out var top-addr/ebx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= # pop args var _d/xmm0: float <- pop-number-from-value-stack out2 var d/ecx: int <- convert _d # select screen from top of out (but don't pop it) compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var _data/eax: (addr array value) <- lookup *data-ah var data/edi: (addr array value) <- copy _data var top/eax: int <- copy *top-addr top <- decrement var target-offset/eax: (offset value) <- compute-offset data, top var target-val/ebx: (addr value) <- index data, target-offset var type/eax: (addr int) <- get target-val, type compare *type, 4/screen break-if-!= var target-ah/eax: (addr handle screen) <- get target-val, screen-data var _target/eax: (addr screen) <- lookup *target-ah var target/edi: (addr screen) <- copy _target var bound-a/ebx: (addr int) <- get target, num-rows var bound/ebx: int <- copy *bound-a var c/edx: (addr int) <- get target, cursor-col var r/eax: (addr int) <- get target, cursor-row var row/eax: int <- copy *r { compare d, 0 break-if-<= compare *c, bound break-if->= print-string target "─" # no increment; the print took care of it move-cursor target, row, *c d <- decrement loop } break $evaluate:process-word } ## HACKS: we're trying to avoid turning this into Forth { var dup?/eax: boolean <- stream-data-equal? curr-stream, "dup" compare dup?, 0 break-if-= # read src-val from out var out2/esi: (addr value-stack) <- copy out var top-addr/ecx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var data/eax: (addr array value) <- lookup *data-ah var top/ecx: int <- copy *top-addr top <- decrement var offset/edx: (offset value) <- compute-offset data, top var src-val/edx: (addr value) <- index data, offset # push a copy of it top <- increment var offset/ebx: (offset value) <- compute-offset data, top var target-val/ebx: (addr value) <- index data, offset copy-object src-val, target-val # commit var top-addr/ecx: (addr int) <- get out2, top increment *top-addr break $evaluate:process-word } { var swap?/eax: boolean <- stream-data-equal? curr-stream, "swap" compare swap?, 0 break-if-= # read top-val from out var out2/esi: (addr value-stack) <- copy out var top-addr/ecx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var data/eax: (addr array value) <- lookup *data-ah var top/ecx: int <- copy *top-addr top <- decrement var offset/edx: (offset value) <- compute-offset data, top var top-val/edx: (addr value) <- index data, offset # read next val from out top <- decrement var offset/ebx: (offset value) <- compute-offset data, top var pen-top-val/ebx: (addr value) <- index data, offset # swap var tmp: value var tmp-a/eax: (addr value) <- address tmp copy-object top-val, tmp-a copy-object pen-top-val, top-val copy-object tmp-a, pen-top-val break $evaluate:process-word } ### if curr-stream defines a binding, save top of stack to bindings { var done?/eax: boolean <- stream-empty? curr-stream compare done?, 0/false break-if-!= var new-byte/eax: byte <- read-byte curr-stream compare new-byte, 0x3d/= break-if-!= # pop target-val from out var out2/esi: (addr value-stack) <- copy out var top-addr/ecx: (addr int) <- get out2, top compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get out2, data var data/eax: (addr array value) <- lookup *data-ah var top/edx: int <- copy *top-addr top <- decrement var dest-offset/edx: (offset value) <- compute-offset data, top var target-val/edx: (addr value) <- index data, dest-offset # create binding from curr-stream to target-val var key-h: (handle array byte) var key/ecx: (addr handle array byte) <- address key-h stream-to-array curr-stream, key bind-in-table bindings, key, target-val break $evaluate:process-word } rewind-stream curr-stream ### if curr-stream is a known function name, call it appropriately { var callee-h: (handle function) var callee-ah/eax: (addr handle function) <- address callee-h find-function functions, curr-stream, callee-ah var callee/eax: (addr function) <- lookup *callee-ah compare callee, 0 break-if-= perform-call callee, out, functions break $evaluate:process-word } ### if it's a name, push its value { compare bindings, 0 break-if-= var tmp: (handle array byte) var curr-string-ah/edx: (addr handle array byte) <- address tmp stream-to-array curr-stream, curr-string-ah # unfortunate leak var curr-string/eax: (addr array byte) <- lookup *curr-string-ah var val-storage: (handle value) var val-ah/edi: (addr handle value) <- address val-storage lookup-binding bindings, curr-string, val-ah var val/eax: (addr value) <- lookup *val-ah compare val, 0 break-if-= push-value-stack out, val break $evaluate:process-word } ### if the word starts with a quote and ends with a quote, turn it into a string { var start/eax: byte <- stream-first curr-stream compare start, 0x22/double-quote break-if-!= var end/eax: byte <- stream-final curr-stream compare end, 0x22/double-quote break-if-!= var h: (handle array byte) var s/eax: (addr handle array byte) <- address h unquote-stream-to-array curr-stream, s # leak push-string-to-value-stack out, *s break $evaluate:process-word } ### if the word starts with a '[' and ends with a ']', turn it into an array { var start/eax: byte <- stream-first curr-stream compare start, 0x5b/[ break-if-!= var end/eax: byte <- stream-final curr-stream compare end, 0x5d/] break-if-!= # wastefully create a new input string to strip quotes var h: (handle array value) var input-ah/eax: (addr handle array byte) <- address h unquote-stream-to-array curr-stream, input-ah # leak # wastefully parse input into int-array # TODO: support parsing arrays of other types var input/eax: (addr array byte) <- lookup *input-ah var h2: (handle array int) var int-array-ah/esi: (addr handle array int) <- address h2 parse-array-of-decimal-ints input, int-array-ah # leak var _int-array/eax: (addr array int) <- lookup *int-array-ah var int-array/esi: (addr array int) <- copy _int-array var len/ebx: int <- length int-array # push value-array of same size as int-array var h3: (handle array value) var value-array-ah/eax: (addr handle array value) <- address h3 populate value-array-ah, len push-array-to-value-stack out, *value-array-ah # copy int-array into value-array var _value-array/eax: (addr array value) <- lookup *value-array-ah var value-array/edi: (addr array value) <- copy _value-array var i/eax: int <- copy 0 { compare i, len break-if->= var src-addr/ecx: (addr int) <- index int-array, i var src/ecx: int <- copy *src-addr var src-f/xmm0: float <- convert src var dest-offset/edx: (offset value) <- compute-offset value-array, i var dest-val/edx: (addr value) <- index value-array, dest-offset var dest/edx: (addr float) <- get dest-val, number-data copy-to *dest, src-f i <- increment loop } break $evaluate:process-word } ### otherwise assume it's a literal number and push it { var n/eax: int <- parse-decimal-int-from-stream curr-stream var n-f/xmm0: float <- convert n push-number-to-value-stack out, n-f } } # termination check compare curr, end break-if-= # update var next-word-ah/edx: (addr handle word) <- get curr, next curr <- lookup *next-word-ah # loop } # process next line if necessary var line/eax: (addr line) <- copy scratch var next-line-ah/eax: (addr handle line) <- get line, next var next-line/eax: (addr line) <- lookup *next-line-ah compare next-line, 0 break-if-= evaluate functions, bindings, next-line, end, out } fn test-evaluate { var line-storage: line var line/esi: (addr line) <- address line-storage var first-word-ah/eax: (addr handle word) <- get line-storage, data allocate-word-with first-word-ah, "3" append-word-with *first-word-ah, "=a" var next-line-ah/eax: (addr handle line) <- get line-storage, next allocate next-line-ah var next-line/eax: (addr line) <- lookup *next-line-ah var first-word-ah/eax: (addr handle word) <- get next-line, data allocate-word-with first-word-ah, "a" var functions-storage: (handle function) var functions/ecx: (addr handle function) <- address functions-storage var table-storage: table var table/ebx: (addr table) <- address table-storage initialize-table table, 0x10 var stack-storage: value-stack var stack/edi: (addr value-stack) <- address stack-storage initialize-value-stack stack, 0x10 evaluate functions, table, line, 0, stack var x-f/xmm0: float <- pop-number-from-value-stack stack var x/eax: int <- convert x-f check-ints-equal x, 3, "F - test-evaluate" } fn find-function first: (addr handle function), name: (addr stream byte), out: (addr handle function) { var curr/esi: (addr handle function) <- copy first $find-function:loop: { var _f/eax: (addr function) <- lookup *curr var f/ecx: (addr function) <- copy _f compare f, 0 break-if-= var curr-name-ah/eax: (addr handle array byte) <- get f, name var curr-name/eax: (addr array byte) <- lookup *curr-name-ah var done?/eax: boolean <- stream-data-equal? name, curr-name compare done?, 0/false { break-if-= copy-handle *curr, out break $find-function:loop } curr <- get f, next loop } } fn perform-call _callee: (addr function), caller-stack: (addr value-stack), functions: (addr handle function) { var callee/ecx: (addr function) <- copy _callee # create bindings for args var table-storage: table var table/esi: (addr table) <- address table-storage initialize-table table, 0x10 bind-args callee, caller-stack, table # obtain body var body-ah/eax: (addr handle line) <- get callee, body var body/eax: (addr line) <- lookup *body-ah # perform call var stack-storage: value-stack var stack/edi: (addr value-stack) <- address stack-storage initialize-value-stack stack, 0x10 #? print-string-to-real-screen "about to enter recursive eval\n" evaluate functions, table, body, 0, stack #? print-string-to-real-screen "exited recursive eval\n" # pop target-val from out var top-addr/ecx: (addr int) <- get stack, top compare *top-addr, 0 break-if-<= var data-ah/eax: (addr handle array value) <- get stack, data var data/eax: (addr array value) <- lookup *data-ah var top/edx: int <- copy *top-addr top <- decrement var dest-offset/edx: (offset value) <- compute-offset data, top var target-val/edx: (addr value) <- index data, dest-offset # stitch target-val into caller-stack push-value-stack caller-stack, target-val } # pop args from the caller-stack and bind them to successive args # implies: function args are stored in reverse order fn bind-args _callee: (addr function), _caller-stack: (addr value-stack), table: (addr table) { var callee/ecx: (addr function) <- copy _callee var curr-arg-ah/eax: (addr handle word) <- get callee, args var curr-arg/eax: (addr word) <- lookup *curr-arg-ah # var curr-key-storage: (handle array byte) var curr-key/edx: (addr handle array byte) <- address curr-key-storage { compare curr-arg, 0 break-if-= # create binding word-to-string curr-arg, curr-key { # pop target-val from caller-stack var caller-stack/esi: (addr value-stack) <- copy _caller-stack var top-addr/ecx: (addr int) <- get caller-stack, top compare *top-addr, 0 break-if-<= decrement *top-addr var data-ah/eax: (addr handle array value) <- get caller-stack, data var data/eax: (addr array value) <- lookup *data-ah var top/ebx: int <- copy *top-addr var dest-offset/ebx: (offset value) <- compute-offset data, top var target-val/ebx: (addr value) <- index data, dest-offset # create binding from curr-key to target-val bind-in-table table, curr-key, target-val } # var next-arg-ah/edx: (addr handle word) <- get curr-arg, next curr-arg <- lookup *next-arg-ah loop } } # Copy of 'simplify' that just tracks the maximum stack depth needed # Doesn't actually need to simulate the stack, since every word has a predictable effect. fn max-stack-depth first-word: (addr word), final-word: (addr word) -> _/edi: int { var curr-word/eax: (addr word) <- copy first-word var curr-depth/ecx: int <- copy 0 var result/edi: int <- copy 0 $max-stack-depth:loop: { $max-stack-depth:process-word: { # handle operators { var add?/eax: boolean <- word-equal? curr-word, "+" compare add?, 0 break-if-= curr-depth <- decrement break $max-stack-depth:process-word } { var sub?/eax: boolean <- word-equal? curr-word, "-" compare sub?, 0 break-if-= curr-depth <- decrement break $max-stack-depth:process-word } { var mul?/eax: boolean <- word-equal? curr-word, "*" compare mul?, 0 break-if-= curr-depth <- decrement break $max-stack-depth:process-word } # otherwise it's an int (do we need error-checking?) curr-depth <- increment # update max depth if necessary { compare curr-depth, result break-if-<= result <- copy curr-depth } } # if curr-word == final-word break compare curr-word, final-word break-if-= # curr-word = curr-word->next var next-word-ah/edx: (addr handle word) <- get curr-word, next curr-word <- lookup *next-word-ah # loop } return result }