Programmer 7500/MAX_PROGRAMMERS.iso/INFO/ARC_LBR/LHA211SR.ZIP/LHASRC.EXE/CRCIO_.ASM

Assembly Source File | 1991-03-03 | 5.5 KB | 376 lines

;***********************************************
;    crcio_.asm -- input/output
;***********************************************
            page    0, 128

include    amscls.inc
$_init    GEN

CGROUP    GROUP    TEXT
DGROUP    GROUP    DATA,BSS

TEXT    segment byte public 'CODE'
    assume    cs:CGROUP, ds:DGROUP, ss:DGROUP
TEXT    ends

DATA    segment byte public 'DATA'
DATA    ends

BSS    segment byte public 'DATA'
            public    infile_
infile_        dw    1 dup (?)
            public    outfile_
outfile_    dw    1 dup (?)
            public    dispflg_
dispflg_    dw    1 dup (?)

crctable_    dw    100h dup (?)
            public    crc_
crc_        dw    1 dup (?)
            public    bitbuf_
bitbuf_        dw    1 dup (?)

subbitbuf_    db    1 dup (?)
bitcount_    db    1 dup (?)


BSS    ends
TEXT    segment byte public 'CODE'
    assume    cs:CGROUP, ds:DGROUP, ss:DGROUP

;
;void make_crctable(uchar crcpoly)
;

    public    make_crctable_
make_crctable_:
    cld
    push    ds
    pop        es
    push    cx
    push    dx
    push    di
    mov        bx, ax
    mov     di, offset DGROUP:crctable_
    xor     dx, dx
    $_do
        mov     ax, dx
        mov     cx, 8
        $_do
            $_if <shr ax, 1>, C
                xor     ax, bx
            $_endif
        $_until <LOOP>
        stosw
    $_until <inc dl>, Z
    pop     di
    pop     dx
    pop     cx
    ret

;
;ushort calccrc(uchar *p, uint n)
;

    public    calccrc_
calccrc_:
    push    cx
    push    si
    mov        si, ax
    mov        cx, bx
    mov        bx, crc_
    jcxz    nofile
    xor        ah, ah
    cld
    $_do
        lodsb
        xor        bl, al
        mov        al, bh
        mov        bh, ah
        shl        bx, 1
        mov        bx, crctable_[bx]
        xor        bx, ax
    $_until <LOOP>
nofile:
    mov        ax, bx
    mov        crc_, ax
    pop        si
    pop        cx
    ret

;
;ushort getbits(uchar n)
;

    public    getbits_
getbits_:
    push    cx
    mov        cl, 16
    sub        cl, al
    push    bitbuf_
    call    fillbuf_
    pop        ax
    shr        ax, cl
    pop        cx
    ret

;
;    stream control structure of LSI C-86
;

iob        struc
mode        db        ?
ptr            dw        ?
rcount        dw        ?
wcount        dw        ?
base        dw        ?
bufsiz        dw        ?
fd            dw        ?
smallbuf    db        ?
iob        ends

;
;void fillbuf(uchar n)  /* Shift bitbuf n bits left, read n bits */
;

    public    fillbuf_
fillbuf_:
    push    cx
    push    dx
    mov        ch, al
    mov        cl, bitcount_
    mov        dx, bitbuf_
    mov        al, subbitbuf_
    $_if <cmp ch, cl>, A
        sub        ch, cl
        shl        dx, cl
        rol        al, cl
        add        dl, al
        mov        cl, 8
fb1:
        xor        ax, ax
        sub        word ptr compsize_, 1
        sbb        word ptr compsize_ + 2, ax
        $_if , NS
            mov        bx, infile_
            $_if <dec rcount[bx]>, NS
                inc        ptr[bx]
                mov        bx, ptr[bx]
                mov        al, [bx - 1]
            $_else
                mov        ax, bx
                push    bx
                call    fgetc_
                pop        bx
                $_if <or ax, ax>, S
                    mov        ax, offset DGROUP:RDERR_
                    jmp        fileerror_
                $_endif
            $_endif
        $_endif
        $_if <cmp ch, cl>, A
            sub        ch, cl
            mov        dh, dl
            mov        dl, al
            jmp        fb1
        $_endif
    $_endif
    sub        cl, ch
    mov        bitcount_, cl
    mov        cl, ch
    xor        ah, ah
    shl        dx, cl
    shl        ax, cl
    add        dl, ah
    mov        bitbuf_, dx
    mov        subbitbuf_, al
    pop        dx
    pop        cx
    ret


