akkartik
/
mu
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

7698 - starting to test-drive baremetal shell

This commit is contained in:
Kartik Agaram 2021-02-07 23:45:31 -08:00
parent 0be63b75c2
commit bfcf5c7252
4 changed files with 259 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
baremetal/500text-screen.mu
View File

@ -90,8 +90,17 @@ fn draw-grapheme screen: (addr screen), g: grapheme, x: int, y: int, color: int,
copy-to *dest-color, src-color
}
# not really needed for a real screen, though it shouldn't do any harm
fn screen-cell-index screen-on-stack: (addr screen), x: int, y: int -> _/ecx: int {
var screen/esi: (addr screen) <- copy screen-on-stack
# only one bounds check isn't automatically handled
{
var xmax/eax: (addr int) <- get screen, width
var xcurr/ecx: int <- copy x
compare xcurr, *xmax
break-if-<
abort "tried to print out of screen bounds"
}
var height-addr/eax: (addr int) <- get screen, height
var result/ecx: int <- copy y
result <- multiply *height-addr

11
baremetal/501draw-text.mu
View File

@ -499,3 +499,14 @@ fn draw-text-wrapping-down-then-right-from-cursor-over-full-screen screen: (addr
width, height <- screen-size screen
draw-text-wrapping-down-then-right-from-cursor screen, text, 0/xmin, 0/ymin, width, height, color, background-color
}
# hacky error-handling
# just go into an infinite loop
fn abort e: (addr array byte) {
var dummy1/eax: int <- copy 0
var dummy2/ecx: int <- copy 0
dummy1, dummy2 <- draw-text-wrapping-right-then-down-over-full-screen 0/screen, e, 0/x, 0x2f/y, 0xf/fg=white, 0xc/bg=red
{
loop
}
}

10
baremetal/504test-screen.mu
View File

@ -5,12 +5,12 @@
# Tab characters (that translate into multiple screen cells) not supported.
fn check-screen-row screen: (addr screen), y: int, expected: (addr array byte), msg: (addr array byte) {
check-screen-row-from screen, y, 0/y, expected, msg
check-screen-row-from screen, 0/x, y, expected, msg
}
fn check-screen-row-from screen-on-stack: (addr screen), x: int, y: int, expected: (addr array byte), msg: (addr array byte) {
var screen/esi: (addr screen) <- copy screen-on-stack
var idx/ecx: int <- screen-cell-index screen, y, x
var idx/ecx: int <- screen-cell-index screen, x, y
# compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
var e: (stream byte 0x100)
var e-addr/edx: (addr stream byte) <- address e
@ -67,7 +67,7 @@ fn check-screen-row-in-color screen: (addr screen), fg: int, y: int, expected: (
fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, y: int, x: int, expected: (addr array byte), msg: (addr array byte) {
var screen/esi: (addr screen) <- copy screen-on-stack
var idx/ecx: int <- screen-cell-index screen, y, x
var idx/ecx: int <- screen-cell-index screen, x, y
# compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
var e: (stream byte 0x100)
var e-addr/edx: (addr stream byte) <- address e
@ -156,7 +156,7 @@ fn check-screen-row-in-background-color screen: (addr screen), bg: int, y: int,
fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg: int, y: int, x: int, expected: (addr array byte), msg: (addr array byte) {
var screen/esi: (addr screen) <- copy screen-on-stack
var idx/ecx: int <- screen-cell-index screen, y, x
var idx/ecx: int <- screen-cell-index screen, x, y
# compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
var e: (stream byte 0x100)
var e-addr/edx: (addr stream byte) <- address e
@ -248,7 +248,7 @@ fn check-background-color-in-screen-row screen: (addr screen), bg: int, y: int,
fn check-background-color-in-screen-row-from screen-on-stack: (addr screen), bg: int, y: int, x: int, expected-bitmap: (addr array byte), msg: (addr array byte) {
var screen/esi: (addr screen) <- copy screen-on-stack
var idx/ecx: int <- screen-cell-index screen, y, x
var idx/ecx: int <- screen-cell-index screen, x, y
# compare background color where 'expected-bitmap' is a non-space
var e: (stream byte 0x100)
var e-addr/edx: (addr stream byte) <- address e

234
baremetal/shell/grapheme-stack.mu Normal file
View File

@ -0,0 +1,234 @@
type grapheme-stack {
data: (handle array grapheme)
top: int
}
fn initialize-grapheme-stack _self: (addr grapheme-stack), n: int {
var self/esi: (addr grapheme-stack) <- copy _self
var d/edi: (addr handle array grapheme) <- get self, data
populate d, n
var top/eax: (addr int) <- get self, top
copy-to *top, 0
}
fn clear-grapheme-stack _self: (addr grapheme-stack) {
var self/esi: (addr grapheme-stack) <- copy _self
var top/eax: (addr int) <- get self, top
copy-to *top, 0
}
fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
var self/esi: (addr grapheme-stack) <- copy _self
var top/eax: (addr int) <- get self, top
compare *top, 0
{
break-if-!=
return 1/true
}
return 0/false
}
fn push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme {
var self/esi: (addr grapheme-stack) <- copy _self
var top-addr/ecx: (addr int) <- get self, top
var data-ah/edx: (addr handle array grapheme) <- get self, data
var data/eax: (addr array grapheme) <- lookup *data-ah
var top/edx: int <- copy *top-addr
var dest-addr/edx: (addr grapheme) <- index data, top
var val/eax: grapheme <- copy _val
copy-to *dest-addr, val
add-to *top-addr, 1
}
fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
var self/esi: (addr grapheme-stack) <- copy _self
var top-addr/ecx: (addr int) <- get self, top
{
compare *top-addr, 0
break-if->
return -1
}
subtract-from *top-addr, 1
var data-ah/edx: (addr handle array grapheme) <- get self, data
var data/eax: (addr array grapheme) <- lookup *data-ah
var top/edx: int <- copy *top-addr
var result-addr/eax: (addr grapheme) <- index data, top
return *result-addr
}
fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack) {
var src/esi: (addr grapheme-stack) <- copy _src
var data-ah/edi: (addr handle array grapheme) <- get src, data
var _data/eax: (addr array grapheme) <- lookup *data-ah
var data/edi: (addr array grapheme) <- copy _data
var top-addr/ecx: (addr int) <- get src, top
var i/eax: int <- copy 0
{
compare i, *top-addr
break-if->=
var g/edx: (addr grapheme) <- index data, i
push-grapheme-stack dest, *g
i <- increment
loop
}
}
# dump stack to screen from bottom to top
# colors hardcoded
fn render-stack-from-bottom _self: (addr grapheme-stack), screen: (addr screen), x: int, y: int {
var self/esi: (addr grapheme-stack) <- copy _self
var data-ah/edi: (addr handle array grapheme) <- get self, data
var _data/eax: (addr array grapheme) <- lookup *data-ah
var data/edi: (addr array grapheme) <- copy _data
var top-addr/ecx: (addr int) <- get self, top
var i/eax: int <- copy 0
{
compare i, *top-addr
break-if->=
var g/edx: (addr grapheme) <- index data, i
draw-grapheme screen, *g, x, y, 3/fg=cyan, 0/bg
i <- increment
increment x # assume left to right
loop
}
}
# dump stack to screen from top to bottom
# optionally render a 'cursor' with the top grapheme
fn render-stack-from-top _self: (addr grapheme-stack), screen: (addr screen), x: int, y: int, render-cursor?: boolean {
var self/esi: (addr grapheme-stack) <- copy _self
var data-ah/edi: (addr handle array grapheme) <- get self, data
var _data/eax: (addr array grapheme) <- lookup *data-ah
var data/edi: (addr array grapheme) <- copy _data
var top-addr/ecx: (addr int) <- get self, top
var i/eax: int <- copy *top-addr
i <- decrement
# if render-cursor?, peel off first iteration
{
compare render-cursor?, 0/false
break-if-=
compare i, 0
break-if-<
var g/edx: (addr grapheme) <- index data, i
draw-grapheme screen, *g, x, y, 3/fg=cyan, 7/bg=cursor
i <- decrement
increment x # assume left to right
}
# remaining iterations
{
compare i, 0
break-if-<
var g/edx: (addr grapheme) <- index data, i
draw-grapheme screen, *g, x, y, 3/fg=cyan, 0/bg
i <- decrement
increment x # assume left to right
loop
}
}
fn test-render-grapheme-stack {
# setup: gs = "abc"
var gs-storage: grapheme-stack
var gs/edi: (addr grapheme-stack) <- address gs-storage
initialize-grapheme-stack gs, 5
var g/eax: grapheme <- copy 0x61/a
push-grapheme-stack gs, g
g <- copy 0x62/b
push-grapheme-stack gs, g
g <- copy 0x63/c
push-grapheme-stack gs, g
# setup: screen
var screen-on-stack: screen
var screen/esi: (addr screen) <- address screen-on-stack
initialize-screen screen, 5, 4
#
render-stack-from-bottom gs, screen, 0/x, 0/y
check-screen-row screen, 0/y, "abc ", "F - test-render-grapheme-stack from bottom"
check-background-color-in-screen-row screen, 7/bg=cursor, 0/y, " ", "F - test-render-grapheme-stack bg from bottom"
#
render-stack-from-top gs, screen, 0/x, 1/y, 0/cursor=false
check-screen-row screen, 1/y, "cba ", "F - test-render-grapheme-stack from top without cursor"
check-background-color-in-screen-row screen, 7/bg=cursor, 1/y, " ", "F - test-render-grapheme-stack bg from top without cursor"
#
render-stack-from-top gs, screen, 0/x, 2/y, 1/cursor=true
check-screen-row screen, 2/y, "cba ", "F - test-render-grapheme-stack from top with cursor"
check-background-color-in-screen-row screen, 7/bg=cursor, 2/y, "| ", "F - test-render-grapheme-stack bg from top with cursor"
}
# compare from bottom
# beware: modifies 'stream', which must be disposed of after a false result
fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
var self/esi: (addr grapheme-stack) <- copy _self
var data-ah/edi: (addr handle array grapheme) <- get self, data
var _data/eax: (addr array grapheme) <- lookup *data-ah
var data/edi: (addr array grapheme) <- copy _data
var top-addr/ecx: (addr int) <- get self, top
var i/ebx: int <- copy 0
{
compare i, *top-addr
break-if->=
# if curr != expected, return false
{
var curr-a/edx: (addr grapheme) <- index data, i
var expected/eax: grapheme <- read-grapheme s
{
compare expected, *curr-a
break-if-=
return 0/false
}
}
i <- increment
loop
}
return 1 # true
}
# compare from bottom
# beware: modifies 'stream', which must be disposed of after a false result
fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
var self/esi: (addr grapheme-stack) <- copy _self
var data-ah/edi: (addr handle array grapheme) <- get self, data
var _data/eax: (addr array grapheme) <- lookup *data-ah
var data/edi: (addr array grapheme) <- copy _data
var top-addr/eax: (addr int) <- get self, top
var i/ebx: int <- copy *top-addr
i <- decrement
{
compare i, 0
break-if-<
{
var curr-a/edx: (addr grapheme) <- index data, i
var expected/eax: grapheme <- read-grapheme s
# if curr != expected, return false
{
compare expected, *curr-a
break-if-=
return 0/false
}
}
i <- decrement
loop
}
return 1 # true
}
fn grapheme-stack-is-decimal-integer? _self: (addr grapheme-stack) -> _/eax: boolean {
var self/esi: (addr grapheme-stack) <- copy _self
var data-ah/eax: (addr handle array grapheme) <- get self, data
var _data/eax: (addr array grapheme) <- lookup *data-ah
var data/edx: (addr array grapheme) <- copy _data
var top-addr/ecx: (addr int) <- get self, top
var i/ebx: int <- copy 0
var result/eax: boolean <- copy 1/true
$grapheme-stack-is-integer?:loop: {
compare i, *top-addr
break-if->=
var g/edx: (addr grapheme) <- index data, i
result <- is-decimal-digit? *g
compare result, 0/false
break-if-=
i <- increment
loop
}
return result
}