7836
This commit is contained in:
Kartik K. Agaram
parent
ce64fef18f
commit
0517cfd573
|
|
@ -1,263 +0,0 @@
|
|||
# todo: turn this into a sum type
|
||||
type value {
|
||||
type: int
|
||||
number-data: float # if type = 0
|
||||
text-data: (handle array byte) # if type = 1
|
||||
array-data: (handle array value) # if type = 2
|
||||
boolean-data: boolean # if type = 3
|
||||
}
|
||||
|
||||
# top-level? is a hack just for numbers
|
||||
# we'll eventually need to return a y coordinate as well to render 2D values
|
||||
fn render-value screen: (addr screen), _val: (addr value), x: int, y: int, top-level?: boolean -> _/eax: int {
|
||||
var val/esi: (addr value) <- copy _val
|
||||
var val-type/ecx: (addr int) <- get val, type
|
||||
compare *val-type, 1/string
|
||||
{
|
||||
break-if-!=
|
||||
var val-ah/eax: (addr handle array byte) <- get val, text-data
|
||||
var _val-string/eax: (addr array byte) <- lookup *val-ah
|
||||
var val-string/ecx: (addr array byte) <- copy _val-string
|
||||
var new-x/eax: int <- render-string screen, val-string, x, y
|
||||
return new-x
|
||||
}
|
||||
compare *val-type, 2/array
|
||||
{
|
||||
break-if-!=
|
||||
var val-ah/eax: (addr handle array value) <- get val, array-data
|
||||
var _val-array/eax: (addr array value) <- lookup *val-ah
|
||||
var val-array/edx: (addr array value) <- copy _val-array
|
||||
var new-x/eax: int <- render-array screen, val-array, x, y
|
||||
return new-x
|
||||
}
|
||||
compare *val-type, 3/boolean
|
||||
{
|
||||
break-if-!=
|
||||
var val/eax: (addr boolean) <- get val, boolean-data
|
||||
var new-x/eax: int <- render-boolean screen, *val, x, y
|
||||
return new-x
|
||||
}
|
||||
# render ints by default for now
|
||||
var val-num/eax: (addr float) <- get val, number-data
|
||||
var new-x/eax: int <- render-number screen, *val-num, x, y, top-level?
|
||||
return new-x
|
||||
}
|
||||
|
||||
fn initialize-value-with-integer _self: (addr value), n: int {
|
||||
var self/esi: (addr value) <- copy _self
|
||||
var type/eax: (addr int) <- get self, type
|
||||
copy-to *type, 0/number
|
||||
var val/xmm0: float <- convert n
|
||||
var dest/eax: (addr float) <- get self, number-data
|
||||
copy-to *dest, val
|
||||
}
|
||||
|
||||
fn initialize-value-with-float _self: (addr value), n: float {
|
||||
var self/esi: (addr value) <- copy _self
|
||||
var type/eax: (addr int) <- get self, type
|
||||
copy-to *type, 0/number
|
||||
var val/xmm0: float <- copy n
|
||||
var dest/eax: (addr float) <- get self, number-data
|
||||
copy-to *dest, val
|
||||
}
|
||||
|
||||
# synaesthesia
|
||||
# TODO: right-justify
|
||||
fn render-number screen: (addr screen), val: float, x: int, y: int, top-level?: boolean -> _/eax: int {
|
||||
# if we're inside an array, don't color
|
||||
compare top-level?, 0
|
||||
{
|
||||
break-if-!=
|
||||
var new-x/eax: int <- render-float-decimal screen, val, 3/precision, x, y, 3/fg, 0/bg
|
||||
return new-x
|
||||
}
|
||||
var val-int/eax: int <- convert val
|
||||
var _bg/eax: int <- hash-color val-int
|
||||
var bg/ecx: int <- copy _bg
|
||||
var fg/edx: int <- copy 7
|
||||
{
|
||||
compare bg, 2
|
||||
break-if-!=
|
||||
fg <- copy 0
|
||||
}
|
||||
{
|
||||
compare bg, 3
|
||||
break-if-!=
|
||||
fg <- copy 0
|
||||
}
|
||||
{
|
||||
compare bg, 6
|
||||
break-if-!=
|
||||
fg <- copy 0
|
||||
}
|
||||
draw-code-point screen, 0x20/space, x, y, fg, bg
|
||||
increment x
|
||||
var new-x/eax: int <- render-float-decimal screen, val, 3/precision, x, y, fg, bg
|
||||
draw-code-point screen, 0x20/space, new-x, y, fg, bg
|
||||
new-x <- increment
|
||||
return new-x
|
||||
}
|
||||
|
||||
fn hash-color val: int -> _/eax: int {
|
||||
var quotient/eax: int <- copy 0
|
||||
var remainder/edx: int <- copy 0
|
||||
quotient, remainder <- integer-divide val, 7 # assumes that 7 is always the background color
|
||||
return remainder
|
||||
}
|
||||
|
||||
fn test-render-number {
|
||||
# setup: screen
|
||||
var screen-on-stack: screen
|
||||
var screen/edi: (addr screen) <- address screen-on-stack
|
||||
initialize-screen screen, 0x20, 4
|
||||
# integers render with some padding spaces
|
||||
var new-x/eax: int <- render-number screen, 0/n, 0/x, 0/y, 1/at-top-level
|
||||
check-screen-row screen, 0/y, " 0 ", "F - test-render-number"
|
||||
check-ints-equal new-x, 3, "F - test-render-number: result"
|
||||
# we won't bother testing the background colors; lots of flexibility there
|
||||
}
|
||||
|
||||
fn initialize-value-with-string _self: (addr value), s: (addr array byte) {
|
||||
var self/esi: (addr value) <- copy _self
|
||||
var type/eax: (addr int) <- get self, type
|
||||
copy-to *type, 1/string
|
||||
var dest/eax: (addr handle array byte) <- get self, text-data
|
||||
copy-array-object s, dest
|
||||
}
|
||||
|
||||
fn render-string screen: (addr screen), _val: (addr array byte), x: int, y: int -> _/eax: int {
|
||||
var val/esi: (addr array byte) <- copy _val
|
||||
compare val, 0
|
||||
{
|
||||
break-if-!=
|
||||
return x
|
||||
}
|
||||
var orig-len/ecx: int <- length val
|
||||
# truncate to 12 graphemes
|
||||
# TODO: more sophisticated interactive rendering
|
||||
var truncated: (handle array byte)
|
||||
var truncated-ah/eax: (addr handle array byte) <- address truncated
|
||||
substring val, 0, 0xc, truncated-ah
|
||||
var _truncated-string/eax: (addr array byte) <- lookup *truncated-ah
|
||||
var truncated-string/edx: (addr array byte) <- copy _truncated-string
|
||||
var len/ebx: int <- length truncated-string
|
||||
draw-code-point screen, 0x22/double-quote, x, y, 7/fg, 0/bg
|
||||
increment x
|
||||
var new-x/eax: int <- draw-text-rightward-over-full-screen screen, truncated-string, x, y, 7/fg, 0/bg
|
||||
compare len, orig-len
|
||||
{
|
||||
break-if-=
|
||||
new-x <- draw-text-rightward-over-full-screen screen, "...", new-x, y, 7/fg, 0/bg
|
||||
}
|
||||
draw-code-point screen, 0x22/double-quote, new-x, y, 7/fg, 0/bg
|
||||
new-x <- increment
|
||||
return new-x
|
||||
}
|
||||
|
||||
fn test-render-string {
|
||||
# setup: screen
|
||||
var screen-on-stack: screen
|
||||
var screen/edi: (addr screen) <- address screen-on-stack
|
||||
initialize-screen screen, 0x20, 4
|
||||
# strings render with quotes
|
||||
var new-x/eax: int <- render-string screen, "abc", 0/x, 0/y
|
||||
check-screen-row screen, 0/y, "\"abc\"", "F - test-render-string"
|
||||
check-ints-equal new-x, 5, "F - test-render-string: result"
|
||||
}
|
||||
|
||||
fn initialize-value-with-array-of-integers _self: (addr value), s: (addr array byte) {
|
||||
# parse s into a temporary array of ints
|
||||
var tmp-storage: (handle array int)
|
||||
var tmp-ah/eax: (addr handle array int) <- address tmp-storage
|
||||
parse-array-of-decimal-ints s, tmp-ah # leak
|
||||
var _tmp/eax: (addr array int ) <- lookup *tmp-ah
|
||||
var tmp/esi: (addr array int ) <- copy _tmp
|
||||
# load the array into values
|
||||
var self/edi: (addr value) <- copy _self
|
||||
var type/eax: (addr int) <- get self, type
|
||||
copy-to *type, 2/string
|
||||
var dest-array-ah/eax: (addr handle array value) <- get self, array-data
|
||||
var len/ebx: int <- length tmp
|
||||
populate dest-array-ah, len
|
||||
var _dest-array/eax: (addr array value) <- lookup *dest-array-ah
|
||||
var dest-array/edi: (addr array value) <- copy _dest-array
|
||||
var i/eax: int <- copy 0
|
||||
{
|
||||
compare i, len
|
||||
break-if->=
|
||||
var src-addr/ecx: (addr int) <- index tmp, i
|
||||
var src/ecx: int <- copy *src-addr
|
||||
var src-f/xmm0: float <- convert src
|
||||
var dest-offset/edx: (offset value) <- compute-offset dest-array, i
|
||||
var dest-val/edx: (addr value) <- index dest-array, dest-offset
|
||||
var dest/edx: (addr float) <- get dest-val, number-data
|
||||
copy-to *dest, src-f
|
||||
i <- increment
|
||||
loop
|
||||
}
|
||||
}
|
||||
|
||||
fn render-array screen: (addr screen), _arr: (addr array value), x: int, y: int -> _/eax: int {
|
||||
# don't surround in spaces
|
||||
draw-code-point screen, 0x5b/open-bracket, x, y, 7/fg, 0/bg
|
||||
increment x
|
||||
var arr/esi: (addr array value) <- copy _arr
|
||||
var max/ecx: int <- length arr
|
||||
var i/edx: int <- copy 0
|
||||
var new-x/eax: int <- copy x
|
||||
{
|
||||
compare i, max
|
||||
break-if->=
|
||||
{
|
||||
compare i, 0
|
||||
break-if-=
|
||||
draw-code-point screen, 0x20/space, new-x, y, 7/fg, 0/bg
|
||||
new-x <- increment
|
||||
}
|
||||
var off/ecx: (offset value) <- compute-offset arr, i
|
||||
var x/ecx: (addr value) <- index arr, off
|
||||
new-x <- render-value screen, x, new-x, y, 0/nested
|
||||
i <- increment
|
||||
loop
|
||||
}
|
||||
draw-code-point screen, 0x5d/close-bracket, new-x, y, 7/fg, 0/bg
|
||||
new-x <- increment
|
||||
return new-x
|
||||
}
|
||||
|
||||
fn test-render-array {
|
||||
# setup: screen
|
||||
var screen-on-stack: screen
|
||||
var screen/edi: (addr screen) <- address screen-on-stack
|
||||
initialize-screen screen, 0x20, 4
|
||||
#
|
||||
var val-storage: value
|
||||
var val/eax: (addr value) <- address val-storage
|
||||
initialize-value-with-array-of-integers val, "0 1 2"
|
||||
var val-array-ah/eax: (addr handle array value) <- get val, array-data
|
||||
var val-array/eax: (addr array value) <- lookup *val-array-ah
|
||||
var new-x/eax: int <- render-array screen, val-array, 0/x, 0/y
|
||||
check-screen-row screen, 0/y, "[0 1 2]", "F - test-render-array"
|
||||
check-ints-equal new-x, 7, "F - test-render-array: result"
|
||||
}
|
||||
|
||||
fn initialize-value-with-boolean _self: (addr value), _b: boolean {
|
||||
var self/esi: (addr value) <- copy _self
|
||||
var type/eax: (addr int) <- get self, type
|
||||
copy-to *type, 3/boolean
|
||||
var dest/edi: (addr boolean) <- get self, boolean-data
|
||||
var b/esi: boolean <- copy _b
|
||||
copy-to *dest, b
|
||||
}
|
||||
|
||||
fn render-boolean screen: (addr screen), val: boolean, x: int, y: int -> _/eax: int {
|
||||
var new-x/eax: int <- copy 0
|
||||
compare val, 0/false
|
||||
{
|
||||
break-if-=
|
||||
new-x <- draw-text-rightward-over-full-screen screen, "true", new-x, y, 7/fg, 0/bg
|
||||
return new-x
|
||||
}
|
||||
new-x <- draw-text-rightward-over-full-screen screen, "false", new-x, y, 7/fg, 0/bg
|
||||
return new-x
|
||||
}
|
||||
Loading…
Reference in New Issue