;
;void putbits(uchar n, ushort x)  /* Write rightmost n bits of x */
;

    public    putbits_
putbits_:
    push    cx
    mov        cl, 16
    sub        cl, al
    shl        bx, cl
    pop        cx


;
;void putcode(uchar n, ushort x)  /* Write rightmost n bits of x */
;
    public    putcode_
putcode_:

    push    cx
    push    dx
    mov        ch, al
    mov        cl, bitcount_
    mov        al, subbitbuf_
    $_if <cmp ch, cl>, B
        rol        bh, cl
        or        al, bh
        mov        subbitbuf_, al
        sub        cl, ch
        mov        bitcount_, cl
        pop        dx
        pop        cx
        ret
    $_endif
    sub        ch, cl

    xor        dh, dh
    mov        dl, bh
    shl        dx, cl

    shl        bx, cl
    or        al, dh
    mov        dx, bx
    mov        cl, 8
pc1:
    sub        word ptr compsize_, 1
    sbb        word ptr compsize_ + 2, 0
    jb        disable
    mov        bx, outfile_
    $_if <dec wcount[bx]>, NS
        inc        ptr[bx]
        mov        bx, ptr[bx]
        mov        [bx - 1], al
    $_else
        xor        ah, ah
        inc        wcount[bx]
        call    fputc_
        $_if <or ax, ax>, S
            mov        ax, offset DGROUP:WTERR_
            mov        bx, outfile_
            jmp        fileerror_
        $_endif
    $_endif
    $_if <cmp ch, cl>, AE
        sub        ch, cl
        mov        al, dh
        mov        dh, dl
        jmp        pc1
    $_endif
    mov        subbitbuf_, dh
    sub        cl, ch
    mov        bitcount_, cl
    pop        dx
    pop        cx
    ret

disable:
    mov        unpackable_, 1
    inc        word ptr compsize_
    inc        word ptr compsize_ + 2
    pop        dx
    pop        cx
    ret


;
;int fread_crc(uchar *p, int n, FILE *f)
;

    public    fread_crc_
fread_crc_:
    push    cx
    push    dx
    mov        dx, ax
    xchg    bx, cx
    mov        bx, fd[bx]
    mov        ah, 3fh
    int        21h
    mov        bx, ax
    xchg    ax, dx
    $_if <or bx, bx>, NZ
        call    calccrc_
    $_endif
    mov        ax, dx
    pop        dx
    pop        cx
    ret


;
;void fwrite_crc(uchar *p, int n, FILE *f)
;

    public    fwrite_crc_
fwrite_crc_:
    push    cx
    push    dx
    mov        dx, ax
    push    bx
    call    calccrc_
    pop        bx
    jcxz    fc0
    xchg    bx, cx
    push    bx
    mov        bx, fd[bx]
    mov        ah, 40h
    int        21h
    pop        dx
    $_if <cmp ax, cx>, NE, AND
        mov        ax, bx
        call    isatty_
    $_c  <or ax, ax>, Z
        mov        ax, offset DGROUP:WTERR_
        mov        bx, dx
        jmp        fileerror_
    $_endif
fc0:
    pop        dx
    pop        cx
    ret


;
;void init_getbits(void)
;

    public    init_getbits_
init_getbits_:
    xor        ax, ax
    mov        word ptr DGROUP:[bitbuf_], ax
    mov        byte ptr DGROUP:[subbitbuf_], al
    mov        byte ptr DGROUP:[bitcount_], al
    mov        al,16
    jmp        fillbuf_


;
;void init_putbits(void)
;

    public    init_putbits_
init_putbits_:
    mov        byte ptr DGROUP:[bitcount_], 8
    mov        byte ptr DGROUP:[subbitbuf_], 0
    RET


    EXTRN    fileerror_:near
    EXTRN    WTERR_:near
    EXTRN    RDERR_:near
    EXTRN    fgetc_:near
    EXTRN    fwrite_:near
    EXTRN    fread_:near
    EXTRN    fputc_:near
    EXTRN    isatty_:near
    EXTRN    dispmark_:near
TEXT    ends

    EXTRN    unpackable_:word
    EXTRN    origsize_:dword
    EXTRN    compsize_:dword
    EXTRN    _iob_:byte

    END