ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/PROG/ASSEMBLY/STDLIB.ZIP/SPRINTF.ASM

Assembly Source File | 1990-07-09 | 15.6 KB | 819 lines

stdlib        segment    para public 'slcode'
        assume    cs:stdlib
        extrn    sl_ISize:far, sl_ULSize:far
        extrn    sl_LSize:far, sl_USize:far
        extrn    sl_itoa:far, sl_free:far
        extrn    sl_wtoa:far, sl_ltoa:far
        extrn    sl_ultoa:far, sl_htoa:far
        extrn    sl_utoa:far
        extrn    sl_malloc:far, sl_realloc:far
;
;
;
; Sprintf- Like the "C" routine by the same name.  Calling sequence:
;
;               call    sprintf
;               db      "format string",0
;               dd      item1, item2, ..., itemn
;
; Just like the PRINTF routine except it performs an in-memory format
; operation rather than printing the data to the current output device.
; Returns a pointer to the formatted string in ES:DI.
; See the PRINTF routine for more details about this guy.
;
;
cr        equ    0dh
ff        equ    0ch
lf        equ    0ah
tab        equ    09h
bs        equ    08h
;
RtnAdrs        equ    2[bp]
;
;
;
aindex        dw    ?
aptr        dd    ?
;
;
; sp_BufSize is a public variable so the user can adjust the size.
;
        public    sp_BufSize
sp_BufSize    dw    2048
;
;
        public    sl_sprintf
sl_sprintf    proc    far
        push    bp
        mov    bp, sp
        pushf
        push    ax cx
;
; Request some memory from the system.  If there isn't enough available,
; try half as much and repeat.  If there is no memory available, return
; with the carry set.
;
        mov    cx, sp_BufSize
TryAgain:    call    sl_malloc
        jnc    DoSPRINTF
        shr    cx, 1
        cmp    cx, 128            ;Need at least 128 bytes.
        jae    TryAgain
        pop    cx ax
        popf
                pop    bp
        stc
        ret
;
; The following code simulates a far call to sbprintf.  We can't make the
; call because we need to skip the MOV BP, SP instruction which appears
; at the beginning of the code.
;
DoSPRINTF:         push    cs            ;Push fake return address
        mov    ax, offset RA
        push    ax
        push    bp            ;Push stuff on stack
        pushf
        push    ax bx cx dx di si es ds
        jmp    sl_sbprintf2
;
; Return back to this point from sbprintf.
;
RA:        push    di
        mov    cx, 1
        mov    al, ch
FindLength:    cmp    al, es:[di]
        jz    AtEnd
        inc    cx
        inc    di
        jmp    FindLength
;
AtEnd:        pop    di
        call    sl_realloc
        pop    cx ax
        popf
                pop    bp
        clc
        ret
sl_sprintf    endp
;
;
;
;
; SBPRINTF- Like sprintf except it doesn't allocate storage for the
; formatted string.  Instead, you must pass it the address of a suitable
; buffer in es:di.
;
;
        public  sl_sbprintf
sl_sbprintf    proc    far
        push    bp
        mov    bp, sp
        pushf
        push    ax bx cx dx di si es ds
;
; Save ptr to buffer area.
;
sl_sbprintf2:    mov    word ptr cs:aptr, di
        mov    word ptr cs:aptr+2, es
        mov    cs:aindex, 0
;
; Get pointers to the return address (format string).
;
        cld
        les    di, RtnAdrs
        lds    si, RtnAdrs
;
; Okay, search for the end of the format string.  After these instructions,
; di points just beyond the zero byte at the end of the format string.  This,
; of course, points at the first address beyond the format string.
;
        mov    al, 0
        mov    cx, 65535
    repne    scasb
;
PrintItems:    lodsb            ;Get char si points at.
        cmp    al, 0        ;EOS?
        jz    PrintfDone
        cmp    al, "%"        ;Start of a format string?
        jz    FmtItem
        cmp    al, "\"        ;Escape character?
        jnz    PrintIt
        call    GetEscChar
