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

Assembly Source File | 1990-06-25 | 10.4 KB | 525 lines

stdlib        segment    para public 'slcode'
        assume    cs:stdlib
    extrn sl_print:far,sl_putw:far, sl_putcr:far
print    macro
 call sl_print
  endm
;
        extrn    sl_gets:far, sl_free:far, sl_atoi2:far
        extrn    sl_atou2:far, sl_atol2:far, sl_atoul2:far
        extrn    sl_atoh2:far
;
;
; Scanf- Like the "C" routine by the same name.  Calling sequence:
;
;               call    scanf
;               db      "format string",0
;               dd      item1, item2, ..., itemn
;
; The format string is identical to "C".  Item1..Itemn are pointers to
; values to print for this string.  Each item must be matched by the
; corresponding "%xxx" item in the format string.
;
; Format string format:
;
; 1)    If a non-whitespace character in the format string matches the next
;    input character, scanf eats that input character;  otherwise scanf
;    ignores the character in the format string.  If any whitespace char-
;    acter appears, scanf ignores all leading whitespace characters (new-
;    line not included) before an item.  If there is no whitespace on the
;    input, scanf ignores the whitespace characters in the input stream.
;
; 2)    Format Control Strings:
;
;    General format:  "%^f" where:
;
;                ^ = ^
;                f = a format character
;
;            The "^" is optional.
;
;    ^ present    The address associated with f is the address of a
;                pointer to the object, not the address of
;                the object itself.  The pointer is a far ptr.
;
;    f is one of the following
;
;        d -    Read a signed integer in decimal notation.
;        i -    Read a signed integer in decimal notation.
;        x -    Read a word value in hexadecimal notation.
;        h -    Read a byte value in hexadecimal notation.
;        u -    Read an unsigned integer in decimal notation.
;        c -    Read a character.
;        s -    Read a string.
;
;        ld-    Read a long signed integer.
;        li-    Read a long signed integer.
;        lx-    Read a long hexadecimal number.
;        lu-    Read a long unsigned number.
;
;
;    Calling Sequence:
;
;        call    Scanf
;        db    "Format String",0
;        dd    adrs1, adrs2, ..., adrsn
;
;    Where the format string is ala "C" (and the descriptions above)
;    and adrs1..adrsn are addresses (far ptr) to the items to print.
;    Unless the "^" modifier is present, these addresses are the actual
;    addresses of the objects to print.
;
; Note: Scanf always calls GETS to read a new string from the standard
;    input device.  Reading a string variable always reads all input
;    from the current position to the end of the current line.
;
;
cr        equ    0dh
ff        equ    0ch
lf        equ    0ah
tab        equ    09h
bs        equ    08h
;
RtnAdrs        equ    2[bp]
OprndPtr    equ    -4[bp]
InputPtr    equ    -8[bp]
InpIndex    equ    -10[bp]
;
        public  sl_scanf
sl_scanf    proc    far
;
; Read a line from the standard input and save away a pointer to it.
;
        push    bp
        mov    bp, sp
        sub    sp, 10            ;Save ptr to operands here.
        pushf
        push    ax
        push    bx
        push    cx
        push    dx
        push    di
        push    si
        push    es
        push    ds
;
        call    sl_gets
        call    scanf
        les    di, InputPtr
        call    sl_free
        mov    di, OprndPtr
        mov    RtnAdrs, di    ;Put out new return address.
;
        pop    ds
        pop    es
        pop    si
        pop    di
        pop    dx
        pop    cx
        pop    bx
        pop    ax
        popf
        mov    sp, bp        ;Remove local variables.
        pop    bp
        ret
;
sl_scanf    endp
;
;
; SSCANF-    Just like SCANF except you pass a pointer to the data
;        string in es:di rather than having scanf read it from
;        the keyboard.
;
        public    sl_sscanf
sl_sscanf    proc    far
        push    bp
        mov    bp, sp
        sub    sp, 10            ;Save ptr to operands here.
        pushf
        push    ax
        push    bx
        push    cx
        push    dx
        push    di
        push    si
        push    es
        push    ds
;
        call    scanf
        mov    di, OprndPtr
        mov    RtnAdrs, di    ;Put out new return address.
