311decimal-int.subx

   1 # Helpers for decimal ints.
   2
   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
  21
  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
  47
  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
  85
  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
 171
 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
 199
 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
 227
 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
 255
 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
 283
 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
 311
 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
 363
 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
 376
 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
 389
 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
 402
 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
 415
 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
 428
 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
 538
 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
 562
 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
 580
 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
 598
 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
 622
 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