Columbia Kermit/kermit.zip/archives/msr313src.zip/msnut1.asm

Assembly Source File | 1993-07-12 | 16KB | 746 lines

       NAME    MSNUT1
; File MSNUT1.ASM
; Provides various Intel 8088 level operations, including
; display facilities (via msg buffer or DOS) for char, strings, etc.
;
; Copyright 1991, University of Waterloo.
;  Copyright (C) 1985, 1993, Trustees of Columbia University in the
;  City of New York.  Permission is granted to any individual or institution
;  to use this software as long as it is not sold for profit.  This copyright
;  notice must be retained.  This software may not be included in commercial
;  products without written permission of Columbia University.
;
; Written by Erick Engelke of the University of Waterloo, Waterloo,
;  Ontario, Canada,
;  and by Joe R. Doupnik, Utah State University,
;  [e-mail], [e-mail].
;
; Edit history
; 27 August 1992 version 3.13
; 6 Sept 1991 v3.11
; Last Edit
; 13 May 1993

cr    equ    0dh
lf    equ    0ah
conout    equ    2
dos    equ    21h
allocmem equ    48h
freemem    equ    49h

MSGBUFLEN equ    512            ; coordinate with msntnd.c
BIOSCLK    equ    046ch
HI_MAX    equ    018h
LO_MAX    equ     0b0h

_TEXT    SEGMENT  WORD PUBLIC 'CODE'
_TEXT    ENDS
_DATA    SEGMENT  WORD PUBLIC 'DATA'
_DATA    ENDS
CONST    SEGMENT  WORD PUBLIC 'CONST'
CONST    ENDS
_BSS    SEGMENT  WORD PUBLIC 'BSS'
_BSS    ENDS
DGROUP    GROUP    CONST, _BSS, _DATA
    ASSUME  CS: _TEXT, DS: DGROUP, SS: DGROUP

_DATA    SEGMENT
    extrn    _doslevel:word, _msgcnt:word, _msgbuf:byte,_display_mode:byte
_DATA    ENDS

_TEXT    segment

        ; Compute 1's-complement sum of data buffer
        ; unsigned checksum( unsigned word *buf, unsigned cnt)

    public    _checksum
_checksum proc    near
    push    bp
    mov    bp,sp
    push    si
    push    bx
    push    cx
    push    dx
        mov     si,[bp+4+0]        ; offset of data to be checked
    mov     cx,[bp+4+2]        ; cx = cnt
    mov    bl,cl
    shr     cx,1            ; group into words
    xor    dx,dx            ; set checksum to 0
        cld
    jcxz    chk3
        clc
chk1:    lodsw
    adc    dx,ax
    loop    chk1
                    ; resolve remainder
chk2:    adc     dx,0
        jc    chk2
chk3:    and    bl,1
    jz    chk5
        xor     ah,ah
    lodsb
        clc
        add     dx,ax
chk4:    adc     dx,0
    jc    chk4
chk5:    mov    ax,dx            ; result into ax
        or      ax,ax
    jnz    chk6
        mov     ax,0ffffh
chk6:    pop    dx
    pop    cx
    pop    bx
    pop    si
    pop    bp
    ret
_checksum endp

;  ntohl(longword x)    32 bit network (big endian) to host (little endian)
;  htonl(longword x)    32 bit host (little endian) to network (big endian)
;  intel(longword x)
;  Reverse order of 4 byte groups between big and little endian forms
;
    public    _intel, _ntohl, _htonl

_intel    proc    near
_ntohl    equ    this byte
_htonl    equ    this byte
    push    bp
    mov    bp,sp
    mov    ax,[bp+4+2]
    mov    dx,[bp+4+0]
    xchg    al,ah
    xchg    dl,dh
    pop    bp
    ret
_intel    endp

;  ntohs(word x)    16 bit network (big endian) to host (little endian)
;  htons(word x)    16 bit host (little endian) to network (big endian)
;  intel16(word x)
;  Reverse order of 2 byte groups between big and little endian forms
    public    _intel16, _ntohs, _htons
_intel16 proc    near
_ntohs    equ    this byte
_htons    equ    this byte
    push    bp
    mov    bp,sp
    mov    ax,[bp+4+0]
    xchg    al,ah
    pop    bp
    ret
_intel16 endp


; int ourmod(int top, int bottom)
; Perform modulo function on 16 bit quantities
    public    _ourmod
