Liren Large Software Subsidy 5/05.iso/a/a003/1.ddi/OVUSERM.ASM

Assembly Source File | 1986-09-29 | 27.2 KB | 732 lines

;*
;**************************************************************************
;*                                                                        *
;*          OVUSER.ASM: Overlay Loader User Module for PLINK86plus        *
;*        Copyright (C) 1985, 1986 by Phoenix Software Associates Ltd.    *
;*                                                                        *
;**************************************************************************
;*
;*
     title     Runtime Overlay Loader User Module for PLINK86
     subttl    Phoenix Software Associates, Ltd.
     .sfcond
;
;
;    Users may modify this routine and link it into their programs to
;customize the way the PLINK86 overlay loader operates.  All messages
;generated at runtime, as well as any communications carried out with the
;operator, are handled here.  This module also controls the process by which
;the linkage editor searches for the overlays.  Modifications should be made
;with care:  Phoenix will probably be unsympathetic to those who make
;changes and then expect us to help with the debugging.  However, virtually
;any modifications needed to make your application run more smoothly may be
;accomplished by making minor changes to this code.  Also, see the file
;"SAMPLE.ASM" for a much simpler version of this module.
;
;    As the program begins execution the $OVLYIU routine is called before
;the application code executes.  Initialization is performed here.  The DS
;register is set to enable local data to be accessed, but the ES register
;points to the MSDOS program segment prefix.  The standard user module uses
;this to obtain the address of the environment (specifically the PATH
;string).  These strings are directory names used by the system to find
;executable files, and they are used in the same way here to find overlay
;files.
;
;    The overlay loader calls symbol $OVLYxU each time it is about to open a
;new overlay file (keep in mind that a file can contain several overlays),
;or whenever a fatal error is encountered while reading an overlay.  The
;name of the overlay file being requested is provided in a string area
;labled by public symbol $OVLYFN, and may be modified if desired.  The file
;name must be terminated by a NUL, and the string area must be at least 13
;bytes long. As initialized by the overlay loader, the file name consists of
;a name and type only, of maximum length 8 and 3 chars respectively,
;separated by a period.
;
;    A result code is provided in the AL register describing what happened
;during the previous attempt to load an current overlay from the current
;file:
;
;   0 - The first attempt to load an overlay has not been made yet.
;   1 - The overlay file was not found.
;   2 - The overlay file couldn't be opened due to a disk error.  These
;       errors are things like no disk in drive, drive not ready, or media
;       errors such as seek and CRC problems.
;   3 - The overlay couldn't be read completely (premature EOF).  The file
;       is probably smashed.
;   4 - The overlay couldn't be read because of a disk error (drive not
;       ready, media error, etc).
;   5 - An "invalid handle" error was returned when the file was accessed.
;       Possible the file was closed because another task was terminated
;       (due to the strange way MSDOS 2 tries to support multi-tasking).
;
;    After possibly making modifications to the overlay file name, the
;$OVLYxU routine must return, in the AL register, a function code
;instructing the overlay loader how to handle the next attempt to load the
;overlay:
;
;   0 - Try to load the overlay from the file name given in $OVLYFN.
;   1 - Give up.  The program is normally terminated when this code is
;       received.  However, if the user program called the overlay loader
;       itself (at the LOAD$ routine, see PLINK86 user manual), an error
;       code may be returned to the user program at its option.
;
;Standard Search Sequence for Overlay Load Request:
;   a) try the unmodified file name
;   b) if running under MSDOS 3.0 or above, try prepending the directory
;           portion of the original DOS command (part of the environment)
;   c) try prepending each string from the MSDOS 2.0 PATH variable, if any
;   d) prepend a default string to the file name (our default is "A:")
;   e) prompt the operator for a string to prepend to the file name
;           at this point, the operator may terminate the program (standard
;           mechanism is to input a '.').  code 1 is returned to the
;           overlay loader.
;
     name OVUSERM
;
;
;
;   The following symbols may be used to customize versions of OVUSER.
    ;
    ;