;
        pop    ds
        pop    es
        pop    si
        pop    di
        pop    dx
        pop    cx
        pop    bx
        pop    ax
        popf
        mov    sp, bp        ;Remove local variables.
        pop    bp
        ret
sl_sscanf    endp
;
;
; "Guts" of the scanf routines.
;
scanf        proc    near
        mov    InputPtr+2, es        ;Sock away ptr to string.
        mov    InputPtr, di
        mov    word ptr InpIndex, 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
        mov     OprndPtr, di
        mov    OprndPtr+2, es
;
ScanItems:      lodsb            ;Get char si points at.
ScanItems2:    cmp    al, 0        ;EOS?
        jz    ScanfDone
        cmp    al, "%"        ;Start of a format string?
        jz    FmtItem
SkipIt:        cmp    al, " "
        jz    SkipWS
        les    di, InputPtr
        mov    bx, InpIndex
        cmp    al, es:[di][bx]
        jnz    ScanItems
        inc    word ptr InpIndex
        jmp    ScanItems
;
SkipWS:        les    di, InputPtr
        mov    bx, InpIndex
SkipWSLp:    cmp    byte ptr es:[di][bx], ' '
        jnz    DoneSkip
        inc    bx
        jmp    SkipWSLp
;
DoneSkip:    mov    InpIndex, bx
Skip2:        lodsb
        cmp    al, ' '            ;Skip additional whitespace
        jz    Skip2            ; in the format string.
        dec    si
        jmp    ScanItems
;
;
FmtItem:    call    GetFmtItem    ;Process the format item here.
        jmp    ScanItems
;
;
ScanfDone:        ret
scanf        endp
;
;
;
; If we just saw a "%", come down here to handle the format item.
;
GetFmtItem    proc    near
;
        lodsb                ;Get char beyond "%"
;
; See if the user wants to specify a handle rather than a straight pointer
;
        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    GetDec
        cmp    al, 'I'
        je    GetDec
        cmp    al, 'C'
        je    GetChar
;
        cmp    al, 'X'
        jne    TryH
        jmp    GetHexWord
;
TryH:        cmp    al, 'H'
        jne    TryU
        jmp    GetHexByte
;
TryU:        cmp    al, 'U'
        jne    TryString
        jmp    GetUDec
;
TryString:    cmp    al, 'S'
        jne    TryLong
        jmp    GetString
;
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    Default
        jmp    LongU
;
;
;
; If none of the above, simply return without printing anything.
;
Default:    ret
;
;
;
;
;
; Get a signed decimal value here.
;
GetDec:        call    GetPtr            ;Get next pointer into ES:BX
        push    ax            ;Save possible "^" char in ah
        push    es
        les    di, InputPtr
        add    di, InpIndex        ;Point SI at integer.
        cmp    byte ptr es:[di], 0    ;At end of string?
        jz    QuitGetDec
        call    sl_atoi2        ;Convert to integer in AX.
        sub    di, InputPtr
        mov    InpIndex, di
        pop    es                 ; Ignore overflow or error.
        mov    es:[bx], ax
;
        pop    ax
        ret
;
QuitGetDec:    pop    es
        pop    ax
        ret                ;We're done!
;
;
;
; Print a character variable here.
;
GetChar:    call    GetPtr            ;Get next pointer into ES:BX
        push    ax            ;Save possible "^" char in ah
        push    es
        les    di, InputPtr
        add    di, InpIndex        ;Point SI at char.
        mov    al, es:[di]        ;Get char
        cmp    al, 0            ;See if at EOS.
        jz    QuitGetChar
        inc    word ptr InpIndex    ;Bump up index.
        pop    es
        mov    es:[bx], al
;
        pop    ax
        ret
;
QuitGetChar:    pop    es
        pop    ax
        ret                ;We're done!
;
;
;
; Print a hexadecimal word value here.
;
GetHexWord:    call    GetPtr            ;Get next pointer into ES:BX
        push    ax            ;Save possible "^" char in ah
        push    es
        les    di, InputPtr
        add    di, InpIndex        ;Point SI at integer.
        cmp    byte ptr es:[di], 0    ;Check for EOS
        jz    QuitGetHexWord
        call    sl_atoh2        ;Convert to integer in AX.
        sub    di, InputPtr
        mov    InpIndex, di
        pop    es                 ; Ignore overflow or error.
        mov    es:[bx], ax
