Hall of Fame/HallofFameCDROM.cdr/proglc/tnylib.lzh/_XN.ASM

Assembly Source File | 1986-11-21 | 3.9 KB | 175 lines

include compiler.inc
    ttl    _XN, 1.04, 08-28-86 jwk

;binary to ascii conversion
;
;        call is _x?(n,bfr,base) unsigned long n; char *bfr;
;            int base; /* only _xn takes base */
;        BUFFER MUST BE AT LEAST 12 BYTES, NO CHECK MADE!!!
;
;
;    REGISTERS at entry--
;        AX:    unknown
;        BX:    unknown
;        CX:    unknown
;        DX:    unknown
;        SI:    unknown
;        DI:    unknown
;        BP:    Frame pointer of calling routine.
;        DS:    unknown
;        ES:    unknown
;
;          at exit--
;        AX:    Offset of "bfr" start, same as supplied.
;        BX:    zero
;        CX:    zero
;        DX:    Segment of "bfr" start (if not small model).
;        SI:    Restored.
;        DI:    Restored.
;        BP:    Restored.
;        DS:    Restored.
;        ES:    Segment of "bfr"
;
;    SIDE EFFECTS (including effect on RAM):
;        Converts its argument (as unsigned long) to ASCII,
;        using supplied base in range from 2 to 36 inclusive, and
;        stores characters in buffer as null-terminated string.
;

    dseg

    cseg

    procdef    _xn <<n1,word>,<n2,word>,<bfr,ptr>,<base,word>>
    pushreg
    mov    si,base
    jmp    short    xc
;
    entrdef    _xh
    pushreg
    mov    si,16
    jmp    short    xc
;
    entrdef    _xo
    pushreg
    mov    si,8
    jmp    short    xc
;
    entrdef    _xd
    pushreg
    mov    si,10

xc:
    mov    ax,n1        ;LSW of number
    mov    dx,n2        ;MSW of number
    ldptr    di,bfr        ;buffer address to use
    call    cvtl        ;macro not needed, no args to pass
    clc
    retptrm    bfr

    pend    _xn

    internal    cvtl
;
;    internal routine to perform the conversion and store chars
;    (chars are stored in reverse sequence, then un-reversed)
;
;    REGISTERS at entry--
;        AX:    LSW of number to convert
;        BX:    unknown
;        CX:    unknown
;        DX:    MSW of number to convert
;        SI:    base quantity (2 to 36)
;        DI:    buffer address offset to start
;        BP:    Frame pointer of calling routine (_xn).
;        DS:    unknown
;        ES:    buffer address segment
;
;          at exit--
;        AX:    last pair of chars swapped
;        BX:    zero
;        CX:    zero
;        DX:    zero
;        SI:    offset near middle of buffer
;        DI:    offset near middle of buffer
;        BP:    Restored
;        DS:    unchanged
;        ES:    buffer address segment
;
;    SIDE EFFECTS (including effect on RAM):
;        Stores remainders, converted to ASCII, at ES:DI,
;        then reverses chars in buffer to the correct sequence
;        using the K&P "swap the ends" algorithm.

    push    bp        ;don't use macro here; bp-4 offset
    mov    bp,sp        ;...must not be modified!
    push    di        ;save buffer start for "reverse"
    xor    bx,bx        ;clear work register
    push    bx        ;clear the dividend work reg
    cld            ;set for ascending STOSB action
    xchg    ax,bx
    stosb            ;put in terminating NULL first
    xchg    ax,bx
;
;    this does 32-bit division/remainder arithmetic
;
cv0:
    mov    cx,32        ;32 bits must be shifted
cv1:
    xchg    cx,[bp-4]    ;swap loop count/work reg
    shl    ax,1        ;puts 0 bit in quotient
    rcl    dx,1
    rcl    bx,1
    rcl    cx,1
    or    cx,cx        ;will it go?
    jnz    cv2        ;yes since base is < 8 bits
    cmp    si,bx        ;maybe...
    ja    cv3        ;no
cv2:
    sub    bx,si        ;32-bit subtract
    sbb    cx,0
    inc    ax        ;sets low bit of Q to 1
cv3:
    xchg    cx,[bp-4]    ;swap back
    loop    cv1        ;do it for all 32 bits
;
;    quotient in DX:AX, remainder ( < base ) in BL, BH==0
;
    xchg    ax,bx        ;set up to save remainder
    add    al,'0'        ;convert to ASCII
    cmp    al,'9'
    jbe    cv4        ;not in A-F range
    add    al,7        ;map to UC alpha
cv4:
    stosb            ;put it in buffer
    mov    al,ah        ;clear work reg for next time
    xchg    ax,bx        ;get LSW of quotient back
    or    ax,ax        ;and test for conversion done
    jnz    cv0        ;no, go do another divide
    or    dx,dx        ;maybe...
    jnz    cv0        ;no
;
;    this point is not reached until conversion is complete
;
cv5:
    pop    ax        ;balance the stack (work reg word)
    pop    si        ;offset to front of buffer
cv6:
    dec    di
    cmp    si,di        ;check for overlap (or same)
    jae    cv7        ;yep, all swapped around
    mov    ah,es:[si]    ; note that lodsb/stosb would
    mov    al,es:[di]    ; take more code because one
    mov    es:[di],ah    ; is incrementing while the
    mov    es:[si],al    ; other is decrementing
    inc    si
    jmp    cv6
cv7:
    mov    sp,bp
    pop    bp
    ret

cvtl    endp            ;pend macro is only for public procs
;
    finish