about summary refs log tree commit diff stats
path: root/apps/browse/main.mu
blob: 91eb46e0090a434ac8a5805cbbd063910055de5f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
fn main args-on-stack: (addr array addr array byte) -> _/ebx: int {
  var args/eax: (addr array addr array byte) <- copy args-on-stack
  var len/ecx: int <- length args
  # if (len(args) <= 1) print usage and exit
  compare len, 1
  {
    break-if->
    print-string-to-real-screen "usage: browse [filename]\n"
    print-string-to-real-screen "    or browse test\n"
    return 1
  }
  # if (args[1] == "test") run-tests()
  var tmp/ecx: (addr addr array byte) <- index args, 1
  var tmp2/eax: boolean <- string-equal? *tmp, "test"
  compare tmp2, 0
  {
    break-if-=
    run-tests
    return 0  # TODO: get at Num-test-failures somehow
  }
  # otherwise interactive mode
  var args/eax: (addr array addr array byte) <- copy args-on-stack
  var arg/eax: (addr addr array byte) <- index args, 1
  var filename/eax: (addr array byte) <- copy *arg
  var file-storage: (handle buffered-file)
  var file-storage-addr/esi: (addr handle buffered-file) <- address file-storage
  open filename, 0, file-storage-addr
  var fs/eax: (addr buffered-file) <- lookup file-storage
  # if no file, exit
  {
    compare fs, 0
    break-if-!=
    print-string-to-real-screen "file not found\n"
    return 1
  }
  #
  interactive fs
  return 0
}

fn interactive fs: (addr buffered-file) {
  enable-screen-grid-mode
  enable-keyboard-immediate-mode
  # initialize screen state
  var paginated-screen-storage: paginated-screen
  var paginated-screen/eax: (addr paginated-screen) <- address paginated-screen-storage
  initialize-paginated-screen paginated-screen, 0x40, 2, 5
  normal-text paginated-screen
  #
  {
    render paginated-screen, fs
    var key/eax: grapheme <- read-key-from-real-keyboard
    compare key, 0x71  # 'q'
    loop-if-!=
  }
  enable-keyboard-type-mode
  enable-screen-type-mode
}

fn render screen: (addr paginated-screen), fs: (addr buffered-file) {
  start-drawing screen
  render-normal screen, fs
}

fn test-render-multicolumn-text {
  # input text
  var input-storage: (handle buffered-file)
  var input-ah/eax: (addr handle buffered-file) <- address input-storage
  populate-buffered-file-containing "abcdefgh", input-ah
  var in/eax: (addr buffered-file) <- lookup input-storage
  # output screen
  var pg: paginated-screen
  var pg-addr/ecx: (addr paginated-screen) <- address pg
  initialize-fake-paginated-screen pg-addr, 3, 6, 2, 1, 1  # 3 rows, 6 columns, 2 pages * 2 columns each
  #
  render pg-addr, in
  var screen-ah/eax: (addr handle screen) <- get pg, screen
  var screen/eax: (addr screen) <- lookup *screen-ah
  check-screen-row screen, 1, "      ", "F - test-render-multicolumn-text/row1"
  check-screen-row screen, 2, " ab ef", "F - test-render-multicolumn-text/row2"
  check-screen-row screen, 3, " cd gh", "F - test-render-multicolumn-text/row3"
}

fn test-render-heading-text {
  # input text
  var input-storage: (handle buffered-file)
  var input-ah/eax: (addr handle buffered-file) <- address input-storage
  populate-buffered-file-containing "# abc\n\ndef", input-ah
  var in/eax: (addr buffered-file) <- lookup input-storage
  # output screen
  var pg: paginated-screen
  var pg-addr/ecx: (addr paginated-screen) <- address pg
  initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1  # 6 columns, single page
  #
  render pg-addr, in
  var screen-ah/eax: (addr handle screen) <- get pg, screen
  var screen/eax: (addr screen) <- lookup *screen-ah
  check-screen-row          screen,       1, "      ", "F - test-render-heading-text/row1"
  check-screen-row-in-color screen, 0xa0, 2, " abc  ", "F - test-render-heading-text/heading"
  check-screen-row          screen,       3, "      ", "F - test-render-heading-text/row3"
  check-screen-row          screen,       4, " def  ", "F - test-render-heading-text/row4"
}

