Mu - apps/browse/main.mu

From 91a5f3e10300fd84db26690095329592de0942d7 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Fri, 11 Sep 2020 00:59:56 -0700 Subject: 6774 --- html/apps/browse/main.mu.html | 461 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 461 insertions(+) create mode 100644 html/apps/browse/main.mu.html (limited to 'html/apps/browse/main.mu.html') diff --git a/html/apps/browse/main.mu.html b/html/apps/browse/main.mu.html new file mode 100644 index 00000000..72eae1e4 --- /dev/null +++ b/html/apps/browse/main.mu.html @@ -0,0 +1,461 @@ + + + + +Mu - apps/browse/main.mu + + + + + + + + + + +https://github.com/akkartik/mu/blob/master/apps/browse/main.mu +
+  1 fn main args-on-stack: (addr array addr array byte) -> exit-status/ebx: int {
+  2   var args/eax: (addr array addr array byte) <- copy args-on-stack
+  3   var tmp/ecx: int <- length args
+  4   $main-body: {
+  5     # if (len(args) <= 1) print usage and exit
+  6     compare tmp, 1
+  7     {
+  8       break-if->
+  9       print-string-to-real-screen "usage: browse [filename]\n"
+ 10       print-string-to-real-screen "    or browse test\n"
+ 11       exit-status <- copy 1
+ 12       break $main-body
+ 13     }
+ 14     # if (args[1] == "test") run-tests()
+ 15     var tmp2/ecx: (addr addr array byte) <- index args, 1
+ 16     var tmp3/eax: boolean <- string-equal? *tmp2, "test"
+ 17     compare tmp3, 0
+ 18     {
+ 19       break-if-=
+ 20       run-tests
+ 21       exit-status <- copy 0  # TODO: get at Num-test-failures somehow
+ 22       break $main-body
+ 23     }
+ 24     # otherwise interactive mode
+ 25     exit-status <- interactive args-on-stack
+ 26   }
+ 27 }
+ 28 
+ 29 fn interactive args: (addr array addr array byte) -> exit-status/ebx: int {
+ 30   # initialize fs from args[1]
+ 31   var filename/eax: (addr array byte) <- first-arg args
+ 32   var file-storage: (handle buffered-file)
+ 33   var file-storage-addr/esi: (addr handle buffered-file) <- address file-storage
+ 34   open filename, 0, file-storage-addr
+ 35   var _fs/eax: (addr buffered-file) <- lookup file-storage
+ 36   var fs/esi: (addr buffered-file) <- copy _fs
+ 37   #
+ 38   enable-screen-grid-mode
+ 39   enable-keyboard-immediate-mode
+ 40   # initialize screen state
+ 41   var paginated-screen-storage: paginated-screen
+ 42   var paginated-screen/eax: (addr paginated-screen) <- address paginated-screen-storage
+ 43   initialize-paginated-screen paginated-screen, 0x40, 2, 5
+ 44   normal-text paginated-screen
+ 45   #
+ 46   {
+ 47     render paginated-screen, fs
+ 48     var key/eax: byte <- read-key
+ 49     compare key, 0x71  # 'q'
+ 50     loop-if-!=
+ 51   }
+ 52   enable-keyboard-type-mode
+ 53   enable-screen-type-mode
+ 54   exit-status <- copy 0
+ 55 }
+ 56 
+ 57 fn render screen: (addr paginated-screen), fs: (addr buffered-file) {
+ 58   start-drawing screen
+ 59   render-normal screen, fs
+ 60 }
+ 61 
+ 62 fn test-render-multicolumn-text {
+ 63   # input text
+ 64   var input-storage: (handle buffered-file)
+ 65   var input-ah/eax: (addr handle buffered-file) <- address input-storage
+ 66   populate-buffered-file-containing "abcdefgh", input-ah
+ 67   var in/eax: (addr buffered-file) <- lookup input-storage
+ 68   # output screen
+ 69   var pg: paginated-screen
+ 70   var pg-addr/ecx: (addr paginated-screen) <- address pg
+ 71   initialize-fake-paginated-screen pg-addr, 3, 6, 2, 1, 1  # 3 rows, 6 columns, 2 pages * 2 columns each
+ 72   #
+ 73   render pg-addr, in
+ 74   var screen-ah/eax: (addr handle screen) <- get pg, screen
+ 75   var screen/eax: (addr screen) <- lookup *screen-ah
+ 76   check-screen-row screen, 1, "      ", "F - test-render-multicolumn-text/row1"
+ 77   check-screen-row screen, 2, " ab ef", "F - test-render-multicolumn-text/row2"
+ 78   check-screen-row screen, 3, " cd gh", "F - test-render-multicolumn-text/row3"
+ 79 }
+ 80 
+ 81 fn test-render-heading-text {
+ 82   # input text
+ 83   var input-storage: (handle buffered-file)
+ 84   var input-ah/eax: (addr handle buffered-file) <- address input-storage
+ 85   populate-buffered-file-containing "# abc\n\ndef", input-ah
+ 86   var in/eax: (addr buffered-file) <- lookup input-storage
+ 87   # output screen
+ 88   var pg: paginated-screen
+ 89   var pg-addr/ecx: (addr paginated-screen) <- address pg
+ 90   initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1  # 6 columns, single page
+ 91   #
+ 92   render pg-addr, in
+ 93   var screen-ah/eax: (addr handle screen) <- get pg, screen
+ 94   var screen/eax: (addr screen) <- lookup *screen-ah
+ 95   check-screen-row          screen,       1, "      ", "F - test-render-heading-text/row1"
+ 96   check-screen-row-in-color screen, 0xa0, 2, " abc  ", "F - test-render-heading-text/heading"
+ 97   check-screen-row          screen,       3, "      ", "F - test-render-heading-text/row3"
+ 98   check-screen-row          screen,       4, " def  ", "F - test-render-heading-text/row4"
+ 99 }
+100 
+101 fn test-render-bold-text {
+102   # input text
+103   var input-storage: (handle buffered-file)
+104   var input-ah/eax: (addr handle buffered-file) <- address input-storage
+105   populate-buffered-file-containing "a *b* c", input-ah
+106   var in/eax: (addr buffered-file) <- lookup input-storage
+107   # output screen
+108   var pg: paginated-screen
+109   var pg-addr/ecx: (addr paginated-screen) <- address pg
+110   initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1  # 6 columns, single page
+111   #
+112   render pg-addr, in
+113   var screen-ah/eax: (addr handle screen) <- get pg, screen
+114   var screen/eax: (addr screen) <- lookup *screen-ah
+115   check-screen-row         screen, 2, " a b c", "F - test-render-bold-text/text"
+116   check-screen-row-in-bold screen, 2, "   b  ", "F - test-render-bold-text/bold"
+117 }
+118 
+119 # terminals don't always support italics, so we'll just always render italics
+120 # as bold.
+121 fn test-render-pseudoitalic-text {
+122   # input text
+123   var input-storage: (handle buffered-file)
+124   var input-ah/eax: (addr handle buffered-file) <- address input-storage
+125   populate-buffered-file-containing "a _b_ c", input-ah
+126   var in/eax: (addr buffered-file) <- lookup input-storage
+127   # output screen
+128   var pg: paginated-screen
+129   var pg-addr/ecx: (addr paginated-screen) <- address pg
+130   initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1  # 6 columns, single page
+131   #
+132   render pg-addr, in
+133   var screen-ah/eax: (addr handle screen) <- get pg, screen
+134   var screen/eax: (addr screen) <- lookup *screen-ah
+135   check-screen-row         screen, 2, " a b c", "F - test-render-pseudoitalic-text/text"
+136   check-screen-row-in-bold screen, 2, "   b  ", "F - test-render-pseudoitalic-text/bold"
+137 }
+138 
+139 fn test-render-asterisk-in-text {
+140   # input text
+141   var input-storage: (handle buffered-file)
+142   var input-ah/eax: (addr handle buffered-file) <- address input-storage
+143   populate-buffered-file-containing "a*b*c", input-ah
+144   var in/eax: (addr buffered-file) <- lookup input-storage
+145   # output screen
+146   var pg: paginated-screen
+147   var pg-addr/ecx: (addr paginated-screen) <- address pg
+148   initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1  # 6 columns, single page
+149   #
+150   render pg-addr, in
+151   var screen-ah/eax: (addr handle screen) <- get pg, screen
+152   var screen/eax: (addr screen) <- lookup *screen-ah
+153   check-screen-row         screen, 2, " a*b*c", "F - test-render-bold-text/text"
+154   check-screen-row-in-bold screen, 2, "      ", "F - test-render-bold-text/bold"
+155 }
+156 
+157 fn render-normal screen: (addr paginated-screen), fs: (addr buffered-file) {
+158   var newline-seen?/esi: boolean <- copy 0  # false
+159   var start-of-paragraph?/edi: boolean <- copy 1  # true
+160   var previous-grapheme/ebx: grapheme <- copy 0
+161 $render-normal:loop: {
+162     # if done-drawing?(screen) break
+163     var done?/eax: boolean <- done-drawing? screen
+164     compare done?, 0  # false
+165     break-if-!=
+166     var c/eax: grapheme <- read-grapheme-buffered fs
+167 $render-normal:loop-body: {
+168       # if (c == EOF) break
+169       compare c, 0xffffffff  # EOF marker
+170       break-if-= $render-normal:loop
+171 
+172       ## if (c == newline) perform some fairly sophisticated parsing for soft newlines
+173       compare c, 0xa  # newline
+174       {
+175         break-if-!=
+176         # if it's the first newline, buffer it
+177         compare newline-seen?, 0
+178         {
+179           break-if-!=
+180           newline-seen? <- copy 1  # true
+181           break $render-normal:loop-body
+182         }
+183         # otherwise render two newlines
+184         {
+185           break-if-=
+186           add-grapheme screen, 0xa  # newline
+187           add-grapheme screen, 0xa  # newline
+188           newline-seen? <- copy 0  # false
+189           start-of-paragraph? <- copy 1  # true
+190           break $render-normal:loop-body
+191         }
+192       }
+193       # if start of paragraph and c == '#', switch to header
+194       compare start-of-paragraph?, 0
+195       {
+196         break-if-=
+197         compare c, 0x23  # '#'
+198         {
+199           break-if-!=
+200           render-header-line screen, fs
+201           newline-seen? <- copy 1  # true
+202           break $render-normal:loop-body
+203         }
+204       }
+205       # c is not a newline
+206       start-of-paragraph? <- copy 0  # false
+207       # if c is unprintable (particularly a '\r' CR), skip it
+208       compare c, 0x20
+209       loop-if-< $render-normal:loop
+210       # If there's a newline buffered and c is a space, print the buffered
+211       # newline (hard newline).
+212       # If there's a newline buffered and c is not a newline or space, print a
+213       # space (soft newline).
+214       compare newline-seen?, 0  # false
+215 $render-normal:flush-buffered-newline: {
+216         break-if-=
+217         newline-seen? <- copy 0  # false
+218         {
+219           compare c, 0x20
+220           break-if-!=
+221           add-grapheme screen, 0xa  # newline
+222           break $render-normal:flush-buffered-newline
+223         }
+224         add-grapheme screen, 0x20  # space
+225         # fall through to print c
+226       }
+227       ## end soft newline support
+228 
+229 $render-normal:whitespace-separated-regions: {
+230         # if previous-grapheme wasn't whitespace, skip this block
+231         {
+232           compare previous-grapheme, 0x20  # space
+233           break-if-=
+234           compare previous-grapheme, 0xa  # newline
+235           break-if-=
+236           break $render-normal:whitespace-separated-regions
+237         }
+238         # if (c == '*') switch to bold
+239         compare c, 0x2a  # '*'
+240         {
+241           break-if-!=
+242           start-color-on-paginated-screen screen, 0xec, 7  # 236 = darkish gray
+243           start-bold-on-paginated-screen screen
+244             render-until-asterisk screen, fs
+245           normal-text screen
+246           break $render-normal:loop-body
+247         }
+248         # if (c == '_') switch to bold
+249         compare c, 0x5f  # '_'
+250         {
+251           break-if-!=
+252           start-color-on-paginated-screen screen, 0xec, 7  # 236 = darkish gray
+253           start-bold-on-paginated-screen screen
+254             render-until-underscore screen, fs
+255           normal-text screen
+256           break $render-normal:loop-body
+257         }
+258       }
+259       #
+260       add-grapheme screen, c
+261     }  # $render-normal:loop-body
+262     previous-grapheme <- copy c
+263     loop
+264   }  # $render-normal:loop
+265 }
+266 
+267 fn render-header-line screen: (addr paginated-screen), fs: (addr buffered-file) {
+268 $render-header-line:body: {
+269   # compute color based on number of '#'s
+270   var header-level/esi: int <- copy 1  # caller already grabbed one
+271   var c/eax: grapheme <- copy 0
+272   {
+273     # if done-drawing?(screen) return
+274     {
+275       var done?/eax: boolean <- done-drawing? screen
+276       compare done?, 0  # false
+277       break-if-!= $render-header-line:body
+278     }
+279     #
+280     c <- read-grapheme-buffered fs
+281     # if (c != '#') break
+282     compare c, 0x23  # '#'
+283     break-if-!=
+284     #
+285     header-level <- increment
+286     #
+287     loop
+288   }
+289   start-heading screen, header-level
+290   {
+291     # if done-drawing?(screen) break
+292     {
+293       var done?/eax: boolean <- done-drawing? screen
+294       compare done?, 0  # false
+295       break-if-!=
+296     }
+297     #
+298     c <- read-grapheme-buffered fs
+299     # if (c == EOF) break
+300     compare c, 0xffffffff  # EOF marker
+301     break-if-=
+302     # if (c == newline) break
+303     compare c, 0xa  # newline
+304     break-if-=
+305     #
+306     add-grapheme screen, c
+307     #
+308     loop
+309   }
+310   normal-text screen
+311 }
+312 }
+313 
+314 # colors for a light background, going from bright to dark (meeting up with bold-text)
+315 fn start-heading screen: (addr paginated-screen), header-level: int {
+316 $start-heading:body: {
+317   start-bold-on-paginated-screen screen
+318   compare header-level, 1
+319   {
+320     break-if-!=
+321     start-color-on-paginated-screen screen, 0xa0, 7
+322     break $start-heading:body
+323   }
+324   compare header-level, 2
+325   {
+326     break-if-!=
+327     start-color-on-paginated-screen screen, 0x7c, 7
+328     break $start-heading:body
+329   }
+330   compare header-level, 3
+331   {
+332     break-if-!=
+333     start-color-on-paginated-screen screen, 0x58, 7
+334     break $start-heading:body
+335   }
+336   compare header-level, 4
+337   {
+338     break-if-!=
+339     start-color-on-paginated-screen screen, 0x34, 7
+340     break $start-heading:body
+341   }
+342   start-color-on-paginated-screen screen, 0xe8, 7
+343 }
+344 }
+345 
+346 fn render-until-asterisk screen: (addr paginated-screen), fs: (addr buffered-file) {
+347   {
+348     # if done-drawing?(screen) break
+349     var done?/eax: boolean <- done-drawing? screen
+350     compare done?, 0  # false
+351     break-if-!=
+352     #
+353     var c/eax: grapheme <- read-grapheme-buffered fs
+354     # if (c == EOF) break
+355     compare c, 0xffffffff  # EOF marker
+356     break-if-=
+357     # if (c == '*') break
+358     compare c, 0x2a  # '*'
+359     break-if-=
+360     #
+361     add-grapheme screen, c
+362     #
+363     loop
+364   }
+365 }
+366 
+367 fn render-until-underscore screen: (addr paginated-screen), fs: (addr buffered-file) {
+368   {
+369     # if done-drawing?(screen) break
+370     var done?/eax: boolean <- done-drawing? screen
+371     compare done?, 0  # false
+372     break-if-!=
+373     #
+374     var c/eax: grapheme <- read-grapheme-buffered fs
+375     # if (c == EOF) break
+376     compare c, 0xffffffff  # EOF marker
+377     break-if-=
+378     # if (c == '_') break
+379     compare c, 0x5f  # '_'
+380     break-if-=
+381     #
+382     add-grapheme screen, c
+383     #
+384     loop
+385   }
+386 }
+387 
+388 fn first-arg args-on-stack: (addr array addr array byte) -> out/eax: (addr array byte) {
+389   var args/eax: (addr array addr array byte) <- copy args-on-stack
+390   var result/eax: (addr addr array byte) <- index args, 1
+391   out <- copy *result
+392 }
+393 
+394 fn normal-text screen: (addr paginated-screen) {
+395   reset-formatting-on-paginated-screen screen
+396   start-color-on-paginated-screen screen, 0xec, 7  # 236 = darkish gray
+397 }
+
+ + + -- cgit 1.4.1-2-gfad0