_ourmod    proc    near
    push    bp
    mov    bp,sp
    push    bx
    mov    ax,[bp+4+0]        ; top number
    mov    bx,[bp+4+2]        ; bottom number (radix)
    xor    dx,dx
    or    bx,bx            ; bottom is zero?
    jz    ourmod1            ; z = yes, return zero
    div    bx
ourmod1:mov    ax,dx            ; return remainder
    pop    bx
    pop    bp
    ret
_ourmod    endp

; int ourdiv(int top, int bottom)
; Perform 16 bit integer division
    public    _ourdiv
_ourdiv    proc    near
    push    bp
    mov    bp,sp
    push    bx
    mov    ax,[bp+4+0]        ; top
    mov    bx,[bp+4+2]        ; bottom
    xor    dx,dx
    or    bx,bx            ; divide by zero?
    jz    outdiv1            ; z = yes, divide by one
    div    bx
outdiv1:pop    bx
    pop    bp            ; quotient is returned in ax
    ret
_ourdiv    endp

; int ourlmod(long top, int bottom)
; Perform 32 bit integer modulo function
    public    _ourlmod
_ourlmod proc    near
    push    bp
    mov    bp,sp
    push    bx
    mov    ax,[bp+4+0]        ; top lower 16 bits
    mov    dx,[bp+4+2]        ; top upper 16 bits
    mov    bx,[bp+4+4]        ; bottom
    or    bx,bx            ; zero?
    jz    outlmo1            ; z = yes divide by 2^16 and quit
    div    bx
outlmo1:mov    ax,dx            ; return remainder in ax
    pop    bx
    pop    bp
    ret
_ourlmod endp

; int ourldiv(long top, int bottom)
; Perform 32 bit integer division of 32 bit quotient by 16 bit divisor
    public    _ourldiv
_ourldiv proc    near
    push    bp
    mov    bp,sp
    push    bx
    mov    ax,[bp+4+0]        ; top lower 16 bits
    mov    dx,[bp+4+2]        ; top upper 16 bits
    mov    bx,[bp+4+4]        ; bottom
    cmp    dx,bx            ; about to overflow?
    jae    ourldiv1        ; ae = yes, return 0xffffh
    div    bx
    xor    dx,dx            ; clear remainder (high order ret)
    pop    bx
    pop    bp            ; quotient is returned in dx:ax
    ret
ourldiv1:mov    ax,0ffffh        ; overflow indication
    xor    dx,dx            ; clear high order
    pop    bx
    pop    bp
    ret
_ourldiv endp

; long ourlmul(long top, int bottom)
; Perform 32 bit integer multiplication of 32 bit multiplicand by 16 bit mult
    public    _ourlmul
_ourlmul proc    near
    push    bp
    mov    bp,sp
    push    bx
    push    cx
    mov    ax,[bp+4+2]        ; top upper 16 bits
    mov    bx,[bp+4+4]        ; bottom
    mul    bx
    mov    cx,ax            ; save product (no overflow noted)
    mov    ax,[bp+4+0]        ; top lower 16 bits
    mul    bx
    adc    dx,cx            ; new upper 16 bits
    pop    cx
    pop    bx
    mov    sp,bp
    pop    bp            ; long product is returned in dx:ax
    ret
_ourlmul endp

; void * bcopy(src, dest, count)
; void *dest, *src;
; size_t count;
; copy count bytes from src to dest
    public    _bcopy
_bcopy proc    near
    push    bp
    mov    bp,sp
    push    es
    push    si
    push    di
    push    cx
    mov    ax,ds            ; set to same data segment
    mov    es,ax
    mov    si,[bp+4+0]        ; offset of source
    mov    di,[bp+4+2]        ; offset of destination
    mov    cx,[bp+4+4]        ; count
    cld
    push    di            ; push dest address for return
    jcxz    bcopy2            ; z = nothing to copy
    or    di,di            ; is destination NULL?
    jz    bcopy2            ; z = yes, don't do a thing
    cmp    si,di            ; is source after destination?
    ja    bcopy1            ; a = yes, no overlap problem
    je    bcopy2            ; e = same place, do nothing
    add    di,cx            ; start at the ends
    dec    di
    add    si,cx
    dec    si
    std                ; work backward
bcopy1:    rep    movsb
bcopy2:    pop    ax            ; recover return destination
    cld
    pop    cx
    pop    di
    pop    si
    pop    es
    mov    sp,bp
    pop    bp
    ret
