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