PrintIt:    call    PutIt
        jmp    PrintItems
;
FmtItem:    call    GetFmtItem    ;Process the format item here.
        jmp    PrintItems
;
PrintfDone:    mov    RtnAdrs, di    ;Put out new return address.
        pop    ds
        pop    es
        pop    si
        pop    di
        pop    dx
        pop    cx
        pop    bx
        pop    ax
        pop    bp
        popf
        clc
        ret
sl_sbprintf    endp
;
; GetEscChar- Handles items immediately following the escape character "\".
;
;    Special escape characters (upper/lower case is acceptable):
;
;        n    Newline (cr/lf)
;        t    tab
;        b    backspace
;        r    return
;        l    line feed
;        f    formfeed
;        \    \
;        %    &
;        0xhh    Char with hex character code hh.  Must have exactly
;            two hexadecimal digits.
;
GetEscChar    proc    near
        lodsb            ;Get next character
        cmp    al, 'n'
        je    RtnNL
        cmp    al, 'N'
        je    RtnNL
        cmp    al, 't'
        je    RtnTab
        cmp    al, 'T'
        je    RtnTab
        cmp    al, 'b'
        je    RtnBS
        cmp    al, 'B'
        je    RtnBS
        cmp    al, 'r'
        je    RtnRtn
        cmp    al, 'R'
        je    RtnRtn
        cmp    al, 'l'
        je    RtnLF
        cmp    al, 'L'
        je    RtnLF
        cmp    al, 'f'
        je    RtnFF
        cmp    al, 'F'
        je    RtnFF
;
; Check for the presence of a 0xhh value here:
;
        cmp    al, '0'
        jne    RtnChar
        cmp    byte ptr [si], 'x'
        je    GetHex
        cmp    byte ptr [si], 'X'
        jne    RtnChar
;
; Okay, process the hex value here.  Note that exactly two hex digits must
; follow the 0x.
;
GetHex:        inc    si        ;Point at first hex digit.
        lodsb            ;Get first hex digit.
        and    al, 05fh    ;l.c. -> u.c.
        cmp    al, 'A'
        jb    GotIt
        sub    al, '7'
GotIt:        shl    al, 1        ;Put into H.O. nibble.
        shl    al, 1
        shl    al, 1
        shl    al, 1
        mov    ah, al        ;Save for later
        lodsb            ;Get next char.
        and    al, 05fh
        cmp    al, 'A'
        jb    GotIt2
        sub    al, '7'
GotIt2:        and    al, 0fh
        or    al, ah
        ret            ;Return hex constant.
;
; RtnNL (return Newline) cheats.  It needs to return two characters.
; Since GetEscChar only returns a single character, this code goes ahead
; and calls putc to output the CR and the returns the LF.
;
RtnNL:        mov    al, cr
        call    PutIt
        mov    al, lf
        ret
;
RtnTab:        mov    al, tab
        ret
;
RtnBS:        mov    al, bs
        ret
;
RtnRtn:        mov    al, cr
        ret
;
RtnLF:        mov    al, lf
        ret
;
RtnFF:        mov    al, ff
RtnChar:    ret
;
GetEscChar    endp
;
;
;
GetFmtItem    proc    near
        lodsb                ;Get char beyond "%"
;
        mov    cx, 1            ;Default field width is 1.
        mov    dl, 0            ;Default is right justified
        mov    dh, ' '            ;Default fill char is space.
        mov    ah, ' '            ;Assume straight ptr, not handle.
;
; See if the user wants the value left justified:
;
        cmp    al, '-'
        jne    NotLeftJust
        inc    dl            ;Set to right justified
        lodsb                ;Get next character.
;
; See if the user wants to change the padding character.
;
NotLeftJust:    cmp    al, '\'
        jne    NoPadChange
        lodsb                ;Get Padding Character.
        mov    dh, al            ;Save padding character.
        lodsb                ;Get next character
;
; See if the user wants a different field width:
;
NoPadChange:    cmp    al, '0'
        jb    NoFldWidth
        cmp    al, '9'
        ja    NoFldWidth
        call    GetDecVal