_bcopy endp

; void * bcopy(src, dest, count)
; void * FAR dest, * FAR src;
; size_t count;
; copy count bytes from src to dest
    public    _bcopyff
_bcopyff proc    near
    push    bp
    mov    bp,sp
    push    es
    push    ds
    push    si
    push    di
    push    cx
    push    dx
    lds    si,dword ptr [bp+4+0]    ; source
    les    di,dword ptr [bp+4+4]    ; destination
    mov    cx,[bp+4+8]        ; count
    cld
    jcxz    bcopyff2        ; z = nothing to copy
    mov    ax,ds
    mov    dx,es
    or    ax,ax            ; is destination NULL?
    jz    bcopyff2        ; z = yes, don't do a thing
    cmp    ax,dx            ; is source seg after destination?
    ja    bcopyff1        ; a = yes, no overlap problem
    jb    bcopyff3        ; b = no, no overlap the other way
    cmp    si,di            ; is source offset after destination?
    ja    bcopyff1        ; a = yes, no overlap problem
    je    bcopyff2        ; e = same place, do nothing
bcopyff3:add    di,cx            ; start at the ends
    dec    di
    add    si,cx
    dec    si
    std                ; work backward
bcopyff1:rep    movsb
bcopyff2:xor    ax,ax            ; say null destination
    cld
    pop    dx
    pop    cx
    pop    di
    pop    si
    pop    ds
    pop    es
    mov    sp,bp
    pop    bp
    ret
_bcopyff endp


; void * memset(dest, c, count)
; void *dest;
; char c;
; size_t count;
; Store count copies of byte c in destination area dest
    public    _memset
_memset    proc    near
    push    bp
    mov    bp,sp
    push    es
    push    di
    push    cx
    mov    ax,ds            ; setup data segment
    mov    es,ax
    mov    di,[bp+4+0]        ; offset of destination
    or    di,di            ; is it NULL?
    jz    memset1            ; z = yes, don't do a thing
    push    di            ; save dest for return
    mov    al,[bp+4+2]        ; byte of character c
    mov    ah,al
    mov    cx,[bp+4+4]        ; count
    jcxz    memset1            ; z = do nothing
    cld
    shr    cx,1
    jnc    memset2
    stosb
memset2:rep    stosw
    pop    ax            ; return pointer to destination
memset1:pop    cx
    pop    di
    pop    es
    mov    sp,bp
    pop    bp
    ret
_memset    endp

; Allocate size bytes from DOS free memory.
; void FAR * malloc(size_t size)
; Returns FAR pointer in dx:ax, or 0L if failure. Size is an unsigned int.
    public    _malloc
_malloc    proc    near
    push    bp
    mov    bp,sp
    push    bx
    push    cx
    mov    bx,[bp+4+0]        ; bytes wanted
    add    bx,15            ; round up
    mov    cl,4
    shr    bx,cl            ; convert to # of paragraphs
    mov    cx,bx            ; remember quantity wanted
    mov    ah,allocmem        ; DOS memory allocator
    int    dos            ; returns segment in ax
    jc    malloc1            ; c = fatal error
    cmp    cx,bx            ; paragraphs wanted vs delivered
    je    malloc2            ; e = got the block
    push    es            ; insufficient, return it
    mov    es,ax            ; identify the block
    mov    ah,freemem        ; free the unwanted block
    int    dos
    pop    es
malloc1:xor    ax,ax            ; return 0L on failure
malloc2:mov    dx,ax            ; segment
    xor    ax,ax            ; offset
    pop    cx
    pop    bx
    pop    bp
    ret
_malloc    endp

; Free a block of memory allocated from the DOS memory pool.
; void free(FAR * memblock);
    public    _free
_free    proc    near
    push    bp
    mov    bp,sp
    push    ax
    push    es
    mov    ax,[bp+4+2]        ; get high order (segment) arg
    or    ax,ax            ; NULL?
    jz    free1            ; z = yes, leave it alone
    mov    es,ax            ; identify the block
    mov    ah,freemem        ; free the unwanted block
    int    dos
free1:    pop    es
    pop    ax
    pop    bp
    ret
_free    endp

; int fstchr(const char FAR * p, word len, byte c)
; finds first occurence of unsigned byte in low part of c and returns
; the number of bytes preceeding it in the buffer, or len if not found.
    public    _fstchr
