home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / asmutil / stdlib.zip / SPRINTF.ASM < prev    next >
Assembly Source File  |  1990-07-09  |  16KB  |  819 lines
  1. stdlib        segment    para public 'slcode'
  2.         assume    cs:stdlib
  3.         extrn    sl_ISize:far, sl_ULSize:far
  4.         extrn    sl_LSize:far, sl_USize:far
  5.         extrn    sl_itoa:far, sl_free:far
  6.         extrn    sl_wtoa:far, sl_ltoa:far
  7.         extrn    sl_ultoa:far, sl_htoa:far
  8.         extrn    sl_utoa:far
  9.         extrn    sl_malloc:far, sl_realloc:far
  10. ;
  11. ;
  12. ;
  13. ; Sprintf- Like the "C" routine by the same name.  Calling sequence:
  14. ;
  15. ;               call    sprintf
  16. ;               db      "format string",0
  17. ;               dd      item1, item2, ..., itemn
  18. ;
  19. ; Just like the PRINTF routine except it performs an in-memory format
  20. ; operation rather than printing the data to the current output device.
  21. ; Returns a pointer to the formatted string in ES:DI.
  22. ; See the PRINTF routine for more details about this guy.
  23. ;
  24. ;
  25. cr        equ    0dh
  26. ff        equ    0ch
  27. lf        equ    0ah
  28. tab        equ    09h
  29. bs        equ    08h
  30. ;
  31. RtnAdrs        equ    2[bp]
  32. ;
  33. ;
  34. ; 
  35. aindex        dw    ?
  36. aptr        dd    ?
  37. ;
  38. ;
  39. ; sp_BufSize is a public variable so the user can adjust the size.
  40. ;
  41.         public    sp_BufSize
  42. sp_BufSize    dw    2048
  43. ;
  44. ;
  45.         public    sl_sprintf
  46. sl_sprintf    proc    far
  47.         push    bp
  48.         mov    bp, sp
  49.         pushf
  50.         push    ax cx
  51. ;
  52. ; Request some memory from the system.  If there isn't enough available,
  53. ; try half as much and repeat.  If there is no memory available, return
  54. ; with the carry set.
  55. ;
  56.         mov    cx, sp_BufSize
  57. TryAgain:    call    sl_malloc
  58.         jnc    DoSPRINTF
  59.         shr    cx, 1
  60.         cmp    cx, 128            ;Need at least 128 bytes.
  61.         jae    TryAgain
  62.         pop    cx ax
  63.         popf
  64.                 pop    bp
  65.         stc
  66.         ret
  67. ;
  68. ; The following code simulates a far call to sbprintf.  We can't make the
  69. ; call because we need to skip the MOV BP, SP instruction which appears
  70. ; at the beginning of the code.
  71. ;
  72. DoSPRINTF:         push    cs            ;Push fake return address
  73.         mov    ax, offset RA
  74.         push    ax
  75.         push    bp            ;Push stuff on stack
  76.         pushf
  77.         push    ax bx cx dx di si es ds
  78.         jmp    sl_sbprintf2
  79. ;
  80. ; Return back to this point from sbprintf.
  81. ;
  82. RA:        push    di
  83.         mov    cx, 1
  84.         mov    al, ch
  85. FindLength:    cmp    al, es:[di]
  86.         jz    AtEnd
  87.         inc    cx
  88.         inc    di
  89.         jmp    FindLength
  90. ;
  91. AtEnd:        pop    di
  92.         call    sl_realloc
  93.         pop    cx ax
  94.         popf
  95.                 pop    bp
  96.         clc
  97.         ret        
  98. sl_sprintf    endp
  99. ;
  100. ;
  101. ;
  102. ;
  103. ; SBPRINTF- Like sprintf except it doesn't allocate storage for the
  104. ; formatted string.  Instead, you must pass it the address of a suitable
  105. ; buffer in es:di.
  106. ;
  107. ;
  108.         public  sl_sbprintf
  109. sl_sbprintf    proc    far
  110.         push    bp
  111.         mov    bp, sp
  112.         pushf
  113.         push    ax bx cx dx di si es ds
  114. ;
  115. ; Save ptr to buffer area.
  116. ;
  117. sl_sbprintf2:    mov    word ptr cs:aptr, di
  118.         mov    word ptr cs:aptr+2, es
  119.         mov    cs:aindex, 0
  120. ;
  121. ; Get pointers to the return address (format string).
  122. ;
  123.         cld
  124.         les    di, RtnAdrs
  125.         lds    si, RtnAdrs
  126. ;
  127. ; Okay, search for the end of the format string.  After these instructions,
  128. ; di points just beyond the zero byte at the end of the format string.  This,
  129. ; of course, points at the first address beyond the format string.
  130. ;
  131.         mov    al, 0
  132.         mov    cx, 65535
  133.     repne    scasb
  134. ;
  135. PrintItems:    lodsb            ;Get char si points at.
  136.         cmp    al, 0        ;EOS?
  137.         jz    PrintfDone
  138.         cmp    al, "%"        ;Start of a format string?
  139.         jz    FmtItem
  140.         cmp    al, "\"        ;Escape character?
  141.         jnz    PrintIt
  142.         call    GetEscChar
  143. PrintIt:    call    PutIt
  144.         jmp    PrintItems
  145. ;
  146. FmtItem:    call    GetFmtItem    ;Process the format item here.
  147.         jmp    PrintItems
  148. ;
  149. PrintfDone:    mov    RtnAdrs, di    ;Put out new return address.
  150.         pop    ds
  151.         pop    es
  152.         pop    si
  153.         pop    di
  154.         pop    dx
  155.         pop    cx
  156.         pop    bx
  157.         pop    ax
  158.         pop    bp
  159.         popf
  160.         clc
  161.         ret
  162. sl_sbprintf    endp
  163. ;
  164. ; GetEscChar- Handles items immediately following the escape character "\".
  165. ;
  166. ;    Special escape characters (upper/lower case is acceptable):
  167. ;
  168. ;        n    Newline (cr/lf)
  169. ;        t    tab
  170. ;        b    backspace
  171. ;        r    return
  172. ;        l    line feed
  173. ;        f    formfeed
  174. ;        \    \
  175. ;        %    &
  176. ;        0xhh    Char with hex character code hh.  Must have exactly
  177. ;            two hexadecimal digits.
  178. ;
  179. GetEscChar    proc    near
  180.         lodsb            ;Get next character
  181.         cmp    al, 'n'
  182.         je    RtnNL
  183.         cmp    al, 'N'
  184.         je    RtnNL
  185.         cmp    al, 't'
  186.         je    RtnTab
  187.         cmp    al, 'T'
  188.         je    RtnTab
  189.         cmp    al, 'b'
  190.         je    RtnBS
  191.         cmp    al, 'B'
  192.         je    RtnBS
  193.         cmp    al, 'r'
  194.         je    RtnRtn
  195.         cmp    al, 'R'
  196.         je    RtnRtn
  197.         cmp    al, 'l'
  198.         je    RtnLF
  199.         cmp    al, 'L'
  200.         je    RtnLF
  201.         cmp    al, 'f'
  202.         je    RtnFF
  203.         cmp    al, 'F'
  204.         je    RtnFF
  205. ;
  206. ; Check for the presence of a 0xhh value here:
  207. ;
  208.         cmp    al, '0'
  209.         jne    RtnChar
  210.         cmp    byte ptr [si], 'x'
  211.         je    GetHex
  212.         cmp    byte ptr [si], 'X'
  213.         jne    RtnChar
  214. ;
  215. ; Okay, process the hex value here.  Note that exactly two hex digits must
  216. ; follow the 0x.
  217. ;
  218. GetHex:        inc    si        ;Point at first hex digit.
  219.         lodsb            ;Get first hex digit.
  220.         and    al, 05fh    ;l.c. -> u.c.
  221.         cmp    al, 'A'
  222.         jb    GotIt
  223.         sub    al, '7'
  224. GotIt:        shl    al, 1        ;Put into H.O. nibble.
  225.         shl    al, 1
  226.         shl    al, 1
  227.         shl    al, 1
  228.         mov    ah, al        ;Save for later
  229.         lodsb            ;Get next char.
  230.         and    al, 05fh
  231.         cmp    al, 'A'
  232.         jb    GotIt2
  233.         sub    al, '7'
  234. GotIt2:        and    al, 0fh
  235.         or    al, ah
  236.         ret            ;Return hex constant.
  237. ;
  238. ; RtnNL (return Newline) cheats.  It needs to return two characters.
  239. ; Since GetEscChar only returns a single character, this code goes ahead
  240. ; and calls putc to output the CR and the returns the LF.
  241. ;
  242. RtnNL:        mov    al, cr
  243.         call    PutIt
  244.         mov    al, lf
  245.         ret
  246. ;
  247. RtnTab:        mov    al, tab
  248.         ret
  249. ;
  250. RtnBS:        mov    al, bs
  251.         ret
  252. ;
  253. RtnRtn:        mov    al, cr
  254.         ret
  255. ;
  256. RtnLF:        mov    al, lf
  257.         ret
  258. ;
  259. RtnFF:        mov    al, ff
  260. RtnChar:    ret
  261. ;
  262. GetEscChar    endp
  263. ;
  264. ;
  265. ;
  266. GetFmtItem    proc    near
  267.         lodsb                ;Get char beyond "%"
  268. ;
  269.         mov    cx, 1            ;Default field width is 1.
  270.         mov    dl, 0            ;Default is right justified
  271.         mov    dh, ' '            ;Default fill char is space.
  272.         mov    ah, ' '            ;Assume straight ptr, not handle.
  273. ;
  274. ; See if the user wants the value left justified:
  275. ;
  276.         cmp    al, '-'
  277.         jne    NotLeftJust
  278.         inc    dl            ;Set to right justified
  279.         lodsb                ;Get next character.
  280. ;
  281. ; See if the user wants to change the padding character.
  282. ;
  283. NotLeftJust:    cmp    al, '\'
  284.         jne    NoPadChange
  285.         lodsb                ;Get Padding Character.
  286.         mov    dh, al            ;Save padding character.
  287.         lodsb                ;Get next character
  288. ;
  289. ; See if the user wants a different field width:
  290. ;
  291. NoPadChange:    cmp    al, '0'
  292.         jb    NoFldWidth
  293.         cmp    al, '9'
  294.         ja    NoFldWidth
  295.         call    GetDecVal
  296. ;
  297. ; See if the user wants to specify a handle rather than a straight pointer
  298. ;
  299. NoFldWidth:    cmp    al, '^'
  300.         jne     ChkFmtChars
  301.         mov    ah, al
  302.         lodsb                ;Skip "^" character
  303. ;
  304. ; Okay, process the format characters down here.
  305. ;
  306. ChkFmtChars:    and    al, 05fh        ;l.c. -> U.C.
  307.         cmp    al, 'D'
  308.         je    PrintDec
  309.         cmp    al, 'I'
  310.         je    PrintDec
  311.         cmp    al, 'C'
  312.         je    PrintChar
  313. ;
  314.         cmp    al, 'X'
  315.         jne    TryH
  316.         jmp    PrintHexWord
  317. ;
  318. TryH:        cmp    al, 'H'
  319.         jne    TryU
  320.         jmp    PrintHexByte
  321. ;
  322. TryU:        cmp    al, 'U'
  323.         jne    TryString
  324.         jmp    PrintUDec
  325. ;
  326. TryString:    cmp    al, 'S'
  327.         jne    TryLong
  328.         jmp    PrintString
  329. ;
  330. TryLong:    cmp    al, 'L'
  331.         jne    Default
  332. ;
  333. ; If we've got the "L" modifier, this is a long value to print, get the
  334. ; data type character as the next value:
  335. ;
  336.         lodsb
  337.         and    al, 05fh        ;l.c. -> U.C.
  338.         cmp    al, 'D'
  339.         je    JmpDec
  340.         cmp    al, 'I'
  341.         jne    TryLU
  342. JmpDec:        jmp    LongDec
  343. ;
  344. TryLU:        cmp    al, 'U'
  345.         jne    TryX
  346.         jmp    LongU
  347. ;
  348. TryX:        cmp    al, 'X'
  349.         jne    Default
  350.         jmp    LongX
  351. ;
  352. ;
  353. ;
  354. ; If none of the above, simply return without printing anything.
  355. ;
  356. Default:        ret
  357. ;
  358. ;
  359. ;
  360. ;
  361. ;
  362. ; Print a signed decimal value here.
  363. ;
  364. PrintDec:    call    GetPtr            ;Get next pointer into ES:BX
  365.         mov    ax, es:[bx]        ;Get value to print.
  366.         call    sl_ISize        ;Get the size of this guy.
  367.         sub    cx, ax                 ;Compute padding
  368.         mov    ax, es:[bx]        ;Retrieve value to print.
  369.         js    NoPadDec        ;Is CX negative?
  370.         cmp    dl, 0            ;Right justified?
  371.         jne    LeftJustDec
  372.         call    PrintPad        ;Print padding characters
  373.         call    PutIti            ;Print the integer
  374.         ret                ;We're done!
  375. ;
  376. ; Print left justified value here.
  377. ;
  378. LeftJustDec:    call    PutIti
  379.         call    PrintPad
  380.         ret
  381. ;
  382. ; Print non-justified value here:
  383. ;
  384. NoPadDec:    call    PutIti
  385.         ret
  386. ;
  387. ;
  388. ;
  389. ; Print a character variable here.
  390. ;
  391. PrintChar:    call    GetPtr            ;Get next pointer into ES:BX
  392.         mov    al, es:[bx]        ;Retrieve value to print.
  393.                 dec    cx
  394.         js    NoPadChar        ;Is CX negative?
  395.         cmp    dl, 0            ;Right justified?
  396.         jne    LeftJustChar
  397.         call    PrintPad        ;Print padding characters
  398.         call    PutIt            ;Print the character
  399.         ret                ;We're done!
  400. ;
  401. ; Print left justified value here.
  402. ;
  403. LeftJustChar:    call    PutIt
  404.         call    PrintPad
  405.         ret
  406. ;
  407. ; Print non-justified character here:
  408. ;
  409. NoPadChar:    call    PutIt
  410.         ret
  411. ;
  412. ;
  413. ;
  414. ;
  415. ; Print a hexadecimal word value here.
  416. ;
  417. PrintHexWord:    call    GetPtr            ;Get next pointer into ES:BX
  418.         mov    ax, es:[bx]        ;Get value to print.
  419.         sub    cx, 4            ;Compute padding
  420.         js    NoPadHexW        ;Is CX negative?
  421.         cmp    dl, 0            ;Right justified?
  422.         jne    LeftJustHexW
  423.         call    PrintPad        ;Print padding characters
  424.         call    PutItw            ;Print the hex value
  425.         ret                ;We're done!
  426. ;
  427. ; Print left justified value here.
  428. ;
  429. LeftJustHexW:    call    PutItw
  430.         call    PrintPad
  431.         ret
  432. ;
  433. ; Print non-justified value here:
  434. ;
  435. NoPadHexW:    call    PutItw
  436.         ret
  437. ;
  438. ;
  439. ;
  440. ;
  441. ; Print hex bytes here.
  442. ;
  443. ;
  444. PrintHexByte:    call    GetPtr            ;Get next pointer into ES:BX
  445.         mov    ax, es:[bx]        ;Get value to print.
  446.         sub    cx, 4            ;Compute padding
  447.         js    NoPadHexB        ;Is CX negative?
  448.         cmp    dl, 0            ;Right justified?
  449.         jne    LeftJustHexB
  450.         call    PrintPad        ;Print padding characters
  451.         call    PutIth            ;Print the hex value
  452.         ret                ;We're done!
  453. ;
  454. ; Print left justified value here.
  455. ;
  456. LeftJustHexB:    call    PutIth
  457.         call    PrintPad
  458.         ret
  459. ;
  460. ; Print non-justified value here:
  461. ;
  462. NoPadHexB:    call    PutIth
  463.         ret
  464. ;
  465. ;
  466. ;
  467. ; Output unsigned decimal numbers here:
  468. ;
  469. PrintUDec:    call    GetPtr            ;Get next pointer into ES:BX
  470.         mov    ax, es:[bx]        ;Get value to print.
  471.         call    sl_USize        ;Get the size of this guy.
  472.         sub    cx, ax                 ;Compute padding
  473.         mov    ax, es:[bx]        ;Retrieve value to print.
  474.         js    NoPadUDec        ;Is CX negative?
  475.         cmp    dl, 0            ;Right justified?
  476.         jne    LeftJustUDec
  477.         call    PrintPad        ;Print padding characters
  478.         call    PutItu            ;Print the integer
  479.         ret                ;We're done!
  480. ;
  481. ; Print left justified value here.
  482. ;
  483. LeftJustUDec:    call    PutItu
  484.         call    PrintPad
  485.         ret
  486. ;
  487. ; Print non-justified value here:
  488. ;
  489. NoPadUDec:    call    PutItu
  490.         ret
  491. ;
  492. ;
  493. ;
  494. ;
  495. ; Output a string here:
  496. ;
  497. PrintString:    call    GetPtr            ;Get next pointer into ES:BX
  498. ;
  499. ; Compute the length of the string:
  500. ;
  501.         push    di
  502.         push    cx
  503.         mov    cx, -1
  504.         mov    di, bx
  505.         mov    al, 0
  506.     repne    scasb
  507.         mov    ax, cx
  508.         neg    ax
  509.         dec    ax
  510.         dec    ax
  511.         pop    cx
  512.         pop    di
  513.         sub    cx, ax            ;Field width - String Length.
  514. ;
  515.         js    NoPadStr        ;Is CX negative?
  516.         cmp    dl, 0            ;Right justified?
  517.         jne    LeftJustStr
  518.         call    PrintPad        ;Print padding characters
  519.         call    Puts            ;Print the string
  520.         ret                ;We're done!
  521. ;
  522. ; Print left justified value here.
  523. ;
  524. LeftJustStr:    call    Puts
  525.         call    PrintPad
  526.         ret
  527. ;
  528. ; Print non-justified value here:
  529. ;
  530. NoPadStr:    call    Puts
  531.         ret
  532. GetFmtItem    endp
  533. ;
  534. ;
  535. ;
  536. ; Print a signed long decimal value here.
  537. ;
  538. LongDec:    call    GetPtr            ;Get next pointer into ES:BX
  539.         mov    ax, es:[bx]        ;Get value to print.
  540.         push    dx
  541.         mov    dx, es:2[bx]
  542.         call    sl_LSize        ;Get the size of this guy.
  543.         pop    dx
  544.         sub    cx, ax                 ;Compute padding
  545.         mov    ax, es:[bx]        ;Retrieve value to print.
  546.         js    NoPadLong        ;Is CX negative?
  547.         cmp    dl, 0            ;Right justified?
  548.         jne    LeftJustLong
  549.         call    PrintPad        ;Print padding characters
  550.         mov    dx, es:2[bx]        ;Get H.O. word
  551.         call    PutItL            ;Print the integer
  552.         ret                ;We're done!
  553. ;
  554. ; Print left justified value here.
  555. ;
  556. LeftJustLong:    push    dx
  557.         mov    dx, es:2[bx]        ;Get H.O. word
  558.         call    PutItL
  559.         pop    dx
  560.         call    PrintPad
  561.         ret
  562. ;
  563. ; Print non-justified value here:
  564. ;
  565. NoPadLong:    mov    dx, es:2[bx]        ;Get H.O. word
  566.         call    PutItl
  567.         ret
  568. ;
  569. ;
  570. ; Print an unsigned long decimal value here.
  571. ;
  572. LongU:        call    GetPtr            ;Get next pointer into ES:BX
  573.         mov    ax, es:[bx]        ;Get value to print.
  574.         push    dx
  575.         mov    dx, es:[bx]
  576.         call    sl_ULSize        ;Get the size of this guy.
  577.         pop    dx
  578.         sub    cx, ax                 ;Compute padding
  579.         mov    ax, es:[bx]        ;Retrieve value to print.
  580.         js    NoPadULong        ;Is CX negative?
  581.         cmp    dl, 0            ;Right justified?
  582.         jne    LeftJustULong
  583.         call    PrintPad        ;Print padding characters
  584.         mov    dx, es:2[bx]        ;Get H.O. word
  585.         call    PutItUL            ;Print the integer
  586.         ret                ;We're done!
  587. ;
  588. ; Print left justified value here.
  589. ;
  590. LeftJustULong:    mov    dx, es:2[bx]        ;Get H.O. word
  591.         call    PutItUL
  592.         call    PrintPad
  593.         ret
  594. ;
  595. ; Print non-justified value here:
  596. ;
  597. NoPadULong:    mov    dx, es:2[bx]        ;Get H.O. word
  598.         call    Putitul
  599.         ret
  600. ;
  601. ;
  602. ; Print a long hexadecimal value here.
  603. ;
  604. LongX:        call    GetPtr            ;Get next pointer into ES:BX
  605.         sub    cx, 8            ;Compute padding
  606.         js    NoPadXLong        ;Is CX negative?
  607.         cmp    dl, 0            ;Right justified?
  608.         jne    LeftJustXLong
  609.         call    PrintPad        ;Print padding characters
  610.         mov    ax, es:2[bx]        ;Get H.O. word
  611.         call    PutItw
  612.         mov    ax, es:[bx]
  613.         call    PutItw
  614.         ret                ;We're done!
  615. ;
  616. ; Print left justified value here.
  617. ;
  618. LeftJustxLong:    mov    ax, es:2[bx]        ;Get H.O. word
  619.         call    PutItw
  620.         mov    ax, es:[bx]        ;Get L.O. word
  621.         call    PutItw
  622.         call    PrintPad
  623.         ret
  624. ;
  625. ; Print non-justified value here:
  626. ;
  627. NoPadxLong:    mov    ax, es:2[bx]        ;Get H.O. word
  628.         call    PutItw
  629.         mov    ax, es:[bx]
  630.         call    PutItw
  631.         ret
  632. ;
  633. ;
  634. ;
  635. ;
  636. ; Puts- Outputs the zero terminated string pointed at by ES:BX.
  637. ;
  638. Puts        proc    near
  639. PutsLp:        mov    al, es:[bx]
  640.         cmp    al, 0
  641.         je    PutsDone
  642.         call    putIt
  643.         inc    bx
  644.         jmp    PutsLp
  645. ;
  646. PutsDone:    ret
  647. Puts        endp
  648. ;
  649. ;
  650. ;
  651. ;
  652. ;
  653. ; PrintPad-    Prints padding characters.  Character to print is in DH.
  654. ;        We must print it CX times.  CX must be greater than zero.
  655. ;
  656. PrintPad    proc    near
  657.         push    ax
  658.         mov    al, dh
  659.         jcxz    NoPadding
  660. PPLoop:        call    PutIt
  661.         loop    PPLoop
  662. NoPadding:    pop    ax
  663.         ret
  664. PrintPad    endp
  665. ;
  666. ;
  667. ;
  668. ;
  669. ;
  670. ; GetPtr- Grabs the next pointer which DS:DI points at and returns this
  671. ;      far pointer in ES:BX.
  672. ;
  673. GetPtr        proc    near
  674.         les    bx, [di]
  675.         add    di, 4
  676. ;
  677. ; See if this is a handle rather than a pointer.
  678. ;
  679.         cmp    ah, '^'
  680.         jne    NotHandle
  681.         les    bx, es:[bx]
  682. NotHandle:    ret
  683. GetPtr        endp
  684. ;
  685. ;
  686. ;
  687. ;
  688. ;
  689. ; GetDecVal-    Converts the string of decimal digits in AL and [SI] into
  690. ;        an integer and returns this integer in CX.
  691. ;
  692. GetDecVal    proc    near
  693.         push    dx
  694.         dec    si
  695.         xor    cx, cx
  696. DecLoop:    lodsb
  697.         cmp    al, '0'
  698.         jb    NoMore
  699.         cmp    al, '9'
  700.         ja    NoMore
  701.         and    al, 0fh
  702.         shl    cx, 1            ;Compute CX := CX*10 + al
  703.         mov    dx, cx
  704.         shl    cx, 1
  705.         shl    cx, 1
  706.         add    cx, dx
  707.         add    cl, al
  708.         adc    ch, 0
  709.         jmp    DecLoop
  710. NoMore:        pop    dx
  711.         ret
  712. GetDecVal    endp
  713. ;
  714. ;
  715. ; PutItL - outputs the unsigned long value in AX to the string.
  716. ;
  717. PutItL        proc
  718.         push    bx cx es si ds di
  719.         call    sl_ltoa
  720.         call    ConCat
  721.         pop    di ds si es cx bx
  722.         ret
  723. PutItL        endp
  724. ;
  725. ;
  726. ; PutItUL - outputs the unsigned long value in AX to the string.
  727. ;
  728. PutItUL        proc
  729.         push    bx cx es si ds di
  730.         call    sl_ultoa
  731.         call    ConCat
  732.         pop    di ds si es cx bx
  733.         ret
  734. PutItUL        endp
  735. ;
  736. ;
  737. ;
  738. ; PutItw - outputs the hexadecimal value in AX to the string.
  739. ;
  740. PutItw        proc
  741.         push    bx cx es si ds di
  742.         call    sl_wtoa
  743.         call    ConCat
  744.         pop    di ds si es cx bx
  745.         ret
  746. PutItw        endp
  747. ;
  748. ; 
  749. ; PutIth - outputs the hexadecimal value in AL to the string.
  750. ;
  751. PutIth        proc
  752.         push    bx cx es si ds di
  753.         call    sl_htoa
  754.         call    ConCat
  755.         pop    di ds si es cx bx
  756.         ret
  757. PutIth        endp
  758. ;
  759. ;
  760. ;
  761. ; PutIti - outputs the integer in AX to the string.
  762. ;
  763. PutIti        proc
  764.         push    bx cx es si ds di
  765.         call    sl_itoa
  766.         call    ConCat
  767.         pop    di ds si es cx bx
  768.         ret
  769. PutIti        endp
  770. ;
  771. ;
  772. ; PutItu - outputs the unsigned integer in AX to the string.
  773. ;
  774. PutItu        proc
  775.         push    bx cx es si ds di
  776.         call    sl_utoa
  777.         call    ConCat
  778.         pop    di ds si es cx bx
  779.         ret
  780. PutItu        endp
  781. ;
  782. ;
  783. ;
  784. ; ConCat- Concatenates the string pointed at by ES:DI to the end of our
  785. ;      formatted string.
  786. ;
  787. ConCat        proc    near
  788.         push    di
  789.         lds    si, cs:aptr
  790.         mov    bx, cs:aindex
  791.         sub    di, bx
  792. PILp:        mov    al, es:[di][bx]
  793.         mov    [si][bx], al
  794.         inc    bx
  795.         cmp    al, 0
  796.         jne    PILp
  797.         dec    bx
  798.         mov    cs:aindex, bx
  799.         pop    di
  800.         call    sl_free
  801.         ret
  802. ConCat        endp
  803. ;
  804. ; PutIt writes the character in AL to the string buffer area.
  805. ;
  806. PutIt        proc
  807.         push    es si bx
  808.         mov    bx, cs:aindex
  809.         les    si, cs:aptr
  810.         mov    es:[si][bx], al
  811.         mov    byte ptr es:1[si][bx], 0
  812.         inc     cs:aindex
  813.         pop    bx si es
  814.         ret
  815. PutIt        endp
  816. ;
  817. stdlib        ends
  818.         end
  819.