;
; See if the user wants to specify a handle rather than a straight pointer
;
NoFldWidth:    cmp    al, '^'
        jne     ChkFmtChars
        mov    ah, al
        lodsb                ;Skip "^" character
;
; Okay, process the format characters down here.
;
ChkFmtChars:    and    al, 05fh        ;l.c. -> U.C.
        cmp    al, 'D'
        je    PrintDec
        cmp    al, 'I'
        je    PrintDec
        cmp    al, 'C'
        je    PrintChar
;
        cmp    al, 'X'
        jne    TryH
        jmp    PrintHexWord
;
TryH:        cmp    al, 'H'
        jne    TryU
        jmp    PrintHexByte
;
TryU:        cmp    al, 'U'
        jne    TryString
        jmp    PrintUDec
;
TryString:    cmp    al, 'S'
        jne    TryLong
        jmp    PrintString
;
TryLong:    cmp    al, 'L'
        jne    Default
;
; If we've got the "L" modifier, this is a long value to print, get the
; data type character as the next value:
;
        lodsb
        and    al, 05fh        ;l.c. -> U.C.
        cmp    al, 'D'
        je    JmpDec
        cmp    al, 'I'
        jne    TryLU
JmpDec:        jmp    LongDec
;
TryLU:        cmp    al, 'U'
        jne    TryX
        jmp    LongU
;
TryX:        cmp    al, 'X'
        jne    Default
        jmp    LongX
;
;
;
; If none of the above, simply return without printing anything.
;
Default:        ret
;
;
;
;
;
; Print a signed decimal value here.
;
PrintDec:    call    GetPtr            ;Get next pointer into ES:BX
        mov    ax, es:[bx]        ;Get value to print.
        call    sl_ISize        ;Get the size of this guy.
        sub    cx, ax                 ;Compute padding
        mov    ax, es:[bx]        ;Retrieve value to print.
        js    NoPadDec        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustDec
        call    PrintPad        ;Print padding characters
        call    PutIti            ;Print the integer
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustDec:    call    PutIti
        call    PrintPad
        ret
;
; Print non-justified value here:
;
NoPadDec:    call    PutIti
        ret
;
;
;
; Print a character variable here.
;
PrintChar:    call    GetPtr            ;Get next pointer into ES:BX
        mov    al, es:[bx]        ;Retrieve value to print.
                dec    cx
        js    NoPadChar        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustChar
        call    PrintPad        ;Print padding characters
        call    PutIt            ;Print the character
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustChar:    call    PutIt
        call    PrintPad
        ret
;
; Print non-justified character here:
;
NoPadChar:    call    PutIt
        ret
;
;
;
;
; Print a hexadecimal word value here.
;
PrintHexWord:    call    GetPtr            ;Get next pointer into ES:BX
        mov    ax, es:[bx]        ;Get value to print.
        sub    cx, 4            ;Compute padding
        js    NoPadHexW        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustHexW
        call    PrintPad        ;Print padding characters
        call    PutItw            ;Print the hex value
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustHexW:    call    PutItw
        call    PrintPad
        ret
;
; Print non-justified value here:
;
NoPadHexW:    call    PutItw
        ret
;
;
;
;
; Print hex bytes here.
;
;
PrintHexByte:    call    GetPtr            ;Get next pointer into ES:BX
        mov    ax, es:[bx]        ;Get value to print.
        sub    cx, 4            ;Compute padding
        js    NoPadHexB        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustHexB
        call    PrintPad        ;Print padding characters
        call    PutIth            ;Print the hex value
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustHexB:    call    PutIth
        call    PrintPad
        ret
;
; Print non-justified value here:
;
NoPadHexB:    call    PutIth
        ret