;
        pop    ax
        ret
;
QuitGetHexWord:    pop    es
        pop    ax
        ret                ;We're done!
;
;
;
;
; Print hex bytes here.
;
;
GetHexByte:    call    GetPtr            ;Get next pointer into ES:BX
        push    ax            ;Save possible "^" char in ah
        push    es
        les    di, InputPtr
        add    di, InpIndex        ;Point SI at integer.
        cmp    byte ptr es:[di], 0    ;Check for EOS.
        jz    QuitGetHexByte
        call    sl_atoh2        ;Convert to integer in AX.
        sub    di, InputPtr
        mov    InpIndex, di
        pop    es                 ; Ignore overflow or error.
        mov    es:[bx], al
;
        pop    ax
        ret
;
QuitGetHexByte:    pop    es
        pop    ax
        ret                ;We're done!
;
;
;
; Output unsigned decimal numbers here:
;
GetUDec:    call    GetPtr            ;Get next pointer into ES:BX
        push    ax            ;Save possible "^" char in ah
        push    es
        les    di, InputPtr
        add    di, InpIndex        ;Point SI at integer.
        cmp    byte ptr es:[di], 0    ;Check for EOS.
        jz    QuitGetUDec
        call    sl_atou2        ;Convert to integer in AX.
        sub    di, InputPtr
        mov    InpIndex, di
        pop    es                 ; Ignore overflow or error.
        mov    es:[bx], ax
;
        pop    ax
        ret
;
QuitGetUDec:    pop    es
        pop    ax
        ret                ;We're done!
;
;
; Output a string here:
;
GetString:    push    ax
        push    si
        push    es
        push    ds
;
        call    GetPtr
        mov    di, bx
        lds    si, InputPtr
        add    si, InpIndex
GetStrLp:    lodsb            ;Get next char
        stosb
        cmp    al, 0
        jnz    GetStrLp
        sub    si, InputPtr
        dec    si
        mov    InpIndex, si
;
        pop    ds
        pop    es
        pop    si
        pop    ax
        ret                ;We're done!
;
;
;
; Print a signed long decimal value here.
;
LongDec:    push    dx
        call    GetPtr            ;Get next pointer into ES:BX
        push    ax            ;Save possible "^" char in ah
        push    es
        les    di, InputPtr
        add    di, InpIndex        ;Point SI at integer.
        cmp    byte ptr es:[di], 0    ;Check for EOS.
        jz    QuitLongDec
        call    sl_atol2        ;Convert to integer in AX.
        sub    di, InputPtr
        mov    InpIndex, di
        pop    es                 ; Ignore overflow or error.
        mov    es:[bx], ax
        mov    es:2[bx], dx
;
        pop    ax
        pop    dx
        ret                ;We're done!
;
QuitLongDec:    pop    es
        pop    ax
        pop    dx
        ret
;
;
;
; Print an unsigned long decimal value here.
;
LongU:        push    dx
        call    GetPtr            ;Get next pointer into ES:BX
        push    ax            ;Save possible "^" char in ah
        push    es
        les    di, InputPtr
        add    di, InpIndex        ;Point SI at integer.
        cmp    byte ptr es:[di], 0
        je    QuitLongU
        call    sl_atoul2        ;Convert to integer in AX.
        sub    di, InputPtr
        mov    InpIndex, di
        pop    es                 ; Ignore overflow or error.
        mov    es:[bx], ax
        mov    es:2[bx], dx
;
        pop    ax
        pop    dx
        ret                ;We're done!
;
QuitLongU:    pop    es
        pop    ax
        pop    dx
        ret
;
GetFmtItem    endp
;
;
;
;
;
;
; GetPtr- Grabs the next pointer which OprndPtr points at and returns this
;      far pointer in ES:BX.
;
GetPtr        proc    near
        les    di, OprndPtr
        les    bx, es:[di]
        add    word ptr OprndPtr, 4
;
; See if this is a handle rather than a pointer.
;
        cmp    ah, '^'
        jne    NotHandle
        les    bx, es:[bx]
NotHandle:    ret
GetPtr        endp
;
;
;
;
stdlib        ends
        end