MULTICOPY    equ 0    ;    set to true for shared overlays
VIANET        equ 0    ;    set to true to include Vianet support
MYDEBUG        equ 0    ;    set to true to debug this module
;
;
; The following public symbols are declared here in order to force the
;   assembler to order the segments as OVcode, OVdata.  MASM 3.0+ outputs
;   the segments in the order they are defined, whereas previous versions
;   output the segments in alphabetical order.
;
;
OVcode  segment  para  public   'OVLOADER'
     public    $OVLYIU            ;entry point to initialize user module
     public    $OVLYFN            ;overlay file name string
     public    $OVEXIT            ;overlay manager exit routine
     public    $OVLEND            ;subroutine invoked at the end of a
                                  ;   each overlay load request
     if MYDEBUG
         public   $$get_prefix
         public   $$is_separator
         public   $$prepend
         public   $$error_msg
     endif
         extrn     $OVCLOSE: far  ;close open overlay file, if any
         public    $OVLYMU        ;entry point for MSDOS user routine

                                  ;fatal messages
         public    $needdos2      ;   need dos 2.0 i/o capability
         public   $roverflow  ;   overlay loader reload stack overflow
         public   $runderflow ;   overlay loader reload stack undeflow
         if MYDEBUG
             public   $$try_path_strings
             public   $$try_exe_path
         endif
OVcode  ends
;
;
;********
;* Data *
;********
;
CR              equ  0Dh
LF              equ  0Ah
STD_OPN         equ  20h     ;NETBIOS standard shared open mode
STD_SEP         equ  '\'     ;char to separate Msdos 2.0 directory names
ABORT_SEARCH    equ  '.'     ;operator request to abort search for an ovly
;
;
OVdata    segment   word public 'OVLOADER'
    extrn  $OVRERR$: byte    ;1 => return error to user
    extrn  $OVOM$: byte      ;open mode for overlay files -
                             ;    network may be running => shared files
    extrn  $OVDOS2: byte     ;-1 => MSDOS >= 2.0 running

    DosVer    db   0    ;MSDOS version number.
    EnvPar    dw   0    ;paragraph address of environment
    EnvOff    dw   0    ;offset to PATH string
    TryEnv    dw   0    ;current offset to PATH string
    EPN       dw   0    ;Execution Path Name (MSDOS version >= 3 only).
    Path db   "PATH"    ;environment name for executable files path string
    Psize =   4         ;length of Path
    ExeTyp db ".EXE"    ;Executable file type name
    ExeLen    dw   0    ;Length of path portion of executable name (DOS 3).
    MustAsk   db   0    ;1=>must ask operator for overlay location.
    TriedExe db    0    ;0=>haven't tried EPN to find overlay file (DOS 3).
    Pflag     db   0    ;1=>DspFN should display file name prefix w/ file name
    FNlen     equ 80
    $OVLYFN   db FNlen dup (?) ;overlay file name work area
    KeyBuf    dw   66   ;Buffer size for buffered keyboard input O.S. call.
    Prefix    db   "A:" ;default prefix for file names
              db   64 dup (?)
    is_net_active  db  0  ;true => NETBIOS is active: close overlay files
                          ;        if configured for multiple copy support
    ;
    ;
    ;    All messages are here.
    ;
        $runderflow    db   "PLINK86 Overlay Loader: stack underflow $"
        $roverflow     db   "PLINK86 Overlay Loader: stack overflow $"
    $needdos2 db   "PLINK86 Overlay Loader: dos 2.0 required $"
    SignOn    db   CR,LF,"PLINK86 Overlay Loader - $"
    AskPrf    db   ".",CR,LF,"Enter file name prefix (X: or path name/) "
              db   "or '.' to quit=>$"
    Err       db   "Fatal error - $"
    Err1      db   "Can't find file $"
    Err2      db   "Disk I/O error in $"
    NewLin    db   CR,LF,"$"
OVdata    ends
;
;
;********
;* Code *
;********
;
OVcode    segment    para   public   'OVLOADER'
     assume cs:OVcode, ds:OVdata, es:OVdata
;
;
;*******    Macro for operating system calls.
;* Sys *
;*******
;
;
LodOff macro Reg, Var   ;;macro to load variable offset into register.
        mov  Reg, offset Var        ;;MSDOS, offsets are from segment
endm
;
Sys macro Fun, Arg      ;;macro for invoking Operating system functions
         mov  AH, Fun
     ifnb <Arg>
         LodOff DX, Arg
     endif
         int  21H