fn test-render-bold-text {
  # input text
  var input-storage: (handle buffered-file)
  var input-ah/eax: (addr handle buffered-file) <- address input-storage
  populate-buffered-file-containing "a *b* c", input-ah
  var in/eax: (addr buffered-file) <- lookup input-storage
  # output screen
  var pg: paginated-screen
  var pg-addr/ecx: (addr paginated-screen) <- address pg
  initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1  # 6 columns, single page
  #
  render pg-addr, in
  var screen-ah/eax: (addr handle screen) <- get pg, screen
  var screen/eax: (addr screen) <- lookup *screen-ah
  check-screen-row         screen, 2, " a b c", "F - test-render-bold-text/text"
  check-screen-row-in-bold screen, 2, "   b  ", "F - test-render-bold-text/bold"
}

# terminals don't always support italics, so we'll just always render italics
# as bold.
fn test-render-pseudoitalic-text {
  # input text
  var input-storage: (handle buffered-file)
  var input-ah/eax: (addr handle buffered-file) <- address input-storage
  populate-buffered-file-containing "a _b_ c", input-ah
  var in/eax: (addr buffered-file) <- lookup input-storage
  # output screen
  var pg: paginated-screen
  var pg-addr/ecx: (addr paginated-screen) <- address pg
  initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1  # 6 columns, single page
  #
  render pg-addr, in
  var screen-ah/eax: (addr handle screen) <- get pg, screen
  var screen/eax: (addr screen) <- lookup *screen-ah
  check-screen-row         screen, 2, " a b c", "F - test-render-pseudoitalic-text/text"
  check-screen-row-in-bold screen, 2, "   b  ", "F - test-render-pseudoitalic-text/bold"
}

fn test-render-asterisk-in-text {
  # input text
  var input-storage: (handle buffered-file)
  var input-ah/eax: (addr handle buffered-file) <- address input-storage
  populate-buffered-file-containing "a*b*c", input-ah
  var in/eax: (addr buffered-file) <- lookup input-storage
  # output screen
  var pg: paginated-screen
  var pg-addr/ecx: (addr paginated-screen) <- address pg
  initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1  # 6 columns, single page
  #
  render pg-addr, in
  var screen-ah/eax: (addr handle screen) <- get pg, screen
  var screen/eax: (addr screen) <- lookup *screen-ah
  check-screen-row         screen, 2, " a*b*c", "F - test-render-bold-text/text"
  check-screen-row-in-bold screen, 2, "      ", "F - test-render-bold-text/bold"
}

fn render-normal screen: (addr paginated-screen), fs: (addr buffered-file) {
  var newline-seen?/esi: boolean <- copy 0  # false
  var start-of-paragraph?/edi: boolean <- copy 1  # true
  var previous-grapheme/ebx: grapheme <- copy 0
$render-normal:loop: {
    # if done-drawing?(screen) break
    var done?/eax: boolean <- done-drawing? screen
    compare done?, 0  # false
    break-if-!=
    var c/eax: grapheme <- read-grapheme-buffered 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-grapheme screen, 0xa  # newline
          add-grapheme screen, 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 screen, fs
          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-grapheme screen, 0xa  # newline
          break $render-normal:flush-buffered-newline
        }
        add-grapheme screen, 0x20  # space
        # fall through to print c
      }
      ## end soft newline support

