1 # Structured control flow using break/loop rather than jump.
  2 #
  3 # To run (on Linux):
  4 #   $ ./translate_subx init.linux [012]*.subx apps/subx-params.subx apps/braces.subx
  5 #   $ mv a.elf apps/braces
  6 #
  7 # Example 1:
  8 #   $ cat x.subx
  9 #   {
 10 #     7c/jump-if-< break/disp8
 11 #     74/jump-if-= loop/disp8
 12 #   }
 13 #   $ cat x.subx |apps/braces
 14 #   _loop1:
 15 #     7c/jump-if-< _break1/disp8
 16 #     74/jump-if-= _loop1/disp8
 17 #   _break1:
 18 #
 19 # Example 2:
 20 #   $ cat x.subx
 21 #   {
 22 #     7c/jump-if-< break/disp8
 23 #   }
 24 #   {
 25 #     74/jump-if-= loop/disp8
 26 #   }
 27 #   $ cat x.subx |apps/braces
 28 #   _loop1:
 29 #     7c/jump-if-< _break1/disp8
 30 #   _break1:
 31 #   _loop2:
 32 #     74/jump-if-= _loop2/disp8
 33 #   _break2:
 34 #
 35 # Example 3:
 36 #   $ cat x.subx
 37 #   {
 38 #     {
 39 #       74/jump-if-= loop/disp8
 40 #     }
 41 #     7c/jump-if-< loop/disp8
 42 #   }
 43 #   $ cat x.subx |apps/braces
 44 #   _loop1:
 45 #     _loop2:
 46 #       74/jump-if-= _loop2/disp8
 47 #     _break2:
 48 #     7c/jump-if-< _loop1/disp8
 49 #   _break1:
 50 
 51 == code
 52 
 53 Entry:  # run tests if necessary, a REPL if not
 54     # . prologue
 55     89/<- %ebp 4/r32/esp
 56     # initialize heap
 57     (new-segment *Heap-size Heap)
 58     # if (argc <= 1) goto interactive
 59     81 7/subop/compare *ebp 1/imm32
 60     7e/jump-if-<= $subx-braces-main:interactive/disp8
 61     # if (argv[1] != "test")) goto interactive
 62     (kernel-string-equal? *(ebp+8) "test")  # => eax
 63     3d/compare-eax-and 0/imm32/false
 64     74/jump-if-= $subx-braces-main:interactive/disp8
 65     #
 66     (run-tests)
 67     # syscall(exit, *Num-test-failures)
 68     8b/-> *Num-test-failures 3/r32/ebx
 69     eb/jump $subx-braces-main:end/disp8
 70 $subx-braces-main:interactive:
 71     (subx-braces Stdin Stdout)
 72     # syscall(exit, 0)
 73     bb/copy-to-ebx 0/imm32
 74 $subx-braces-main:end:
 75     e8/call syscall_exit/disp32
 76 
 77 subx-braces:  # in: (addr buffered-file), out: (addr buffered-file)
 78     # pseudocode:
 79     #   var line: (stream byte 512)
 80     #   var label-stack: (stack int 32)  # at most 32 levels of nesting
 81     #   var next-label-id: int = 1
 82     #   while true
 83     #     clear-stream(line)
 84     #     read-line-buffered(in, line)
 85     #     if (line->write == 0) break                           # end of file
 86     #     skip-chars-matching-whitespace(line)
 87     #     if line->data[line->read] == '{'
 88     #       print(out, "_loop" next-label-id ":\n")
 89     #       push(label-stack, next-label-id)
 90     #       ++next-label-id
 91     #       continue
 92     #     if line->data[line->read] == '}'
 93     #       var top = pop(label-stack)
 94     #       print(out, "_break" top ":\n")
 95     #       continue
 96     #     while true
 97     #       var word-slice: (addr slice) = next-word-or-string(line)
 98     #       if slice-empty?(word-slice)                         # end of line
 99     #         break
