https://github.com/akkartik/mu/blob/main/linux/assort.subx

       1 # Read a series of segments from stdin and concatenate segments with the same
       2 # name on stdout.
       3 #
       4 # Segments are emitted in order of first encounter.
       5 #
       6 # Drop lines that are all comments. They could get misleading after assortment
       7 # because we don't know if they refer to the line above or the line below.
       8 #
       9 # To run:
      10 #   $ bootstrap/bootstrap translate [01]*.subx apps/subx-params.subx apps/assort.subx  -o apps/assort
      11 #   $ cat x
      12 #   == code
      13 #   abc
      14 #   == code
      15 #   def
      16 #   $ cat x  |bootstrap/bootstrap run assort
      17 #   == code
      18 #   abc
      19 #   def
      20
      21 == code
      22 #   instruction                     effective address                                                   register    displacement    immediate
      23 # . op          subop               mod             rm32          base        index         scale       r32
      24 # . 1-3 bytes   3 bits              2 bits          3 bits        3 bits      3 bits        2 bits      2 bits      0/1/2/4 bytes   0/1/2/4 bytes
      25
      26 Entry:  # run tests if necessary, convert stdin if not
      27     # . prologue
      28     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
      29
      30     # initialize heap
      31     # . Heap = new-segment(Heap-size)
      32     # . . push args
      33     68/push  Heap/imm32
      34     ff          6/subop/push        0/mod/indirect  5/rm32/.disp32            .             .           .           Heap-size/disp32                  # push *Heap-size
      35     # . . call
      36     e8/call  new-segment/disp32
      37     # . . discard args
      38     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
      39
      40     # - if argc > 1 and argv[1] == "test", then return run_tests()
      41     # if (argc <= 1) goto interactive
      42     81          7/subop/compare     1/mod/*+disp8   5/rm32/ebp    .           .             .           .           0/disp8         1/imm32           # compare *ebp
      43     7e/jump-if-<=  $subx-assort-main:interactive/disp8
      44     # if (!kernel-string-equal?(argv[1], "test")) goto interactive
      45     # . eax = kernel-string-equal?(argv[1], "test")
      46     # . . push args
      47     68/push  "test"/imm32
      48     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           8/disp8         .                 # push *(ebp+8)
      49     # . . call
      50     e8/call  kernel-string-equal?/disp32
      51     # . . discard args
      52     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
      53     # . if (eax == false) goto interactive
      54     3d/compare-eax-and  0/imm32/false
      55     74/jump-if-=  $subx-assort-main:interactive/disp8
      56     # run-tests()
      57     e8/call  run-tests/disp32
      58     # syscall(exit, *Num-test-failures)
      59     8b/copy                         0/mod/indirect  5/rm32/.disp32            .             .           3/r32/ebx   Num-test-failures/disp32          # copy *Num-test-failures to ebx
      60     eb/jump  $subx-assort-main:end/disp8
      61 $subx-assort-main:interactive:
      62     # - otherwise convert stdin
      63     # var ed/eax: exit-descriptor
      64     81          5/subop/subtract    3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # subtract from esp
      65     89/copy                         3/mod/direct    0/rm32/eax    .           .             .           4/r32/esp   .               .                 # copy esp to eax
      66     # configure ed to really exit()
      67     # . ed->target = 0
      68     c7          0/subop/copy        0/mod/direct    0/rm32/eax    .           .             .           .           .               0/imm32           # copy to *eax
      69     # subx-assort(Stdin, Stdout, Stderr, ed)
      70     # . . push args
      71     50/push-eax/ed
      72     68/push  Stderr/imm32
      73     68/push  Stdout/imm32
      74     68/push  Stdin/imm32
      75     # . . call
      76     e8/call  subx-assort/disp32
      77     # . . discard args
      78     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0x10/imm32        # add to esp
      79     # syscall(exit, 0)
      80     bb/copy-to-ebx  0/imm32
      81 $subx-assort-main:end:
      82     e8/call  syscall_exit/disp32
      83
      84 # data structure:
      85 #   table: (addr stream {(handle array byte), (handle stream byte)})     (16 bytes/row)
      86 # inefficient; uses sequential search for looking up segments by name
      87
      88 subx-assort:  # in: (addr buffered-file), out: (addr buffered-file)
      89     # pseudocode:
      90     #   var table: (addr stream {(handle array byte), (handle stream byte)} 10 rows)
      91     #   read-segments(in, table)
      92     #   write-segments(out, table)
      93     #
      94     # . prologue
      95     55/push-ebp
      96     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
      97     # . save registers
      98     51/push-ecx
      99     # var table/ecx: (stream {string, (handle stream byte)} 160)  # 10 rows * 16 bytes/row
     100     81          5/subop/subtract    3/mod/direct    4/rm32/esp    .           .             .           .           .               0xa0/imm32        # subtract from esp
     101     68/push  0xa0/imm32/length
     102     68/push  0/imm32/read
     103     68/push  0/imm32/write
     104     89/copy                         3/mod/direct    1/rm32/ecx    .           .             .           4/r32/esp   .               .                 # copy esp to ecx
     105     # clear-stream(table)
     106     # . . push args
     107     51/push-ecx
     108     # . . call
     109     e8/call  clear-stream/disp32
     110     # . . discard args
     111     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     112 $subx-assort:read:
     113 +--  9 lines: #?     # print("read\n") --------------------------------------------------------------------------------------------------------------------------------------------------
     122     # read-segments(in, table)
     123     # . . push args
     124     51/push-ecx
     125     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           8/disp8         .                 # push *(ebp+8)
     126     # . . call
     127     e8/call  read-segments/disp32
     128     # . . discard args
     129     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     130 $subx-assort:write:
     131 +--  9 lines: #?     # print("write\n") -------------------------------------------------------------------------------------------------------------------------------------------------
     140     # write-segments(out, table)
     141     # . . push args
     142     51/push-ecx
     143     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           0xc/disp8       .                 # push *(ebp+12)
     144     # . . call
     145     e8/call  write-segments/disp32
     146     # . . discard args
     147     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     148 $subx-assort:end:
     149     # . reclaim locals
     150     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xac/imm32        # add to esp
     151     # . restore registers
     152     59/pop-to-ecx
     153     # . epilogue
     154     89/copy                         3/mod/direct    4/rm32/esp    .           .             .           5/r32/ebp   .               .                 # copy ebp to esp
     155     5d/pop-to-ebp
     156     c3/return
     157
     158 test-subx-assort:
     159     # . prologue
     160     55/push-ebp
     161     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
     162     # setup
     163     # . clear-stream(_test-input-stream)
     164     # . . push args
     165     68/push  _test-input-stream/imm32
     166     # . . call
     167     e8/call  clear-stream/disp32
     168     # . . discard args
     169     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     170     # . clear-stream($_test-input-buffered-file->buffer)
     171     # . . push args
     172     68/push  $_test-input-buffered-file->buffer/imm32
     173     # . . call
     174     e8/call  clear-stream/disp32
     175     # . . discard args
     176     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     177     # . clear-stream(_test-output-stream)
     178     # . . push args
     179     68/push  _test-output-stream/imm32
     180     # . . call
     181     e8/call  clear-stream/disp32
     182     # . . discard args
     183     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     184     # . clear-stream($_test-output-buffered-file->buffer)
     185     # . . push args
     186     68/push  $_test-output-buffered-file->buffer/imm32
     187     # . . call
     188     e8/call  clear-stream/disp32
     189     # . . discard args
     190     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     191     # initialize input (meta comments in parens)
     192     #   # comment 1
     193     #     # comment 2 indented
     194     #   == code 0x09000000  (new segment)
     195     #   # comment 3 inside a segment
     196     #   1
     197     #                         (empty line)
     198     #   2 3 # comment 4 inline with other contents
     199     #   == data 0x0a000000  (new segment)
     200     #   4 5/imm32
     201     #   == code  (existing segment but non-contiguous with previous iteration)
     202     #   6 7
     203     #   8 9  (multiple lines)
     204     #   == code  (existing segment contiguous with previous iteration)
     205     #   10 11
     206     # . write(_test-input-stream, "# comment 1\n")
     207     # . . push args
     208     68/push  "# comment 1\n"/imm32
     209     68/push  _test-input-stream/imm32
     210     # . . call
     211     e8/call  write/disp32
     212     # . . discard args
     213     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     214     # . write(_test-input-stream, "  # comment 2 indented\n")
     215     # . . push args
     216     68/push  "  # comment 2 indented\n"/imm32
     217     68/push  _test-input-stream/imm32
     218     # . . call
     219     e8/call  write/disp32
     220     # . . discard args
     221     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     222     # . write(_test-input-stream, "== code 0x09000000\n")
     223     # . . push args
     224     68/push  "== code 0x09000000\n"/imm32
     225     68/push  _test-input-stream/imm32
     226     # . . call
     227     e8/call  write/disp32
     228     # . . discard args
     229     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     230     # . write(_test-input-stream, "# comment 3 inside a segment\n")
     231     # . . push args
     232     68/push  "# comment 3 inside a segment\n"/imm32
     233     68/push  _test-input-stream/imm32
     234     # . . call
     235     e8/call  write/disp32
     236     # . . discard args
     237     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     238     # . write(_test-input-stream, "1\n")
     239     # . . push args
     240     68/push  "1\n"/imm32
     241     68/push  _test-input-stream/imm32
     242     # . . call
     243     e8/call  write/disp32
     244     # . . discard args
     245     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     246     # . write(_test-input-stream, "\n")  # empty line
     247     # . . push args
     248     68/push  Newline/imm32
     249     68/push  _test-input-stream/imm32
     250     # . . call
     251     e8/call  write/disp32
     252     # . . discard args
     253     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     254     # . write(_test-input-stream, "2 3 # comment 4 inline with other contents\n")
     255     # . . push args
     256     68/push  "2 3 # comment 4 inline with other contents\n"/imm32
     257     68/push  _test-input-stream/imm32
     258     # . . call
     259     e8/call  write/disp32
     260     # . . discard args
     261     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     262     # . write(_test-input-stream, "== data 0x0a000000\n")
     263     # . . push args
     264     68/push  "== data 0x0a000000\n"/imm32
     265     68/push  _test-input-stream/imm32
     266     # . . call
     267     e8/call  write/disp32
     268     # . . discard args
     269     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     270     # . write(_test-input-stream, "4 5/imm32\n")
     271     # . . push args
     272     68/push  "4 5/imm32\n"/imm32
     273     68/push  _test-input-stream/imm32
     274     # . . call
     275     e8/call  write/disp32
     276     # . . discard args
     277     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     278     # . write(_test-input-stream, "== code\n")
     279     # . . push args
     280     68/push  "== code\n"/imm32
     281     68/push  _test-input-stream/imm32
     282     # . . call
     283     e8/call  write/disp32
     284     # . . discard args
     285     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     286     # . write(_test-input-stream, "6 7\n")
     287     # . . push args
     288     68/push  "6 7\n"/imm32
     289     68/push  _test-input-stream/imm32
     290     # . . call
     291     e8/call  write/disp32
     292     # . . discard args
     293     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     294     # . write(_test-input-stream, "8 9\n")
     295     # . . push args
     296     68/push  "8 9\n"/imm32
     297     68/push  _test-input-stream/imm32
     298     # . . call
     299     e8/call  write/disp32
     300     # . . discard args
     301     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     302     # . write(_test-input-stream, "== code\n")
     303     # . . push args
     304     68/push  "== code\n"/imm32
     305     68/push  _test-input-stream/imm32
     306     # . . call
     307     e8/call  write/disp32
     308     # . . discard args
     309     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     310     # . write(_test-input-stream, "10 11\n")
     311     # . . push args
     312     68/push  "10 11\n"/imm32
     313     68/push  _test-input-stream/imm32
     314     # . . call
     315     e8/call  write/disp32
     316     # . . discard args
     317     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     318     # subx-assort(_test-input-buffered-file, _test-output-buffered-file)
     319     # . . push args
     320     68/push  _test-output-buffered-file/imm32
     321     68/push  _test-input-buffered-file/imm32
     322     # . . call
     323     e8/call  subx-assort/disp32
     324     # . . discard args
     325     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     326     # . flush(_test-output-buffered-file)
     327     # . . push args
     328     68/push  _test-output-buffered-file/imm32
     329     # . . call
     330     e8/call  flush/disp32
     331     # . . discard args
     332     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     333     # check output
     334     #   == code 0x09000000
     335     #   1
     336     #   2 3 # comment 4 inline with other contents
     337     #   6 7
     338     #   8 9
     339     #   10 11
     340     #   == data 0x0a000000
     341     #   4 5/imm32
     342 +-- 33 lines: #?     # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------
     375     # . check-next-stream-line-equal(_test-output-stream, "== code 0x09000000", msg)
     376     # . . push args
     377     68/push  "F - test-subx-assort/0"/imm32
     378     68/push  "== code 0x09000000"/imm32
     379     68/push  _test-output-stream/imm32
     380     # . . call
     381     e8/call  check-next-stream-line-equal/disp32
     382     # . . discard args
     383     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     384     # . check-next-stream-line-equal(_test-output-stream, "1", msg)
     385     # . . push args
     386     68/push  "F - test-subx-assort/1"/imm32
     387     68/push  "1"/imm32
     388     68/push  _test-output-stream/imm32
     389     # . . call
     390     e8/call  check-next-stream-line-equal/disp32
     391     # . . discard args
     392     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     393     # . check-next-stream-line-equal(_test-output-stream, "2 3 # comment 4 inline with other contents", msg)
     394     # . . push args
     395     68/push  "F - test-subx-assort/2"/imm32
     396     68/push  "2 3 # comment 4 inline with other contents"/imm32
     397     68/push  _test-output-stream/imm32
     398     # . . call
     399     e8/call  check-next-stream-line-equal/disp32
     400     # . . discard args
     401     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     402     # . check-next-stream-line-equal(_test-output-stream, "6 7", msg)
     403     # . . push args
     404     68/push  "F - test-subx-assort/3"/imm32
     405     68/push  "6 7"/imm32
     406     68/push  _test-output-stream/imm32
     407     # . . call
     408     e8/call  check-next-stream-line-equal/disp32
     409     # . . discard args
     410     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     411     # . check-next-stream-line-equal(_test-output-stream, "8 9", msg)
     412     # . . push args
     413     68/push  "F - test-subx-assort/4"/imm32
     414     68/push  "8 9"/imm32
     415     68/push  _test-output-stream/imm32
     416     # . . call
     417     e8/call  check-next-stream-line-equal/disp32
     418     # . . discard args
     419     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     420     # . check-next-stream-line-equal(_test-output-stream, "10 11", msg)
     421     # . . push args
     422     68/push  "F - test-subx-assort/5"/imm32
     423     68/push  "10 11"/imm32
     424     68/push  _test-output-stream/imm32
     425     # . . call
     426     e8/call  check-next-stream-line-equal/disp32
     427     # . . discard args
     428     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     429     # . check-next-stream-line-equal(_test-output-stream, "== data 0x0a000000", msg)
     430     # . . push args
     431     68/push  "F - test-subx-assort/6"/imm32
     432     68/push  "== data 0x0a000000"/imm32
     433     68/push  _test-output-stream/imm32
     434     # . . call
     435     e8/call  check-next-stream-line-equal/disp32
     436     # . . discard args
     437     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     438     # . check-next-stream-line-equal(_test-output-stream, "4 5/imm32", msg)
     439     # . . push args
     440     68/push  "F - test-subx-assort/7"/imm32
     441     68/push  "4 5/imm32"/imm32
     442     68/push  _test-output-stream/imm32
     443     # . . call
     444     e8/call  check-next-stream-line-equal/disp32
     445     # . . discard args
     446     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0xc/imm32         # add to esp
     447     # . epilogue
     448     89/copy                         3/mod/direct    4/rm32/esp    .           .             .           5/r32/ebp   .               .                 # copy ebp to esp
     449     5d/pop-to-ebp
     450     c3/return
     451
     452 read-segments:  # in: (addr buffered-file), table: (addr stream {(handle array byte), (handle stream byte)})
     453     # pseudocode:
     454     #   var curr-segment: (addr stream byte) = 0
     455     #   var line: (stream byte 512)
     456     #   while true
     457     #     clear-stream(line)
     458     #     read-line-buffered(in, line)
     459     #     if (line->write == 0) break             # end of file
     460     #     var word-slice = next-word-or-string(line)
     461     #     if slice-empty?(word-slice)             # whitespace
     462     #       continue
     463     #     if slice-starts-with?(word-slice, "#")  # comment
     464     #       continue
     465     #     if slice-equal?(word-slice, "==")
     466     #       var segment-name = next-word-or-string(line)
     467     #       var segment-slot: (addr handle stream byte) = get-or-insert-slice(table, segment-name, row-size=16)
     468     #       if *segment-slot != 0
     469     #         curr-segment = lookup(*segment-slot)
     470     #         continue
     471     #       new-stream(Heap, Segment-size, 1, segment-slot)
     472     #       curr-segment = lookup(*segment-slot)
     473     #     rewind-stream(line)
     474     #     write-stream(curr-segment, line)  # abort if curr-segment overflows
     475     #
     476     # word-slice and segment-name are both slices with disjoint lifetimes, so
     477     # we'll use the same address for them.
     478     #
     479     # registers:
     480     #   line: ecx
     481     #   word-slice and segment-name: edx
     482     #   segment-name and curr-segment: ebx
     483     #   word-slice->start: esi
     484     #   temporary: eax
     485     #
     486     # . prologue
     487     55/push-ebp
     488     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
     489     # . save registers
     490     50/push-eax
     491     51/push-ecx
     492     52/push-edx
     493     53/push-ebx
     494     56/push-esi
     495     57/push-edi
     496     # var line/ecx: (stream byte 512)
     497     81          5/subop/subtract    3/mod/direct    4/rm32/esp    .           .             .           .           .               0x200/imm32       # subtract from esp
     498     68/push  0x200/imm32/length
     499     68/push  0/imm32/read
     500     68/push  0/imm32/write
     501     89/copy                         3/mod/direct    1/rm32/ecx    .           .             .           4/r32/esp   .               .                 # copy esp to ecx
     502     # var word-slice/edx: slice
     503     68/push  0/imm32/end
     504     68/push  0/imm32/start
     505     89/copy                         3/mod/direct    2/rm32/edx    .           .             .           4/r32/esp   .               .                 # copy esp to edx
     506 $read-segments:loop:
     507     # clear-stream(line)
     508     # . . push args
     509     51/push-ecx
     510     # . . call
     511     e8/call  clear-stream/disp32
     512     # . . discard args
     513     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     514     # read-line-buffered(in, line)
     515     # . . push args
     516     51/push-ecx
     517     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           8/disp8         .                 # push *(ebp+8)
     518     # . . call
     519     e8/call  read-line-buffered/disp32
     520     # . . discard args
     521     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     522 $read-segments:check0:
     523     # if (line->write == 0) break
     524     81          7/subop/compare     0/mod/indirect  1/rm32/ecx    .           .             .           .           .               0/imm32           # compare *ecx
     525     0f 84/jump-if-=  $read-segments:break/disp32
     526 +-- 33 lines: #?     # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------
     559     # next-word-or-string(line, word-slice)
     560     # . . push args
     561     52/push-edx
     562     51/push-ecx
     563     # . . call
     564     e8/call  next-word-or-string/disp32
     565     # . . discard args
     566     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     567 $read-segments:check1:
     568 +--  9 lines: #?     # print("check1\n") ------------------------------------------------------------------------------------------------------------------------------------------------
     577     # if (slice-empty?(word-slice)) continue
     578     # . eax = slice-empty?(word-slice)
     579     # . . push args
     580     52/push-edx
     581     # . . call
     582     e8/call  slice-empty?/disp32
     583     # . . discard args
     584     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     585     # . if (eax != false) continue
     586     3d/compare-eax-and  0/imm32/false
     587     0f 85/jump-if-!=  $read-segments:loop/disp32
     588 $read-segments:check-for-comment:
     589 +--  9 lines: #?     # print("check for comment\n") -------------------------------------------------------------------------------------------------------------------------------------
     598     # if (slice-starts-with?(word-slice, "#")) continue
     599     # . var start/esi: (addr byte) = word-slice->start
     600     8b/copy                         0/mod/indirect  2/rm32/edx    .           .             .           6/r32/esi   .               .                 # copy *ecx to esi
     601     # . var c/eax: byte = *start
     602     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
     603     8a/copy-byte                    0/mod/indirect  6/rm32/esi    .           .             .           0/r32/AL    .               .                 # copy byte at *esi to AL
     604     # . if (c == '#') continue
     605     3d/compare-eax-and  0x23/imm32/hash
     606     0f 84/jump-if-=  $read-segments:loop/disp32
     607 $read-segments:check-for-segment-header:
     608 +--  9 lines: #?     # print("check for segment header\n") ------------------------------------------------------------------------------------------------------------------------------
     617 +-- 40 lines: #?     # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------
     657     # if !slice-equal?(word-slice, "==") goto next check
     658     # . eax = slice-equal?(word-slice, "==")
     659     # . . push args
     660     68/push  "=="/imm32
     661     52/push-edx
     662     # . . call
     663     e8/call  slice-equal?/disp32
     664     # . . discard args
     665     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     666     # . if (eax == false) goto next check
     667     3d/compare-eax-and  0/imm32/false
     668     0f 84/jump-if-=  $read-segments:regular-line/disp32
     669     # segment-name = next-word-or-string(line)
     670     # . . push args
     671     52/push-edx
     672     51/push-ecx
     673     # . . call
     674     e8/call  next-word-or-string/disp32
     675     # . . discard args
     676     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     677 +-- 40 lines: #?     # dump segment name ------------------------------------------------------------------------------------------------------------------------------------------------
     717     # var segment-slot/edi: (addr handle stream byte) = get-or-insert-slice(table, segment-name, row-size=16, Heap)
     718     # . eax = get-or-insert-slice(table, segment-name, row-size=16, Heap)
     719     # . . push args
     720     68/push  Heap/imm32
     721     68/push  0x10/imm32/row-size
     722     52/push-edx
     723     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           0xc/disp8       .                 # push *(ebp+12)
     724     # . . call
     725     e8/call  get-or-insert-slice/disp32
     726     # . . discard args
     727     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0x10/imm32        # add to esp
     728     # . edi = eax
     729     89/copy                         3/mod/direct    7/rm32/edi    .           .             .           0/r32/eax   .               .                 # copy eax to edi
     730 +-- 33 lines: #?     # print("slot: " segment-slot "\n") --------------------------------------------------------------------------------------------------------------------------------
     763     # if (*segment-slot != 0) update curr-segment and continue
     764     81          7/subop/compare     0/mod/indirect  7/rm32/edi    .           .             .           .           .               0/imm32           # compare edi
     765     0f 84/jump-if-=  $read-segments:create-segment/disp32
     766     # var curr-segment/ebx: (addr stream byte) = lookup(*segment-slot)
     767     # . eax = lookup(*segment-slot)
     768     # . . push args
     769     ff          6/subop/push        1/mod/*+disp8   7/rm32/edi    .           .             .           .           4/disp8         .                 # push *(edi+4)
     770     ff          6/subop/push        0/mod/indirect  7/rm32/edi    .           .             .           .           .               .                 # push *edi
     771     # . . call
     772     e8/call  lookup/disp32
     773     # . . discard args
     774     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     775     # . ebx = eax
     776     89/copy                         3/mod/direct    3/rm32/ebx    .           .             .           0/r32/eax   .               .                 # copy eax to ebx
     777     # continue
     778     e9/jump  $read-segments:loop/disp32
     779 $read-segments:create-segment:
     780     # new-stream(Heap, Segment-size, 1, segment-slot)
     781     # . . push args
     782     57/push-edi
     783     68/push  1/imm32
     784     ff          6/subop/push        0/mod/indirect  5/rm32/.disp32            .             .           .           Segment-size/disp32               # push *Segment-size
     785     68/push  Heap/imm32
     786     # . . call
     787     e8/call  new-stream/disp32
     788     # . . discard args
     789     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0x10/imm32        # add to esp
     790     # var curr-segment/ebx: (addr stream byte) = lookup(*segment-slot)
     791     # . eax = lookup(*segment-slot)
     792     # . . push args
     793     ff          6/subop/push        1/mod/*+disp8   7/rm32/edi    .           .             .           .           4/disp8         .                 # push *(edi+4)
     794     ff          6/subop/push        0/mod/indirect  7/rm32/edi    .           .             .           .           .               .                 # push *edi
     795     # . . call
     796     e8/call  lookup/disp32
     797     # . . discard args
     798     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     799     # . ebx = eax
     800     89/copy                         3/mod/direct    3/rm32/ebx    .           .             .           0/r32/eax   .               .                 # copy eax to ebx
     801     # fall through
     802 $read-segments:regular-line:
     803 +--  9 lines: #?     # print("regular line\n") ------------------------------------------------------------------------------------------------------------------------------------------
     812 +-- 33 lines: #?     # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------
     845 +-- 33 lines: #?     # print("addr: " curr-segment->write "\n") -------------------------------------------------------------------------------------------------------------------------
     878 +-- 33 lines: #?     # print("write: " curr-segment->write "\n") ------------------------------------------------------------------------------------------------------------------------
     911 +-- 33 lines: #?     # print("size: " curr-segment->size "\n") --------------------------------------------------------------------------------------------------------------------------
     944     # rewind-stream(line)
     945     # . . push args
     946     51/push-ecx
     947     # . . call
     948     e8/call  rewind-stream/disp32
     949     # . . discard args
     950     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
     951 +--  9 lines: #?     # print("write stream\n") ------------------------------------------------------------------------------------------------------------------------------------------
     960     # write-stream(curr-segment, line)
     961     # . . push args
     962     51/push-ecx
     963     53/push-ebx
     964     # . . call
     965     e8/call  write-stream/disp32
     966     # . . discard args
     967     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
     968     # loop
     969 +--  9 lines: #?     # print("loop\n") --------------------------------------------------------------------------------------------------------------------------------------------------
     978     e9/jump  $read-segments:loop/disp32
     979 $read-segments:break:
     980 $read-segments:end:
     981     # . reclaim locals
     982     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               0x214/imm32       # add to esp
     983     # . restore registers
     984     5f/pop-to-edi
     985     5e/pop-to-esi
     986     5b/pop-to-ebx
     987     5a/pop-to-edx
     988     59/pop-to-ecx
     989     58/pop-to-eax
     990     # . epilogue
     991     89/copy                         3/mod/direct    4/rm32/esp    .           .             .           5/r32/ebp   .               .                 # copy ebp to esp
     992     5d/pop-to-ebp
     993     c3/return
     994
     995 write-segments:  # out: (addr buffered-file), table: (addr stream {(handle array byte), (handle stream byte)})
     996     # pseudocode:
     997     #   var curr = table->data
     998     #   var max = &table->data[table->write]
     999     #   while curr < max
    1000     #     var stream: (addr stream byte) = lookup(table[i].stream)
    1001     #     write-stream-data(out, stream)
    1002     #     curr += 16
    1003     #   flush(out)
    1004     #
    1005     # . prologue
    1006     55/push-ebp
    1007     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
    1008     # . save registers
    1009     50/push-eax
    1010     52/push-edx
    1011     56/push-esi
    1012     # esi = table
    1013     8b/copy                         1/mod/*+disp8   5/rm32/ebp    .           .             .           6/r32/esi   0xc/disp8       .                 # copy *(ebp+12) to esi
    1014     # var write/edx: int = table->write
    1015     8b/copy                         0/mod/indirect  6/rm32/esi    .           .             .           2/r32/edx   .               .                 # copy *esi to edx
    1016     # var curr/esi: (addr byte) = table->data
    1017     81          0/subop/add         3/mod/direct    6/rm32/esi    .           .             .           .           .               0xc/imm32         # add to eax
    1018     # var max/edx: (addr byte) = curr + write
    1019     01/add                          3/mod/direct    2/rm32/edx    .           .             .           6/r32/esi   .               .                 # add esi to edx
    1020 $write-segments:loop:
    1021     # if (curr >= max) break
    1022     39/compare                      3/mod/direct    6/rm32/esi    .           .             .           2/r32/edx   .               .                 # compare esi with edx
    1023     73/jump-if-addr>=  $write-segments:break/disp8
    1024     # var stream/eax: (addr stream byte) = lookup(table[i].stream)
    1025     # . . push args
    1026     ff          6/subop/push        1/mod/*+disp8   6/rm32/esi    .           .             .           .           0xc/disp8       .                 # push *(esi+12)
    1027     ff          6/subop/push        1/mod/*+disp8   6/rm32/esi    .           .             .           .           8/disp8         .                 # push *(esi+8)
    1028     # . . call
    1029     e8/call  lookup/disp32
    1030     # . . discard args
    1031     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
    1032     # write-stream-data(out, stream)
    1033     # . . push args
    1034     50/push-eax
    1035     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           8/disp8         .                 # push *(ebp+8)
    1036     # . . call
    1037     e8/call  write-stream-data/disp32
    1038     # . . discard args
    1039     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
    1040 $write-segments:continue:
    1041     # curr += 16
    1042     81          0/subop/add         3/mod/direct    6/rm32/esi    .           .             .           .           .               0x10/imm32        # add to esi
    1043     eb/jump  $write-segments:loop/disp8
    1044 $write-segments:break:
    1045     # flush(out)
    1046     # . . push args
    1047     ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp    .           .             .           .           8/disp8         .                 # push *(ebp+8)
    1048     # . . call
    1049     e8/call  flush/disp32
    1050     # . . discard args
    1051     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               4/imm32           # add to esp
    1052 $write-segments:end:
    1053     # . restore registers
    1054     5e/pop-to-esi
    1055     5a/pop-to-edx
    1056     58/pop-to-eax
    1057     # . epilogue
    1058     89/copy                         3/mod/direct    4/rm32/esp    .           .             .           5/r32/ebp   .               .                 # copy ebp to esp
    1059     5d/pop-to-ebp
    1060     c3/return
    1061
    1062 # . . vim:nowrap:textwidth=0