| blob | b736ba03d3e9db275e272618fc5c9c96d09f9f37 |
1 # Helpers for decimal ints.
3 # if slice doesn't contain a decimal number, return 0
4 parse-decimal-int-from-slice: # in: (addr slice) -> out/eax: int
5 # . prologue
6 55/push-ebp
7 89/<- %ebp 4/r32/esp
8 # . save registers
9 51/push-ecx
10 # ecx = in
11 8b/-> *(ebp+8) 1/r32/ecx
12 #
13 (parse-decimal-int-helper *ecx *(ecx+4)) # => eax
14 $parse-decimal-int-from-slice:end:
15 # . restore registers
16 59/pop-to-ecx
17 # . epilogue
18 89/<- %esp 5/r32/ebp
19 5d/pop-to-ebp
20 c3/return
22 # if slice doesn't contain a decimal number, return 0
23 parse-decimal-int: # in: (addr array byte) -> result/eax: int
24 # . prologue
25 55/push-ebp
26 89/<- %ebp 4/r32/esp
27 # . save registers
28 51/push-ecx
29 52/push-edx
30 # eax = in
31 8b/-> *(ebp+8) 0/r32/eax
32 # var start/ecx: (addr byte) = &in->data
33 8d/copy-address *(eax+4) 1/r32/ecx
34 # var end/edx: (addr byte) = &in->data[in->size]
35 8b/-> *eax 2/r32/edx
36 8d/copy-address *(eax+edx+4) 2/r32/edx
37 #
38 (parse-decimal-int-helper %ecx %edx) # => eax
39 $parse-decimal-int:end:
40 # . restore registers
41 5a/pop-to-edx
42 59/pop-to-ecx
43 # . epilogue
44 89/<- %esp 5/r32/ebp
45 5d/pop-to-ebp
46 c3/return
48 parse-decimal-int-from-stream: # in: (addr stream byte) -> result/eax: int
49 # . prologue
50 55/push-ebp
51 89/<- %ebp 4/r32/esp
52 # . save registers
53 51/push-ecx
54 52/push-edx
55 # eax = in
56 8b/-> *(ebp+8) 0/r32/eax
57 # var start/ecx: (addr byte) = &in->data[in->read]
58 8b/-> *(eax+4) 1/r32/ecx
59 8d/copy-address *(eax+ecx+0xc) 1/r32/ecx
60 # var end/edx: (addr byte) = &in->data[in->write]
61 8b/-> *eax 2/r32/edx
62 8d/copy-address *(eax+edx+0xc) 2/r32/edx
63 # trim a trailing newline
64 {
65 # speculatively trim
66 4a/decrement-edx
67 # if it's a newline, break
68 8a/byte-> *edx 0/r32/eax
69 25/and-eax-with 0xff/imm32
70 3d/compare-eax-and 0xa/imm32/newline
71 74/jump-if-= break/disp8
72 # not a newline, so restore it
73 42/increment-edx
74 }
75 #
76 (parse-decimal-int-helper %ecx %edx) # => eax
77 $parse-decimal-int-from-stream:end:
78 # . restore registers
79 5a/pop-to-edx
80 59/pop-to-ecx
81 # . epilogue
82 89/<- %esp 5/r32/ebp
83 5d/pop-to-ebp
84 c3/return
86 parse-decimal-int-helper: # start: (addr byte), end: (addr byte) -> result/eax: int
87 # . prologue
88 55/push-ebp
89 89/<- %ebp 4/r32/esp
90 # . save registers
91 51/push-ecx
92 52/push-edx
93 53/push-ebx
94 56/push-esi
95 57/push-edi
96 # var curr/esi: (addr byte) = start
97 8b/-> *(ebp+8) 6/r32/esi
98 # edi = end
99 8b/-> *(ebp+0xc) 7/r32/edi
100 # var negate?/edx: boolean = false
101 ba/copy-to-edx 0/imm32/false
102 # if (*curr == '-') ++curr, negate = true
103 {
104 $parse-decimal-int-helper:negative:
105 b8/copy-to-eax 0/imm32
106 8a/copy-byte *esi 0/r32/AL
107 3d/compare-eax-and 0x2d/imm32/-
108 75/jump-if-!= break/disp8
109 # . ++curr
110 46/increment-esi
111 # . negate = true
112 ba/copy-to-edx 1/imm32/true
113 }
114 # spill negate?
115 52/push-edx
116 # var result/eax: int = 0
117 b8/copy-to-eax 0/imm32
118 # var digit/ecx: int = 0
119 b9/copy-to-ecx 0/imm32
120 # const TEN/ebx: int = 10
121 bb/copy-to-ebx 0xa/imm32
122 {
123 $parse-decimal-int-helper:loop:
124 # if (curr >= in->end) break
125 39/compare %esi 7/r32/edi
126 73/jump-if-addr>= break/disp8
127 # if !decimal-digit?(*curr) return 0
128 8a/copy-byte *esi 1/r32/CL
129 50/push-eax
130 (decimal-digit? %ecx) # => eax
131 {
132 3d/compare-eax-and 0/imm32/false
133 75/jump-if-!= break/disp8
134 58/pop-to-eax
135 b8/copy-to-eax 0/imm32
136 eb/jump $parse-decimal-int-helper:negate/disp8
137 }
138 58/pop-to-eax
139 # digit = from-decimal-char(*curr)
140 81 5/subop/subtract %ecx 0x30/imm32/zero
141 # TODO: error checking
142 # result = result * 10 + digit
143 ba/copy-to-edx 0/imm32
144 f7 4/subop/multiply-into-edx-eax %ebx
145 # TODO: check edx for overflow
146 01/add %eax 1/r32/ecx
147 # ++curr
148 46/increment-esi
149 #
150 eb/jump loop/disp8
151 }
152 $parse-decimal-int-helper:negate:
153 # if (negate?) result = -result
154 5a/pop-to-edx
155 {
156 81 7/subop/compare %edx 0/imm32/false
157 74/jump-if-= break/disp8
158 f7 3/subop/negate %eax
159 }
160 $parse-decimal-int-helper:end:
161 # . restore registers
162 5f/pop-to-edi
163 5e/pop-to-esi
164 5b/pop-to-ebx
165 5a/pop-to-edx
166 59/pop-to-ecx
167 # . epilogue
168 89/<- %esp 5/r32/ebp
169 5d/pop-to-ebp
170 c3/return
172 test-parse-decimal-int-from-slice-single-digit:
173 # . prologue
174 55/push-ebp
175 89/<- %ebp 4/r32/esp
176 # . save registers
177 50/push-eax
178 51/push-ecx
179 # (eax..ecx) = "3"
180 b8/copy-to-eax "3"/imm32
181 8b/-> *eax 1/r32/ecx
182 8d/copy-address *(eax+ecx+4) 1/r32/ecx
183 05/add-to-eax 4/imm32
184 # var slice/ecx: slice = {eax, ecx}
185 51/push-ecx
186 50/push-eax
187 89/<- %ecx 4/r32/esp
188 #
189 (parse-decimal-int-from-slice %ecx) # => eax
190 (check-ints-equal %eax 3 "F - test-parse-decimal-int-from-slice-single-digit")
191 $test-parse-decimal-int-helper-single-digit:end:
192 # . restore registers
193 59/pop-to-ecx
194 58/pop-to-eax
195 # . epilogue
196 89/<- %esp 5/r32/ebp
197 5d/pop-to-ebp
198 c3/return
200 test-parse-decimal-int-from-slice-multi-digit:
201 # . prologue
202 55/push-ebp
203 89/<- %ebp 4/r32/esp
204 # . save registers
205 50/push-eax
206 51/push-ecx
207 # (eax..ecx) = "34"
208 b8/copy-to-eax "34"/imm32
209 8b/-> *eax 1/r32/ecx
210 8d/copy-address *(eax+ecx+4) 1/r32/ecx
211 05/add-to-eax 4/imm32
212 # var slice/ecx: slice = {eax, ecx}
213 51/push-ecx
214 50/push-eax
215 89/<- %ecx 4/r32/esp
216 #
217 (parse-decimal-int-from-slice %ecx) # => eax
218 (check-ints-equal %eax 0x22 "F - test-parse-decimal-int-from-slice-multi-digit") # 34 in hex
219 $test-parse-decimal-int-helper-multi-digit:end:
220 # . restore registers
221 59/pop-to-ecx
222 58/pop-to-eax
223 # . epilogue
224 89/<- %esp 5/r32/ebp
225 5d/pop-to-ebp
226 c3/return
228 test-parse-decimal-int-from-slice-zero:
229 # . prologue
230 55/push-ebp
231 89/<- %ebp 4/r32/esp
232 # . save registers
233 50/push-eax
234 51/push-ecx
235 # (eax..ecx) = "00"
236 b8/copy-to-eax "00"/imm32
237 8b/-> *eax 1/r32/ecx
238 8d/copy-address *(eax+ecx+4) 1/r32/ecx
239 05/add-to-eax 4/imm32
240 # var slice/ecx: slice = {eax, ecx}
241 51/push-ecx
242 50/push-eax
243 89/<- %ecx 4/r32/esp
244 #
245 (parse-decimal-int-from-slice %ecx) # => eax
246 (check-ints-equal %eax 0 "F - test-parse-decimal-int-from-slice-zero")
247 $test-parse-decimal-int-helper-zero:end:
248 # . restore registers
249 59/pop-to-ecx
250 58/pop-to-eax
251 # . epilogue
252 89/<- %esp 5/r32/ebp
253 5d/pop-to-ebp
254 c3/return
256 test-parse-decimal-int-from-slice-negative:
257 # . prologue
258 55/push-ebp
259 89/<- %ebp 4/r32/esp
260 # . save registers
261 50/push-eax
262 51/push-ecx
263 # (eax..ecx) = "-3"
264 b8/copy-to-eax "-3"/imm32
265 8b/-> *eax 1/r32/ecx
266 8d/copy-address *(eax+ecx+4) 1/r32/ecx
267 05/add-to-eax 4/imm32
268 # var slice/ecx: slice = {eax, ecx}
269 51/push-ecx
270 50/push-eax
271 89/<- %ecx 4/r32/esp
272 #
273 (parse-decimal-int-from-slice %ecx) # => eax
274 (check-ints-equal %eax -3 "F - test-parse-decimal-int-from-slice-negative")
275 $test-parse-decimal-int-helper-negative:end:
276 # . restore registers
277 59/pop-to-ecx
278 58/pop-to-eax
279 # . epilogue
280 89/<- %esp 5/r32/ebp
281 5d/pop-to-ebp
282 c3/return
284 test-parse-decimal-int-from-slice-multi-digit-negative:
285 # . prologue
286 55/push-ebp
287 89/<- %ebp 4/r32/esp
288 # . save registers
289 50/push-eax
290 51/push-ecx
291 # (eax..ecx) = "-32"
292 b8/copy-to-eax "-32"/imm32
293 8b/-> *eax 1/r32/ecx
294 8d/copy-address *(eax+ecx+4) 1/r32/ecx
295 05/add-to-eax 4/imm32
296 # var slice/ecx: slice = {eax, ecx}
297 51/push-ecx
298 50/push-eax
299 89/<- %ecx 4/r32/esp
300 #
301 (parse-decimal-int-from-slice %ecx) # => eax
302 (check-ints-equal %eax -0x20 "F - test-parse-decimal-int-from-slice-multi-digit-negative") # -32 in hex
303 $test-parse-decimal-int-helper-multi-digit-negative:end:
304 # . restore registers
305 59/pop-to-ecx
306 58/pop-to-eax
307 # . epilogue
308 89/<- %esp 5/r32/ebp
309 5d/pop-to-ebp
310 c3/return
312 decimal-size: # n: int -> result/eax: int
313 # pseudocode:
314 # edi = 0
315 # eax = n
316 # if eax < 0
317 # ++edi # for '-'
318 # negate eax
319 # while true
320 # edx = 0
321 # eax, edx = eax/10, eax%10
322 # ++edi
323 # if (eax == 0) break
324 # eax = edi
325 #
326 # . prologue
327 55/push-ebp
328 89/<- %ebp 4/r32/esp
329 # . save registers
330 51/push-ecx
331 52/push-edx
332 57/push-edi
333 # edi = 0
334 bf/copy-to-edi 0/imm32
335 # eax = n
336 8b/-> *(ebp+8) 0/r32/eax
337 # if (n < 0) negate n, increment edi
338 {
339 3d/compare-eax-with 0/imm32
340 7d/jump-if->= break/disp8
341 f7 3/subop/negate %eax
342 47/increment-edi
343 }
344 # const ten/ecx = 10
345 b9/copy-to-ecx 0xa/imm32
346 {
347 ba/copy-to-edx 0/imm32
348 f7 7/subop/idiv-edx-eax-by %ecx # eax = edx:eax/10; edx = edx:eax%10
349 47/increment-edi
350 3d/compare-eax-and 0/imm32
351 75/jump-if-!= loop/disp8
352 }
353 $decimal-size:end:
354 89/<- %eax 7/r32/edi
355 # . restore registers
356 5f/pop-to-edi
357 5a/pop-to-edx
358 59/pop-to-ecx
359 # . epilogue
360 89/<- %esp 5/r32/ebp
361 5d/pop-to-ebp
362 c3/return
364 test-decimal-size-of-zero:
365 # . prologue
366 55/push-ebp
367 89/<- %ebp 4/r32/esp
368 #
369 (decimal-size 0) # => eax
370 (check-ints-equal %eax 1 "F - test-decimal-size-of-zero")
371 $test-decimal-size-of-zero:end:
372 # . epilogue
373 89/<- %esp 5/r32/ebp
374 5d/pop-to-ebp
375 c3/return
377 test-decimal-size-single-digit:
378 # . prologue
379 55/push-ebp
380 89/<- %ebp 4/r32/esp
381 #
382 (decimal-size 4) # => eax
383 (check-ints-equal %eax 1 "F - test-decimal-size-single-digit")
384 $test-decimal-size-single-digit:end:
385 # . epilogue
386 89/<- %esp 5/r32/ebp
387 5d/pop-to-ebp
388 c3/return
390 test-decimal-size-multi-digit:
391 # . prologue
392 55/push-ebp
393 89/<- %ebp 4/r32/esp
394 #
395 (decimal-size 0xa) # => eax
396 (check-ints-equal %eax 2 "F - test-decimal-size-multi-digit")
397 $test-decimal-size-multi-digit:end:
398 # . epilogue
399 89/<- %esp 5/r32/ebp
400 5d/pop-to-ebp
401 c3/return
403 test-decimal-size-single-digit-negative:
404 # . prologue
405 55/push-ebp
406 89/<- %ebp 4/r32/esp
407 #
408 (decimal-size -4) # => eax
409 (check-ints-equal %eax 2 "F - test-decimal-size-single-digit-negative")
410 $test-decimal-size-single-digit-negative:end:
411 # . epilogue
412 89/<- %esp 5/r32/ebp
413 5d/pop-to-ebp
414 c3/return
416 test-decimal-size-multi-digit-negative:
417 # . prologue
418 55/push-ebp
419 89/<- %ebp 4/r32/esp
420 #
421 (decimal-size -0xa) # => eax
422 (check-ints-equal %eax 3 "F - test-decimal-size-multi-digit-negative")
423 $test-decimal-size-multi-digit-negative:end:
424 # . epilogue
425 89/<- %esp 5/r32/ebp
426 5d/pop-to-ebp
427 c3/return
429 _parse-array-of-decimal-ints: # ad: (addr allocation-descriptor), s: (addr array byte), out: (addr handle array int)
430 # pseudocode
431 # end = &s->data[s->size]
432 # curr = s->data
433 # size = 0
434 # while true
435 # if (curr >= end) break
436 # curr = skip-chars-matching-in-slice(curr, end, ' ')
437 # if (curr >= end) break
438 # curr = skip-chars-not-matching-in-slice(curr, end, ' ')
439 # ++size
440 # allocate-array(ad, size*4, out)
441 # var slice: slice = {s->data, 0}
442 # curr = lookup(out)->data
443 # while true
444 # if (slice->start >= end) break
445 # slice->start = skip-chars-matching-in-slice(slice->start, end, ' ')
446 # if (slice->start >= end) break
447 # slice->end = skip-chars-not-matching-in-slice(slice->start, end, ' ')
448 # *curr = parse-hex-int-from-slice(slice)
449 # curr += 4
450 # slice->start = slice->end
451 # return result
452 #
453 # . prologue
454 55/push-ebp
455 89/<- %ebp 4/r32/esp
456 # . save registers
457 50/push-eax
458 51/push-ecx
459 52/push-edx
460 53/push-ebx
461 56/push-esi
462 57/push-edi
463 # esi = s
464 8b/-> *(ebp+0xc) 6/r32/esi
465 # var curr/ecx: (addr byte) = s->data
466 8d/copy-address *(esi+4) 1/r32/ecx
467 # var end/edx: (addr byte) = &s->data[s->size]
468 # . edx = s->size
469 8b/-> *esi 2/r32/edx
470 # . edx += curr
471 01/add-to %edx 1/r32/ecx
472 # var size/ebx: int = 0
473 31/xor-with %ebx 3/r32/ebx
474 $_parse-array-of-decimal-ints:loop1:
475 # if (curr >= end) break
476 39/compare %ecx 2/r32/edx
477 73/jump-if-addr>= $_parse-array-of-decimal-ints:break1/disp8
478 # curr = skip-chars-matching-in-slice(curr, end, ' ')
479 (skip-chars-matching-in-slice %ecx %edx 0x20) # => eax
480 89/<- %ecx 0/r32/eax
481 # if (curr >= end) break
482 39/compare %ecx 2/r32/edx
483 73/jump-if-addr>= $_parse-array-of-decimal-ints:break1/disp8
484 # curr = skip-chars-not-matching-in-slice(curr, end, ' ')
485 (skip-chars-not-matching-in-slice %ecx %edx 0x20) # => eax
486 89/<- %ecx 0/r32/eax
487 # size += 4
488 81 0/subop/add %ebx 4/imm32
489 eb/jump $_parse-array-of-decimal-ints:loop1/disp8
490 $_parse-array-of-decimal-ints:break1:
491 (allocate-array *(ebp+8) %ebx *(ebp+0x10))
492 $_parse-array-of-decimal-ints:pass2:
493 # var slice/edi: slice = {s->data, 0}
494 68/push 0/imm32/end
495 8d/copy-address *(esi+4) 7/r32/edi
496 57/push-edi
497 89/<- %edi 4/r32/esp
498 # curr = lookup(out)->data
499 8b/-> *(ebp+0x10) 0/r32/eax
500 (lookup *eax *(eax+4)) # => eax
501 8d/copy-address *(eax+4) 1/r32/ecx
502 $_parse-array-of-decimal-ints:loop2:
503 # if (slice->start >= end) break
504 39/compare *edi 2/r32/edx
505 73/jump-if-addr>= $_parse-array-of-decimal-ints:end/disp8
506 # slice->start = skip-chars-matching-in-slice(slice->start, end, ' ')
507 (skip-chars-matching-in-slice *edi %edx 0x20) # => eax
508 89/<- *edi 0/r32/eax
509 # if (slice->start >= end) break
510 39/compare *edi 2/r32/edx
511 73/jump-if-addr>= $_parse-array-of-decimal-ints:end/disp8
512 # slice->end = skip-chars-not-matching-in-slice(slice->start, end, ' ')
513 (skip-chars-not-matching-in-slice *edi %edx 0x20) # => eax
514 89/<- *(edi+4) 0/r32/eax
515 # *curr = parse-hex-int-from-slice(slice)
516 (parse-decimal-int-from-slice %edi)
517 89/<- *ecx 0/r32/eax
518 # curr += 4
519 81 0/subop/add %ecx 4/imm32
520 # slice->start = slice->end
521 8b/-> *(edi+4) 0/r32/eax
522 89/<- *edi 0/r32/eax
523 eb/jump $_parse-array-of-decimal-ints:loop2/disp8
524 $_parse-array-of-decimal-ints:end:
525 # . reclaim locals
526 81 0/subop/add %esp 8/imm32
527 # . restore registers
528 5f/pop-to-edi
529 5e/pop-to-esi
530 5b/pop-to-ebx
531 5a/pop-to-edx
532 59/pop-to-ecx
533 58/pop-to-eax
534 # . epilogue
535 89/<- %esp 5/r32/ebp
536 5d/pop-to-ebp
537 c3/return
539 test-parse-array-of-decimal-ints:
540 # . prologue
541 55/push-ebp
542 89/<- %ebp 4/r32/esp
543 # var h/esi: (handle array int)
544 68/push 0/imm32
545 68/push 0/imm32
546 89/<- %esi 4/r32/esp
547 # var ecx: (array int) = [1, 2, 3]
548 68/push 3/imm32
549 68/push 2/imm32
550 68/push 1/imm32
551 68/push 0xc/imm32/size
552 89/<- %ecx 4/r32/esp
553 #
554 (_parse-array-of-decimal-ints Heap "1 2 3" %esi)
555 (lookup *esi *(esi+4)) # => eax
556 (array-equal? %ecx %eax) # => eax
557 (check-ints-equal %eax 1 "F - test-parse-array-of-decimal-ints")
558 # . epilogue
559 89/<- %esp 5/r32/ebp
560 5d/pop-to-ebp
561 c3/return
563 test-parse-array-of-decimal-ints-empty:
564 # - empty string = empty array
565 # . prologue
566 55/push-ebp
567 89/<- %ebp 4/r32/esp
568 # var h/esi: handle
569 68/push 0/imm32
570 68/push 0/imm32
571 89/<- %esi 4/r32/esp
572 #
573 (_parse-array-of-decimal-ints Heap "" %esi)
574 (lookup *esi *(esi+4)) # => eax
575 (check-ints-equal *eax 0 "F - test-parse-array-of-decimal-ints-empty")
576 # . epilogue
577 89/<- %esp 5/r32/ebp
578 5d/pop-to-ebp
579 c3/return
581 test-parse-array-of-decimal-ints-just-whitespace:
582 # - just whitespace = empty array
583 # . prologue
584 55/push-ebp
585 89/<- %ebp 4/r32/esp
586 # var h/esi: handle
587 68/push 0/imm32
588 68/push 0/imm32
589 89/<- %esi 4/r32/esp
590 #
591 (_parse-array-of-decimal-ints Heap Space %esi)
592 (lookup *esi *(esi+4)) # => eax
593 (check-ints-equal *eax 0 "F - test-parse-array-of-decimal-ints-just-whitespace")
594 # . epilogue
595 89/<- %esp 5/r32/ebp
596 5d/pop-to-ebp
597 c3/return
599 test-parse-array-of-decimal-ints-extra-whitespace:
600 # . prologue
601 55/push-ebp
602 89/<- %ebp 4/r32/esp
603 # var h/esi: handle
604 68/push 0/imm32
605 68/push 0/imm32
606 89/<- %esi 4/r32/esp
607 # var ecx: (array int) = [1, 2, 3]
608 68/push 3/imm32
609 68/push 2/imm32
610 68/push 1/imm32
611 68/push 0xc/imm32/size
612 89/<- %ecx 4/r32/esp
613 #
614 (_parse-array-of-decimal-ints Heap " 1 2 3 " %esi)
615 (lookup *esi *(esi+4)) # => eax
616 (array-equal? %ecx %eax) # => eax
617 (check-ints-equal %eax 1 "F - test-parse-array-of-decimal-ints-extra-whitespace")
618 # . epilogue
619 89/<- %esp 5/r32/ebp
620 5d/pop-to-ebp
621 c3/return
623 parse-array-of-decimal-ints: # s: (addr array byte), out: (addr handle array int)
624 # . prologue
625 55/push-ebp
626 89/<- %ebp 4/r32/esp
627 #
628 (_parse-array-of-decimal-ints Heap *(ebp+8) *(ebp+0xc))
629 $parse-array-of-decimal-ints:end:
630 # . epilogue
631 89/<- %esp 5/r32/ebp
632 5d/pop-to-ebp
633 c3/return