diff options
Diffstat (limited to 'apps/browse')
| -rw-r--r-- | apps/browse/README.md | 10 | ||||
| -rw-r--r-- | apps/browse/file-state.mu | 45 | ||||
| -rw-r--r-- | apps/browse/main.mu | 271 | ||||
| -rw-r--r-- | apps/browse/screen-position-state.mu | 172 |
4 files changed, 498 insertions, 0 deletions
diff --git a/apps/browse/README.md b/apps/browse/README.md new file mode 100644 index 00000000..776ec2de --- /dev/null +++ b/apps/browse/README.md @@ -0,0 +1,10 @@ +Render a subset of Markdown. + +To run: + + ``` + $ ./translate_mu apps/browse.mu + $ ./a.elf __text_file__ + ``` + +Press 'q' to quit. All other keys scroll down. diff --git a/apps/browse/file-state.mu b/apps/browse/file-state.mu new file mode 100644 index 00000000..d42bf8bf --- /dev/null +++ b/apps/browse/file-state.mu @@ -0,0 +1,45 @@ +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-= + var g/eax: grapheme <- copy c + print-grapheme 0, g + loop +} diff --git a/apps/browse/main.mu b/apps/browse/main.mu new file mode 100644 index 00000000..ca7bcab1 --- /dev/null +++ b/apps/browse/main.mu @@ -0,0 +1,271 @@ +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 + normal-text + { + render fs, screen-position-state + var key/eax: byte <- read-key + compare key, 0x71 # 'q' + loop-if-!= + } + 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) { + var newline-seen?/esi: boolean <- copy 0 # false + var start-of-paragraph?/edi: boolean <- copy 1 # true + var previous-char/ebx: byte <- copy 0 +$render-normal:loop: { + # 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 +$render-normal:loop-body: { + # if (c == EOF) break + compare c, 0xffffffff # EOF marker + break-if-= $render-normal:loop + + ## if (c == newline) perform some fairly sophisticated parsing for soft newlines + compare c, 0xa # newline + { + break-if-!= + # if it's the first newline, buffer it + compare newline-seen?, 0 + { + break-if-!= + newline-seen? <- copy 1 # true + break $render-normal:loop-body + } + # otherwise render two newlines + { + break-if-= + add-char state, 0xa # newline + add-char state, 0xa # newline + newline-seen? <- copy 0 # false + start-of-paragraph? <- copy 1 # true + break $render-normal:loop-body + } + } + # if start of paragraph and c == '#', switch to header + compare start-of-paragraph?, 0 + { + break-if-= + compare c, 0x23 # '#' + { + break-if-!= + render-header-line fs, state + newline-seen? <- copy 1 # true + break $render-normal:loop-body + } + } + # c is not a newline + start-of-paragraph? <- copy 0 # false + # if c is unprintable (particularly a '\r' CR), skip it + compare c, 0x20 + loop-if-< $render-normal:loop + # If there's a newline buffered and c is a space, print the buffered + # newline (hard newline). + # If there's a newline buffered and c is not a newline or space, print a + # space (soft newline). + compare newline-seen?, 0 # false +$render-normal:flush-buffered-newline: { + break-if-= + newline-seen? <- copy 0 # false + { + compare c, 0x20 + break-if-!= + add-char state, 0xa # newline + break $render-normal:flush-buffered-newline + } + add-char state, 0x20 # space + # fall through to print c + } + ## end soft newline support + +$render-normal:whitespace-separated-regions: { + # if previous-char wasn't whitespace, skip this block + { + compare previous-char, 0x20 # space + break-if-= + compare previous-char, 0xa # newline + break-if-= + break $render-normal:whitespace-separated-regions + } + # if (c == '*') switch to bold + compare c, 0x2a # '*' + { + break-if-!= + start-bold 0 + render-until-asterisk fs, state + normal-text + break $render-normal:loop-body + } + # if (c == '_') switch to bold + compare c, 0x5f # '_' + { + break-if-!= + start-color 0, 0xec, 7 # 236 = darkish gray + start-bold 0 + render-until-underscore fs, state + reset-formatting 0 + start-color 0, 0xec, 7 # 236 = darkish gray + break $render-normal:loop-body + } + } + # + add-char state, c + } # $render-normal:loop-body + previous-char <- copy c + loop + } # $render-normal:loop +} + +fn render-header-line fs: (addr file-state), state: (addr screen-position-state) { +$render-header-line:body: { + # compute color based on number of '#'s + var header-level/esi: int <- copy 1 # caller already grabbed one + var c/eax: byte <- copy 0 + { + # if done-drawing?(state) return + { + var done?/eax: boolean <- done-drawing? state + compare done?, 0 # false + break-if-!= $render-header-line:body + } + # + c <- next-char fs + # if (c != '#') break + compare c, 0x23 # '#' + break-if-!= + # + header-level <- increment + # + loop + } + start-heading header-level + { + # if done-drawing?(state) break + { + var done?/eax: boolean <- done-drawing? state + compare done?, 0 # false + break-if-!= + } + # + c <- next-char fs + # if (c == EOF) break + compare c, 0xffffffff # EOF marker + break-if-= + # if (c == newline) break + compare c, 0xa # newline + break-if-= + # + add-char state, c + # + loop + } + normal-text +} +} + +# colors for a light background, going from bright to dark (meeting up with bold-text) +fn start-heading header-level: int { +$start-heading:body: { + start-bold 0 + compare header-level, 1 + { + break-if-!= + start-color 0, 0xa0, 7 + break $start-heading:body + } + compare header-level, 2 + { + break-if-!= + start-color 0, 0x7c, 7 + break $start-heading:body + } + compare header-level, 3 + { + break-if-!= + start-color 0, 0x58, 7 + break $start-heading:body + } + compare header-level, 4 + { + break-if-!= + start-color 0, 0x34, 7 + break $start-heading:body + } + start-color 0, 0xe8, 7 +} +} + +fn render-until-asterisk 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-= + # if (c == '*') break + compare c, 0x2a # '*' + break-if-= + # + add-char state, c + # + loop + } +} + +fn render-until-underscore 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-= + # if (c == '_') break + compare c, 0x5f # '_' + break-if-= + # + add-char state, 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 +} + +fn normal-text { + reset-formatting 0 + start-color 0, 0xec, 7 # 236 = darkish gray +} diff --git a/apps/browse/screen-position-state.mu b/apps/browse/screen-position-state.mu new file mode 100644 index 00000000..7b53ae07 --- /dev/null +++ b/apps/browse/screen-position-state.mu @@ -0,0 +1,172 @@ +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 + # page-width + var self/esi: (addr screen-position-state) <- copy _self + var nrows/eax: int <- copy 0xa + var ncols/ecx: int <- copy 0x20 + nrows, ncols <- screen-size 0 # Comment this out to debug with a tiny page. You'll also need to adjust rightcol below. + 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, nrows + # + 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 + clear-screen 0 + # self->leftcol = page-margin + tmp <- get self, leftcol + copy-to *tmp, 5 # left-margin + # self->rightcol = self->leftcol + page-width + tmp <- get self, rightcol +#? copy-to *tmp, 0x1f # ncols - 1 + copy-to *tmp, 0x45 # left-margin + page-width + # 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 { +$add-char:body: { + var self/esi: (addr screen-position-state) <- copy _self + { + compare c, 0xa # newline + break-if-!= + next-line self + reposition-cursor self + break $add-char:body + } + # print c + var g/eax: grapheme <- copy c + print-grapheme 0, g + # 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 + var tmp/eax: (addr int) <- copy 0 + var tmp2/ecx: int <- copy 0 + # self->col = self->leftcol + tmp <- get self, leftcol + tmp2 <- copy *tmp + tmp <- get self, col + copy-to *tmp, tmp2 + # self->row++ + tmp <- get self, row + increment *tmp + # if (self->row > self->botrow) next-page(self) + tmp2 <- 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 + var tmp/eax: (addr int) <- copy 0 + var tmp2/ecx: int <- copy 0 +#? # temporary: stop +#? tmp <- get self, ncols +#? tmp2 <- copy *tmp +#? tmp <- get self, rightcol +#? copy-to *tmp, tmp2 + # real: multiple pages + # self->leftcol = self->rightcol + page-margin + tmp <- get self, rightcol + tmp2 <- copy *tmp + tmp2 <- add 5 # page-margin + tmp <- get self, leftcol + copy-to *tmp, tmp2 + # self->rightcol = self->leftcol + page-width + tmp2 <- copy *tmp + tmp2 <- add 0x40 # page-width + tmp <- get self, rightcol + copy-to *tmp, tmp2 + # 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 +} + +fn done-drawing? _self: (addr screen-position-state) -> result/eax: boolean { +$done-drawing?:body: { + # return self->rightcol >= self->ncols + var self/esi: (addr screen-position-state) <- copy _self + var max/ecx: (addr int) <- get self, ncols + var tmp/eax: (addr int) <- get self, rightcol + var right/eax: int <- copy *tmp + compare right, *max + { + break-if->= + result <- copy 0 # false + break $done-drawing?:body + } + { + 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 0, *r *c +} |