From b3998440f35026a0ad45e85cc6de0e8cc62b00f1 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Fri, 5 Jun 2020 13:56:19 -0700 Subject: [PATCH] 6468 --- mu_instructions | 4 +- mu_summary | 2 +- prototypes/browse/18/main.mu | 2 - prototypes/browse/19/README.md | 5 + prototypes/browse/19/file-state.mu | 44 ++++++ prototypes/browse/19/main.mu | 50 +++++++ prototypes/browse/19/screen-position-state.mu | 128 ++++++++++++++++++ 7 files changed, 230 insertions(+), 5 deletions(-) create mode 100644 prototypes/browse/19/README.md create mode 100644 prototypes/browse/19/file-state.mu create mode 100644 prototypes/browse/19/main.mu create mode 100644 prototypes/browse/19/screen-position-state.mu diff --git a/mu_instructions b/mu_instructions index c5df279c..5ce9e07c 100644 --- a/mu_instructions +++ b/mu_instructions @@ -220,9 +220,9 @@ var/reg <- length arr/reg2: (addr array T) If a record (product) type T was defined to have elements a, b, c, ... of types T_a, T_b, T_c, ..., then accessing one of those elements f of type T_f: -var/reg: (addr T_f) <- get var2/reg2: (addr F), f +var/reg: (addr T_f) <- get var2/reg2: (addr T), f => "8d/copy-address *(" reg2 "+" offset(f) ") " reg "/r32" -var/reg: (addr T_f) <- get var2: (addr F), f +var/reg: (addr T_f) <- get var2: T, f => "8d/copy-address *(ebp+" var2.stack-offset "+" offset(f) ") " reg "/r32" # Handles for safe access to the heap diff --git a/mu_summary b/mu_summary index 1ac7a086..f97e1bd6 100644 --- a/mu_summary +++ b/mu_summary @@ -215,7 +215,7 @@ Similarly, conditional loops: var/reg: (addr T_f) <- get var/reg: (addr T), f where record (product) type T has elements a, b, c, ... of types T_a, T_b, T_c, ... - var/reg: (addr T_f) <- get var: (addr T), f + var/reg: (addr T_f) <- get var: T, f ## Handles for safe access to the heap diff --git a/prototypes/browse/18/main.mu b/prototypes/browse/18/main.mu index e2b41b73..7bb7d07d 100644 --- a/prototypes/browse/18/main.mu +++ b/prototypes/browse/18/main.mu @@ -1,8 +1,6 @@ fn main args: (addr array (addr array byte)) -> exit-status/ebx: int { # initialize fs from args[1] var filename/eax: (addr array byte) <- first-arg args -#? print-string filename -#? print-string "\n" var file-state-storage: file-state var fs/esi: (addr file-state) <- address file-state-storage init-file-state fs, filename diff --git a/prototypes/browse/19/README.md b/prototypes/browse/19/README.md new file mode 100644 index 00000000..47975886 --- /dev/null +++ b/prototypes/browse/19/README.md @@ -0,0 +1,5 @@ +Fill in screen state code. + +It's not quite working yet. Lines don't wrap. + +But at least we're moving the cursor correctly before we start drawing. diff --git a/prototypes/browse/19/file-state.mu b/prototypes/browse/19/file-state.mu new file mode 100644 index 00000000..35f40229 --- /dev/null +++ b/prototypes/browse/19/file-state.mu @@ -0,0 +1,44 @@ +type file-state { + source: (handle buffered-file) + eof?: boolean +} + +fn init-file-state _self: (addr file-state), filename: (addr array byte) { + var self/eax: (addr file-state) <- copy _self + load-file self, filename + var eof/eax: (addr boolean) <- get self, eof? + copy-to *eof, 0 # false +} + +fn load-file _self: (addr file-state), filename: (addr array byte) { + var self/eax: (addr file-state) <- copy _self + var out/esi: (addr handle buffered-file) <- get self, source + open filename, 0, out # 0 = read mode +} + +fn next-char _self: (addr file-state) -> result/eax: byte { + var self/ecx: (addr file-state) <- copy _self + var source/eax: (addr handle buffered-file) <- get self, source + var in/eax: (addr buffered-file) <- lookup *source + result <- read-byte-buffered in + # if result == EOF, set eof? + compare result, 0xffffffff # EOF marker + { + var eof/ecx: (addr boolean) <- get self, eof? + copy-to *eof, 1 # true + } +} + +fn done-reading? _self: (addr file-state) -> result/eax: boolean { + var self/eax: (addr file-state) <- copy _self + var eof/eax: (addr boolean) <- get self, eof? + result <- copy *eof +} + +fn dump in: (addr buffered-file) { + var c/eax: byte <- read-byte-buffered in + compare c, 0xffffffff # EOF marker + break-if-= + print-byte c + loop +} diff --git a/prototypes/browse/19/main.mu b/prototypes/browse/19/main.mu new file mode 100644 index 00000000..6457ca81 --- /dev/null +++ b/prototypes/browse/19/main.mu @@ -0,0 +1,50 @@ +fn main args: (addr array (addr array byte)) -> exit-status/ebx: int { + # initialize fs from args[1] + var filename/eax: (addr array byte) <- first-arg args + var file-state-storage: file-state + var fs/esi: (addr file-state) <- address file-state-storage + init-file-state fs, filename + # + enable-screen-grid-mode + enable-keyboard-immediate-mode + # initialize screen state from screen size + var screen-position-state-storage: screen-position-state + var screen-position-state/eax: (addr screen-position-state) <- address screen-position-state-storage + init-screen-position-state screen-position-state + { + render fs, screen-position-state + var key/eax: byte <- read-key + } + enable-keyboard-type-mode + enable-screen-type-mode + exit-status <- copy 0 +} + +fn render fs: (addr file-state), state: (addr screen-position-state) { + start-drawing state + render-normal fs, state +} + +fn render-normal fs: (addr file-state), state: (addr screen-position-state) { + { + # if done-drawing?(state) break + var done?/eax: boolean <- done-drawing? state + compare done?, 0 # false + break-if-!= + # + var c/eax: byte <- next-char fs + # if (c == EOF) break + compare c, 0xffffffff # EOF marker + break-if-= + # + print-byte c + # + loop + } +} + +fn first-arg args-on-stack: (addr array (addr array byte)) -> out/eax: (addr array byte) { + var args/eax: (addr array (addr array byte)) <- copy args-on-stack + var result/eax: (addr addr array byte) <- index args, 1 + out <- copy *result +} diff --git a/prototypes/browse/19/screen-position-state.mu b/prototypes/browse/19/screen-position-state.mu new file mode 100644 index 00000000..3bfd361b --- /dev/null +++ b/prototypes/browse/19/screen-position-state.mu @@ -0,0 +1,128 @@ +type screen-position-state { + nrows: int # const + ncols: int # const + toprow: int + botrow: int + leftcol: int + rightcol: int + row: int + col: int +} + +fn init-screen-position-state _self: (addr screen-position-state) { + # hardcoded parameters: + # top-margin + # page-margin + # text-width + # page-height (temporary) + var self/esi: (addr screen-position-state) <- copy _self + var nrows/eax: int <- copy 0 + var ncols/ecx: int <- copy 0 + nrows, ncols <- screen-size + var dest/edx: (addr int) <- copy 0 + # self->nrows = nrows + dest <- get self, nrows + copy-to *dest, nrows + # self->ncols = ncols + dest <- get self, ncols + copy-to *dest, ncols + # self->toprow = top-margin + dest <- get self, toprow + copy-to *dest, 2 # top-margin + # self->botrow = nrows + dest <- get self, botrow + copy-to *dest, 0x22 # top-margin + page-height + # self->leftcol = page-margin + dest <- get self, leftcol + copy-to *dest, 5 # left-margin + # self->rightcol = self->leftcol + text-width + dest <- get self, rightcol + copy-to *dest, 0x45 # left-margin + text-width + # + start-drawing self +} + +fn start-drawing _self: (addr screen-position-state) { + var self/esi: (addr screen-position-state) <- copy _self + var tmp/eax: (addr int) <- copy 0 + var tmp2/ecx: int <- copy 0 + # self->row = self->toprow + tmp <- get self, toprow + tmp2 <- copy *tmp + tmp <- get self, row + copy-to *tmp, tmp2 + # self->col = self->leftcol + tmp <- get self, leftcol + tmp2 <- copy *tmp + tmp <- get self, col + copy-to *tmp, tmp2 + # + reposition-cursor self +} + +fn add-char _self: (addr screen-position-state), c: byte { + var self/esi: (addr screen-position-state) <- copy _self + # print c + print-byte c + # self->col++ + var tmp/eax: (addr int) <- get self, col + increment *tmp + # if (self->col > self->rightcol) next-line(self) + var tmp2/ecx: int <- copy *tmp + tmp <- get self, rightcol + compare tmp2, *tmp + { + break-if-<= + next-line self + reposition-cursor self + } +} + +fn next-line _self: (addr screen-position-state) { + var self/esi: (addr screen-position-state) <- copy _self + # self->row++ + var tmp/eax: (addr int) <- get self, row + increment *tmp + # if (self->row > self->botrow) next-page(self) + var tmp2/ecx: int <- copy *tmp + tmp <- get self, botrow + compare tmp2, *tmp + { + break-if-<= + next-page self + } +} + +fn next-page _self: (addr screen-position-state) { + var self/esi: (addr screen-position-state) <- copy _self + # TMP + var tmp/eax: (addr int) <- get self, row + increment *tmp +} + +fn done-drawing? _self: (addr screen-position-state) -> result/eax: boolean { + var self/esi: (addr screen-position-state) <- copy _self + # TMP + var r/eax: (addr int) <- get self, row + var tmp/ecx: (addr int) <- get self, botrow + var max/ecx: int <- copy *tmp +$done-drawing?:check: { + compare *r, max + { + break-if->= + result <- copy 0 # false + break $done-drawing?:check + } + { + break-if-< + result <- copy 1 # true + } + } +} + +fn reposition-cursor _self: (addr screen-position-state) { + var self/esi: (addr screen-position-state) <- copy _self + var r/eax: (addr int) <- get self, row + var c/ecx: (addr int) <- get self, col + move-cursor *r *c +}