endm
;
;
;
;
; $$get_prefix ------------------------------------------------------------
;
;       This subroutine prompts the operator for a file name prefix.  This
;           prefix is then used to try to find the file with the requested
;           overlay.  If the operator complies, the string is left in the
;           Prefix buffer.  The operator can abort the search by entering
;           the ABORT_SEARCH character specified above.
;
;       Returns: carry clear iff string left in Prefix
;                carry set   iff operator entered ABORT_SEARCH
;
;
$$get_prefix proc near
     Sys  9, AskPrf                  ;prompt for path/file
     Sys  10, KeyBuf                 ;get new prefix
     Sys  9, NewLin
     mov  AL, byte ptr Prefix        ;get first char from buffer
     cmp  AL, ABORT_SEARCH           ;
     jz   gp_abort                   ;if '.' abort

     mov  BL, byte ptr KeyBuf + 1    ;BL = # chars read.
     xor  BH, BH
     mov  byte ptr Prefix[ BX ], 0   ;set last byte to NUL
     xor  SI, SI                     ;use SI as pointer to buffer
  gp_convert:                        ;start at zero
     mov  AL, byte ptr Prefix[ SI ]  ;get a character from buffer
     test AL, -1                     ;exit if done
     jz   gp_ok
     cmp  AL, 'z' + 1                ;if not lowercase
     jnc  gp_next
     cmp  AL, 'a'                    ;ASCII a-z
     jc   gp_next                    ;get the next char
     and  AL, 0DFH                   ;else force to uppercase
     mov  byte ptr Prefix[ SI ], AL  ;and re-save to keyboard buffer
  gp_next:                           ;
     inc  SI                         ;point to next char
     jmp  gp_convert                 ;and go convert it

  gp_ok:                             ;everything is ok
     clc                             ;   string is in Prefix
     ret
  gp_abort:                          ;operator wants to quit
     stc                             ;   notify overlay loader
     ret
$$get_prefix endp
;
;
;
; $$is_separator ----------------------------------------------------------
;
;       The zero flag is set iff the character in AL is a valid path name
;           separator or a valid drive-pathname separator.  If it is not,
;           AL is changed to the standard path name separator.
;
;
$$is_separator proc near
     cmp  AL, ':'             ;a valid separator?
     jz   got_it
     cmp  AL, '/'
     jz   got_it
     cmp  AL, '\'
     jz   got_it
     mov  AL, STD_SEP         ;No, use standard one.
  got_it:
     ret
$$is_separator endp
;
;
;
; $$prepend ---------------------------------------------------------------
;
;   The file name prefix pointed to by BP:SI is appended to the front of
;       the file name string.  Much of the code here involves moving
;       segment registers around, because the prefix may exist in a
;       different segment if it is coming from the PATH in the environment
;       area.  At the end of this routine SI points to the end of the
;       source prefix string.  If there is no separator at the end of the
;       prefix one is added (STD_SEP).
;
$$prepend proc near
     mov  DS, BP            ;DS:SI points to prefix
     push SI
     xor  DX, DX            ;DX := length of file name prefix
  Count:
     lodsb
     inc  DX
     or   AL, AL
     jz   CntEnd
     cmp  AL, ' '
     jz   CntEnd
     cmp  AL, ';'
     jnz  Count
  CntEnd:
     dec  DX
     pop  SI
     ;fall through

  Appnd2:
     mov  BX, ES            ;save current DS and ES  in BX.
     mov  DS, BP            ;DS:SI points to prefix
     push SI
     add  SI, DX            ;get to end of prefix, look at last char.
     dec  SI
     lodsb                  ;save it in AL.
     mov  DS, BX            ;restore my DS.
     call $$is_separator    ;see if   last char is separator,  save
     mov  AH, 0             ;separator in AL.
     jnz  Shift             ;no, but now have it in  AL
     inc  AH                ;AH is # of chars not used in prefix.
     dec  DX                ;leave out separator, will put back later.
  Shift:
     LodOff  SI,$OVLYFN     ;DS:SI -> end of file name
     push SI                ;ES:DI -> end of file name area
     add  SI, FNlen - 1
     mov  DI, SI
     inc  DX
     sub  SI, DX
     mov  CX, FNlen         ;shift file name up by length of prefix.
     sub  CX, DX            ;plus separator byte.
     dec  DX
     std
     rep  movsb
     cld
     pop  DI                ;move prefix to file name area.
     pop  SI
     mov  DS, BP
     mov  CX, DX
     rep  movsb
     mov  DS, BX            ;restore my DS
     mov  byte ptr [DI],AL  ;add file name separator.
     mov  AL, AH            ;get SI to end of prefix
     mov  AH, 0
     add  SI, AX
     ret
