home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / msvp98b1.lzh / MSNUT1.ORG < prev    next >
Text File  |  1993-05-14  |  12KB  |  585 lines
  1.        NAME    MSNUT1
  2. ; File MSNUT1.ASM
  3. ; Provides various Intel 8088 level operations, including
  4. ; display facilities (via msg buffer or DOS) for char, strings, etc.
  5. ;
  6. ; Copyright 1991, University of Waterloo.
  7. ;  Copyright (C) 1985, 1992, Trustees of Columbia University in the 
  8. ;  City of New York.  Permission is granted to any individual or institution
  9. ;  to use this software as long as it is not sold for profit.  This copyright
  10. ;  notice must be retained.  This software may not be included in commercial
  11. ;  products without written permission of Columbia University.
  12. ; 
  13. ; Written by Erick Engelke of the University of Waterloo, Waterloo, 
  14. ;  Ontario, Canada,
  15. ;  and by Joe R. Doupnik, Utah State University, 
  16. ;  jrd@cc.usu.edu, jrd@usu.Bitnet.
  17. ;
  18. ; Edit history
  19. ; 6 Sept 1991 v3.11
  20. ; Last Edit
  21. ; 2 Feb 1992
  22.  
  23. cr    equ    0dh
  24. lf    equ    0ah
  25. conout    equ    2
  26. dos    equ    21h
  27.  
  28. BIOSCLK    equ    046ch
  29. HI_MAX    equ    018h
  30. LO_MAX    equ     0b0h
  31.  
  32. _TEXT    SEGMENT  WORD PUBLIC 'CODE'
  33. _TEXT    ENDS
  34. _DATA    SEGMENT  WORD PUBLIC 'DATA'
  35. _DATA    ENDS
  36. CONST    SEGMENT  WORD PUBLIC 'CONST'
  37. CONST    ENDS
  38. _BSS    SEGMENT  WORD PUBLIC 'BSS'
  39. _BSS    ENDS
  40. DGROUP    GROUP    CONST, _BSS, _DATA
  41.     ASSUME  CS: _TEXT, DS: DGROUP, SS: DGROUP
  42.  
  43. _DATA    SEGMENT
  44.     extrn    _doslevel:word, _msgcnt:word, _msgbuf:byte,_display_mode:byte
  45. _DATA    ENDS
  46.  
  47. _TEXT    segment
  48.  
  49.         ; Compute 1's-complement sum of data buffer
  50.         ; unsigned checksum( unsigned word *buf, unsigned cnt)
  51.  
  52.     public    _checksum
  53. _checksum proc    near
  54.     push    bp
  55.     mov    bp,sp
  56.     push    si
  57.     push    bx
  58.     push    cx
  59.     push    dx
  60.         mov     si,[bp+4+0]        ; offset of data to be checked
  61.     mov     cx,[bp+4+2]        ; cx = cnt
  62.     mov    bl,cl
  63.     shr     cx,1            ; group into words
  64.     xor    dx,dx            ; set checksum to 0
  65.         cld
  66.     jcxz    chk3
  67.         clc
  68. chk1:    lodsw
  69.     adc    dx,ax
  70.     loop    chk1
  71.                     ; resolve remainder
  72. chk2:    adc     dx,0
  73.         jc    chk2
  74. chk3:    and    bl,1
  75.     jz    chk5
  76.         xor     ah,ah
  77.     lodsb
  78.         clc
  79.         add     dx,ax
  80. chk4:    adc     dx,0
  81.     jc    chk4
  82. chk5:    mov    ax,dx            ; result into ax
  83.         or      ax,ax
  84.     jnz    chk6
  85.         mov     ax,0ffffh
  86. chk6:    pop    dx
  87.     pop    cx
  88.     pop    bx
  89.     pop    si
  90.     pop    bp
  91.     ret
  92. _checksum endp
  93.  
  94. ;  ntohl(longword x)    32 bit network (big endian) to host (little endian)
  95. ;  htonl(longword x)    32 bit host (little endian) to network (big endian)
  96. ;  intel(longword x)
  97. ;  Reverse order of 4 byte groups between big and little endian forms
  98. ;
  99.     public    _intel, _ntohl, _htonl
  100.  
  101. _intel    proc    near
  102. _ntohl    equ    this byte
  103. _htonl    equ    this byte
  104.     push    bp
  105.     mov    bp,sp
  106.     mov    ax,[bp+4+2]
  107.     mov    dx,[bp+4+0]
  108.     xchg    al,ah
  109.     xchg    dl,dh
  110.     pop    bp
  111.     ret
  112. _intel    endp
  113.  
  114. ;  ntohs(word x)    16 bit network (big endian) to host (little endian)
  115. ;  htons(word x)    16 bit host (little endian) to network (big endian)
  116. ;  intel16(word x)
  117. ;  Reverse order of 2 byte groups between big and little endian forms
  118.     public    _intel16, _ntohs, _htons
  119. _intel16 proc    near
  120. _ntohs    equ    this byte
  121. _htons    equ    this byte
  122.     push    bp
  123.     mov    bp,sp
  124.     mov    ax,[bp+4+0]
  125.     xchg    al,ah
  126.     pop    bp
  127.     ret
  128. _intel16 endp
  129.  
  130.  
  131. ; int ourmod(int top, int bottom)
  132. ; Perform modulo function on 16 bit quantities
  133.     public    _ourmod
  134. _ourmod    proc    near
  135.     push    bp
  136.     mov    bp,sp
  137.     push    bx
  138.     mov    ax,[bp+4+0]        ; top number
  139.     mov    bx,[bp+4+2]        ; bottom number (radix)
  140.     xor    dx,dx
  141.     or    bx,bx            ; bottom is zero?
  142.     jz    ourmod1            ; z = yes, return zero
  143.     div    bx
  144. ourmod1:mov    ax,dx            ; return remainder
  145.     pop    bx
  146.     pop    bp
  147.     ret
  148. _ourmod    endp
  149.  
  150. ; int ourdiv(int top, int bottom)
  151. ; Perform 16 bit integer division
  152.     public    _ourdiv
  153. _ourdiv    proc    near
  154.     push    bp
  155.     mov    bp,sp
  156.     push    bx
  157.     mov    ax,[bp+4+0]        ; top
  158.     mov    bx,[bp+4+2]        ; bottom
  159.     xor    dx,dx
  160.     or    bx,bx            ; divide by zero?
  161.     jz    outdiv1            ; z = yes, divide by one
  162.     div    bx
  163. outdiv1:pop    bx
  164.     pop    bp            ; quotient is returned in ax
  165.     ret
  166. _ourdiv    endp
  167.  
  168. ; int ourlmod(long top, int bottom)
  169. ; Perform 32 bit integer modulo function
  170.     public    _ourlmod
  171. _ourlmod proc    near
  172.     push    bp
  173.     mov    bp,sp
  174.     push    bx
  175.     mov    ax,[bp+4+0]        ; top lower 16 bits
  176.     mov    dx,[bp+4+2]        ; top upper 16 bits
  177.     mov    bx,[bp+4+4]        ; bottom
  178.     or    bx,bx            ; zero?
  179.     jz    outlmo1            ; z = yes divide by 2^16 and quit
  180.     div    bx
  181. outlmo1:mov    ax,dx            ; return remainder in ax
  182.     pop    bx
  183.     pop    bp
  184.     ret
  185. _ourlmod endp
  186.  
  187. ; int ourldiv(long top, int bottom)
  188. ; Perform 32 bit integer division of 32 bit quotient by 16 bit divisor
  189.     public    _ourldiv
  190. _ourldiv proc    near
  191.     push    bp
  192.     mov    bp,sp
  193.     push    bx
  194.     mov    ax,[bp+4+0]        ; top lower 16 bits
  195.     mov    dx,[bp+4+2]        ; top upper 16 bits
  196.     mov    bx,[bp+4+4]        ; bottom
  197.     cmp    dx,bx            ; about to overflow?
  198.     jae    ourldiv1        ; ae = yes, return 0xffffh
  199.     div    bx
  200.     xor    dx,dx            ; clear remainder (high order ret)
  201.     pop    bx
  202.     pop    bp            ; quotient is returned in dx:ax
  203.     ret
  204. ourldiv1:mov    ax,0ffffh        ; overflow indication
  205.     xor    dx,dx            ; clear high order
  206.     pop    bx
  207.     pop    bp
  208.     ret
  209. _ourldiv endp
  210.  
  211. ; long ourlmul(long top, int bottom)
  212. ; Perform 32 bit integer multiplication of 32 bit multiplicand by 16 bit mult
  213.     public    _ourlmul
  214. _ourlmul proc    near
  215.     push    bp
  216.     mov    bp,sp
  217.     push    bx
  218.     push    cx
  219.     mov    ax,[bp+4+2]        ; top upper 16 bits
  220.     mov    bx,[bp+4+4]        ; bottom
  221.     mul    bx
  222.     mov    cx,ax            ; save product (no overflow noted)
  223.     mov    ax,[bp+4+0]        ; top lower 16 bits
  224.     mul    bx
  225.     adc    dx,cx            ; new upper 16 bits
  226.     pop    cx
  227.     pop    bx
  228.     mov    sp,bp
  229.     pop    bp            ; long product is returned in dx:ax
  230.     ret
  231. _ourlmul endp
  232.  
  233. ; void * bcopy(src, dest, count)
  234. ; void *dest, *src;
  235. ; size_t count;
  236. ; copy count bytes from src to dest
  237.     public    _bcopy
  238. _bcopy proc    near
  239.     push    bp
  240.     mov    bp,sp
  241.     push    es
  242.     push    si
  243.     push    di
  244.     push    cx
  245.     mov    ax,ds            ; set to same data segment
  246.     mov    es,ax
  247.     mov    si,[bp+4+0]        ; offset of source
  248.     mov    di,[bp+4+2]        ; offset of destination
  249.     mov    cx,[bp+4+4]        ; count
  250.     cld
  251.     push    di            ; push dest address for return
  252.     jcxz    bcopy2            ; z = nothing to copy
  253.     or    di,di            ; is destination NULL?
  254.     jz    bcopy2            ; z = yes, don't do a thing
  255.     cmp    si,di            ; is source after destination?
  256.     ja    bcopy1            ; a = yes, no overlap problem
  257.     je    bcopy2            ; e = same place, do nothing
  258.     add    di,cx            ; start at the ends
  259.     dec    di
  260.     add    si,cx
  261.     dec    si
  262.     std                ; work backward
  263. bcopy1:    rep    movsb
  264. bcopy2:    pop    ax            ; recover return destination
  265.     cld
  266.     pop    cx
  267.     pop    di
  268.     pop    si
  269.     pop    es
  270.     mov    sp,bp
  271.     pop    bp
  272.     ret
  273. _bcopy endp
  274.  
  275. ; void * memset(dest, c, count)
  276. ; void *dest;
  277. ; char c;
  278. ; size_t count;
  279. ; Store count copies of byte c in destination area dest
  280.     public    _memset
  281. _memset    proc    near
  282.     push    bp
  283.     mov    bp,sp
  284.     push    es
  285.     push    di
  286.     push    cx
  287.     mov    ax,ds            ; setup data segment
  288.     mov    es,ax
  289.     mov    di,[bp+4+0]        ; offset of destination
  290.     or    di,di            ; is it NULL?
  291.     jz    memset1            ; z = yes, don't do a thing
  292.     push    di            ; save dest for return
  293.     mov    al,[bp+4+2]        ; byte of character c
  294.     mov    ah,al
  295.     mov    cx,[bp+4+4]        ; count
  296.     jcxz    memset1            ; z = do nothing
  297.     cld
  298.     shr    cx,1
  299.     jnc    memset2
  300.     stosb
  301. memset2:rep    stosw
  302.     pop    ax            ; return pointer to destination
  303. memset1:pop    cx
  304.     pop    di
  305.     pop    es
  306.     mov    sp,bp
  307.     pop    bp
  308.     ret
  309. _memset    endp
  310.  
  311. ;  Timer routines - use set_*timeout to receive a clock value which
  312. ;                   can later be tested by calling chk_timeout with
  313. ;                   that clock value to determine if a timeout has
  314. ;                   occurred.  chk_timeout returns 0 if NOT timed out.
  315. ;  Usage:   long set_timeout( int seconds );
  316. ;           long set_ttimeout( int bios_ticks );
  317. ;           int chk_timeout( long value );
  318. ;
  319. ;  (c) 1990 University of Waterloo,
  320. ;           Faculty of Engineering,
  321. ;           Engineering Microcomputer Network Development Office
  322. ;  version
  323. ;    0.1    7-Nov -1990   E. P. Engelke
  324.  
  325.     public    _set_ttimeout
  326. _set_ttimeout proc    near
  327.     push    bp
  328.     mov    bp,sp
  329.     push    es
  330.         xor     ax,ax
  331.         cwd
  332.         mov     es,ax
  333.         mov     ax,[bp+4+0]        ; initial Bios clock ticks
  334.     pushf                ; critical section
  335.     cli
  336.         add     ax,es:[BIOSCLK+0];
  337.         adc     dx,es:[BIOSCLK+2];
  338.     popf                ; end critical section
  339.     pop    es
  340.     pop    bp
  341.     ret
  342. _set_ttimeout endp
  343.  
  344.     public    _set_timeout
  345. _set_timeout proc near
  346.     push    bp
  347.     mov    bp,sp
  348.     push    es
  349.     push    cx
  350.     xor    ax,ax            ; reference low memory
  351.     mov    es,ax
  352.     mov    ax,[bp+4+0]        ; seconds
  353.     xor    dx,dx
  354.     mov    cx,1165
  355.     mul    cx            ; 1165/64 = 18.203...
  356.     mov    cx,6
  357. tmp:    shr    dx,1
  358.     rcr    ax,1
  359.     loop    tmp
  360.     pushf                ; critical section
  361.     cli
  362.     add    ax,es:[BIOSCLK+0]
  363.     adc    dx,es:[BIOSCLK+2]
  364.     popf                ; end critical section
  365.     pop    cx
  366.     pop    es
  367.     pop    bp
  368.     ret
  369. _set_timeout    endp
  370.  
  371.     public    _chk_timeout
  372. _chk_timeout    proc near
  373.     push    bp
  374.     mov    bp,sp
  375.     push    cx
  376.     push    es
  377.     xor    ax,ax
  378.     mov    es,ax
  379.     pushf                ; critical section
  380.     cli
  381.     mov    cx,es:[BIOSCLK+0]
  382.     mov    bx,es:[BIOSCLK+2]
  383.     popf                ; end critical section
  384.     pop    es
  385.     mov    ax,[bp+4+0]        ; timeout value
  386.     mov    dx,[bp+4+2]
  387.     cmp    dx,bx            ; if timeout < clock, has expired
  388.         jb      ret_tru
  389.     cmp    ax,cx
  390.         jbe    ret_tru
  391.                     ; may have gone over by one day
  392.     sub    ax,LO_MAX
  393.     sbb    dx,HI_MAX
  394.     jc    ret_fal            ; c = nope, timeout is today
  395.                     ; test timeout new values
  396.     cmp    dx,bx
  397.     jb    ret_tru
  398.     cmp    ax,cx
  399.     ja    ret_fal
  400. ret_tru:mov    ax,1            ; say have timed out
  401.     pop    cx
  402.     pop    bp
  403.     ret
  404.  
  405. ret_fal:xor    ax,ax            ; say have not timed out
  406.     pop    cx
  407.     pop    bp
  408.     ret
  409. _chk_timeout    endp
  410.  
  411. ; unsigned long realclock(void)
  412.     public    _realclock
  413. _realclock    proc near        ; get Bios time of day dword
  414.     push    es
  415.     xor    ax,ax            ; reference low memory
  416.     mov    es,ax
  417.     pushf                ; critical section
  418.     cli
  419.     mov    ax,es:[BIOSCLK+0]    ; return Bios time of day tick count
  420.     mov    dx,es:[BIOSCLK+2]
  421.     popf                ; end critical section
  422.     pop    es
  423.     ret
  424. _realclock endp
  425.  
  426. ; void _chkstk()
  427. ; Stack checker
  428. ; {
  429. ;  ;
  430. ; }
  431.     public    __chkstk, __aNchkstk
  432. __chkstk proc    near            ; MSC v5.1
  433. __aNchkstk equ    this byte        ; MSC v6.00
  434.     pop    bx            ; pop return address
  435.     sub    sp,ax            ; down adjust stack pointer
  436.     jmp    bx            ; return the no-stack way
  437. __chkstk endp
  438.  
  439.  
  440. ; void 
  441. ; outch(char ch)
  442. ; Sends character to the screen via the msgbuf buffer if operating at
  443. ; interrupt level, or via DOS if operating at task level.
  444.     public    _outch
  445. _outch    proc    near
  446.     push    bp
  447.     mov    bp,sp
  448.     push    ax
  449.     push    bx
  450.     cmp    _display_mode,0        ; quiet screen?
  451.     je    outch3            ; e = yes
  452.     mov    al,[bp+4]        ; get the character
  453.     cmp    _doslevel,0        ; at DOS task level?
  454.     je    outch1            ; e = no
  455.     mov    ah,conout        ; use DOS
  456.     push    dx
  457.     mov    dl,al
  458.     int    dos
  459.     pop    dx
  460.     jmp    short outch3
  461. outch1:    cmp    _msgcnt,256        ; is buffer filled?
  462.     ja    outch3            ; a = yes, discard this byte
  463.     mov    bx,_msgcnt
  464.     mov    _msgbuf[bx],al
  465.     inc    _msgcnt
  466. outch3:    pop    bx
  467.     pop    ax
  468.     mov    sp,bp
  469.     pop    bp
  470.     ret
  471. _outch    endp
  472.  
  473.  
  474. ; void 
  475. ; outsn(char * string, int count)
  476. ; display counted string
  477.     public    _outsn
  478. _outsn    proc    near
  479.     push    bp
  480.     mov    bp,sp
  481.     push    ax
  482.     push    si
  483.     mov    si,[bp+4]        ; string address
  484.     mov    cx,[bp+4+2]        ; string length
  485.     cld
  486. outsn1:    lodsb
  487.     or    al,al
  488.         jz      outsn2
  489.     push    ax            ; push arg
  490.         call    _outch
  491.     pop    ax            ; clean stack
  492.     loop    outsn1
  493. outsn2:    pop    si
  494.     pop    ax
  495.     mov    sp,bp
  496.     pop    bp
  497.     ret
  498. _outsn    endp
  499.  
  500. ; void 
  501. ; outs(char * string)
  502. ; display asciiz string
  503.     public    _outs
  504. _outs    proc    near
  505.     push    bp
  506.     mov    bp,sp
  507.     push    ax
  508.     push    si
  509.     mov    si,[bp+4]        ; asciiz string address
  510.     cld
  511. outs1:    lodsb
  512.         or      al,al            ; terminator ?
  513.     jz     outs2            ; z = yes
  514.     push    ax            ; push arg
  515.     call    _outch
  516.     pop    ax            ; clean stack
  517.     jmp    short outs1
  518. outs2:    pop    si
  519.     pop    ax
  520.     mov    sp,bp
  521.     pop    bp
  522.     ret
  523. _outs    endp
  524.  
  525. ; void
  526. ; outhex(char c)
  527. ; display char in hex
  528.     public _outhex
  529. _outhex    proc    near
  530.     push    bp
  531.     mov    bp,sp
  532.     push    ax
  533.         mov     ax,[bp+4]        ; incoming character
  534.         mov     cl, 4
  535.         shr     al, cl
  536.         call    outh
  537.         mov     ax,[bp+4]
  538.         call    outh
  539.     pop    ax
  540.     mov    sp,bp
  541.     pop    bp
  542.     ret
  543.  
  544. ; worker for outhex
  545. outh    proc    near
  546.     and     al,0fh
  547.         cmp     al,9
  548.         jbe     outh1
  549.         add     al,'A' - '9' - 1
  550. outh1:    add     al,'0'
  551.         push    ax
  552.         call    _outch
  553.         pop     ax
  554.         ret
  555. outh    endp
  556. _outhex    endp
  557.  
  558. ; output a string of hex chars
  559. ; void
  560. ; outhexes(char * string, int count )
  561.     public    _outhexes
  562. _outhexes proc    near
  563.     push    bp
  564.     mov    bp,sp
  565.     push    ax
  566.     push    si            ; preserve such things
  567.     mov    si,[bp+4]        ; get string pointer
  568.     mov    cx,[bp+4+2]        ; get char count
  569.     cld
  570. outhexs1:lodsb                ; read a byte
  571.     push    cx            ; save loop counter
  572.     push    ax
  573.     call    _outhex            ; display as hex pair
  574.     add    sp,2            ; clean stack
  575.     pop    cx
  576.     loop    outhexs1        ; do count's worth
  577.     pop    si
  578.     pop    ax
  579.     mov    sp,bp
  580.     pop    bp
  581.     ret
  582. _outhexes endp
  583. _TEXT    ends
  584.         end
  585.