;
;
;
; Output unsigned decimal numbers here:
;
PrintUDec:    call    GetPtr            ;Get next pointer into ES:BX
        mov    ax, es:[bx]        ;Get value to print.
        call    sl_USize        ;Get the size of this guy.
        sub    cx, ax                 ;Compute padding
        mov    ax, es:[bx]        ;Retrieve value to print.
        js    NoPadUDec        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustUDec
        call    PrintPad        ;Print padding characters
        call    PutItu            ;Print the integer
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustUDec:    call    PutItu
        call    PrintPad
        ret
;
; Print non-justified value here:
;
NoPadUDec:    call    PutItu
        ret
;
;
;
;
; Output a string here:
;
PrintString:    call    GetPtr            ;Get next pointer into ES:BX
;
; Compute the length of the string:
;
        push    di
        push    cx
        mov    cx, -1
        mov    di, bx
        mov    al, 0
    repne    scasb
        mov    ax, cx
        neg    ax
        dec    ax
        dec    ax
        pop    cx
        pop    di
        sub    cx, ax            ;Field width - String Length.
;
        js    NoPadStr        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustStr
        call    PrintPad        ;Print padding characters
        call    Puts            ;Print the string
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustStr:    call    Puts
        call    PrintPad
        ret
;
; Print non-justified value here:
;
NoPadStr:    call    Puts
        ret
GetFmtItem    endp
;
;
;
; Print a signed long decimal value here.
;
LongDec:    call    GetPtr            ;Get next pointer into ES:BX
        mov    ax, es:[bx]        ;Get value to print.
        push    dx
        mov    dx, es:2[bx]
        call    sl_LSize        ;Get the size of this guy.
        pop    dx
        sub    cx, ax                 ;Compute padding
        mov    ax, es:[bx]        ;Retrieve value to print.
        js    NoPadLong        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustLong
        call    PrintPad        ;Print padding characters
        mov    dx, es:2[bx]        ;Get H.O. word
        call    PutItL            ;Print the integer
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustLong:    push    dx
        mov    dx, es:2[bx]        ;Get H.O. word
        call    PutItL
        pop    dx
        call    PrintPad
        ret
;
; Print non-justified value here:
;
NoPadLong:    mov    dx, es:2[bx]        ;Get H.O. word
        call    PutItl
        ret
;
;
; Print an unsigned long decimal value here.
;
LongU:        call    GetPtr            ;Get next pointer into ES:BX
        mov    ax, es:[bx]        ;Get value to print.
        push    dx
        mov    dx, es:[bx]
        call    sl_ULSize        ;Get the size of this guy.
        pop    dx
        sub    cx, ax                 ;Compute padding
        mov    ax, es:[bx]        ;Retrieve value to print.
        js    NoPadULong        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustULong
        call    PrintPad        ;Print padding characters
        mov    dx, es:2[bx]        ;Get H.O. word
        call    PutItUL            ;Print the integer
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustULong:    mov    dx, es:2[bx]        ;Get H.O. word
        call    PutItUL
        call    PrintPad
        ret
;
; Print non-justified value here:
;
NoPadULong:    mov    dx, es:2[bx]        ;Get H.O. word
        call    Putitul
        ret
;
;
; Print a long hexadecimal value here.
;
LongX:        call    GetPtr            ;Get next pointer into ES:BX
        sub    cx, 8            ;Compute padding
        js    NoPadXLong        ;Is CX negative?
        cmp    dl, 0            ;Right justified?
        jne    LeftJustXLong
        call    PrintPad        ;Print padding characters
        mov    ax, es:2[bx]        ;Get H.O. word
        call    PutItw
        mov    ax, es:[bx]
        call    PutItw
        ret                ;We're done!
;
; Print left justified value here.
;
LeftJustxLong:    mov    ax, es:2[bx]        ;Get H.O. word
        call    PutItw
        mov    ax, es:[bx]        ;Get L.O. word
        call    PutItw
        call    PrintPad
        ret
;
; Print non-justified value here:
;
NoPadxLong:    mov    ax, es:2[bx]        ;Get H.O. word
        call    PutItw
        mov    ax, es:[bx]
        call    PutItw
        ret