_fstchr proc    near
    push    bp
    mov    bp,sp
    push    es
    push    bx
    push    cx
    push    di
    les    di,dword ptr [bp+4+0]    ; Far string address
    mov    bx,es            ; check for NULL
    mov    ax,-1            ; error return value
    or    bx,bx            ; NULL?
    jz    fstchr1            ; z = yes, return -1
    mov    bx,di            ; remember starting offset
    mov    cx,[bp+4+4]        ; number of bytes to examine
    jcxz    fstchr1            ; z = empty string, return -1
    mov    ax,[bp+4+6]        ; pattern is in al
    cld
    repne    scasb
    mov    ax,di            ; ending place
    dec    ax            ; minus auto inc of rep
    sub    ax,bx            ; minus starting offset
fstchr1:pop    di
    pop    cx
    pop    bx
    pop    es
    pop    bp
    ret
_fstchr endp

;  Timer routines - use set_*timeout to receive a clock value which
;                   can later be tested by calling chk_timeout with
;                   that clock value to determine if a timeout has
;                   occurred.  chk_timeout returns 0 if NOT timed out.
;  Usage:   long set_timeout( int seconds );
;           long set_ttimeout( int bios_ticks );
;           int chk_timeout( long value );
;
;  (c) 1990 University of Waterloo,
;           Faculty of Engineering,
;           Engineering Microcomputer Network Development Office
;  version
;    0.1    7-Nov -1990   E. P. Engelke

    public    _set_ttimeout
_set_ttimeout proc    near
    push    bp
    mov    bp,sp
    push    es
        xor     ax,ax
        cwd
        mov     es,ax
        mov     ax,[bp+4+0]        ; initial Bios clock ticks
    pushf                ; critical section
    cli
        add     ax,es:[BIOSCLK+0];
        adc     dx,es:[BIOSCLK+2];
    popf                ; end critical section
    pop    es
    pop    bp
    ret
_set_ttimeout endp

    public    _set_timeout
_set_timeout proc near
    push    bp
    mov    bp,sp
    push    es
    push    cx
    xor    ax,ax            ; reference low memory
    mov    es,ax
    mov    ax,[bp+4+0]        ; seconds
    xor    dx,dx
    mov    cx,1165
    mul    cx            ; 1165/64 = 18.203...
    mov    cx,6
tmp:    shr    dx,1
    rcr    ax,1
    loop    tmp
    pushf                ; critical section
    cli
    add    ax,es:[BIOSCLK+0]
    adc    dx,es:[BIOSCLK+2]
    popf                ; end critical section
    pop    cx
    pop    es
    pop    bp
    ret
_set_timeout    endp

    public    _chk_timeout
_chk_timeout    proc near
    push    bp
    mov    bp,sp
    push    cx
    push    es
    xor    ax,ax
    mov    es,ax
    pushf                ; critical section
    cli
    mov    cx,es:[BIOSCLK+0]
    mov    bx,es:[BIOSCLK+2]
    popf                ; end critical section
    pop    es
    mov    ax,[bp+4+0]        ; timeout value
    mov    dx,[bp+4+2]
    cmp    dx,bx            ; if timeout < clock, has expired
        jb      ret_tru
    cmp    ax,cx
        jbe    ret_tru
                    ; may have gone over by one day
    sub    ax,LO_MAX
    sbb    dx,HI_MAX
    jc    ret_fal            ; c = nope, timeout is today
                    ; test timeout new values
    cmp    dx,bx
    jb    ret_tru
    cmp    ax,cx
    ja    ret_fal
ret_tru:mov    ax,1            ; say have timed out
    pop    cx
    pop    bp
    ret

ret_fal:xor    ax,ax            ; say have not timed out
    pop    cx
    pop    bp
    ret
_chk_timeout    endp

; unsigned long realclock(void)
    public    _realclock
_realclock    proc near        ; get Bios time of day dword
    push    es
    xor    ax,ax            ; reference low memory
    mov    es,ax
    pushf                ; critical section
    cli
    mov    ax,es:[BIOSCLK+0]    ; return Bios time of day tick count
    mov    dx,es:[BIOSCLK+2]
    popf                ; end critical section
    pop    es
    ret
_realclock endp

; void _chkstk()
; Stack checker
; {
;  ;
; }
    public    __chkstk, __aNchkstk