$render-normal:whitespace-separated-regions: {
        # if previous-grapheme wasn't whitespace, skip this block
        {
          compare previous-grapheme, 0x20  # space
          break-if-=
          compare previous-grapheme, 0xa  # newline
          break-if-=
          break $render-normal:whitespace-separated-regions
        }
        # if (c == '*') switch to bold
        compare c, 0x2a  # '*'
        {
          break-if-!=
          start-color-on-paginated-screen screen, 0xec, 7  # 236 = darkish gray
          start-bold-on-paginated-screen screen
            render-until-asterisk screen, fs
          normal-text screen
          break $render-normal:loop-body
        }
        # if (c == '_') switch to bold
        compare c, 0x5f  # '_'
        {
          break-if-!=
          start-color-on-paginated-screen screen, 0xec, 7  # 236 = darkish gray
          start-bold-on-paginated-screen screen
            render-until-underscore screen, fs
          normal-text screen
          break $render-normal:loop-body
        }
      }
      #
      add-grapheme screen, c
    }  # $render-normal:loop-body
    previous-grapheme <- copy c
    loop
  }  # $render-normal:loop
}

fn render-header-line screen: (addr paginated-screen), fs: (addr buffered-file) {
$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: grapheme <- copy 0
  {
    # if done-drawing?(screen) return
    {
      var done?/eax: boolean <- done-drawing? screen
      compare done?, 0  # false
      break-if-!= $render-header-line:body
    }
    #
    c <- read-grapheme-buffered fs
    # if (c != '#') break
    compare c, 0x23  # '#'
    break-if-!=
    #
    header-level <- increment
    #
    loop
  }
  start-heading screen, header-level
  {
    # if done-drawing?(screen) break
    {
      var done?/eax: boolean <- done-drawing? screen
      compare done?, 0  # false
      break-if-!=
    }
    #
    c <- read-grapheme-buffered fs
    # if (c == EOF) break
    compare c, 0xffffffff  # EOF marker
    break-if-=
    # if (c == newline) break
    compare c, 0xa  # newline
    break-if-=
    #
    add-grapheme screen, c
    #
    loop
  }
  normal-text screen
}
}

# colors for a light background, going from bright to dark (meeting up with bold-text)
fn start-heading screen: (addr paginated-screen), header-level: int {
$start-heading:body: {
  start-bold-on-paginated-screen screen
  compare header-level, 1
  {
    break-if-!=
    start-color-on-paginated-screen screen, 0xa0, 7
    break $start-heading:body
  }
  compare header-level, 2
  {
    break-if-!=
    start-color-on-paginated-screen screen, 0x7c, 7
    break $start-heading:body
  }
  compare header-level, 3
  {
    break-if-!=
    start-color-on-paginated-screen screen, 0x58, 7
    break $start-heading:body
  }
  compare header-level, 4
  {
    break-if-!=
    start-color-on-paginated-screen screen, 0x34, 7
    break $start-heading:body
  }
  start-color-on-paginated-screen screen, 0xe8, 7
}
}

fn render-until-asterisk screen: (addr paginated-screen), fs: (addr buffered-file) {
  {
    # if done-drawing?(screen) break
    var done?/eax: boolean <- done-drawing? screen
    compare done?, 0  # false
    break-if-!=
    #
    var c/eax: grapheme <- read-grapheme-buffered fs
    # if (c == EOF) break
    compare c, 0xffffffff  # EOF marker
    break-if-=
    # if (c == '*') break
    compare c, 0x2a  # '*'
    break-if-=
    #
    add-grapheme screen, c
    #
    loop
  }
}

fn render-until-underscore screen: (addr paginated-screen), fs: (addr buffered-file) {
  {
    # if done-drawing?(screen) break
    var done?/eax: boolean <- done-drawing? screen
    compare done?, 0  # false
    break-if-!=
    #
    var c/eax: grapheme <- read-grapheme-buffered fs
    # if (c == EOF) break
    compare c, 0xffffffff  # EOF marker
    break-if-=
    # if (c == '_') break
    compare c, 0x5f  # '_'
    break-if-=
    #
    add-grapheme screen, c
    #
    loop
  }
}

fn normal-text screen: (addr paginated-screen) {
  reset-formatting-on-paginated-screen screen
  start-color-on-paginated-screen screen, 0xec, 7  # 236 = darkish gray
}