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 *target-type-addr, 1/string
{
break-if-!=
# compute length
var src-ah/eax: (addr handle array byte) <- get target-val, text-data
var src/eax: (addr array byte) <- lookup *src-ah
var result/ebx: int <- length src
var result-f/xmm0: float <- convert result
# save result into target-val
var type-addr/eax: (addr int) <- get target-val, type
copy-to *type-addr, 0/int
var target-string-ah/eax: (addr handle array byte) <- get target-val, text-data
clear-object target-string-ah
var target/eax: (addr float) <- get target-val, number-data
copy-to *target, result-f
break $evaluate:process-word
}
compare *target-type-addr, 2/array
{
break-if-!=
# compute length
var src-ah/eax: (addr handle array value) <- get target-val, array-data
var src/eax: (addr array value) <- lookup *src-ah
var result/ebx: int <- length src
var result-f/xmm0: float <- convert result
# save result into target-val
var type-addr/eax: (addr int) <- get target-val, type
copy-to *type-addr, 0/int
var target-array-ah/eax: (addr handle array value) <- get target-val, array-data
clear-object target-array-ah
var target/eax: (addr float) <- get target-val, number-data
copy-to *target, result-f
break $evaluate:process-word
}
}
## files
{
var open?/eax: boolean <- stream-data-equal? curr-stream, "open"
compare open?, 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 string
var target-type-addr/eax: (addr int) <- get target-val, type
compare *target-type-addr, 1/string
break-if-!=
# open target-val as a filename and save the handle in target-val
var src-ah/eax: (addr handle array byte) <- get target-val, text-data
var src/eax: (addr array byte) <- lookup *src-ah
var result-ah/ecx: (addr handle buffered-file) <- get target-val, file-data
open src, 0, result-ah # write? = false
# save result into target-val
var type-addr/eax: (addr int) <- get target-val, type
copy-to *type-addr, 3/file
var target-string-ah/eax: (addr handle array byte) <- get target-val, text-data
var filename-ah/ecx: (addr handle array byte) <- get target-val, filename
copy-object target-string-ah, filename-ah
clear-object target-string-ah
break $evaluate:process-word
}
{
var read?/eax: boolean <- stream-data-equal? curr-stream, "read"
compare read?, 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 a line from the file and save 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
read-line-buffered file, s-addr
var target/eax: (addr handle array byte) <- get target-val, 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 slurp?/eax: boolean <- stream-data-equal? curr-stream, "slurp"
compare slurp?, 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-!=
# slurp all contents from file and save 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 target/eax: (addr handle array byte) <- get target-val, 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
}