$$prepend endp
;
;
;
    ;
    ;
    ; $$try_path_strings --------------------------------------------------
    ;
    ;   If MSDOS 2.0+ is running, the file name prefix is set up as the
    ;       next directory name from the PATH string in the environment,
    ;       if any exist.
    ;
    $$try_path_strings proc near
         cmp  DosVer, 1           ;if running 2.0,
         jbe  NoPath
         mov  SI, TryEnv          ;try next path
         or   SI, SI
         jz   NoPath
         push DS                  ;DS:SI->next environment string
         mov  AX, EnvPar
         mov  DS, AX

      TryP1:
         lodsb                    ;get to start of next directory path
         cmp  AL, ';'
         jz   TryP1
         cmp  AL, ' '
         jz   TryP1
         dec  SI

         test byte ptr [SI], -1   ;anything here?
         mov  BP, DS              ;(BP -> prefix paragraph)
         pop  DS                  ;(restore DS)
         jz   NoPath
         call $$prepend           ;append to file name.
         mov  TryEnv, SI          ;save new ptr for next time.
         clc                      ;fn ready to use now.
         ret

      NoPath:
         stc
         ret
    $$try_path_strings endp
    ;
    ;
    ;
    ; $$try_exe_path ------------------------------------------------------
    ;
    ;   If MSDOS 3.0+ is running "EnvOff" points to the complete path name
    ;       the program was executed from.  If the overlay file name in
    ;       $OVLYFN has a type of ".EXE" this path name is substituted for
    ;       the $OVLYFN name.  That way someone can rename the .EXE file
    ;       and the loader will still be able to find the .EXE file.  For
    ;       auxilliary overlay files (not of type .EXE) the path portion of
    ;       the file name is preppended to the front of $OVLYFN:  it is
    ;       assumed that the auxilliary files will reside in the same
    ;       directory as the EXE file.
    ;
    ;
    $$try_exe_path proc near
         LodOff    DI,$OvlyFN     ;get to end of name.
         mov  CX, -1
         mov  AL, 0
         repnz     scasb
         sub  DI, 5               ;look at last 4 chars.
         LodOff    SI,ExeTyp      ;is it .EXE file?
         mov  CX, 4
         repz cmpsb
         jz   Try1
         mov  SI, EPN             ;No, append path portion of
         mov  DX, ExeLen          ;.EXE name to given name.
         mov  BP, EnvPar
         mov  DS, BP
         jmp  Appnd2

      Try1:
         mov  SI, EPN             ;Yes, move in entire name as is.
         push DS
         mov  DS, EnvPar
         LodOff    DI,$OvlyFN
         mov  CX, FNlen
         rep  movsb
         pop  DS
         ret
    $$try_exe_path endp
;
;
;
; $$error_msg -------------------------------------------------------------
;
;   An error message is generated from the code in AL.
;
;
$$error_msg proc near
     push AX
     Sys  9, SignOn
     pop  AX
     LodOff    DX, Err1       ;This msg for errs 1 and 2
     cmp  AL,3
     jc   EM
     LodOff    DX, Err2       ;this one for errs 3 and 4.
  EM:
     Sys  9
     test Pflag, -1           ;want prefix printed?
     jz   DspFN1
     LodOff    SI, Prefix     ;yes, SI points to it.
     call near ptr DspFN2     ;print it.
     dec  SI                  ;was last character a separator?
     mov  AL, [SI]
     call $$is_separator
     jz   DspFN1
     mov  DL, STD_SEP         ;no, better print one
     Sys  2
  DspFN1:
     LodOff    SI,$OVLYFN     ;now print file name.
  DspFN2:
     mov  DL, [SI]            ;display text from SI until NUL found.
     or   DL,DL
     jz   DspFN3
     push SI
     Sys  2
     pop  SI
     inc  SI
     jmp  DspFN2
  DspFN3:
     ret