100     #       if slice-starts-with?(word-slice, "#")              # comment
101     #         continue
102     #       if slice-starts-with?(word-slice, "break/")
103     #         var top = top(label-stack)
104     #         print(out, "_break" top)
105     #         word-slice->start += len("break")
106     #       else if slice-starts-with?(word-slice, "loop/")
107     #         var top = top(label-stack)
108     #         print(out, "_loop" top)
109     #         word-slice->start += len("loop")
110     #       print(out, word-slice " ")
111     #     print(out, "\n")
112     #   flush(out)
113     # . prologue
114     55/push-ebp
115     89/<- %ebp 4/r32/esp
116     # . save registers
117     50/push-eax
118     51/push-ecx
119     52/push-edx
120     53/push-ebx
121     56/push-esi
122     57/push-edi
123     # esi = in
124     8b/-> *(ebp+8) 6/r32/esi
125     # var line/ecx: (stream byte 512)
126     81 5/subop/subtract %esp 0x200/imm32
127     68/push 0x200/imm32/length
128     68/push 0/imm32/read
129     68/push 0/imm32/write
130     89/<- %ecx 4/r32/esp
131     # var label-stack/edx: (stack int 32)
132     81 5/subop/subtract %esp 0x80/imm32
133     68/push 0x80/imm32/length
134     68/push 0/imm32/top
135     89/<- %edx 4/r32/esp
136     # var next-label-id/ebx: int = 1
137     c7 0/subop/copy %ebx 1/imm32
138     # var word-slice/edi: slice
139     68/push 0/imm32/end
140     68/push 0/imm32/start
141     89/<- %edi 4/r32/esp
142 $subx-braces:line-loop:
143     (clear-stream %ecx)
144     (read-line-buffered %esi %ecx)
145 $subx-braces:check0:
146     # if (line->write == 0) break
147     81 7/subop/compare *ecx 0/imm32
148     0f 84/jump-if-=  $subx-braces:break/disp32
149     (skip-chars-matching-whitespace %ecx)
150 $subx-braces:check-for-curly-open:
151     # if (line->data[line->read] != '{') goto next check
152     # . eax = line->data[line->read]
153     8b/-> *(ecx+4) 0/r32/eax
154     8a/copy-byte *(ecx+eax+0xc) 0/r32/AL
155     81 4/subop/and %eax 0xff/imm32
156     # . if (eax != '{') continue
157     3d/compare-eax-and 0x7b/imm32/open-curly
158     0f 85/jump-if-!= $subx-braces:check-for-curly-closed/disp32
159 $subx-braces:emit-curly-open:
160     # print(out, "_loop" next-label-id ":")
161     (write-buffered *(ebp+0xc) "_loop")
162     (write-int32-hex-buffered *(ebp+0xc) %ebx)
163     (write-buffered *(ebp+0xc) ":")
164     # push(label-stack, next-label-id)
165     (push %edx %ebx)
166     # ++next-label-id
167     ff 0/subop/increment %ebx
168     # continue
169     e9/jump  $subx-braces:next-line/disp32
170 $subx-braces:check-for-curly-closed:
171     # if (line->data[line->read] != '}') goto next check
172     3d/compare-eax-and 0x7d/imm32/close-curly
173     0f 85/jump-if-= $subx-braces:word-loop/disp32
174 $subx-braces:emit-curly-closed:
175     # eax = pop(label-stack)
176     (pop %edx)
177     # print(out, "_break" eax ":")
178     (write-buffered *(ebp+0xc) "_break")
179     (write-int32-hex-buffered *(ebp+0xc) %eax)
180     (write-buffered *(ebp+0xc) ":")
181     # continue
182     e9/jump  $subx-braces:next-line/disp32
183 $subx-braces:word-loop:
184     (next-word-or-string %ecx %edi)
185 $subx-braces:check1:
186     # if (slice-empty?(word-slice)) break
187     (slice-empty? %edi)
188     3d/compare-eax-and 0/imm32/false
189     0f 85/jump-if-!= $subx-braces:next-line/disp32
190 $subx-braces:check-for-comment:
191     # if (slice-starts-with?(word-slice, "#")) continue
192     # . eax = *word-slice->start
193     8b/-> *edi 0/r32/eax
194     8a/copy-byte *eax 0/r32/AL
195     81 4/subop/and %eax 0xff/imm32
196     # . if (eax == '#') continue
197     3d/compare-eax-and 0x23/imm32/hash
198     74/jump-if-= $subx-braces:word-loop/disp8
199 $subx-braces:check-for-break:
200     # if (!slice-starts-with?(word-slice, "break/")) goto next check
201     # . eax = slice-starts-with?(word-slice, "break/")
202     (slice-starts-with? %edi "break/")
203     # . if (eax == false) goto next check
204     3d/compare-eax-and 0/imm32/false
205     74/jump-if-= $subx-braces:check-for-loop/disp8
206 $subx-braces:emit-break:
207     (top %edx)
208     # print(out, "_break" eax)
209     (write-buffered *(ebp+0xc) "_break")
210     (write-int32-hex-buffered *(ebp+0xc) %eax)
211     # word-slice->start += len("break")
212     81 0/subop/add *edi 5/imm32/strlen
213     # emit rest of word as usual
214     eb/jump $subx-braces:emit-word-slice/disp8
215 $subx-braces:check-for-loop:
216     # if (!slice-starts-with?(word-slice, "loop/")) emit word
217     # . eax = slice-starts-with?(word-slice, "loop/")
218     (slice-starts-with? %edi "loop/")
219     # . if (eax == false) goto next check
220     3d/compare-eax-and 0/imm32/false
221     74/jump-if-= $subx-braces:emit-word-slice/disp8
222 $subx-braces:emit-loop:
223     (top %edx)
224     # print(out, "_loop" eax)
225     (write-buffered *(ebp+0xc) "_loop")
226     (write-int32-hex-buffered *(ebp+0xc) %eax)
227     # word-slice->start += len("loop")
228     81 0/subop/add *edi 4/imm32/strlen
229     # fall through
230 $subx-braces:emit-word-slice:
231     # print(out, word-slice " ")
232     (write-slice-buffered *(ebp+0xc) %edi)
233     (write-buffered *(ebp+0xc) Space)
234     # loop to next word
235     e9/jump $subx-braces:word-loop/disp32
236 $subx-braces:next-line:
237     # print(out, "\n")
238     (write-buffered *(ebp+0xc) Newline)
239     # loop to next line
240     e9/jump $subx-braces:line-loop/disp32
241 $subx-braces:break:
242     (flush *(ebp+0xc))
243 $subx-braces:end:
244     # . reclaim locals
245     81 0/subop/add %esp 0x29c/imm32
246     # . restore registers
247     5f/pop-to-edi
248     5e/pop-to-esi
249     5b/pop-to-ebx
250     5a/pop-to-edx
251     59/pop-to-ecx
252     58/pop-to-eax
253     # . epilogue
254     89/<- %esp 5/r32/ebp
255     5d/pop-to-ebp
256     c3/return
257 
258 test-subx-braces-passes-most-words-through:
259     # . prologue
260     55/push-ebp
261     89/<- %ebp 4/r32/esp
262     # setup
263     (clear-stream _test-input-stream)
264     (clear-stream _test-output-stream)
265     (clear-stream $_test-input-buffered-file->buffer)
266     (clear-stream $_test-output-buffered-file->buffer)
267     # test
268     (write _test-input-stream "== abcd 0x1")
269     (subx-braces _test-input-buffered-file _test-output-buffered-file)
270     # check that the line just passed through
271     (flush _test-output-buffered-file)
272 +--  5 lines: #?     # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------
277     (check-stream-equal _test-output-stream "== abcd 0x1 \n" "F - test-subx-braces-passes-most-words-through")
278     # . epilogue
279     89/<- %esp 5/r32/ebp
280     5d/pop-to-ebp
281     c3/return
282 
283 test-subx-braces-1:
284     # input:
285     #   {
286     #   ab break/imm32
287     #   cd loop/imm32
288     #   }
289     #
290     # output:
291     #   _loop1:
292     #   ab _break1/imm32
293     #   cd _loop1/imm32
294     #   _break1:
295     #
296     # . prologue
297     55/push-ebp
298     89/<- %ebp 4/r32/esp
299     # setup
300     (clear-stream _test-input-stream)
301     (clear-stream _test-output-stream)
302     (clear-stream $_test-input-buffered-file->buffer)
303     (clear-stream $_test-output-buffered-file->buffer)
304     # test
305     (write _test-input-stream "{\nab break/imm32\ncd loop/imm32\n}")
306     (subx-braces _test-input-buffered-file _test-output-buffered-file)
307     # check that the line just passed through
308     (flush _test-output-buffered-file)
309 +--  5 lines: #?     # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------
314     (check-stream-equal _test-output-stream "_loop0x00000001:\nab _break0x00000001/imm32 \ncd _loop0x00000001/imm32 \n_break0x00000001:\n" "F - test-subx-braces-1")
315     # . epilogue
316     89/<- %esp 5/r32/ebp
317     5d/pop-to-ebp
318     c3/return
319 
320 test-subx-braces-2:
321     # input:
322     #   {
323     #   {
324     #   ab break/imm32
325     #   }
326     #   cd loop/imm32
327     #   }
328     #
329     # output:
330     #   _loop1:
331     #   _loop2:
332     #   ab _break2/imm32
333     #   _break2:
334     #   cd _loop1/imm32
335     #   _break1:
336     #
337     # . prologue
338     55/push-ebp
339     89/<- %ebp 4/r32/esp
340     # setup
341     (clear-stream _test-input-stream)
342     (clear-stream _test-output-stream)
343     (clear-stream $_test-input-buffered-file->buffer)
344     (clear-stream $_test-output-buffered-file->buffer)
345     # test
346     (write _test-input-stream "{\n{\nab break/imm32\n}\ncd loop/imm32\n}")
347     (subx-braces _test-input-buffered-file _test-output-buffered-file)
348     # check that the line just passed through
349     (flush _test-output-buffered-file)
350 +--  5 lines: #?     # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------
355     (check-stream-equal _test-output-stream "_loop0x00000001:\n_loop0x00000002:\nab _break0x00000002/imm32 \n_break0x00000002:\ncd _loop0x00000001/imm32 \n_break0x00000001:\n" "F - test-subx-braces-2")
356     # . epilogue
357     89/<- %esp 5/r32/ebp
358     5d/pop-to-ebp
359     c3/return