__chkstk proc    near            ; MSC v5.1
__aNchkstk equ    this byte        ; MSC v6.00
    pop    bx            ; pop return address
    sub    sp,ax            ; down adjust stack pointer
    jmp    bx            ; return the no-stack way
__chkstk endp

; Microsoft C v7.0 direct support. Shift left dx:ax by cx. No C calling conv.
; Long shift left
    public    __aNlshl
__aNlshl proc    near
    jcxz    lshift2            ; z = no shift
lshift1:shl    ax,1
    rcl    dx,1
    loop    lshift1
lshift2:ret
__aNlshl endp

; Microsoft C v7.0 direct support. Shift rgt dx:ax by cx. No C calling conv.
; Unsigned long shift right
    public    __aNulshr
__aNulshr proc    near
    jcxz    rshift2            ; z = no shift
rshift1:shr    dx,1
    rcr    ax,1
    loop    rshift1
rshift2:ret
__aNulshr endp

; void
; outch(char ch)
; Sends character to the screen via the msgbuf buffer if operating at
; interrupt level, or via DOS if operating at task level.
    public    _outch
_outch    proc    near
    push    bp
    mov    bp,sp
    push    ax
    push    bx
    cmp    _display_mode,0        ; quiet screen?
    je    outch3            ; e = yes
    mov    al,[bp+4]        ; get the character
    cmp    _doslevel,0        ; at DOS task level?
    je    outch1            ; e = no
    mov    ah,conout        ; use DOS
    push    dx
    mov    dl,al
    int    dos
    pop    dx
    jmp    short outch3
outch1:    cmp    _msgcnt,MSGBUFLEN    ; is buffer filled?
    ja    outch3            ; a = yes, discard this byte
    mov    bx,_msgcnt
    mov    _msgbuf[bx],al
    inc    _msgcnt
outch3:    pop    bx
    pop    ax
    mov    sp,bp
    pop    bp
    ret
_outch    endp


; void
; outsn(char * string, int count)
; display counted string
    public    _outsn
_outsn    proc    near
    push    bp
    mov    bp,sp
    push    ax
    push    si
    mov    si,[bp+4]        ; string address
    mov    cx,[bp+4+2]        ; string length
    cld
outsn1:    lodsb
    or    al,al
        jz      outsn2
    push    ax            ; push arg
        call    _outch
    pop    ax            ; clean stack
    loop    outsn1
outsn2:    pop    si
    pop    ax
    mov    sp,bp
    pop    bp
    ret
_outsn    endp

; void
; outs(char * string)
; display asciiz string
    public    _outs
_outs    proc    near
    push    bp
    mov    bp,sp
    push    ax
    push    si
    mov    si,[bp+4]        ; asciiz string address
    cld
outs1:    lodsb
        or      al,al            ; terminator ?
    jz     outs2            ; z = yes
    push    ax            ; push arg
    call    _outch
    pop    ax            ; clean stack
    jmp    short outs1
outs2:    pop    si
    pop    ax
    mov    sp,bp
    pop    bp
    ret
_outs    endp

; void
; outhex(char c)
; display char in hex
    public _outhex
_outhex    proc    near
    push    bp
    mov    bp,sp
    push    ax
        mov     ax,[bp+4]        ; incoming character
        mov     cl,4
        shr     al,cl
        call    outh
        mov     ax,[bp+4]
        call    outh
    pop    ax
    mov    sp,bp
    pop    bp
    ret

; worker for outhex
outh    proc    near
    and     al,0fh
        cmp     al,9
        jbe     outh1
        add     al,'A' - '9' - 1
outh1:    add     al,'0'
        push    ax
        call    _outch
        pop     ax
        ret
outh    endp
_outhex    endp

; output a string of hex chars
; void
; outhexes(char * string, int count )
    public    _outhexes
_outhexes proc    near
    push    bp
    mov    bp,sp
    push    ax
    push    si            ; preserve such things
    mov    si,[bp+4]        ; get string pointer
    mov    cx,[bp+4+2]        ; get char count
    jcxz    outhexs2        ; z = nothing
    cld
outhexs1:lodsb                ; read a byte
    push    cx            ; save loop counter
    push    ax
    call    _outhex            ; display as hex pair
    add    sp,2            ; clean stack
    pop    cx
    loop    outhexs1        ; do count's worth
outhexs2:pop    si
    pop    ax
    mov    sp,bp
    pop    bp
    ret
_outhexes endp
_TEXT    ends
        end