$$error_msg endp
;
;
;
; $OVLYxU -----------------------------------------------------------------
;
;   This routine is driven  off of the MustAsk flag.  It is initialized to
;       zero as the overlay loader is allowed to use the file name as is.
;       On subsequent tries the various ways of modifying the file name in
;       an effort to find the overlay are attempted.  These all involve
;       adding a prefix to the file name, like a drive specifier or a
;       directory name.  The last method tried is to ask the operator to
;       enter a prefix.  If the operator so instructs, the overlay loader
;       is told to give up and terminate the program.
;
;
$OVLYMU   proc near
     cld                           ;all increments forward.
     or   AL, AL                   ;first attempt on this overlay file?
     jz   First
     cmp  AL, 5                    ;If handle error, try starting over.
     jnz  Error

  First:
     mov  MustAsk,  0              ;Start with internal methods.
     mov  TriedExe, 0              ;try MSDOS 3 EPN
     mov  Pflag,    0              ;don't display prefix yet on error.
     mov  BX, EnvOff            ;set initial environment ptr
     mov  TryEnv, BX
     jmp  short Return             ;try file name as is.

  Error:
     test MustAsk, -1              ;no, is it time to ask operator?
     jnz  Prf
     cmp  DosVer, 3             ;No.
     jc   Try2
     test TriedExe, -1          ;Tried this yet?
     jnz  Try2
     call $$try_exe_path        ;Try MSDOS 3 executable name.
     inc  TriedExe              ;come through here once only
     jmp  short Return
     Try2:
     call $$try_path_strings    ;Try next MSDOS 2 PATH
     jnc  Return                ;Any left?
     inc  MustAsk                  ;No, try default prefix, once.
     jmp  short Prf2
  Prf:
     test $OVRERR$, -1
     jnz  GiveUp
     call $$error_msg              ;Tell operator what problem is,
     mov  Pflag, 1                 ;display file name prefixes from now on,
     call $$get_prefix             ;and ask for new file name prefix.
     jc   GiveUp
  Prf2:
     mov  BP,DS                    ;BP:SI points to prefix.
     LodOff    SI, Prefix          ;append current prefix to file name.
     call $$prepend

  Return:
     mov  AL, 0                    ;Tell loader to try current file name.
     ret
  GiveUp:
     mov  AL, 1                    ;Operator wants to terminate program.
     ret

$OVLYMU   endp
;
;
;
; $OVLYIU -----------------------------------------------------------------
;
;   This is the initialization routine for the user module.  If we are
;       running under MSDOS 2 the environment is searched for the PATH
;       string.  If MSDOS 3 is running the path name used to execute the
;       program appears at the end of the environment and is used instead
;       of the PATH.
;
;    The environment paragraph address is given in the program prefix
;       (pointed to by ES as the program begins execution) at offset 2CH.
;       The environment consists of strings separated by nuls, with an
;       extra nul at the end.  Each string has a name at the front and a
;       value at the end, separated by an equal sign. The string searched
;       for here has a name of "PATH".  The value portion of this string is
;       a list of directory names separated by semi-colons. The command
;       processor looks in these directories to find executable files, so
;       program overlays might also be found there.  If the "PATH" string
;       is found, its address is saved for later use.
;
;    MSDOS 3 passes the name the program was executed under as a string
;       following the end of the environment.  There's an extra word in
;       front of it: I don't know what it is.  The MSDOS ref. says it's a
;       "word count" but it always seems to be set to a one.  This routine
;       ignores it.
;
;
    Space proc near      ;scan ES:DI until a non-blank is found.
         mov  AL," "
         repz scasb
         dec  DI         ;get ES:DI back to non-blank
         ret
    Space endp