;
;
;
;
; Puts- Outputs the zero terminated string pointed at by ES:BX.
;
Puts        proc    near
PutsLp:        mov    al, es:[bx]
        cmp    al, 0
        je    PutsDone
        call    putIt
        inc    bx
        jmp    PutsLp
;
PutsDone:    ret
Puts        endp
;
;
;
;
;
; PrintPad-    Prints padding characters.  Character to print is in DH.
;        We must print it CX times.  CX must be greater than zero.
;
PrintPad    proc    near
        push    ax
        mov    al, dh
        jcxz    NoPadding
PPLoop:        call    PutIt
        loop    PPLoop
NoPadding:    pop    ax
        ret
PrintPad    endp
;
;
;
;
;
; GetPtr- Grabs the next pointer which DS:DI points at and returns this
;      far pointer in ES:BX.
;
GetPtr        proc    near
        les    bx, [di]
        add    di, 4
;
; See if this is a handle rather than a pointer.
;
        cmp    ah, '^'
        jne    NotHandle
        les    bx, es:[bx]
NotHandle:    ret
GetPtr        endp
;
;
;
;
;
; GetDecVal-    Converts the string of decimal digits in AL and [SI] into
;        an integer and returns this integer in CX.
;
GetDecVal    proc    near
        push    dx
        dec    si
        xor    cx, cx
DecLoop:    lodsb
        cmp    al, '0'
        jb    NoMore
        cmp    al, '9'
        ja    NoMore
        and    al, 0fh
        shl    cx, 1            ;Compute CX := CX*10 + al
        mov    dx, cx
        shl    cx, 1
        shl    cx, 1
        add    cx, dx
        add    cl, al
        adc    ch, 0
        jmp    DecLoop
NoMore:        pop    dx
        ret
GetDecVal    endp
;
;
; PutItL - outputs the unsigned long value in AX to the string.
;
PutItL        proc
        push    bx cx es si ds di
        call    sl_ltoa
        call    ConCat
        pop    di ds si es cx bx
        ret
PutItL        endp
;
;
; PutItUL - outputs the unsigned long value in AX to the string.
;
PutItUL        proc
        push    bx cx es si ds di
        call    sl_ultoa
        call    ConCat
        pop    di ds si es cx bx
        ret
PutItUL        endp
;
;
;
; PutItw - outputs the hexadecimal value in AX to the string.
;
PutItw        proc
        push    bx cx es si ds di
        call    sl_wtoa
        call    ConCat
        pop    di ds si es cx bx
        ret
PutItw        endp
;
;
; PutIth - outputs the hexadecimal value in AL to the string.
;
PutIth        proc
        push    bx cx es si ds di
        call    sl_htoa
        call    ConCat
        pop    di ds si es cx bx
        ret
PutIth        endp
;
;
;
; PutIti - outputs the integer in AX to the string.
;
PutIti        proc
        push    bx cx es si ds di
        call    sl_itoa
        call    ConCat
        pop    di ds si es cx bx
        ret
PutIti        endp
;
;
; PutItu - outputs the unsigned integer in AX to the string.
;
PutItu        proc
        push    bx cx es si ds di
        call    sl_utoa
        call    ConCat
        pop    di ds si es cx bx
        ret
PutItu        endp
;
;
;
; ConCat- Concatenates the string pointed at by ES:DI to the end of our
;      formatted string.
;
ConCat        proc    near
        push    di
        lds    si, cs:aptr
        mov    bx, cs:aindex
        sub    di, bx
PILp:        mov    al, es:[di][bx]
        mov    [si][bx], al
        inc    bx
        cmp    al, 0
        jne    PILp
        dec    bx
        mov    cs:aindex, bx
        pop    di
        call    sl_free
        ret
ConCat        endp
;
; PutIt writes the character in AL to the string buffer area.
;
PutIt        proc
        push    es si bx
        mov    bx, cs:aindex
        les    si, cs:aptr
        mov    es:[si][bx], al
        mov    byte ptr es:1[si][bx], 0
        inc     cs:aindex
        pop    bx si es
        ret
PutIt        endp
;
stdlib        ends
        end