;
;
;
;
$OVLYIU   proc near
     Sys  30H                 ;AL := DOS version #
     mov  DosVer, AL          ;Save for later.
     cmp  AL, 2               ;go away if earlier than 2.0
     jnc  IU2
     jmp  IUend
  IU2:                        ;DOS 2.x or later
     mov  $OVDOS2, -1         ;   -1 => use dos 2.0 file handles
     cmp  AL, 3               ;check if on 3.x
     jnc  IUdos3
     jmp  short IUdos2

  IUdos3:
     if MULTICOPY             ;NETBIOS test described in
         mov  ah, 0           ;    "IBM PC Network Program Manual"
         int  2ah
         cmp  ah, 0           ;    ah != 0  =>  NETBIOS is active
         je   IUmulti
         mov  is_net_active, -1
      IUmulti:
     endif
     mov  AL, STD_OPN         ;NETBIOS shared file open mode
     jmp  short IUcontinue

  IUdos2:
     xor  AL, AL              ;vanilla open mode

  IUcontinue:
     if VIANET
         mov  BP, 8AH         ;   check if VIANET installed
         xor  BX, BX
         Sys  0EFH            ;   sets BX: bit 0 => installed
                              ;            bit 4 => 3.0 emulation
         and  BX, 11H
         cmp  BX, 1           ;   installed?
         jb   NoPax
         mov  AL, 30H         ;   read only: net but no 3.0 emulation
     endif
  NoPax:
     mov  $OVOM$, AL          ;   set my open mode
     mov  BX, ES:2CH          ;Save environment paragraph address.
     mov  EnvPar, BX
     mov  ES, BX              ;set ES to environment
     xor  DI, DI              ;DI is offset into it.
     cld                      ;auto-increment forward.
  Srch:
     test byte ptr ES:[DI],-1 ;end of environment?
     jz   E1
     mov  SI, offset Path     ;no, compare next string
     mov  CX, Psize
     repe cmpsb
     mov  CX, -1              ;for REP instructions.
     jz   GotIt               ;Is it a match?

  Skip:
     mov  AL, 0               ;No, get past string and
     repnz     scasb          ;the nul terminating it.
     jmp  Srch

  GotIt:
     call Space               ;Got it:  skip blanks.
     cmp  byte ptr ES:[DI],'='     ;at end   of "PATH"?
     jnz  Skip                ;no, had match on prefix.
     inc  DI                  ;yes, get over =.
     call Space               ;and spaces.
     mov  EnvOff, DI          ;save pointer to it.
  E1:
     cmp  DosVer, 2           ;Is it version 3 or more?
     jna  IUend
                              ;yes, find execution path name.
     xor  DI, DI              ;DI->front of environment.
     mov  CX, -1              ;for REP instructions.
     mov  AL, 0               ;strings end with NUL.
  Its3:
     cmp  byte ptr ES:[DI],AL ;end of   environment?
     jz   EnvEnd
     repnz     scasb          ;no:  skip next environment string.
     jmp  Its3
  EnvEnd:
     add  DI, 3               ;get over NUL and mystery word.
     mov  EPN, DI             ;save pointer to it.
     xor  DX, DX
  GetExL:
     mov  AL,byte ptr ES:[DI] ;get length of path name portion
     inc  DI
     inc  DX
     cmp  AL, 0               ;of this name.
     jz   IUend
     call $$is_separator
     jnz  GetExL
     mov  ExeLen, DX
     jmp  GetExL
  IUend:
     ret
$OVLYIU   endp
;
;
;
; $OVLEND -----------------------------------------------------------------
;
;    $OVLEND is invoked at the end of a request for an overlay load.  By
;         default, it determines whether to close the current overlay file.
;         However, it may be customized for any post-overlay-load use:
;         for example, if you are overlaying code and data, after an
;         overlay is loaded, parts of the data segment could be initialized
;         according to some run-time criterion.
;
;    By default, the file remains open until the user explicitly closes it
;         via $OVCLOSE, or the next load operation determines a different
;         overlay file must be used.
;
;    This module may be configured to allow multiple copies of a single
;         executable (and its overlays) to be running concurrently across a
;         network conforming to the NETBIOS standard.  PLINK86 will open
;         overlay files in "shared" mode;  however, DOS 3.0 uses read/write
;         mode to initially load a program: this restriction means that
;         the overlay loader should automatically close all open files
;         after a load, if NETBIOS is active.
;
;              Some NETBIOS standard vendors: IBM Network
;                                             AT&T Starlan
;                                             Novell Advanced Network
;
;         If your application does not put any overlays into the DOS loaded
;              .EXE file, you do not need to turn MULTICOPY on.
;
;
$OVLEND proc near
    if   MULTICOPY
         pushf                    ;save flags: they give status of load
         cmp  is_net_active, -1   ;check if running under NETBIOS standard
         jne  lendend             ;
         call $OVCLOSE            ;    close any open files
      lendend:
         popf                     ;restore load status
    endif
    ret
$OVLEND endp
;
;
;
; $OVEXIT -----------------------------------------------------------------
;
;   $OVEXIT is called by the overlay loader when a fatal condition has been
;       found: it is included in this file to allow users to cleanup their
;       open files, etc. before the application terminates.
;
;
$OVEXIT proc near
        call  $OVCLOSE
        mov al, 0ffh
        mov ah, 4ch
        int 21h
    ret
$OVEXIT endp

OVcode    ends
     end