MSDOS.ASM

; 86-DOS  High-performance operating system for the 8086  version 1.25
;       by Tim Paterson


; ****************** Revision History *************************
;          >> EVERY change must noted below!! <<
;
; 0.34 12/29/80 General release, updating all past customers
; 0.42 02/25/81 32-byte directory entries added
; 0.56 03/23/81 Variable record and sector sizes
; 0.60 03/27/81 Ctrl-C exit changes, including register save on user stack
; 0.74 04/15/81 Recognize I/O devices with file names
; 0.75 04/17/81 Improve and correct buffer handling
; 0.76 04/23/81 Correct directory size when not 2^N entries
; 0.80 04/27/81 Add console input without echo, Functions 7 & 8
; 1.00 04/28/81 Renumber for general release
; 1.01 05/12/81 Fix bug in `STORE'
; 1.10 07/21/81 Fatal error trapping, NUL device, hidden files, date & time,
;               RENAME fix, general cleanup
; 1.11 09/03/81 Don't set CURRENT BLOCK to 0 on open; fix SET FILE SIZE
; 1.12 10/09/81 Zero high half of CURRENT BLOCK after all (CP/M programs don't)
; 1.13 10/29/81 Fix classic "no write-through" error in buffer handling
; 1.20 12/31/81 Add time to FCB; separate FAT from DPT; Kill SMALLDIR;
;               Add FLUSH and MAPDEV calls; allow disk mapping in DSKCHG;
;               Lots of smaller improvements
; 1.21 01/06/82 HIGHMEM switch to run DOS in high memory
; 1.22 01/12/82 Add VERIFY system call to enable/disable verify after write
; 1.23 02/11/82 Add defaulting to parser; use variable escape character
;               Don't zero extent field in IBM version (back to 1.01!)
; 1.24 03/01/82 Restore fcn. 27 to 1.0 level; add fcn. 28
; 1.25 03/03/82 Put marker (00) at end of directory to speed searches
;
; *************************************************************


; Interrupt Entry Points:

; INTBASE:      ABORT
; INTBASE+4:    COMMAND
; INTBASE+8:    BASE EXIT ADDRESS
; INTBASE+C:    CONTROL-C ABORT
; INTBASE+10H:  FATAL ERROR ABORT
; INTBASE+14H:  BIOS DISK READ
; INTBASE+18H:  BIOS DISK WRITE
; INTBASE+40H:  Long jump to CALL entry point

        IF      IBM
ESCCH   EQU     0
CANCEL  EQU     1BH             ;Cancel with ESC
TOGLINS EQU     TRUE            ;One key toggles insert mode
TOGLPRN EQU     TRUE            ;One key toggles printer echo
NUMDEV  EQU     6               ;Include "COM1" as I/O device name
ZEROEXT EQU     TRUE
        ELSE
ESCCH   EQU     1BH
CANCEL  EQU     "X"-"@"         ;Cancel with Ctrl-X
TOGLINS EQU     FALSE           ;Separate keys for insert mode on and off
TOGLPRN EQU     FALSE           ;Separate keys for printer echo on and off
NUMDEV  EQU     5               ;Number of I/O device names
ZEROEXT EQU     FALSE
        ENDIF

MAXCALL EQU     36
MAXCOM  EQU     46
INTBASE EQU     80H
INTTAB  EQU     20H
ENTRYPOINTSEG   EQU     0CH
ENTRYPOINT      EQU     INTBASE+40H
CONTC   EQU     INTTAB+3
EXIT    EQU     INTBASE+8
LONGJUMP EQU    0EAH
LONGCALL EQU    9AH
MAXDIF  EQU     0FFFH
SAVEXIT EQU     10

; Field definition for FCBs

FCBLOCK STRUC
        DB      12 DUP (?)              ;Drive code and name
EXTENT  DW      ?
RECSIZ  DW      ?       ;Size of record (user settable)
FILSIZ  DW      ?       ;Size of file in bytes
DRVBP   DW      ?       ;BP for SEARCH FIRST and SEARCH NEXT
FDATE   DW      ?       ;Date of last writing
FTIME   DW      ?       ;Time of last writing
DEVID   DB      ?       ;Device ID number, bits 0-5
                        ;bit 7=0 for file, bit 7=1 for I/O device
                        ;If file, bit 6=0 if dirty
                        ;If I/O device, bit 6=0 if EOF (input)
FIRCLUS DW      ?       ;First cluster of file
LSTCLUS DW      ?       ;Last cluster accessed
CLUSPOS DW      ?       ;Position of last cluster accessed
        DB      ?       ;Forces NR to offset 32
NR      DB      ?       ;Next record
RR      DB      3 DUP (?)               ;Random record
FCBLOCK ENDS
FILDIRENT       = FILSIZ                ;Used only by SEARCH FIRST and SEARCH NEXT

; Description of 32-byte directory entry (same as returned by SEARCH FIRST
; and SEARCH NEXT, functions 17 and 18).
;
; Location      bytes   Description
;
;    0          11      File name and extension ( 0E5H if empty)
;   11           1      Attributes. Bits 1 or 2 make file hidden
;   12          10      Zero field (for expansion)
;   22           2      Time. Bits 0-4=seconds/2, bits 5-10=minute, 11-15=hour
;   24           2      Date. Bits 0-4=day, bits 5-8=month, bits 9-15=year-1980
;   26           2      First allocation unit ( < 4080 )
;   28           4      File size, in bytes (LSB first, 30 bits max.)
;
; The File Allocation Table uses a 12-bit entry for each allocation unit on
; the disk. These entries are packed, two for every three bytes. The contents
; of entry number N is found by 1) multiplying N by 1.5; 2) adding the result
; to the base address of the Allocation Table; 3) fetching the 16-bit word at
; this address; 4) If N was odd (so that N*1.5 was not an integer), shift the
; word right four bits; 5) mask to 12 bits (AND with 0FFF hex). Entry number
; zero is used as an end-of-file trap in the OS and as a flag for directory
; entry size (if SMALLDIR selected). Entry 1 is reserved for future use. The
; first available allocation unit is assigned entry number two, and even
; though it is the first, is called cluster 2. Entries greater than 0FF8H are
; end of file marks; entries of zero are unallocated. Otherwise, the contents
; of a FAT entry is the number of the next cluster in the file.


; Field definition for Drive Parameter Block

DPBLOCK STRUC
DEVNUM  DB      ?       ;I/O driver number
DRVNUM  DB      ?       ;Physical Unit number
SECSIZ  DW      ?       ;Size of physical sector in bytes
CLUSMSK DB      ?       ;Sectors/cluster - 1
CLUSSHFT DB     ?       ;Log2 of sectors/cluster
FIRFAT  DW      ?       ;Starting record of FATs
FATCNT  DB      ?       ;Number of FATs for this drive
MAXENT  DW      ?       ;Number of directory entries
FIRREC  DW      ?       ;First sector of first cluster
MAXCLUS DW      ?       ;Number of clusters on drive + 1
FATSIZ  DB      ?       ;Number of records occupied by FAT
FIRDIR  DW      ?       ;Starting record of directory
FAT     DW      ?       ;Pointer to start of FAT
DPBLOCK ENDS

DPBSIZ  EQU     20      ;Size of the structure in bytes
DIRSEC  =       FIRREC  ;Number of dir. sectors (init temporary)
DSKSIZ  =       MAXCLUS ;Size of disk (temp used during init only)

;The following are all of the segments used
;They are declared in the order that they should be placed in the executable

CODE    SEGMENT
CODE    ENDS

CONSTANTS       SEGMENT BYTE
CONSTANTS       ENDS

DATA    SEGMENT WORD
DATA    ENDS

DOSGROUP        GROUP   CODE,CONSTANTS,DATA

SEGBIOS SEGMENT
SEGBIOS ENDS


; BOIS entry point definitions

        IF      IBM
BIOSSEG EQU     60H
        ENDIF
        IF      NOT IBM
BIOSSEG EQU     40H
        ENDIF

SEGBIOS         SEGMENT AT BIOSSEG
                ORG     0
                DB      3 DUP (?)       ;Reserve room for jump to init code
BIOSSTAT        DB      3 DUP (?)       ;Console input status check
BIOSIN          DB      3 DUP (?)       ;Get console character
BIOSOUT         DB      3 DUP (?)       ;Output console character
BIOSPRINT       DB      3 DUP (?)       ;Output to printer
BIOSAUXIN       DB      3 DUP (?)       ;Get byte from auxilliary
BIOSAUXOUT      DB      3 DUP (?)       ;Output byte to auxilliary
BIOSREAD        DB      3 DUP (?)       ;Disk read
BIOSWRITE       DB      3 DUP (?)       ;Disk write
BIOSDSKCHG      DB      3 DUP (?)       ;Dsik-change status
BIOSSETDATE     DB      3 DUP (?)       ;Set date
BIOSSETTIME     DB      3 DUP (?)       ;Set time
BIOSGETTIME     DB      3 DUP (?)       ;Get time and date
BIOSFLUSH       DB      3 DUP (?)       ;Clear console input buffer
BIOSMAPDEV      DB      3 DUP (?)       ;Dynamic disk table mapper

SEGBIOS ENDS
; Location of user registers relative user stack pointer

STKPTRS STRUC
AXSAVE  DW      ?
BXSAVE  DW      ?
CXSAVE  DW      ?
DXSAVE  DW      ?
SISAVE  DW      ?
DISAVE  DW      ?
BPSAVE  DW      ?
DSSAVE  DW      ?
ESSAVE  DW      ?
IPSAVE  DW      ?
CSSAVE  DW      ?
FSAVE   DW      ?
STKPTRS ENDS

; Start of code

CODE    SEGMENT
ASSUME  CS:DOSGROUP,DS:DOSGROUP,ES:DOSGROUP,SS:DOSGROUP

        ORG     0
CODSTRT EQU     $
        JMP     DOSINIT

ESCCHAR DB      ESCCH   ;Lead-in character for escape sequences
ESCTAB: 
        IF      NOT IBM
        DB      "S"     ;Copy one char
        DB      "V"     ;Skip one char
        DB      "T"     ;Copy to char
        DB      "W"     ;Skip to char
        DB      "U"     ;Copy line
        DB      "E"     ;Kill line (no change in template)
        DB      "J"     ;Reedit line (new template)
        DB      "D"     ;Backspace
        DB      "P"     ;Enter insert mode
        DB      "Q"     ;Exit insert mode
        DB      "R"     ;Escape character
        DB      "R"     ;End of table
        ENDIF
        IF      IBM
        DB      64      ;Crtl-Z - F6
        DB      77      ;Copy one char - -->
        DB      59      ;Copy one char - F1
        DB      83      ;Skip one char - DEL
        DB      60      ;Copy to char - F2
        DB      62      ;Skip to char - F4
        DB      61      ;Copy line - F3
        DB      61      ;Kill line (no change to template ) - Not used
        DB      63      ;Reedit line (new template) - F5
        DB      75      ;Backspace - <--
        DB      82      ;Enter insert mode - INS (toggle)
        DB      65      ;Escape character - F7
        DB      65      ;End of table
        ENDIF

ESCTABLEN EQU   $-ESCTAB
        IF      NOT IBM
HEADER  DB      13,10,"MS-DOS version 1.25"
        IF      HIGHMEM
        DB      "H"
        ENDIF
        IF      DSKTEST
        DB      "D"
        ENDIF

        DB      13,10
        DB      "Copyright 1981,82 Microsoft, Inc.",13,10,"$"
        ENDIF

QUIT:
        MOV     AH,0
        JMP     SHORT SAVREGS

COMMAND: ;Interrupt call entry point
        CMP     AH,MAXCOM
        JBE     SAVREGS
BADCALL:
        MOV     AL,0
IRET:   IRET

ENTRY:  ;System call entry point and dispatcher
        POP     AX              ;IP from the long call at 5
        POP     AX              ;Segment from the long call at 5
        POP     CS:[TEMP]       ;IP from the CALL 5
        PUSHF                   ;Start re-ordering the stack
        CLI
        PUSH    AX              ;Save segment
        PUSH    CS:[TEMP]       ;Stack now ordered as if INT had been used
        CMP     CL,MAXCALL      ;This entry point doesn't get as many calls
        JA      BADCALL
        MOV     AH,CL
SAVREGS:
        PUSH    ES
        PUSH    DS
        PUSH    BP
        PUSH    DI
        PUSH    SI
        PUSH    DX
        PUSH    CX
        PUSH    BX
        PUSH    AX

        IF      DSKTEST
        MOV     AX,CS:[SPSAVE]
        MOV     CS:[NSP],AX
        MOV     AX,CS:[SSSAVE]
        MOV     CS:[NSS],AX
        POP     AX
        PUSH    AX
        ENDIF

        MOV     CS:[SPSAVE],SP
        MOV     CS:[SSSAVE],SS
        MOV     SP,CS
        MOV     SS,SP
REDISP:
        MOV     SP,OFFSET DOSGROUP:IOSTACK
        STI                     ;Stack OK now
        MOV     BL,AH
        MOV     BH,0
        SHL     BX,1
        CLD
        CMP     AH,12
        JLE     SAMSTK
        MOV     SP,OFFSET DOSGROUP:DSKSTACK
SAMSTK:
        CALL    CS:[BX+DISPATCH]
LEAVE:
        CLI
        MOV     SP,CS:[SPSAVE]
        MOV     SS,CS:[SSSAVE]
        MOV     BP,SP
        MOV     BYTE PTR [BP.AXSAVE],AL

        IF      DSKTEST
        MOV     AX,CS:[NSP]
        MOV     CS:[SPSAVE],AX
        MOV     AX,CS:[NSS]
        MOV     CS:[SSSAVE],AX
        ENDIF

        POP     AX
        POP     BX
        POP     CX
        POP     DX
        POP     SI
        POP     DI
        POP     BP
        POP     DS
        POP     ES
        IRET
; Standard Functions
DISPATCH DW     ABORT           ;0
        DW      CONIN
        DW      CONOUT
        DW      READER
        DW      PUNCH
        DW      LIST            ;5
        DW      RAWIO
        DW      RAWINP
        DW      IN
        DW      PRTBUF
        DW      BUFIN           ;10
        DW      CONSTAT
        DW      FLUSHKB
        DW      DSKRESET
        DW      SELDSK
        DW      OPEN            ;15
        DW      CLOSE
        DW      SRCHFRST
        DW      SRCHNXT
        DW      DELETE
        DW      SEQRD           ;20
        DW      SEQWRT
        DW      CREATE
        DW      RENAME
        DW      INUSE
        DW      GETDRV          ;25
        DW      SETDMA
        DW      GETFATPT
        DW      GETFATPTDL
        DW      GETRDONLY
        DW      SETATTRIB       ;30
        DW      GETDSKPT
        DW      USERCODE
        DW      RNDRD
        DW      RNDWRT
        DW      FILESIZE        ;35
        DW      SETRNDREC
; Extended Functions
        DW      SETVECT
        DW      NEWBASE
        DW      BLKRD
        DW      BLKWRT          ;40
        DW      MAKEFCB
        DW      GETDATE
        DW      SETDATE
        DW      GETTIME
        DW      SETTIME         ;45
        DW      VERIFY

INUSE:
GETIO:
SETIO:
GETRDONLY:
SETATTRIB:
USERCODE:
        MOV     AL,0
        RET

VERIFY:
        AND     AL,1
        MOV     CS:VERFLG,AL
        RET

FLUSHKB:
        PUSH    AX
        CALL    FAR PTR BIOSFLUSH
        POP     AX
        MOV     AH,AL
        CMP     AL,1
        JZ      REDISPJ
        CMP     AL,6
        JZ      REDISPJ
        CMP     AL,7
        JZ      REDISPJ
        CMP     AL,8
        JZ      REDISPJ
        CMP     AL,10
        JZ      REDISPJ
        MOV     AL,0
        RET

REDISPJ:JMP     REDISP

READER:
AUXIN:
        CALL    STATCHK
        CALL    FAR PTR BIOSAUXIN 
        RET

PUNCH:
        MOV     AL,DL
AUXOUT:
        PUSH    AX
        CALL    STATCHK
        POP     AX
        CALL    FAR PTR BIOSAUXOUT 
        RET


UNPACK:

; Inputs:
;       DS = CS
;       BX = Cluster number
;       BP = Base of drive parameters
;       SI = Pointer to drive FAT
; Outputs:
;       DI = Contents of FAT for given cluster
;       Zero set means DI=0 (free cluster)
; No other registers affected. Fatal error if cluster too big.

        CMP     BX,[BP.MAXCLUS]
        JA      HURTFAT
        LEA     DI,[SI+BX]
        SHR     BX,1
        MOV     DI,[DI+BX]
        JNC     HAVCLUS
        SHR     DI,1
        SHR     DI,1
        SHR     DI,1
        SHR     DI,1
        STC
HAVCLUS:
        RCL     BX,1
        AND     DI,0FFFH
        RET
HURTFAT:
        PUSH    AX
        MOV     AH,80H          ;Signal Bad FAT to INT 24H handler
        MOV     DI,0FFFH        ;In case INT 24H returns (it shouldn't)
        CALL    FATAL
        POP     AX              ;Try to ignore bad FAT
        RET


PACK:

; Inputs:
;       DS = CS
;       BX = Cluster number
;       DX = Data
;       SI = Pointer to drive FAT
; Outputs:
;       The data is stored in the FAT at the given cluster.
;       BX,DX,DI all destroyed
;       No other registers affected

        MOV     DI,BX
        SHR     BX,1
        ADD     BX,SI
        ADD     BX,DI
        SHR     DI,1
        MOV     DI,[BX]
        JNC     ALIGNED
        SHL     DX,1
        SHL     DX,1
        SHL     DX,1
        SHL     DX,1
        AND     DI,0FH
        JMP     SHORT PACKIN
ALIGNED:
        AND     DI,0F000H
PACKIN:
        OR      DI,DX
        MOV     [BX],DI
        RET

DEVNAME:
        MOV     SI,OFFSET DOSGROUP:IONAME       ;List of I/O devices with file names
        MOV     BH,NUMDEV               ;BH = number of device names
LOOKIO:
        MOV     DI,OFFSET DOSGROUP:NAME1
        MOV     CX,4                    ;All devices are 4 letters
        REPE    CMPSB                   ;Check for name in list
        JZ      IOCHK                   ;If first 3 letters OK, check for the rest
        ADD     SI,CX                   ;Point to next device name
        DEC     BH
        JNZ     LOOKIO
CRET:
        STC                             ;Not found
        RET

IOCHK:
        IF      IBM
        CMP     BH,NUMDEV       ;Is it the first device?
        JNZ     NOTCOM1
        MOV     BH,2            ;Make it the same as AUX
NOTCOM1:
        ENDIF
        NEG     BH
        MOV     CX,2            ;Check rest of name but not extension
        MOV     AX,2020H
        REPE    SCASW           ;Make sure rest of name is blanks
        JNZ     CRET
RET1:   RET                     ;Zero set so CREATE works

GETFILE:
; Same as GETNAME except ES:DI points to FCB on successful return
        CALL    MOVNAME
        JC      RET1
        PUSH    DX
        PUSH    DS
        CALL    FINDNAME
        POP     ES
        POP     DI
RET2:   RET


GETNAME:

; Inputs:
;       DS,DX point to FCB
; Function:
;       Find file name in disk directory. First byte is
;       drive number (0=current disk). "?" matches any
;       character.
; Outputs:
;       Carry set if file not found
;       ELSE
;       Zero set if attributes match (always except when creating)
;       BP = Base of drive parameters
;       DS = CS
;       ES = CS
;       BX = Pointer into directory buffer
;       SI = Pointer to First Cluster field in directory entry
;       [DIRBUF] has directory record with match
;       [NAME1] has file name
; All other registers destroyed.

        CALL    MOVNAME
        JC      RET2            ;Bad file name?
FINDNAME:
        MOV     AX,CS
        MOV     DS,AX
        CALL    DEVNAME
        JNC     RET2
        CALL    STARTSRCH
CONTSRCH:
        CALL    GETENTRY
        JC      RET2
SRCH:
        MOV     AH,BYTE PTR [BX]
        OR      AH,AH                   ;End of directory?
        JZ      FREE
        CMP     AH,[DELALL]             ;Free entry?
        JZ      FREE
        MOV     SI,BX
        MOV     DI,OFFSET DOSGROUP:NAME1
        MOV     CX,11
WILDCRD:
        REPE    CMPSB
        JZ      FOUND
        CMP     BYTE PTR [DI-1],"?"
        JZ      WILDCRD
NEXTENT:
        CALL    NEXTENTRY
        JNC     SRCH
RET3:   RET

FREE:
        CMP     [ENTFREE],-1            ;Found a free entry before?
        JNZ     TSTALL                  ;If so, ignore this one
        MOV     CX,[LASTENT]
        MOV     [ENTFREE],CX
TSTALL:
        CMP     AH,[DELALL]             ;At end of directory?
        JZ      NEXTENT                 ;No - continue search
        STC                             ;Report not found
        RET
 
FOUND:
;Check if attributes allow finding it
        MOV     AH,[ATTRIB]             ;Attributes of search
        NOT     AH
        AND     AH,[SI]                 ;Compare with attributes of file
        ADD     SI,15   
        AND     AH,6                    ;Only look at bits 1 and 2
        JZ      RET3
        TEST    BYTE PTR [CREATING],-1  ;Pass back mismatch if creating
        JZ      NEXTENT                 ;Otherwise continue searching
        RET


GETENTRY:

; Inputs:
;       [LASTENT] has previously searched directory entry
; Function:
;       Locates next sequential directory entry in preparation for search
; Outputs:
;       Carry set if none
;       ELSE
;       AL = Current directory block
;       BX = Pointer to next directory entry in [DIRBUF]
;       DX = Pointer to first byte after end of DIRBUF
;       [LASTENT] = New directory entry number

        MOV     AX,[LASTENT]
        INC     AX                      ;Start with next entry
        CMP     AX,[BP.MAXENT]
        JAE     NONE
GETENT:
        MOV     [LASTENT],AX
        MOV     CL,4
        SHL     AX,CL
        XOR     DX,DX
        SHL     AX,1
        RCL     DX,1                    ;Account for overflow in last shift
        MOV     BX,[BP.SECSIZ]
        AND     BL,255-31               ;Must be multiple of 32
        DIV     BX
        MOV     BX,DX                   ;Position within sector
        MOV     AH,[BP.DEVNUM]          ;AL=Directory sector no.
        CMP     AX,[DIRBUFID]
        JZ      HAVDIRBUF
        PUSH    BX
        CALL    DIRREAD
        POP     BX
HAVDIRBUF:
        MOV     DX,OFFSET DOSGROUP:DIRBUF
        ADD     BX,DX
        ADD     DX,[BP.SECSIZ]
        RET

NEXTENTRY:

; Inputs:
;       Same as outputs of GETENTRY, above
; Function:
;       Update AL, BX, and [LASTENT] for next directory entry.
;       Carry set if no more.

        MOV     DI,[LASTENT]
        INC     DI
        CMP     DI,[BP.MAXENT]
        JAE     NONE
        MOV     [LASTENT],DI
        ADD     BX,32
        CMP     BX,DX
        JB      HAVIT
        INC     AL                      ;Next directory sector
        PUSH    DX                      ;Save limit
        CALL    DIRREAD
        POP     DX
        MOV     BX,OFFSET DOSGROUP:DIRBUF
HAVIT:
        CLC
        RET

NONE:
        CALL    CHKDIRWRITE
        STC
RET4:   RET


DELETE: ; System call 19
        CALL    MOVNAME
        MOV     AL,-1
        JC      RET4
        MOV     AL,CS:[ATTRIB]
        AND     AL,6                    ;Look only at hidden bits
        CMP     AL,6                    ;Both must be set
        JNZ     NOTALL
        MOV     CX,11
        MOV     AL,"?"
        MOV     DI,OFFSET DOSGROUP:NAME1
        REPE    SCASB                   ;See if name is *.*
        JNZ     NOTALL
        MOV     BYTE PTR CS:[DELALL],0  ;DEL *.* - flag deleting all
NOTALL:
        CALL    FINDNAME
        MOV     AL,-1
        JC      RET4
        OR      BH,BH           ;Check if device name
        JS      RET4            ;Can't delete I/O devices
DELFILE:
        MOV     BYTE PTR [DIRTYDIR],-1
        MOV     AH,[DELALL]
        MOV     BYTE PTR [BX],AH
        MOV     BX,[SI]
        MOV     SI,[BP.FAT]
        OR      BX,BX
        JZ      DELNXT
        CMP     BX,[BP.MAXCLUS]
        JA      DELNXT
        CALL    RELEASE
DELNXT:
        CALL    CONTSRCH
        JNC     DELFILE
        CALL    FATWRT
        CALL    CHKDIRWRITE
        XOR     AL,AL
        RET


RENAME: ;System call 23
        CALL    MOVNAME
        JC      ERRET
        ADD     SI,5
        MOV     DI,OFFSET DOSGROUP:NAME2
        CALL    LODNAME
        JC      ERRET           ;Report error if second name invalid
        CALL    FINDNAME
        JC      ERRET
        OR      BH,BH           ;Check if I/O device name
        JS      ERRET           ;If so, can't rename it
        MOV     SI,OFFSET DOSGROUP:NAME1
        MOV     DI,OFFSET DOSGROUP:NAME3
        MOV     CX,6            ;6 words (12 bytes)--include attribute byte
        REP     MOVSW           ;Copy name to search for
RENFIL:
        MOV     DI,OFFSET DOSGROUP:NAME1
        MOV     SI,OFFSET DOSGROUP:NAME2
        MOV     CX,11
NEWNAM:
        LODSB
        CMP     AL,"?"
        JNZ     NOCHG
        MOV     AL,[BX]
NOCHG:
        STOSB
        INC     BX
        LOOP    NEWNAM
        MOV     BYTE PTR [DI],6 ;Stop duplicates with any attributes
        CALL    DEVNAME         ;Check if giving it a device name
        JNC     RENERR
        PUSH    [LASTENT]       ;Save position of match
        MOV     [LASTENT],-1    ;Search entire directory for duplicate
        CALL    CONTSRCH        ;See if new name already exists
        POP     AX
        JNC     RENERR                  ;Error if found
        CALL    GETENT                  ;Re-read matching entry
        MOV     DI,BX
        MOV     SI,OFFSET DOSGROUP:NAME1
        MOV     CX,5
        MOVSB
        REP     MOVSW                   ;Replace old name with new one
        MOV     BYTE PTR [DIRTYDIR],-1  ;Flag change in directory
        MOV     SI,OFFSET DOSGROUP:NAME3
        MOV     DI,OFFSET DOSGROUP:NAME1
        MOV     CX,6                    ;Include attribute byte
        REP     MOVSW                   ;Copy name back into search buffer
        CALL    CONTSRCH
        JNC     RENFIL
        CALL    CHKDIRWRITE
        XOR     AL,AL
        RET

RENERR:
        CALL    CHKDIRWRITE
ERRET:
        MOV     AL,-1
RET5:   RET


MOVNAME:

; Inputs:
;       DS, DX point to FCB or extended FCB
; Outputs:
;       DS:DX point to normal FCB
;       ES = CS
;       If file name OK:
;       BP has base of driver parameters
;       [NAME1] has name in upper case
; All registers except DX destroyed
; Carry set if bad file name or drive

        MOV     CS:WORD PTR [CREATING],0E500H   ;Not creating, not DEL *.*
        MOV     AX,CS
        MOV     ES,AX
        MOV     DI,OFFSET DOSGROUP:NAME1
        MOV     SI,DX
        LODSB
        MOV     CS:[EXTFCB],AL  ;Set flag if extended FCB in use
        MOV     AH,0            ;Set default attributes
        CMP     AL,-1           ;Is it an extended FCB?
        JNZ     HAVATTRB
        ADD     DX,7            ;Adjust to point to normal FCB
        ADD     SI,6            ;Point to drive select byte
        MOV     AH,[SI-1]       ;Get attribute byte
        LODSB           ;Get drive select byte
HAVATTRB:
        MOV     CS:[ATTRIB],AH  ;Save attributes
        CALL    GETTHISDRV
LODNAME:
; This entry point copies a file name from DS,SI
; to ES,DI converting to upper case.
        CMP     BYTE PTR [SI]," "       ;Don't allow blank as first letter
        STC                     ;In case of error
        JZ      RET5
        MOV     CX,11
MOVCHK:
        CALL    GETLET
        JB      RET5
        JNZ     STOLET          ;Is it a delimiter?
        CMP     AL," "          ;This is the only delimiter allowed
        STC                     ;In case of error
        JNZ     RET5
STOLET:
        STOSB
        LOOP    MOVCHK
        CLC                     ;Got through whole name - no error
RET6:   RET

GETTHISDRV:
        CMP     CS:[NUMDRV],AL
        JC      RET6
        DEC     AL
        JNS     PHYDRV
        MOV     AL,CS:[CURDRV]
PHYDRV:
        MOV     CS:[THISDRV],AL
        RET
        

OPEN:   ;System call 15
        CALL    GETFILE
DOOPEN:
; Enter here to perform OPEN on file already found
; in directory. DS=CS, BX points to directory
; entry in DIRBUF, SI points to First Cluster field, and
; ES:DI point to the FCB to be opened. This entry point
; is used by CREATE.
        JC      ERRET
        OR      BH,BH           ;Check if file is I/O device
        JS      OPENDEV         ;Special handler if so
        MOV     AL,[THISDRV]
        INC     AX
        STOSB
        XOR     AX,AX
        IF      ZEROEXT
        ADD     DI,11
        STOSW                   ;Zero low byte of extent field if IBM only
        ENDIF
        IF      NOT ZEROEXT
        ADD     DI,12           ;Point to high half of CURRENT BLOCK field
        STOSB                   ;Set it to zero (CP/M programs set low byte)
        ENDIF
        MOV     AL,128          ;Default record size
        STOSW                   ;Set record size
        LODSW                   ;Get starting cluster
        MOV     DX,AX           ;Save it for the moment
        MOVSW                   ;Transfer size to FCB
        MOVSW
        MOV     AX,[SI-8]       ;Get date
        STOSW                   ;Save date in FCB
        MOV     AX,[SI-10]      ;Get time
        STOSW                   ;Save it in FCB
        MOV     AL,[BP.DEVNUM]
        OR      AL,40H
        STOSB
        MOV     AX,DX           ;Restore starting cluster
        STOSW                   ; first cluster
        STOSW                   ; last cluster accessed
        XOR     AX,AX
        STOSW                   ; position of last cluster
        RET


OPENDEV:
        ADD     DI,13           ;point to 2nd half of extent field
        XOR     AX,AX
        STOSB                   ;Set it to zero
        MOV     AL,128
        STOSW                   ;Set record size to 128
        XOR     AX,AX
        STOSW
        STOSW                   ;Set current size to zero
        CALL    DATE16
        STOSW                   ;Date is todays
        XCHG    AX,DX
        STOSW                   ;Use current time
        MOV     AL,BH           ;Get device number
        STOSB
        XOR     AL,AL           ;No error
        RET
FATERR:
        XCHG    AX,DI           ;Put error code in DI
        MOV     AH,2            ;While trying to read FAT
        MOV     AL,[THISDRV]    ;Tell which drive
        CALL    FATAL1
        JMP     SHORT FATREAD
STARTSRCH:
        MOV     AX,-1
        MOV     [LASTENT],AX
        MOV     [ENTFREE],AX
FATREAD:

; Inputs:
;       DS = CS
; Function:
;       If disk may have been changed, FAT is read in and buffers are
;       flagged invalid. If not, no action is taken.
; Outputs:
;       BP = Base of drive parameters
;       Carry set if invalid drive returned by MAPDEV
; All other registers destroyed

        MOV     AL,[THISDRV]
        XOR     AH,AH           ;Set default response to zero & clear carry
        CALL    FAR PTR BIOSDSKCHG      ;See what BIOS has to say
        JC      FATERR
        CALL    GETBP
        MOV     AL,[THISDRV]    ;Use physical unit number
        MOV     SI,[BP.FAT]
        OR      AH,[SI-1]       ;Dirty byte for FAT
        JS      NEWDSK          ;If either say new disk, then it's so
        JNZ     MAPDRV
        MOV     AH,1
        CMP     AX,WORD PTR [BUFDRVNO]  ;Does buffer have dirty sector of this drive?
        JZ      MAPDRV
NEWDSK:
        CMP     AL,[BUFDRVNO]   ;See if buffer is for this drive
        JNZ     BUFOK           ;If not, don't touch it
        MOV     [BUFSECNO],0    ;Flag buffers invalid
        MOV     WORD PTR [BUFDRVNO],00FFH
BUFOK:
        MOV     [DIRBUFID],-1
        CALL    FIGFAT
NEXTFAT:
        PUSH    AX
        CALL    DSKREAD
        POP     AX
        JC      BADFAT
        SUB     AL,[BP.FATCNT]
        JZ      NEWFAT
        CALL    FATWRT
NEWFAT:
        MOV     SI,[BP.FAT]
        MOV     AL,[BP.DEVNUM]
        MOV     AH,[SI]         ;Get first byte of FAT
        OR      AH,0F8H         ;Put in range
        CALL    FAR PTR BIOSMAPDEV
        MOV     AH,0
        MOV     [SI-2],AX       ;Set device no. and reset dirty bit
MAPDRV:
        MOV     AL,[SI-2]       ;Get device number
GETBP:
        MOV     BP,[DRVTAB]     ;Just in case drive isn't valid
        AND     AL,3FH          ;Mask out dirty bit
        CMP     AL,[NUMIO]
        CMC
        JC      RET7
        PUSH    AX
        MOV     AH,DPBSIZ
        MUL     AH
        ADD     BP,AX
        POP     AX
RET7:   RET

BADFAT:
        MOV     CX,DI
        ADD     DX,CX
        DEC     AL
        JNZ     NEXTFAT
        CALL    FIGFAT                          ;Reset registers
        CALL    DREAD                           ;Try first FAT once more
        JMP     SHORT NEWFAT

OKRET1:
        MOV     AL,0
        RET

CLOSE:  ;System call 16
        MOV     DI,DX
        CMP     BYTE PTR [DI],-1                ;Check for extended FCB
        JNZ     NORMFCB3
        ADD     DI,7
NORMFCB3:
        TEST    BYTE PTR [DI.DEVID],0C0H        ;Allow only dirty files
        JNZ     OKRET1                          ;can't close if I/O device, or not writen
        MOV     AL,[DI]                         ;Get physical unit number
        DEC     AL                              ;Make zero = drive A
        MOV     AH,1                            ;Look for dirty buffer
        CMP     AX,CS:WORD PTR [BUFDRVNO]
        JNZ     FNDDIR
;Write back dirty buffer if on same drive
        PUSH    DX
        PUSH    DS
        PUSH    CS
        POP     DS
        MOV     BYTE PTR [DIRTYBUF],0
        MOV     BX,[BUFFER]
        MOV     CX,1
        MOV     DX,[BUFSECNO]
        MOV     BP,[BUFDRVBP]
        CALL    DWRITE
        POP     DS
        POP     DX
FNDDIR:
        CALL    GETFILE
BADCLOSEJ:
        JC      BADCLOSE
        MOV     CX,ES:[DI.FIRCLUS]
        MOV     [SI],CX
        MOV     DX,ES:WORD PTR [DI.FILSIZ]
        MOV     [SI+2],DX
        MOV     DX,ES:WORD PTR [DI.FILSIZ+2]
        MOV     [SI+4],DX
        MOV     DX,ES:[DI.FDATE]
        MOV     [SI-2],DX
        MOV     DX,ES:[DI.FTIME]
        MOV     [SI-4],DX
        CALL    DIRWRITE

CHKFATWRT:
; Do FATWRT only if FAT is dirty and uses same I/O driver
        MOV     SI,[BP.FAT]
        MOV     AL,[BP.DEVNUM]
        MOV     AH,1
        CMP     [SI-2],AX       ;See if FAT dirty and uses same driver
        JNZ     OKRET

FATWRT:

; Inputs:
;       DS = CS
;       BP = Base of drive parameter table
; Function:
;       Write the FAT back to disk and reset FAT
;       dirty bit.
; Outputs:
;       AL = 0
;       BP unchanged
; All other registers destroyed

        CALL    FIGFAT
        MOV     BYTE PTR [BX-1],0
EACHFAT:
        PUSH    DX
        PUSH    CX
        PUSH    BX
        PUSH    AX
        CALL    DWRITE
        POP     AX
        POP     BX
        POP     CX
        POP     DX
        ADD     DX,CX
        DEC     AL
        JNZ     EACHFAT
OKRET:
        MOV     AL,0
        RET

BADCLOSE:
        MOV     SI,[BP.FAT]
        MOV     BYTE PTR [SI-1],0
        MOV     AL,-1
        RET


FIGFAT:
; Loads registers with values needed to read or
; write a FAT.
        MOV     AL,[BP.FATCNT]
        MOV     BX,[BP.FAT]
        MOV     CL,[BP.FATSIZ]  ;No. of records occupied by FAT
        MOV     CH,0
        MOV     DX,[BP.FIRFAT]  ;Record number of start of FATs
        RET


DIRCOMP:
; Prepare registers for directory read or write
        CBW
        ADD     AX,[BP.FIRDIR]
        MOV     DX,AX
        MOV     BX,OFFSET DOSGROUP:DIRBUF
        MOV     CX,1
        RET


CREATE: ;System call 22
        CALL    MOVNAME
        JC      ERRET3
        MOV     DI,OFFSET DOSGROUP:NAME1
        MOV     CX,11
        MOV     AL,"?"
        REPNE   SCASB
        JZ      ERRET3
        MOV     CS:BYTE PTR [CREATING],-1
        PUSH    DX
        PUSH    DS
        CALL    FINDNAME
        JNC     EXISTENT
        MOV     AX,[ENTFREE]    ;First free entry found in FINDNAME
        CMP     AX,-1
        JZ      ERRPOP
        CALL    GETENT          ;Point at that free entry
        JMP     SHORT FREESPOT
ERRPOP:
        POP     DS
        POP     DX
ERRET3:
        MOV     AL,-1
        RET

EXISTENT:
        JNZ     ERRPOP          ;Error if attributes don't match
        OR      BH,BH           ;Check if file is I/O device
        JS      OPENJMP         ;If so, no action
        MOV     CX,[SI]         ;Get pointer to clusters
        JCXZ    FREESPOT
        CMP     CX,[BP.MAXCLUS]
        JA      FREESPOT
        PUSH    BX
        MOV     BX,CX
        MOV     SI,[BP.FAT]
        CALL    RELEASE         ;Free any data already allocated
        CALL    FATWRT
        POP     BX
FREESPOT:
        MOV     DI,BX
        MOV     SI,OFFSET DOSGROUP:NAME1
        MOV     CX,5
        MOVSB
        REP     MOVSW
        MOV     AL,[ATTRIB]
        STOSB
        XOR     AX,AX
        MOV     CL,5
        REP     STOSW
        CALL    DATE16
        XCHG    AX,DX
        STOSW
        XCHG    AX,DX
        STOSW
        XOR     AX,AX
        PUSH    DI
        MOV     CL,6
SMALLENT:
        REP     STOSB
        PUSH    BX
        CALL    DIRWRITE
        POP     BX
        POP     SI
OPENJMP:
        CLC                     ;Clear carry so OPEN won't fail
        POP     ES
        POP     DI
        JMP     DOOPEN


DIRREAD:

; Inputs:
;       DS = CS
;       AL = Directory block number
;       BP = Base of drive parameters
; Function:
;       Read the directory block into DIRBUF.
; Outputs:
;       AX,BP unchanged
; All other registers destroyed.

        PUSH    AX
        CALL    CHKDIRWRITE
        POP     AX
        PUSH    AX
        MOV     AH,[BP.DEVNUM]
        MOV     [DIRBUFID],AX
        CALL    DIRCOMP
        CALL    DREAD
        POP     AX
RET8:   RET


DREAD:

; Inputs:
;       BX,DS = Transfer address
;       CX = Number of sectors
;       DX = Absolute record number
;       BP = Base of drive parameters
; Function:
;       Calls BIOS to perform disk read. If BIOS reports
;       errors, will call HARDERR for further action.
; BP preserved. All other registers destroyed.

        CALL    DSKREAD
        JNC     RET8
        MOV     CS:BYTE PTR [READOP],0
        CALL    HARDERR
        CMP     AL,1            ;Check for retry
        JZ      DREAD
        RET                     ;Ignore otherwise


HARDERR:

;Hard disk error handler. Entry conditions:
;       DS:BX = Original disk transfer address
;       DX = Original logical sector number
;       CX = Number of sectors to go (first one gave the error)
;       AX = Hardware error code
;       DI = Original sector transfer count
;       BP = Base of drive parameters
;       [READOP] = 0 for read, 1 for write

        XCHG    AX,DI           ;Error code in DI, count in AX
        SUB     AX,CX           ;Number of sectors successfully transferred
        ADD     DX,AX           ;First sector number to retry
        PUSH    DX
        MUL     [BP.SECSIZ]     ;Number of bytes transferred
        POP     DX
        ADD     BX,AX           ;First address for retry
        MOV     AH,0            ;Flag disk section in error
        CMP     DX,[BP.FIRFAT]  ;In reserved area?
        JB      ERRINT
        INC     AH              ;Flag for FAT
        CMP     DX,[BP.FIRDIR]  ;In FAT?
        JB      ERRINT
        INC     AH
        CMP     DX,[BP.FIRREC]  ;In directory?
        JB      ERRINT
        INC     AH              ;Must be in data area
ERRINT:
        SHL     AH,1            ;Make room for read/write bit
        OR      AH,CS:[READOP]
FATAL:
        MOV     AL,[BP.DRVNUM]  ;Get drive number
FATAL1:
        PUSH    BP              ;The only thing we preserve
        MOV     CS:[CONTSTK],SP
        CLI                     ;Prepare to play with stack
        MOV     SS,CS:[SSSAVE]
        MOV     SP,CS:[SPSAVE]  ;User stack pointer restored
        INT     24H             ;Fatal error interrupt vector
        MOV     CS:[SPSAVE],SP
        MOV     CS:[SSSAVE],SS
        MOV     SP,CS
        MOV     SS,SP
        MOV     SP,CS:[CONTSTK]
        STI
        POP     BP
        CMP     AL,2
        JZ      ERROR
        RET

DSKREAD:
        MOV     AL,[BP.DEVNUM]
        PUSH    BP
        PUSH    BX
        PUSH    CX
        PUSH    DX
        CALL    FAR PTR BIOSREAD 
        POP     DX
        POP     DI
        POP     BX
        POP     BP
RET9:   RET


CHKDIRWRITE:
        TEST    BYTE PTR [DIRTYDIR],-1
        JZ      RET9

DIRWRITE:

; Inputs:
;       DS = CS
;       AL = Directory block number
;       BP = Base of drive parameters
; Function:
;       Write the directory block into DIRBUF.
; Outputs:
;       BP unchanged
; All other registers destroyed.

        MOV     BYTE PTR [DIRTYDIR],0
        MOV     AL,BYTE PTR [DIRBUFID]
        CALL    DIRCOMP


DWRITE:

; Inputs:
;       BX,DS = Transfer address
;       CX = Number of sectors
;       DX = Absolute record number
;       BP = Base of drive parameters
; Function:
;       Calls BIOS to perform disk write. If BIOS reports
;       errors, will call HARDERR for further action.
; BP preserved. All other registers destroyed.

        MOV     AL,[BP.DEVNUM]
        MOV     AH,CS:VERFLG
        PUSH    BP
        PUSH    BX
        PUSH    CX
        PUSH    DX
        CALL    FAR PTR BIOSWRITE 
        POP     DX
        POP     DI
        POP     BX
        POP     BP
        JNC     RET9
        MOV     CS:BYTE PTR [READOP],1
        CALL    HARDERR
        CMP     AL,1            ;Check for retry
        JZ      DWRITE
        RET


ABORT:
        LDS     SI,CS:DWORD PTR [SPSAVE]
        MOV     DS,[SI.CSSAVE]
        XOR     AX,AX
        MOV     ES,AX
        MOV     SI,SAVEXIT
        MOV     DI,EXIT
        MOVSW
        MOVSW
        MOVSW
        MOVSW
        MOVSW
        MOVSW
ERROR:
        MOV     AX,CS
        MOV     DS,AX
        MOV     ES,AX
        CALL    WRTFATS
        XOR     AX,AX
        CLI
        MOV     SS,[SSSAVE]
        MOV     SP,[SPSAVE]
        MOV     DS,AX
        MOV     SI,EXIT
        MOV     DI,OFFSET DOSGROUP:EXITHOLD
        MOVSW
        MOVSW
        POP     AX
        POP     BX
        POP     CX
        POP     DX
        POP     SI
        POP     DI
        POP     BP
        POP     DS
        POP     ES
        STI             ;Stack OK now
        JMP     CS:DWORD PTR [EXITHOLD]


SEQRD:  ;System call 20
        CALL    GETREC
        CALL    LOAD
        JMP     SHORT FINSEQ

SEQWRT: ;System call 21
        CALL    GETREC
        CALL    STORE
FINSEQ:
        JCXZ    SETNREX
        ADD     AX,1
        ADC     DX,0
        JMP     SHORT SETNREX

RNDRD:  ;System call 33
        CALL    GETRRPOS1
        CALL    LOAD
        JMP     SHORT FINRND

RNDWRT: ;System call 34
        CALL    GETRRPOS1
        CALL    STORE
        JMP     SHORT FINRND

BLKRD:  ;System call 39
        CALL    GETRRPOS
        CALL    LOAD
        JMP     SHORT FINBLK

BLKWRT: ;System call 40
        CALL    GETRRPOS
        CALL    STORE
FINBLK:
        LDS     SI,DWORD PTR [SPSAVE]
        MOV     [SI.CXSAVE],CX
        JCXZ    FINRND
        ADD     AX,1
        ADC     DX,0
FINRND:
        MOV     ES:WORD PTR [DI.RR],AX
        MOV     ES:[DI.RR+2],DL
        OR      DH,DH
        JZ      SETNREX
        MOV     ES:[DI.RR+3],DH ;Save 4 byte of RECPOS only if significant
SETNREX:
        MOV     CX,AX
        AND     AL,7FH
        MOV     ES:[DI.NR],AL
        AND     CL,80H
        SHL     CX,1
        RCL     DX,1
        MOV     AL,CH
        MOV     AH,DL
        MOV     ES:[DI.EXTENT],AX
        MOV     AL,CS:[DSKERR]
        RET

GETRRPOS1:
        MOV     CX,1
GETRRPOS:
        MOV     DI,DX
        CMP     BYTE PTR [DI],-1
        JNZ     NORMFCB1
        ADD     DI,7
NORMFCB1:
        MOV     AX,WORD PTR [DI.RR]
        MOV     DX,WORD PTR [DI.RR+2]
        RET

NOFILERR:
        XOR     CX,CX
        MOV     BYTE PTR [DSKERR],4
        POP     BX
        RET

SETUP:

; Inputs:
;       DS:DI point to FCB
;       DX:AX = Record position in file of disk transfer
;       CX = Record count
; Outputs:
;       DS = CS
;       ES:DI point to FCB
;       BL = DEVID from FCB
;       CX = No. of bytes to transfer
;       BP = Base of drive parameters
;       SI = FAT pointer
;       [RECCNT] = Record count
;       [RECPOS] = Record position in file
;       [FCB] = DI
;       [NEXTADD] = Displacement of disk transfer within segment
;       [SECPOS] = Position of first sector
;       [BYTPOS] = Byte position in file
;       [BYTSECPOS] = Byte position in first sector
;       [CLUSNUM] = First cluster
;       [SECCLUSPOS] = Sector within first cluster
;       [DSKERR] = 0 (no errors yet)
;       [TRANS] = 0 (No transfers yet)
;       [THISDRV] = Physical drive unit number
; If SETUP detects no records will be transfered, it returns 1 level up 
; with CX = 0.

        PUSH    AX
        MOV     AL,[DI]
        DEC     AL
        MOV     CS:[THISDRV],AL
        MOV     AL,[DI.DEVID]
        MOV     SI,[DI.RECSIZ]
        OR      SI,SI
        JNZ     HAVRECSIZ
        MOV     SI,128
        MOV     [DI.RECSIZ],SI
HAVRECSIZ:
        PUSH    DS
        POP     ES              ;Set ES to DS
        PUSH    CS
        POP     DS              ;Set DS to CS
        OR      AL,AL           ;Is it a device?
        JNS     NOTDEVICE
        MOV     AL,0            ;Fake in drive 0 so we can get SP
NOTDEVICE:
        CALL    GETBP
        POP     AX
        JC      NOFILERR
        CMP     SI,64           ;Check if highest byte of RECPOS is significant
        JB      SMALREC
        MOV     DH,0            ;Ignore MSB if record >= 64 bytes
SMALREC:
        MOV     [RECCNT],CX
        MOV     WORD PTR [RECPOS],AX
        MOV     WORD PTR [RECPOS+2],DX
        MOV     [FCB],DI
        MOV     BX,[DMAADD]
        MOV     [NEXTADD],BX
        MOV     BYTE PTR [DSKERR],0
        MOV     BYTE PTR [TRANS],0
        MOV     BX,DX
        MUL     SI
        MOV     WORD PTR [BYTPOS],AX
        PUSH    DX
        MOV     AX,BX
        MUL     SI
        POP     BX
        ADD     AX,BX
        ADC     DX,0            ;Ripple carry
        JNZ     EOFERR
        MOV     WORD PTR [BYTPOS+2],AX
        MOV     DX,AX
        MOV     AX,WORD PTR [BYTPOS]
        MOV     BX,[BP.SECSIZ]
        CMP     DX,BX           ;See if divide will overflow
        JNC     EOFERR
        DIV     BX
        MOV     [SECPOS],AX
        MOV     [BYTSECPOS],DX
        MOV     DX,AX
        AND     AL,[BP.CLUSMSK]
        MOV     [SECCLUSPOS],AL
        MOV     AX,CX           ;Record count
        MOV     CL,[BP.CLUSSHFT]
        SHR     DX,CL
        MOV     [CLUSNUM],DX
        MUL     SI              ;Multiply by bytes per record
        MOV     CX,AX
        ADD     AX,[DMAADD]     ;See if it will fit in one segment
        ADC     DX,0
        JZ      OK              ;Must be less than 64K
        MOV     AX,[DMAADD]
        NEG     AX              ;Amount of room left in segment
        JNZ     PARTSEG         ;All 64K available?
        DEC     AX              ;If so, reduce by one
PARTSEG:
        XOR     DX,DX
        DIV     SI              ;How many records will fit?
        MOV     [RECCNT],AX
        MUL     SI              ;Translate that back into bytes
        MOV     BYTE PTR [DSKERR],2     ;Flag that trimming took place
        MOV     CX,AX
        JCXZ    NOROOM
OK:
        MOV     BL,ES:[DI.DEVID]
        MOV     SI,[BP.FAT]
        RET

EOFERR:
        MOV     BYTE PTR [DSKERR],1
        XOR     CX,CX
NOROOM:
        POP     BX              ;Kill return address
        RET

BREAKDOWN:

;Inputs:
;       DS = CS
;       CX = Length of disk transfer in bytes
;       BP = Base of drive parameters
;       [BYTSECPOS] = Byte position witin first sector
;Outputs:
;       [BYTCNT1] = Bytes to transfer in first sector
;       [SECCNT] = No. of whole sectors to transfer
;       [BYTCNT2] = Bytes to transfer in last sector
;AX, BX, DX destroyed. No other registers affected.

        MOV     AX,[BYTSECPOS]
        MOV     BX,CX
        OR      AX,AX
        JZ      SAVFIR          ;Partial first sector?
        SUB     AX,[BP.SECSIZ]
        NEG     AX              ;Max number of bytes left in first sector
        SUB     BX,AX           ;Subtract from total length
        JAE     SAVFIR
        ADD     AX,BX           ;Don't use all of the rest of the sector
        XOR     BX,BX           ;And no bytes are left
SAVFIR:
        MOV     [BYTCNT1],AX
        MOV     AX,BX
        XOR     DX,DX
        DIV     [BP.SECSIZ]     ;How many whole sectors?
        MOV     [SECCNT],AX
        MOV     [BYTCNT2],DX    ;Bytes remaining for last sector
RET10:  RET


FNDCLUS:

; Inputs:
;       DS = CS
;       CX = No. of clusters to skip
;       BP = Base of drive parameters
;       SI = FAT pointer
;       ES:DI point to FCB
; Outputs:
;       BX = Last cluster skipped to
;       CX = No. of clusters remaining (0 unless EOF)
;       DX = Position of last cluster
; DI destroyed. No other registers affected.

        MOV     BX,ES:[DI.LSTCLUS]
        MOV     DX,ES:[DI.CLUSPOS]
        OR      BX,BX
        JZ      NOCLUS
        SUB     CX,DX
        JNB     FINDIT
        ADD     CX,DX
        XOR     DX,DX
        MOV     BX,ES:[DI.FIRCLUS]
FINDIT:
        JCXZ    RET10
SKPCLP:
        CALL    UNPACK
        CMP     DI,0FF8H
        JAE     RET10
        XCHG    BX,DI
        INC     DX
        LOOP    SKPCLP
        RET
NOCLUS:
        INC     CX
        DEC     DX
        RET


BUFSEC:
; Inputs:
;       AL = 0 if buffer must be read, 1 if no pre-read needed
;       BP = Base of drive parameters
;       [CLUSNUM] = Physical cluster number
;       [SECCLUSPOS] = Sector position of transfer within cluster
;       [BYTCNT1] = Size of transfer
; Function:
;       Insure specified sector is in buffer, flushing buffer before
;       read if necessary.
; Outputs:
;       SI = Pointer to buffer
;       DI = Pointer to transfer address
;       CX = Number of bytes
;       [NEXTADD] updated
;       [TRANS] set to indicate a transfer will occur

        MOV     DX,[CLUSNUM]
        MOV     BL,[SECCLUSPOS]
        CALL    FIGREC
        MOV     [PREREAD],AL
        CMP     DX,[BUFSECNO]
        JNZ     GETSEC
        MOV     AL,[BUFDRVNO]
        CMP     AL,[THISDRV]
        JZ      FINBUF          ;Already have it?
GETSEC:
        XOR     AL,AL
        XCHG    [DIRTYBUF],AL   ;Read dirty flag and reset it
        OR      AL,AL
        JZ      RDSEC
        PUSH    DX
        PUSH    BP
        MOV     BP,[BUFDRVBP]
        MOV     BX,[BUFFER]
        MOV     CX,1
        MOV     DX,[BUFSECNO]
        CALL    DWRITE
        POP     BP
        POP     DX
RDSEC:
        TEST    BYTE PTR [PREREAD],-1
        JNZ     SETBUF
        XOR     AX,AX
        MOV     [BUFSECNO],AX           ;Set buffer valid in case of disk error
        DEC     AX
        MOV     [BUFDRVNO],AL
        MOV     BX,[BUFFER]
        MOV     CX,1
        PUSH    DX
        CALL    DREAD
        POP     DX
SETBUF:
        MOV     [BUFSECNO],DX
        MOV     AL,[THISDRV]
        MOV     [BUFDRVNO],AL
        MOV     [BUFDRVBP],BP
FINBUF:
        MOV     BYTE PTR [TRANS],1      ;A transfer is taking place
        MOV     DI,[NEXTADD]
        MOV     SI,DI
        MOV     CX,[BYTCNT1]
        ADD     SI,CX
        MOV     [NEXTADD],SI
        MOV     SI,[BUFFER]
        ADD     SI,[BYTSECPOS]
        RET

BUFRD:
        XOR     AL,AL           ;Pre-read necessary
        CALL    BUFSEC
        PUSH    ES
        MOV     ES,[DMAADD+2]
        SHR     CX,1
        JNC     EVENRD
        MOVSB
EVENRD:
        REP     MOVSW
        POP     ES
        RET

BUFWRT:
        MOV     AX,[SECPOS]
        INC     AX              ;Set for next sector
        MOV     [SECPOS],AX
        CMP     AX,[VALSEC]     ;Has sector been written before?
        MOV     AL,1
        JA      NOREAD          ;Skip preread if SECPOS>VALSEC
        MOV     AL,0
NOREAD:
        CALL    BUFSEC
        XCHG    DI,SI
        PUSH    DS
        PUSH    ES
        PUSH    CS
        POP     ES
        MOV     DS,[DMAADD+2]
        SHR     CX,1
        JNC     EVENWRT
        MOVSB
EVENWRT:
        REP     MOVSW
        POP     ES
        POP     DS
        MOV     BYTE PTR [DIRTYBUF],1
        RET

NEXTSEC:
        TEST    BYTE PTR [TRANS],-1
        JZ      CLRET
        MOV     AL,[SECCLUSPOS]
        INC     AL
        CMP     AL,[BP.CLUSMSK]
        JBE     SAVPOS
        MOV     BX,[CLUSNUM]
        CMP     BX,0FF8H
        JAE     NONEXT
        MOV     SI,[BP.FAT]
        CALL    UNPACK
        MOV     [CLUSNUM],DI
        INC     [LASTPOS]
        MOV     AL,0
SAVPOS:
        MOV     [SECCLUSPOS],AL
CLRET:
        CLC
        RET
NONEXT:
        STC
        RET

TRANBUF:
        LODSB
        STOSB
        CMP     AL,13           ;Check for carriage return
        JNZ     NORMCH
        MOV     BYTE PTR [SI],10
NORMCH:
        CMP     AL,10
        LOOPNZ  TRANBUF
        JNZ     ENDRDCON
        CALL    OUT             ;Transmit linefeed
        XOR     SI,SI
        OR      CX,CX
        JNZ     GETBUF
        OR      AL,1            ;Clear zero flag--not end of file
ENDRDCON:
        MOV     [CONTPOS],SI
ENDRDDEV:
        MOV     [NEXTADD],DI
        POP     ES
        JNZ     SETFCBJ         ;Zero set if Ctrl-Z found in input
        MOV     DI,[FCB]
        AND     ES:BYTE PTR [DI.DEVID],0FFH-40H ;Mark as no more data available
SETFCBJ:
        JMP     SETFCB

READDEV:
        PUSH    ES
        LES     DI,DWORD PTR [DMAADD]
        INC     BL
        JZ      READCON
        INC     BL
        JNZ     ENDRDDEV
READAUX:
        CALL    AUXIN
        STOSB
        CMP     AL,1AH
        LOOPNZ  READAUX
        JMP     SHORT ENDRDDEV

READCON:
        PUSH    CS
        POP     DS
        MOV     SI,[CONTPOS]
        OR      SI,SI
        JNZ     TRANBUF
        CMP     BYTE PTR [CONBUF],128
        JZ      GETBUF
        MOV     WORD PTR [CONBUF],0FF80H        ;Set up 128-byte buffer with no template
GETBUF:
        PUSH    CX
        PUSH    ES
        PUSH    DI
        MOV     DX,OFFSET DOSGROUP:CONBUF
        CALL    BUFIN           ;Get input buffer
        POP     DI
        POP     ES
        POP     CX
        MOV     SI,2 + OFFSET DOSGROUP:CONBUF
        CMP     BYTE PTR [SI],1AH       ;Check for Ctrl-Z in first character
        JNZ     TRANBUF
        MOV     AL,1AH
        STOSB
        MOV     AL,10
        CALL    OUT             ;Send linefeed
        XOR     SI,SI
        JMP     SHORT ENDRDCON

RDERR:
        XOR     CX,CX
        JMP     WRTERR

RDLASTJ:JMP     RDLAST

LOAD:

; Inputs:
;       DS:DI point to FCB
;       DX:AX = Position in file to read
;       CX = No. of records to read
; Outputs:
;       DX:AX = Position of last record read
;       CX = No. of bytes read
;       ES:DI point to FCB
;       LSTCLUS, CLUSPOS fields in FCB set

        CALL    SETUP
        OR      BL,BL           ;Check for named device I/O
        JS      READDEV
        MOV     AX,ES:WORD PTR [DI.FILSIZ]
        MOV     BX,ES:WORD PTR [DI.FILSIZ+2]
        SUB     AX,WORD PTR [BYTPOS]
        SBB     BX,WORD PTR [BYTPOS+2]
        JB      RDERR
        JNZ     ENUF
        OR      AX,AX
        JZ      RDERR
        CMP     AX,CX
        JAE     ENUF
        MOV     CX,AX
ENUF:
        CALL    BREAKDOWN
        MOV     CX,[CLUSNUM]
        CALL    FNDCLUS
        OR      CX,CX
        JNZ     RDERR
        MOV     [LASTPOS],DX
        MOV     [CLUSNUM],BX
        CMP     [BYTCNT1],0
        JZ      RDMID
        CALL    BUFRD
RDMID:
        CMP     [SECCNT],0
        JZ      RDLASTJ
        CALL    NEXTSEC
        JC      SETFCB
        MOV     BYTE PTR [TRANS],1      ;A transfer is taking place
ONSEC:
        MOV     DL,[SECCLUSPOS]
        MOV     CX,[SECCNT]
        MOV     BX,[CLUSNUM]
RDLP:
        CALL    OPTIMIZE
        PUSH    DI
        PUSH    AX
        PUSH    DS
        MOV     DS,[DMAADD+2]
        PUSH    DX
        PUSH    BX
        PUSHF                   ;Save carry flag
        CALL DREAD
        POPF                    ;Restore carry flag
        POP     DI              ;Initial transfer address
        POP     AX              ;First sector transfered
        POP     DS
        JC      NOTBUFFED       ;Was one of those sectors in the buffer?
        CMP     BYTE PTR [DIRTYBUF],0   ;Is buffer dirty?
        JZ      NOTBUFFED       ;If not no problem
;We have transfered in a sector from disk when a dirty copy of it is in the buffer.
;We must transfer the sector from the buffer to correct memory address
        SUB     AX,[BUFSECNO]   ;How many sectors into the transfer?
        NEG     AX
        MOV     CX,[BP.SECSIZ]
        MUL     CX              ;How many bytes into the transfer?
        ADD     DI,AX
        MOV     SI,[BUFFER]
        PUSH    ES
        MOV     ES,[DMAADD+2]   ;Get disk transfer segment
        SHR     CX,1
        REP     MOVSW
        JNC     EVENMOV
        MOVSB
EVENMOV:
        POP     ES
NOTBUFFED:
        POP     CX
        POP     BX
        JCXZ    RDLAST
        CMP     BX,0FF8H
        JAE     SETFCB
        MOV     DL,0
        INC     [LASTPOS]       ;We'll be using next cluster
        JMP     SHORT RDLP

SETFCB:
        MOV     SI,[FCB]
        MOV     AX,[NEXTADD]
        MOV     DI,AX
        SUB     AX,[DMAADD]     ;Number of bytes transfered
        XOR     DX,DX
        MOV     CX,ES:[SI.RECSIZ]
        DIV     CX              ;Number of records
        CMP     AX,[RECCNT]     ;Check if all records transferred
        JZ      FULLREC
        MOV     BYTE PTR [DSKERR],1
        OR      DX,DX
        JZ      FULLREC         ;If remainder 0, then full record transfered
        MOV     BYTE PTR [DSKERR],3     ;Flag partial last record
        SUB     CX,DX           ;Bytes left in last record
        PUSH    ES
        MOV     ES,[DMAADD+2]
        XCHG    AX,BX           ;Save the record count temporarily
        XOR     AX,AX           ;Fill with zeros
        SHR     CX,1
        JNC     EVENFIL
        STOSB
EVENFIL:
        REP     STOSW
        XCHG    AX,BX           ;Restore record count to AX
        POP     ES
        INC     AX              ;Add last (partial) record to total
FULLREC:
        MOV     CX,AX
        MOV     DI,SI           ;ES:DI point to FCB
SETCLUS:
        MOV     AX,[CLUSNUM]
        MOV     ES:[DI.LSTCLUS],AX
        MOV     AX,[LASTPOS]
        MOV     ES:[DI.CLUSPOS],AX
ADDREC:
        MOV     AX,WORD PTR [RECPOS]
        MOV     DX,WORD PTR [RECPOS+2]
        JCXZ    RET28           ;If no records read, don't change position
        DEC     CX
        ADD     AX,CX           ;Update current record position
        ADC     DX,0
        INC     CX      
RET28:  RET

RDLAST:
        MOV     AX,[BYTCNT2]
        OR      AX,AX
        JZ      SETFCB
        MOV     [BYTCNT1],AX
        CALL    NEXTSEC
        JC      SETFCB
        MOV     [BYTSECPOS],0
        CALL    BUFRD
        JMP     SHORT SETFCB

WRTDEV:
        PUSH    DS
        LDS     SI,DWORD PTR [DMAADD]
        OR      BL,40H
        INC     BL
        JZ      WRTCON
        INC     BL
        JZ      WRTAUX
        INC     BL
        JZ      ENDWRDEV        ;Done if device is NUL
WRTLST:
        LODSB
        CMP     AL,1AH
        JZ      ENDWRDEV
        CALL    LISTOUT
        LOOP    WRTLST
        JMP     SHORT ENDWRDEV

WRTAUX:
        LODSB
        CALL    AUXOUT
        CMP     AL,1AH
        LOOPNZ  WRTAUX
        JMP     SHORT ENDWRDEV

WRTCON:
        LODSB
        CMP     AL,1AH
        JZ      ENDWRDEV
        CALL    OUT
        LOOP    WRTCON
ENDWRDEV:
        POP     DS
        MOV     CX,[RECCNT]
        MOV     DI,[FCB]
        JMP     SHORT ADDREC

HAVSTART:
        MOV     CX,AX
        CALL    SKPCLP
        JCXZ    DOWRTJ
        CALL    ALLOCATE
        JNC     DOWRTJ
WRTERR:
        MOV     BYTE PTR [DSKERR],1
LVDSK:
        MOV     AX,WORD PTR [RECPOS]
        MOV     DX,WORD PTR [RECPOS+2]
        MOV     DI,[FCB]
        RET

DOWRTJ: JMP     DOWRT

WRTEOFJ:
        JMP     WRTEOF

STORE:

; Inputs:
;       DS:DI point to FCB
;       DX:AX = Position in file of disk transfer
;       CX = Record count
; Outputs:
;       DX:AX = Position of last record written
;       CX = No. of records written
;       ES:DI point to FCB
;       LSTCLUS, CLUSPOS fields in FCB set

        CALL    SETUP
        CALL    DATE16
        MOV     ES:[DI.FDATE],AX
        MOV     ES:[DI.FTIME],DX
        OR      BL,BL
        JS      WRTDEV
        AND     BL,3FH          ;Mark file as dirty
        MOV     ES:[DI.DEVID],BL
        CALL    BREAKDOWN
        MOV     AX,WORD PTR [BYTPOS]
        MOV     DX,WORD PTR [BYTPOS+2]
        JCXZ    WRTEOFJ
        DEC     CX
        ADD     AX,CX
        ADC     DX,0            ;AX:DX=last byte accessed
        DIV     [BP.SECSIZ]     ;AX=last sector accessed
        MOV     CL,[BP.CLUSSHFT]
        SHR     AX,CL           ;Last cluster to be accessed
        PUSH    AX
        MOV     AX,ES:WORD PTR [DI.FILSIZ]
        MOV     DX,ES:WORD PTR [DI.FILSIZ+2]
        DIV     [BP.SECSIZ]
        OR      DX,DX
        JZ      NORNDUP
        INC     AX              ;Round up if any remainder
NORNDUP:
        MOV     [VALSEC],AX     ;Number of sectors that have been written
        POP     AX
        MOV     CX,[CLUSNUM]    ;First cluster accessed
        CALL    FNDCLUS
        MOV     [CLUSNUM],BX
        MOV     [LASTPOS],DX
        SUB     AX,DX           ;Last cluster minus current cluster
        JZ      DOWRT           ;If we have last clus, we must have first
        JCXZ    HAVSTART        ;See if no more data
        PUSH    CX              ;No. of clusters short of first
        MOV     CX,AX
        CALL    ALLOCATE
        POP     AX
        JC      WRTERR
        MOV     CX,AX
        MOV     DX,[LASTPOS]
        INC     DX
        DEC     CX
        JZ      NOSKIP
        CALL    SKPCLP
NOSKIP:
        MOV     [CLUSNUM],BX
        MOV     [LASTPOS],DX
DOWRT:
        CMP     [BYTCNT1],0
        JZ      WRTMID
        MOV     BX,[CLUSNUM]
        CALL    BUFWRT  
WRTMID:
        MOV     AX,[SECCNT]
        OR      AX,AX
        JZ      WRTLAST
        ADD     [SECPOS],AX
        CALL    NEXTSEC
        MOV     BYTE PTR [TRANS],1      ;A transfer is taking place
        MOV     DL,[SECCLUSPOS]
        MOV     BX,[CLUSNUM]
        MOV     CX,[SECCNT]
WRTLP:
        CALL    OPTIMIZE
        JC      NOTINBUF        ;Is one of the sectors buffered?
        MOV     [BUFSECNO],0    ;If so, invalidate the buffer since we're
        MOV     WORD PTR [BUFDRVNO],0FFH        ;       completely rewritting it
NOTINBUF:
        PUSH    DI
        PUSH    AX
        PUSH    DS
        MOV     DS,[DMAADD+2]
        CALL    DWRITE
        POP     DS
        POP     CX
        POP     BX
        JCXZ    WRTLAST
        MOV     DL,0
        INC     [LASTPOS]       ;We'll be using next cluster
        JMP     SHORT WRTLP
WRTLAST:
        MOV     AX,[BYTCNT2]
        OR      AX,AX
        JZ      FINWRT
        MOV     [BYTCNT1],AX
        CALL    NEXTSEC
        MOV     [BYTSECPOS],0
        CALL    BUFWRT
FINWRT:
        MOV     AX,[NEXTADD]
        SUB     AX,[DMAADD]
        ADD     AX,WORD PTR [BYTPOS]
        MOV     DX,WORD PTR [BYTPOS+2]
        ADC     DX,0
        MOV     CX,DX
        MOV     DI,[FCB]
        CMP     AX,ES:WORD PTR [DI.FILSIZ]
        SBB     CX,ES:WORD PTR [DI.FILSIZ+2]
        JB      SAMSIZ
        MOV     ES:WORD PTR [DI.FILSIZ],AX
        MOV     ES:WORD PTR [DI.FILSIZ+2],DX
SAMSIZ:
        MOV     CX,[RECCNT]
        JMP     SETCLUS


WRTERRJ:JMP     WRTERR

WRTEOF:
        MOV     CX,AX
        OR      CX,DX
        JZ      KILLFIL
        SUB     AX,1
        SBB     DX,0
        DIV     [BP.SECSIZ]
        MOV     CL,[BP.CLUSSHFT]
        SHR     AX,CL
        MOV     CX,AX
        CALL    FNDCLUS
        JCXZ    RELFILE
        CALL    ALLOCATE
        JC      WRTERRJ
UPDATE:
        MOV     DI,[FCB]
        MOV     AX,WORD PTR [BYTPOS]
        MOV     ES:WORD PTR [DI.FILSIZ],AX
        MOV     AX,WORD PTR [BYTPOS+2]
        MOV     ES:WORD PTR [DI.FILSIZ+2],AX
        XOR     CX,CX
        JMP     ADDREC

RELFILE:
        MOV     DX,0FFFH
        CALL    RELBLKS
SETDIRT:
        MOV     BYTE PTR [SI-1],1
        JMP     SHORT UPDATE

KILLFIL:
        XOR     BX,BX
        XCHG    BX,ES:[DI.FIRCLUS]
        OR      BX,BX
        JZ      UPDATE
        CALL    RELEASE
        JMP     SHORT SETDIRT


OPTIMIZE:

; Inputs:
;       DS = CS
;       BX = Physical cluster
;       CX = No. of records
;       DL = sector within cluster
;       BP = Base of drives parameters
;       [NEXTADD] = transfer address
; Outputs:
;       AX = No. of records remaining
;       BX = Transfer address
;       CX = No. or records to be transferred
;       DX = Physical sector address
;       DI = Next cluster
;       Carry clear if a sector to transfer is in the buffer
;       Carry set otherwise
;       [CLUSNUM] = Last cluster accessed
;       [NEXTADD] updated
; BP unchanged. Note that segment of transfer not set.

        PUSH    DX
        PUSH    BX
        MOV     AL,[BP.CLUSMSK]
        INC     AL              ;Number of sectors per cluster
        MOV     AH,AL
        SUB     AL,DL           ;AL = Number of sectors left in first cluster
        MOV     DX,CX
        MOV     SI,[BP.FAT]
        MOV     CX,0
OPTCLUS:
;AL has number of sectors available in current cluster
;AH has number of sectors available in next cluster
;BX has current physical cluster
;CX has number of sequential sectors found so far
;DX has number of sectors left to transfer
;SI has FAT pointer
        CALL    UNPACK
        ADD     CL,AL
        ADC     CH,0
        CMP     CX,DX
        JAE     BLKDON
        MOV     AL,AH
        INC     BX
        CMP     DI,BX
        JZ      OPTCLUS
        DEC     BX
FINCLUS:
        MOV     [CLUSNUM],BX    ;Last cluster accessed
        SUB     DX,CX           ;Number of sectors still needed
        PUSH    DX
        MOV     AX,CX
        MUL     [BP.SECSIZ]     ;Number of sectors times sector size
        MOV     SI,[NEXTADD]
        ADD     AX,SI           ;Adjust by size of transfer
        MOV     [NEXTADD],AX
        POP     AX              ;Number of sectors still needed
        POP     DX              ;Starting cluster
        SUB     BX,DX           ;Number of new clusters accessed
        ADD     [LASTPOS],BX
        POP     BX              ;BL = sector postion within cluster
        CALL    FIGREC
        MOV     BX,SI
;Now let's see if any of these sectors are already in the buffer
        CMP     [BUFSECNO],DX
        JC      RET100          ;If DX > [BUFSECNO] then not in buffer
        MOV     SI,DX
        ADD     SI,CX           ;Last sector + 1
        CMP     [BUFSECNO],SI
        CMC
        JC      RET100          ;If SI <= [BUFSECNO] then not in buffer
        PUSH    AX
        MOV     AL,[BP.DEVNUM]
        CMP     AL,[BUFDRVNO]   ;Is buffer for this drive?
        POP     AX
        JZ      RET100          ;If so, then we match 
        STC                     ;No match
RET100: RET
BLKDON:
        SUB     CX,DX           ;Number of sectors in cluster we don't want
        SUB     AH,CL           ;Number of sectors in cluster we accepted
        DEC     AH              ;Adjust to mean position within cluster
        MOV     [SECCLUSPOS],AH
        MOV     CX,DX           ;Anyway, make the total equal to the request
        JMP     SHORT FINCLUS


FIGREC:

;Inputs:
;       DX = Physical cluster number
;       BL = Sector postion within cluster
;       BP = Base of drive parameters
;Outputs:
;       DX = physical sector number
;No other registers affected.

        PUSH    CX
        MOV     CL,[BP.CLUSSHFT]
        DEC     DX
        DEC     DX
        SHL     DX,CL
        OR      DL,BL
        ADD     DX,[BP.FIRREC]
        POP     CX
        RET

GETREC:

; Inputs:
;       DS:DX point to FCB
; Outputs:
;       CX = 1
;       DX:AX = Record number determined by EXTENT and NR fields
;       DS:DI point to FCB
; No other registers affected.

        MOV     DI,DX
        CMP     BYTE PTR [DI],-1        ;Check for extended FCB
        JNZ     NORMFCB2
        ADD     DI,7
NORMFCB2:
        MOV     CX,1
        MOV     AL,[DI.NR]
        MOV     DX,[DI.EXTENT]
        SHL     AL,1
        SHR     DX,1
        RCR     AL,1
        MOV     AH,DL
        MOV     DL,DH
        MOV     DH,0
        RET


ALLOCATE:

; Inputs:
;       DS = CS
;       ES = Segment of FCB
;       BX = Last cluster of file (0 if null file)
;       CX = No. of clusters to allocate
;       DX = Position of cluster BX
;       BP = Base of drive parameters
;       SI = FAT pointer
;       [FCB] = Displacement of FCB within segment
; Outputs:
;       IF insufficient space
;         THEN
;       Carry set
;       CX = max. no. of records that could be added to file
;         ELSE
;       Carry clear
;       BX = First cluster allocated
;       FAT is fully updated including dirty bit
;       FIRCLUS field of FCB set if file was null
; SI,BP unchanged. All other registers destroyed.

        PUSH    [SI]
        PUSH    DX
        PUSH    CX
        PUSH    BX
        MOV     AX,BX
ALLOC:
        MOV     DX,BX
FINDFRE:
        INC     BX
        CMP     BX,[BP.MAXCLUS]
        JLE     TRYOUT
        CMP     AX,1
        JG      TRYIN
        POP     BX
        MOV     DX,0FFFH
        CALL    RELBLKS
        POP     AX              ;No. of clusters requested
        SUB     AX,CX           ;AX=No. of clusters allocated
        POP     DX
        POP     [SI]
        INC     DX              ;Position of first cluster allocated
        ADD     AX,DX           ;AX=max no. of cluster in file
        MOV     DL,[BP.CLUSMSK]
        MOV     DH,0
        INC     DX              ;DX=records/cluster
        MUL     DX              ;AX=max no. of records in file
        MOV     CX,AX
        SUB     CX,WORD PTR [RECPOS]    ;CX=max no. of records that could be written
        JA      MAXREC
        XOR     CX,CX           ;If CX was negative, zero it
MAXREC:
        STC
RET11:  RET

TRYOUT:
        CALL    UNPACK
        JZ      HAVFRE
TRYIN:
        DEC     AX
        JLE     FINDFRE
        XCHG    AX,BX
        CALL    UNPACK
        JZ      HAVFRE
        XCHG    AX,BX
        JMP     SHORT FINDFRE
HAVFRE:
        XCHG    BX,DX
        MOV     AX,DX
        CALL    PACK
        MOV     BX,AX
        LOOP    ALLOC
        MOV     DX,0FFFH
        CALL    PACK
        MOV     BYTE PTR [SI-1],1
        POP     BX
        POP     CX              ;Don't need this stuff since we're successful
        POP     DX
        CALL    UNPACK
        POP     [SI]
        XCHG    BX,DI
        OR      DI,DI
        JNZ     RET11
        MOV     DI,[FCB]
        MOV     ES:[DI.FIRCLUS],BX
RET12:  RET


RELEASE:

; Inputs:
;       DS = CS
;       BX = Cluster in file
;       SI = FAT pointer
;       BP = Base of drive parameters
; Function:
;       Frees cluster chain starting with [BX]
; AX,BX,DX,DI all destroyed. Other registers unchanged.

        XOR     DX,DX
RELBLKS:
; Enter here with DX=0FFFH to put an end-of-file mark
; in the first cluster and free the rest in the chain.
        CALL    UNPACK
        JZ      RET12
        MOV     AX,DI
        CALL    PACK
        CMP     AX,0FF8H
        MOV     BX,AX
        JB      RELEASE
RET13:  RET


GETEOF:

; Inputs:
;       BX = Cluster in a file
;       SI = Base of drive FAT
;       DS = CS
; Outputs:
;       BX = Last cluster in the file
; DI destroyed. No other registers affected.

        CALL    UNPACK
        CMP     DI,0FF8H
        JAE     RET13
        MOV     BX,DI
        JMP     SHORT GETEOF


SRCHFRST: ;System call 17
        CALL    GETFILE
SAVPLCE:
; Search-for-next enters here to save place and report
; findings.
        JC      KILLSRCH
        OR      BH,BH
        JS      SRCHDEV
        MOV     AX,[LASTENT]
        MOV     ES:[DI.FILDIRENT],AX
        MOV     ES:[DI.DRVBP],BP
;Information in directory entry must be copied into the first
; 33 bytes starting at the disk transfer address.
        MOV     SI,BX
        LES     DI,DWORD PTR [DMAADD]
        MOV     AX,00FFH
        CMP     AL,[EXTFCB]
        JNZ     NORMFCB
        STOSW
        INC     AL
        STOSW
        STOSW
        MOV     AL,[ATTRIB]
        STOSB
NORMFCB:
        MOV     AL,[THISDRV]
        INC     AL
        STOSB   ;Set drive number
        MOV     CX,16
        REP     MOVSW   ;Copy remaining 10 characters of name
        XOR     AL,AL
        RET

KILLSRCH:
KILLSRCH1       EQU     KILLSRCH+1
;The purpose of the KILLSRCH1 label is to provide a jump label to the following
;   instruction which leaves out the segment override.
        MOV     WORD PTR ES:[DI.FILDIRENT],-1
        MOV     AL,-1
        RET

SRCHDEV:
        MOV     ES:[DI.FILDIRENT],BX
        LES     DI,DWORD PTR [DMAADD]
        XOR     AX,AX
        STOSB           ;Zero drive byte
        SUB     SI,4            ;Point to device name
        MOVSW
        MOVSW
        MOV     AX,2020H
        STOSB
        STOSW
        STOSW
        STOSW                   ;Fill with 8 blanks
        XOR     AX,AX
        MOV     CX,10
        REP     STOSW
        STOSB
RET14:  RET

SRCHNXT: ;System call 18
        CALL    MOVNAME
        MOV     DI,DX
        JC      NEAR PTR KILLSRCH1
        MOV     BP,[DI.DRVBP]
        MOV     AX,[DI.FILDIRENT]
        OR      AX,AX
        JS      NEAR PTR KILLSRCH1
        PUSH    DX
        PUSH    DS
        PUSH    CS
        POP     DS
        MOV     [LASTENT],AX
        CALL    CONTSRCH
        POP     ES
        POP     DI
        JMP     SAVPLCE


FILESIZE: ;System call 35
        CALL    GETFILE
        MOV     AL,-1
        JC      RET14
        ADD     DI,33           ;Write size in RR field
        MOV     CX,ES:[DI.RECSIZ-33]
        OR      CX,CX
        JNZ     RECOK
        MOV     CX,128
RECOK:
        XOR     AX,AX
        XOR     DX,DX           ;Intialize size to zero
        OR      BH,BH           ;Check for named I/O device
        JS      DEVSIZ
        INC     SI
        INC     SI              ;Point to length field
        MOV     AX,[SI+2]       ;Get high word of size
        DIV     CX
        PUSH    AX              ;Save high part of result
        LODSW           ;Get low word of size
        DIV     CX
        OR      DX,DX           ;Check for zero remainder
        POP     DX
        JZ      DEVSIZ
        INC     AX              ;Round up for partial record
        JNZ     DEVSIZ          ;Propagate carry?
        INC     DX
DEVSIZ:
        STOSW
        MOV     AX,DX
        STOSB
        MOV     AL,0
        CMP     CX,64
        JAE     RET14           ;Only 3-byte field if RECSIZ >= 64
        MOV     ES:[DI],AH
        RET


SETDMA: ;System call 26
        MOV     CS:[DMAADD],DX
        MOV     CS:[DMAADD+2],DS
        RET

NOSUCHDRV:
        MOV     AL,-1
        RET

GETFATPT: ;System call 27
        MOV     DL,0                    ;Use default drive

GETFATPTDL:     ;System call 28
        PUSH    CS
        POP     DS
        MOV     AL,DL
        CALL    GETTHISDRV
        JC      NOSUCHDRV
        CALL    FATREAD
        MOV     BX,[BP.FAT]
        MOV     AL,[BP.CLUSMSK]
        INC     AL
        MOV     DX,[BP.MAXCLUS]
        DEC     DX
        MOV     CX,[BP.SECSIZ]
        LDS     SI,DWORD PTR [SPSAVE]
        MOV     [SI.BXSAVE],BX
        MOV     [SI.DXSAVE],DX
        MOV     [SI.CXSAVE],CX
        MOV     [SI.DSSAVE],CS
        RET


GETDSKPT: ;System call 31
        PUSH    CS
        POP     DS
        MOV     AL,[CURDRV]
        MOV     [THISDRV],AL
        CALL    FATREAD
        LDS     SI,DWORD PTR [SPSAVE]
        MOV     [SI.BXSAVE],BP
        MOV     [SI.DSSAVE],CS
        RET


DSKRESET: ;System call 13
        PUSH    CS
        POP     DS
WRTFATS:
; DS=CS. Writes back all dirty FATs. All registers destroyed.
        XOR     AL,AL
        XCHG    AL,[DIRTYBUF]
        OR      AL,AL
        JZ      NOBUF
        MOV     BP,[BUFDRVBP]
        MOV     DX,[BUFSECNO]
        MOV     BX,[BUFFER]
        MOV     CX,1
        CALL    DWRITE
NOBUF:
        MOV     CL,[NUMIO]
        MOV     CH,0
        MOV     BP,[DRVTAB]
WRTFAT:
        PUSH    CX
        CALL    CHKFATWRT
        POP     CX
        ADD     BP,DPBSIZ
        LOOP    WRTFAT
        RET


GETDRV: ;System call 25
        MOV     AL,CS:[CURDRV]
RET15:  RET


SETRNDREC: ;System call 36
        CALL    GETREC
        MOV     [DI+33],AX
        MOV     [DI+35],DL
        CMP     [DI.RECSIZ],64
        JAE     RET15
        MOV     [DI+36],DH      ;Set 4th byte only if record size < 64
RET16:  RET


SELDSK: ;System call 14
        MOV     AL,CS:[NUMDRV]
        CMP     DL,AL
        JNB     RET17
        MOV     CS:[CURDRV],DL
RET17:  RET

BUFIN:  ;System call 10
        MOV     AX,CS
        MOV     ES,AX
        MOV     SI,DX
        MOV     CH,0
        LODSW
        OR      AL,AL
        JZ      RET17
        MOV     BL,AH
        MOV     BH,CH
        CMP     AL,BL
        JBE     NOEDIT
        CMP     BYTE PTR [BX+SI],0DH
        JZ      EDITON
NOEDIT:
        MOV     BL,CH
EDITON:
        MOV     DL,AL
        DEC     DX
NEWLIN:
        MOV     AL,CS:[CARPOS]
        MOV     CS:[STARTPOS],AL
        PUSH    SI
        MOV     DI,OFFSET DOSGROUP:INBUF
        MOV     AH,CH
        MOV     BH,CH
        MOV     DH,CH
GETCH:
        CALL    IN
        CMP     AL,"F"-"@"      ;Ignore ^F
        JZ      GETCH
        CMP     AL,CS:ESCCHAR
        JZ      ESC
        CMP     AL,7FH
        JZ      BACKSP
        CMP     AL,8
        JZ      BACKSP
        CMP     AL,13
        JZ      ENDLIN
        CMP     AL,10
        JZ      PHYCRLF
        CMP     AL,CANCEL
        JZ      KILNEW
SAVCH:
        CMP     DH,DL
        JAE     BUFFUL
        STOSB
        INC     DH
        CALL    BUFOUT
        OR      AH,AH
        JNZ     GETCH
        CMP     BH,BL
        JAE     GETCH
        INC     SI
        INC     BH
        JMP     SHORT GETCH

BUFFUL:
        MOV     AL,7
        CALL    OUT
        JMP     SHORT GETCH

ESC:
        CALL    IN
        MOV     CL,ESCTABLEN
        PUSH    DI
        MOV     DI,OFFSET DOSGROUP:ESCTAB
        REPNE   SCASB
        POP     DI
        SHL     CX,1
        MOV     BP,CX
        JMP     [BP+OFFSET DOSGROUP:ESCFUNC]

ENDLIN:
        STOSB
        CALL    OUT
        POP     DI
        MOV     [DI-1],DH
        INC     DH
COPYNEW:
        MOV     BP,ES
        MOV     BX,DS
        MOV     ES,BX
        MOV     DS,BP
        MOV     SI,OFFSET DOSGROUP:INBUF
        MOV     CL,DH
        REP     MOVSB
        RET
CRLF:
        MOV     AL,13
        CALL    OUT
        MOV     AL,10
        JMP     OUT

PHYCRLF:
        CALL    CRLF
        JMP     SHORT GETCH

KILNEW:
        MOV     AL,"\"
        CALL    OUT
        POP     SI
PUTNEW:
        CALL    CRLF
        MOV     AL,CS:[STARTPOS]
        CALL    TAB
        JMP     NEWLIN

BACKSP:
        OR      DH,DH
        JZ      OLDBAK
        CALL    BACKUP
        MOV     AL,ES:[DI]
        CMP     AL," "
        JAE     OLDBAK
        CMP     AL,9
        JZ      BAKTAB
        CALL    BACKMES
OLDBAK:
        OR      AH,AH
        JNZ     GETCH1
        OR      BH,BH
        JZ      GETCH1
        DEC     BH
        DEC     SI
GETCH1:
        JMP     GETCH
BAKTAB:
        PUSH    DI
        DEC     DI
        STD
        MOV     CL,DH
        MOV     AL," "
        PUSH    BX
        MOV     BL,7
        JCXZ    FIGTAB
FNDPOS:
        SCASB
        JNA     CHKCNT
        CMP     ES:BYTE PTR [DI+1],9
        JZ      HAVTAB
        DEC     BL
CHKCNT:
        LOOP    FNDPOS
FIGTAB:
        SUB     BL,CS:[STARTPOS]
HAVTAB:
        SUB     BL,DH
        ADD     CL,BL
        AND     CL,7
        CLD
        POP     BX
        POP     DI
        JZ      OLDBAK
TABBAK:
        CALL    BACKMES
        LOOP    TABBAK
        JMP     SHORT OLDBAK
BACKUP:
        DEC     DH
        DEC     DI
BACKMES:
        MOV     AL,8
        CALL    OUT
        MOV     AL," "
        CALL    OUT
        MOV     AL,8
        JMP     OUT

TWOESC:
        MOV     AL,ESCCH
        JMP     SAVCH

COPYLIN:
        MOV     CL,BL
        SUB     CL,BH
        JMP     SHORT COPYEACH

COPYSTR:
        CALL    FINDOLD
        JMP     SHORT COPYEACH

COPYONE:
        MOV     CL,1
COPYEACH:
        MOV     AH,0
        CMP     DH,DL
        JZ      GETCH2
        CMP     BH,BL
        JZ      GETCH2
        LODSB
        STOSB
        CALL    BUFOUT
        INC     BH
        INC     DH
        LOOP    COPYEACH
GETCH2:
        JMP     GETCH

SKIPONE:
        CMP     BH,BL
        JZ      GETCH2
        INC     BH
        INC     SI
        JMP     GETCH

SKIPSTR:
        CALL    FINDOLD
        ADD     SI,CX
        ADD     BH,CL
        JMP     GETCH

FINDOLD:
        CALL    IN
        MOV     CL,BL
        SUB     CL,BH
        JZ      NOTFND
        DEC     CX
        JZ      NOTFND
        PUSH    ES
        PUSH    DS
        POP     ES
        PUSH    DI
        MOV     DI,SI
        INC     DI
        REPNE   SCASB
        POP     DI
        POP     ES
        JNZ     NOTFND
        NOT     CL
        ADD     CL,BL
        SUB     CL,BH
RET30:  RET
NOTFND:
        POP     BP
        JMP     GETCH

REEDIT:
        MOV     AL,"@"
        CALL    OUT
        POP     DI
        PUSH    DI
        PUSH    ES
        PUSH    DS
        CALL    COPYNEW
        POP     DS
        POP     ES
        POP     SI
        MOV     BL,DH
        JMP     PUTNEW

ENTERINS:
        IF      TOGLINS
        NOT     AH
        JMP     GETCH
        ENDIF
        IF      NOT TOGLINS
        MOV     AH,-1
        JMP     GETCH

EXITINS:
        MOV     AH,0
        JMP     GETCH
        ENDIF

ESCFUNC DW      GETCH
        DW      TWOESC
        IF      NOT TOGLINS
        DW      EXITINS
        ENDIF
        DW      ENTERINS
        DW      BACKSP
        DW      REEDIT
        DW      KILNEW
        DW      COPYLIN
        DW      SKIPSTR
        DW      COPYSTR
        DW      SKIPONE
        DW      COPYONE

        IF      IBM
        DW      COPYONE
        DW      CTRLZ
CTRLZ:
        MOV     AL,"Z"-"@"
        JMP     SAVCH
        ENDIF
BUFOUT:
        CMP     AL," "
        JAE     OUT
        CMP     AL,9
        JZ      OUT
        PUSH    AX
        MOV     AL,"^"
        CALL    OUT
        POP     AX
        OR      AL,40H
        JMP     SHORT OUT

NOSTOP:
        CMP     AL,"P"-"@"
        JZ      INCHK
        IF      NOT TOGLPRN
        CMP     AL,"N"-"@"
        JZ      INCHK
        ENDIF
        CMP     AL,"C"-"@"
        JZ      INCHK
        RET

CONOUT: ;System call 2
        MOV     AL,DL
OUT:
        CMP     AL,20H
        JB      CTRLOUT
        CMP     AL,7FH
        JZ      OUTCH
        INC     CS:BYTE PTR [CARPOS]
OUTCH:
        PUSH    AX
        CALL    STATCHK
        POP     AX
        CALL    FAR PTR BIOSOUT 
        TEST    CS:BYTE PTR [PFLAG],-1
        JZ      RET18
        CALL    FAR PTR BIOSPRINT 
RET18:  RET

STATCHK:
        CALL    FAR PTR BIOSSTAT 
        JZ      RET18
        CMP     AL,'S'-'@'
        JNZ     NOSTOP
        CALL    FAR PTR BIOSIN          ;Eat Cntrl-S
INCHK:
        CALL    FAR PTR BIOSIN 
        CMP     AL,'P'-'@'
        JZ      PRINTON
        IF      NOT TOGLPRN
        CMP     AL,'N'-'@'
        JZ      PRINTOFF
        ENDIF
        CMP     AL,'C'-'@'
        JNZ     RET18
; Ctrl-C handler.
; "^C" and CR/LF is printed. Then the user registers are restored and the
; user CTRL-C handler is executed. At this point the top of the stack has
; 1) the interrupt return address should the user CTRL-C handler wish to
; allow processing to continue; 2) the original interrupt return address
; to the code that performed the function call in the first place. If the
; user CTRL-C handler wishes to continue, it must leave all registers
; unchanged and IRET. The function that was interrupted will simply be
; repeated.
        MOV     AL,3            ;Display "^C"
        CALL    BUFOUT
        CALL    CRLF
        CLI                     ;Prepare to play with stack
        MOV     SS,CS:[SSSAVE]
        MOV     SP,CS:[SPSAVE]  ;User stack now restored
        POP     AX
        POP     BX
        POP     CX
        POP     DX
        POP     SI
        POP     DI
        POP     BP
        POP     DS
        POP     ES              ;User registers now restored
        INT     CONTC           ;Execute user Ctrl-C handler
        JMP     COMMAND         ;Repeat command otherwise

PRINTON:
        IF      TOGLPRN
        NOT     CS:BYTE PTR [PFLAG]
        RET
        ENDIF
        IF      NOT TOGLPRN
        MOV     CS:BYTE PTR [PFLAG],1
        RET

PRINTOFF:
        MOV     CS:BYTE PTR [PFLAG],0
        RET
        ENDIF

CTRLOUT:
        CMP     AL,13
        JZ      ZERPOS
        CMP     AL,8
        JZ      BACKPOS
        CMP     AL,9
        JNZ     OUTCHJ
        MOV     AL,CS:[CARPOS]
        OR      AL,0F8H
        NEG     AL
TAB:
        PUSH    CX
        MOV     CL,AL
        MOV     CH,0
        JCXZ    POPTAB
TABLP:
        MOV     AL," "
        CALL    OUT
        LOOP    TABLP
POPTAB:
        POP     CX
RET19:  RET

ZERPOS:
        MOV     CS:BYTE PTR [CARPOS],0
OUTCHJ: JMP     OUTCH

BACKPOS:
        DEC     CS:BYTE PTR [CARPOS]
        JMP     OUTCH


CONSTAT: ;System call 11
        CALL    STATCHK
        MOV     AL,0 
        JZ      RET19
        OR      AL,-1
        RET


CONIN:  ;System call 1
        CALL    IN
        PUSH    AX
        CALL    OUT
        POP     AX
        RET


IN:     ;System call 8
        CALL    INCHK
        JZ      IN
RET29:  RET

RAWIO:  ;System call 6
        MOV     AL,DL
        CMP     AL,-1
        JNZ     RAWOUT
        LDS     SI,DWORD PTR CS:[SPSAVE]                ;Get pointer to register save area
        CALL    FAR PTR BIOSSTAT
        JNZ     RESFLG
        OR      BYTE PTR [SI.FSAVE],40H ;Set user's zero flag
        XOR     AL,AL
        RET

RESFLG:
        AND     BYTE PTR [SI.FSAVE],0FFH-40H    ;Reset user's zero flag
RAWINP: ;System call 7
        CALL    FAR PTR BIOSIN 
        RET
RAWOUT:
        CALL    FAR PTR BIOSOUT 
        RET

LIST:   ;System call 5
        MOV     AL,DL
LISTOUT:
        PUSH    AX
        CALL    STATCHK
        POP     AX
        CALL    FAR PTR BIOSPRINT 
RET20:  RET

PRTBUF: ;System call 9
        MOV     SI,DX
OUTSTR:
        LODSB
        CMP     AL,"$"
        JZ      RET20
        CALL    OUT
        JMP     SHORT OUTSTR

OUTMES: ;String output for internal messages
        LODS    CS:BYTE PTR [SI]
        CMP     AL,"$"
        JZ      RET20
        CALL    OUT
        JMP     SHORT OUTMES


MAKEFCB: ;Interrupt call 41
DRVBIT  EQU     2
NAMBIT  EQU     4
EXTBIT  EQU     8
        MOV     DL,0            ;Flag--not ambiguous file name
        TEST    AL,DRVBIT       ;Use current drive field if default?
        JNZ     DEFDRV
        MOV     BYTE PTR ES:[DI],0      ;No - use default drive
DEFDRV:
        INC     DI
        MOV     CX,8
        TEST    AL,NAMBIT       ;Use current name fiels as defualt?
        XCHG    AX,BX           ;Save bits in BX
        MOV     AL," "
        JZ      FILLB           ;If not, go fill with blanks
        ADD     DI,CX
        XOR     CX,CX           ;Don't fill any
FILLB:
        REP     STOSB
        MOV     CL,3
        TEST    BL,EXTBIT       ;Use current extension as default
        JZ      FILLB2
        ADD     DI,CX
        XOR     CX,CX
FILLB2:
        REP     STOSB
        XCHG    AX,CX           ;Put zero in AX
        STOSW
        STOSW                   ;Initialize two words after to zero
        SUB     DI,16           ;Point back at start
        TEST    BL,1            ;Scan off separators if not zero
        JZ      SKPSPC
        CALL    SCANB           ;Peel off blanks and tabs
        CALL    DELIM           ;Is it a one-time-only delimiter?
        JNZ     NOSCAN
        INC     SI              ;Skip over the delimiter
SKPSPC:
        CALL    SCANB           ;Always kill preceding blanks and tabs
NOSCAN:
        CALL    GETLET
        JBE     NODRV           ;Quit if termination character
        CMP     BYTE PTR[SI],":"        ;Check for potential drive specifier
        JNZ     NODRV
        INC     SI              ;Skip over colon
        SUB     AL,"@"          ;Convert drive letter to binary drive number
        JBE     BADDRV          ;Valid drive numbers are 1-15
        CMP     AL,CS:[NUMDRV]
        JBE     HAVDRV
BADDRV:
        MOV     DL,-1
HAVDRV:
        STOSB           ;Put drive specifier in first byte
        INC     SI
        DEC     DI      ;Counteract next two instructions
NODRV:
        DEC     SI      ;Back up
        INC     DI      ;Skip drive byte
        MOV     CX,8
        CALL    GETWORD         ;Get 8-letter file name
        CMP     BYTE PTR [SI],"."
        JNZ     NODOT
        INC     SI              ;Skip over dot if present
        MOV     CX,3            ;Get 3-letter extension
        CALL    MUSTGETWORD
NODOT:
        LDS     BX,CS:DWORD PTR [SPSAVE]
        MOV     [BX.SISAVE],SI
        MOV     AL,DL
        RET

NONAM:
        ADD     DI,CX
        DEC     SI
        RET

GETWORD:
        CALL    GETLET
        JBE     NONAM           ;Exit if invalid character
        DEC     SI
MUSTGETWORD:
        CALL    GETLET
        JBE     FILLNAM
        JCXZ    MUSTGETWORD
        DEC     CX
        CMP     AL,"*"          ;Check for ambiguous file specifier
        JNZ     NOSTAR
        MOV     AL,"?"
        REP     STOSB
NOSTAR:
        STOSB
        CMP     AL,"?"
        JNZ     MUSTGETWORD
        OR      DL,1            ;Flag ambiguous file name
        JMP     MUSTGETWORD
FILLNAM:
        MOV     AL," "
        REP     STOSB
        DEC     SI
RET21:  RET

SCANB:
        LODSB
        CALL    SPCHK
        JZ      SCANB
        DEC     SI
        RET

GETLET:
;Get a byte from [SI], convert it to upper case, and compare for delimiter.
;ZF set if a delimiter, CY set if a control character (other than TAB).
        LODSB
        AND     AL,7FH
        CMP     AL,"a"
        JB      CHK
        CMP     AL,"z"
        JA      CHK
        SUB     AL,20H          ;Convert to upper case
CHK:
        CMP     AL,"."
        JZ      RET21
        CMP     AL,'"'
        JZ      RET21
        CMP     AL,"/"
        JZ      RET21
        CMP     AL,"["
        JZ      RET21
        CMP     AL,"]"
        JZ      RET21

        IF      IBM
DELIM:
        ENDIF
        CMP     AL,":"          ;Allow ":" as separator in IBM version
        JZ      RET21
        IF      NOT IBM
DELIM:
        ENDIF

        CMP     AL,"+"
        JZ      RET101
        CMP     AL,"="
        JZ      RET101
        CMP     AL,";"
        JZ      RET101
        CMP     AL,","
        JZ      RET101
SPCHK:
        CMP     AL,9            ;Filter out tabs too
        JZ      RET101
;WARNING! " " MUST be the last compare
        CMP     AL," "
RET101: RET

SETVECT: ; Interrupt call 37
        XOR     BX,BX
        MOV     ES,BX
        MOV     BL,AL
        SHL     BX,1
        SHL     BX,1
        MOV     ES:[BX],DX
        MOV     ES:[BX+2],DS
        RET


NEWBASE: ; Interrupt call 38
        MOV     ES,DX
        LDS     SI,CS:DWORD PTR [SPSAVE]
        MOV     DS,[SI.CSSAVE]
        XOR     SI,SI
        MOV     DI,SI
        MOV     AX,DS:[2]
        MOV     CX,80H
        REP     MOVSW

SETMEM:

; Inputs:
;       AX = Size of memory in paragraphs
;       DX = Segment
; Function:
;       Completely prepares a program base at the 
;       specified segment.
; Outputs:
;       DS = DX
;       ES = DX
;       [0] has INT 20H
;       [2] = First unavailable segment ([ENDMEM])
;       [5] to [9] form a long call to the entry point
;       [10] to [13] have exit address (from INT 22H)
;       [14] to [17] have ctrl-C exit address (from INT 23H)
;       [18] to [21] have fatal error address (from INT 24H)
; DX,BP unchanged. All other registers destroyed.

        XOR     CX,CX
        MOV     DS,CX
        MOV     ES,DX
        MOV     SI,EXIT
        MOV     DI,SAVEXIT
        MOVSW
        MOVSW
        MOVSW
        MOVSW
        MOVSW
        MOVSW
        MOV     ES:[2],AX
        SUB     AX,DX
        CMP     AX,MAXDIF
        JBE     HAVDIF
        MOV     AX,MAXDIF
HAVDIF:
        MOV     BX,ENTRYPOINTSEG
        SUB     BX,AX
        SHL     AX,1
        SHL     AX,1
        SHL     AX,1
        SHL     AX,1
        MOV     DS,DX
        MOV     DS:[6],AX
        MOV     DS:[8],BX
        MOV     DS:[0],20CDH    ;"INT INTTAB"
        MOV     DS:(BYTE PTR [5]),LONGCALL
        RET

DATE16:
        PUSH    CX
        CALL    READTIME
        SHL     CL,1            ;Minutes to left part of byte
        SHL     CL,1
        SHL     CX,1            ;Push hours and minutes to left end
        SHL     CX,1
        SHL     CX,1
        SHR     DH,1            ;Count every two seconds
        OR      CL,DH           ;Combine seconds with hours and minutes
        MOV     DX,CX
        POP     CX
        MOV     AX,WORD PTR [MONTH]     ;Fetch month and year
        SHL     AL,1                    ;Push month to left to make room for day
        SHL     AL,1
        SHL     AL,1
        SHL     AL,1
        SHL     AX,1
        OR      AL,[DAY]
RET22:  RET

FOURYEARS       EQU     3*365+366

READTIME:
;Gets time in CX:DX. Figures new date if it has changed.
;Uses AX, CX, DX.
        CALL    FAR PTR BIOSGETTIME 
        CMP     AX,[DAYCNT]     ;See if day count is the same
        JZ      RET22
        CMP     AX,FOURYEARS*30 ;Number of days in 120 years
        JAE     RET22           ;Ignore if too large
        MOV     [DAYCNT],AX
        PUSH    SI
        PUSH    CX
        PUSH    DX              ;Save time
        XOR     DX,DX
        MOV     CX,FOURYEARS    ;Number of days in 4 years
        DIV     CX              ;Compute number of 4-year units
        SHL     AX,1
        SHL     AX,1
        SHL     AX,1            ;Multiply by 8 (no. of half-years)
        MOV     CX,AX           ;<240 implies AH=0
        MOV     SI,OFFSET DOSGROUP:YRTAB        ;Table of days in each year
        CALL    DSLIDE          ;Find out which of four years we're in
        SHR     CX,1            ;Convert half-years to whole years
        JNC     SK              ;Extra half-year?
        ADD     DX,200
SK:
        CALL    SETYEAR
        MOV     CL,1            ;At least at first month in year
        MOV     SI,OFFSET DOSGROUP:MONTAB       ;Table of days in each month
        CALL    DSLIDE          ;Find out which month we're in
        MOV     [MONTH],CL
        INC     DX              ;Remainder is day of month (start with one)
        MOV     [DAY],DL
        CALL    WKDAY           ;Set day of week
        POP     DX
        POP     CX
        POP     SI
RET23:  RET

DSLIDE:
        MOV     AH,0
DSLIDE1:
        LODSB           ;Get count of days
        CMP     DX,AX           ;See if it will fit
        JB      RET23           ;If not, done
        SUB     DX,AX
        INC     CX              ;Count one more month/year
        JMP     SHORT DSLIDE1

SETYEAR:
;Set year with value in CX. Adjust length of February for this year.
        MOV     BYTE PTR [YEAR],CL
CHKYR:
        TEST    CL,3            ;Check for leap year
        MOV     AL,28
        JNZ     SAVFEB          ;28 days if no leap year
        INC     AL              ;Add leap day
SAVFEB:
        MOV     [MONTAB+1],AL   ;Store for February
        RET

;Days in year
YRTAB   DB      200,166         ;Leap year
        DB      200,165
        DB      200,165
        DB      200,165

;Days of each month
MONTAB  DB      31              ;January
        DB      28              ;February--reset each time year changes
        DB      31              ;March
        DB      30              ;April
        DB      31              ;May
        DB      30              ;June
        DB      31              ;July
        DB      31              ;August
        DB      30              ;September
        DB      31              ;October
        DB      30              ;November
        DB      31              ;December

GETDATE: ;Function call 42
        PUSH    CS
        POP     DS
        CALL    READTIME        ;Check for rollover to next day
        MOV     AX,[YEAR]
        MOV     BX,WORD PTR [DAY]
        LDS     SI,DWORD PTR [SPSAVE]   ;Get pointer to user registers
        MOV     [SI.DXSAVE],BX  ;DH=month, DL=day
        ADD     AX,1980         ;Put bias back
        MOV     [SI.CXSAVE],AX  ;CX=year
        MOV     AL,CS:[WEEKDAY]
RET24:  RET

SETDATE: ;Function call 43
        MOV     AL,-1           ;Be ready to flag error
        SUB     CX,1980         ;Fix bias in year
        JC      RET24           ;Error if not big enough
        CMP     CX,119          ;Year must be less than 2100
        JA      RET24
        OR      DH,DH
        JZ      RET24
        OR      DL,DL
        JZ      RET24           ;Error if either month or day is 0
        CMP     DH,12           ;Check against max. month
        JA      RET24
        PUSH    CS
        POP     DS
        CALL    CHKYR           ;Set Feb. up for new year
        MOV     AL,DH
        MOV     BX,OFFSET DOSGROUP:MONTAB-1
        XLAT                    ;Look up days in month
        CMP     AL,DL
        MOV     AL,-1           ;Restore error flag, just in case
        JB      RET24           ;Error if too many days
        CALL    SETYEAR
        MOV     WORD PTR [DAY],DX       ;Set both day and month
        SHR     CX,1
        SHR     CX,1
        MOV     AX,FOURYEARS
        MOV     BX,DX
        MUL     CX
        MOV     CL,BYTE PTR [YEAR]
        AND     CL,3
        MOV     SI,OFFSET DOSGROUP:YRTAB
        MOV     DX,AX
        SHL     CX,1            ;Two entries per year, so double count
        CALL    DSUM            ;Add up the days in each year
        MOV     CL,BH           ;Month of year
        MOV     SI,OFFSET DOSGROUP:MONTAB
        DEC     CX              ;Account for months starting with one
        CALL    DSUM            ;Add up days in each month
        MOV     CL,BL           ;Day of month
        DEC     CX              ;Account for days starting with one
        ADD     DX,CX           ;Add in to day total
        XCHG    AX,DX           ;Get day count in AX
        MOV     [DAYCNT],AX
        CALL    FAR PTR BIOSSETDATE 
WKDAY:
        MOV     AX,[DAYCNT]
        XOR     DX,DX
        MOV     CX,7
        INC     AX
        INC     AX              ;First day was Tuesday
        DIV     CX              ;Compute day of week
        MOV     [WEEKDAY],DL
        XOR     AL,AL           ;Flag OK
RET25:  RET

DSUM:
        MOV     AH,0
        JCXZ    RET25
DSUM1:
        LODSB
        ADD     DX,AX
        LOOP    DSUM1
        RET

GETTIME: ;Function call 44
        PUSH    CS
        POP     DS
        CALL    READTIME
        LDS     SI,DWORD PTR [SPSAVE]   ;Get pointer to user registers
        MOV     [SI.DXSAVE],DX
        MOV     [SI.CXSAVE],CX
        XOR     AL,AL
RET26:  RET

SETTIME: ;Function call 45
;Time is in CX:DX in hours, minutes, seconds, 1/100 sec.
        MOV     AL,-1           ;Flag in case of error
        CMP     CH,24           ;Check hours
        JAE     RET26
        CMP     CL,60           ;Check minutes
        JAE     RET26
        CMP     DH,60           ;Check seconds
        JAE     RET26
        CMP     DL,100          ;Check 1/100's
        JAE     RET26
        CALL    FAR PTR BIOSSETTIME 
        XOR     AL,AL
        RET


; Default handler for division overflow trap
DIVOV:
        PUSH    SI
        PUSH    AX
        MOV     SI,OFFSET DOSGROUP:DIVMES
        CALL    OUTMES
        POP     AX
        POP     SI
        INT     23H             ;Use Ctrl-C abort on divide overflow
        IRET

CODSIZ  EQU     $-CODSTRT       ;Size of code segment
CODE    ENDS


;***** DATA AREA *****
CONSTANTS       SEGMENT BYTE
        ORG     0
CONSTRT EQU     $               ;Start of constants segment

IONAME:
        IF      NOT IBM
        DB      "PRN ","LST ","NUL ","AUX ","CON "
        ENDIF
        IF      IBM
        DB      "COM1","PRN ","LPT1","NUL ","AUX ","CON "
        ENDIF
DIVMES  DB      13,10,"Divide overflow",13,10,"$"
CARPOS  DB      0
STARTPOS DB     0
PFLAG   DB      0
DIRTYDIR DB     0               ;Dirty buffer flag
NUMDRV  DB      0       ;Number of drives
NUMIO   DB      ?       ;Number of disk tables
VERFLG  DB      0       ;Initialize with verify off
CONTPOS DW      0
DMAADD  DW      80H             ;User's disk transfer address (disp/seg)
        DW      ?
ENDMEM  DW      ?
MAXSEC  DW      0
BUFFER  DW      ?
BUFSECNO DW     0
BUFDRVNO DB     -1
DIRTYBUF DB     0
BUFDRVBP DW     ?
DIRBUFID DW     -1
DAY     DB      0
MONTH   DB      0
YEAR    DW      0
DAYCNT  DW      -1
WEEKDAY DB      0
CURDRV  DB      0               ;Default to drive A
DRVTAB  DW      0               ;Address of start of DPBs
DOSLEN  EQU     CODSIZ+($-CONSTRT)      ;Size of CODE + CONSTANTS segments
CONSTANTS       ENDS

DATA    SEGMENT WORD
; Init code overlaps with data area below

        ORG     0
INBUF   DB      128 DUP (?)
CONBUF  DB      131 DUP (?)             ;The rest of INBUF and console buffer
LASTENT DW      ?
EXITHOLD DB     4 DUP (?)
FATBASE DW      ?
NAME1   DB      11 DUP (?)              ;File name buffer
ATTRIB  DB      ?
NAME2   DB      11 DUP (?)
NAME3   DB      12 DUP (?)
EXTFCB  DB      ?
;WARNING - the following two items are accessed as a word
CREATING DB     ?
DELALL  DB      ?
TEMP    LABEL   WORD
SPSAVE  DW      ?
SSSAVE  DW      ?
CONTSTK DW      ?
SECCLUSPOS DB   ?       ;Position of first sector within cluster
DSKERR  DB      ?
TRANS   DB      ?
PREREAD DB      ?       ;0 means preread; 1 means optional
READOP  DB      ?
THISDRV DB      ?

        EVEN
FCB     DW      ?       ;Address of user FCB
NEXTADD DW      ?
RECPOS  DB      4 DUP (?)
RECCNT  DW      ?
LASTPOS DW      ?
CLUSNUM DW      ?
SECPOS  DW      ?       ;Position of first sector accessed
VALSEC  DW      ?       ;Number of valid (previously written) sectors
BYTSECPOS DW    ?       ;Position of first byte within sector
BYTPOS  DB      4 DUP (?)               ;Byte position in file of access
BYTCNT1 DW      ?       ;No. of bytes in first sector
BYTCNT2 DW      ?       ;No. of bytes in last sector
SECCNT  DW      ?       ;No. of whole sectors
ENTFREE DW      ?

        DB      80H DUP (?)     ;Stack space
IOSTACK LABEL   BYTE
        DB      80H DUP (?)
DSKSTACK LABEL  BYTE 

        IF      DSKTEST
NSS     DW      ?
NSP     DW      ?
        ENDIF

DIRBUF LABEL    WORD

;Init code below overlaps with data area above

        ORG     0

MOVFAT:
;This section of code is safe from being overwritten by block move
        REP     MOVS    BYTE PTR [DI],[SI]
        CLD
        MOV     ES:[DMAADD+2],DX
        MOV     SI,[DRVTAB]     ;Address of first DPB
        MOV     AL,-1
        MOV     CL,[NUMIO]      ;Number of DPBs
FLGFAT:
        MOV     DI,ES:[SI.FAT]  ;get pointer to FAT
        DEC     DI              ;Point to dirty byte
        STOSB                   ;Flag as unused
        ADD     SI,DPBSIZ       ;Point to next DPB
        LOOP    FLGFAT
        MOV     AX,[ENDMEM]
        CALL    SETMEM          ;Set up segment

XXX     PROC FAR
        RET
XXX     ENDP

DOSINIT:
        CLI
        CLD
        PUSH    CS
        POP     ES
        MOV     ES:[ENDMEM],DX
        LODSB                   ;Get no. of drives & no. of I/O drivers
        MOV     ES:[NUMIO],AL
        MOV     DI,OFFSET DOSGROUP:MEMSTRT
PERDRV:
        MOV     BP,DI
        MOV     AL,ES:[DRVCNT]
        STOSB           ;DEVNUM
        LODSB           ;Physical unit no.
        STOSB           ;DRVNUM
        CMP     AL,15
        JA      BADINIT
        CBW             ;Index into FAT size table
        SHL     AX,1
        ADD     AX,OFFSET DOSGROUP:FATSIZTAB
        XCHG    BX,AX
        LODSW           ;Pointer to DPT
        PUSH    SI
        MOV     SI,AX
        LODSW
        STOSW           ;SECSIZ
        MOV     DX,AX
        CMP     AX,ES:[MAXSEC]
        JBE     NOTMAX
        MOV     ES:[MAXSEC],AX
NOTMAX:
        LODSB
        DEC     AL
        STOSB           ;CLUSMSK
        JZ      HAVSHFT
        CBW
FIGSHFT:
        INC     AH
        SAR     AL,1
        JNZ     FIGSHFT
        MOV     AL,AH
HAVSHFT:
        STOSB           ;CLUSSHFT
        MOVSW           ;FIRFAT (= number of reserved sectors)
        MOVSB           ;FATCNT
        MOVSW           ;MAXENT
        MOV     AX,DX           ;SECSIZ again
        MOV     CL,5
        SHR     AX,CL
        MOV     CX,AX           ;Directory entries per sector
        DEC     AX
        ADD     AX,ES:[BP.MAXENT]
        XOR     DX,DX
        DIV     CX
        STOSW           ;DIRSEC (temporarily)
        MOVSW                   ;DSKSIZ (temporarily)
FNDFATSIZ:
        MOV     AL,1
        MOV     DX,1
GETFATSIZ:
        PUSH    DX
        CALL    FIGFATSIZ
        POP     DX
        CMP     AL,DL           ;Compare newly computed FAT size with trial
        JZ      HAVFATSIZ       ;Has sequence converged?
        CMP     AL,DH           ;Compare with previous trial
        MOV     DH,DL
        MOV     DL,AL           ;Shuffle trials
        JNZ     GETFATSIZ       ;Continue iterations if not oscillating
        DEC     WORD PTR ES:[BP.DSKSIZ] ;Damp those oscillations
        JMP     SHORT FNDFATSIZ ;Try again

BADINIT:
        MOV     SI,OFFSET DOSGROUP:BADMES
        CALL    OUTMES
        STI
        HLT

HAVFATSIZ:
        STOSB                   ;FATSIZ
        MUL     ES:BYTE PTR[BP.FATCNT]  ;Space occupied by all FATs
        ADD     AX,ES:[BP.FIRFAT]
        STOSW                   ;FIRDIR
        ADD     AX,ES:[BP.DIRSEC]
        MOV     ES:[BP.FIRREC],AX       ;Destroys DIRSEC
        CALL    FIGMAX
        MOV     ES:[BP.MAXCLUS],CX
        MOV     AX,BX           ;Pointer into FAT size table
        STOSW                   ;Allocate space for FAT pointer
        MOV     AL,ES:[BP.FATSIZ]
        XOR     AH,AH
        MUL     ES:[BP.SECSIZ]
        CMP     AX,ES:[BX]      ;Bigger than already allocated
        JBE     SMFAT
        MOV     ES:[BX],AX
SMFAT:
        POP     SI              ;Restore pointer to init. table
        MOV     AL,ES:[DRVCNT]
        INC     AL
        MOV     ES:[DRVCNT],AL
        CMP     AL,ES:[NUMIO]
        JAE     CONTINIT
        JMP     PERDRV  

BADINITJ:
        JMP     BADINIT

CONTINIT:
        PUSH    CS
        POP     DS
;Calculate true address of buffers, FATs, free space
        MOV     BP,[MAXSEC]
        MOV     AX,OFFSET DOSGROUP:DIRBUF
        ADD     AX,BP
        MOV     [BUFFER],AX     ;Start of buffer
        ADD     AX,BP
        MOV     [DRVTAB],AX     ;Start of DPBs
        SHL     BP,1            ;Two sectors - directory and buffer
        ADD     BP,DI           ;Allocate buffer space
        ADD     BP,ADJFAC       ;True address of FATs
        PUSH    BP
        MOV     SI,OFFSET DOSGROUP:FATSIZTAB
        MOV     DI,SI
        MOV     CX,16
TOTFATSIZ:
        INC     BP              ;Add one for Dirty byte
        INC     BP              ;Add one for I/O device number
        LODSW                   ;Get size of this FAT
        XCHG    AX,BP
        STOSW                   ;Save address of this FAT
        ADD     BP,AX           ;Compute size of next FAT
        CMP     AX,BP           ;If size was zero done
        LOOPNZ  TOTFATSIZ
        MOV     AL,15
        SUB     AL,CL           ;Compute number of FATs used
        MOV     [NUMDRV],AL
        XOR     AX,AX           ;Set zero flag
        REPZ    SCASW           ;Make sure all other entries are zero
        JNZ     BADINITJ
        ADD     BP,15           ;True start of free space
        MOV     CL,4
        SHR     BP,CL           ;First free segment
        MOV     DX,CS
        ADD     DX,BP
        MOV     BX,0FH
        MOV     CX,[ENDMEM]
        CMP     CX,1            ;Use memory scan?
        JNZ     SETEND
        MOV     CX,DX           ;Start scanning just after DOS
MEMSCAN:
        INC     CX
        JZ      SETEND
        MOV     DS,CX
        MOV     AL,[BX]
        NOT     AL
        MOV     [BX],AL
        CMP     AL,[BX]
        NOT     AL
        MOV     [BX],AL
        JZ      MEMSCAN
SETEND:
        IF      HIGHMEM
        SUB     CX,BP
        MOV     BP,CX           ;Segment of DOS
        MOV     DX,CS           ;Program segment
        ENDIF
        IF      NOT HIGHMEM
        MOV     BP,CS
        ENDIF
; BP has segment of DOS (whether to load high or run in place)
; DX has program segment (whether after DOS or overlaying DOS)
; CX has size of memory in paragraphs (reduced by DOS size if HIGHMEM)
        MOV     CS:[ENDMEM],CX
        IF      HIGHMEM
        MOV     ES,BP
        XOR     SI,SI
        MOV     DI,SI
        MOV     CX,(DOSLEN+1)/2
        PUSH    CS
        POP     DS
        REP MOVSW               ;Move DOS to high memory
        ENDIF
        XOR     AX,AX
        MOV     DS,AX
        MOV     ES,AX
        MOV     DI,INTBASE
        MOV     AX,OFFSET DOSGROUP:QUIT
        STOSW                   ;Set abort address--displacement
        MOV     AX,BP
        MOV     BYTE PTR DS:[ENTRYPOINT],LONGJUMP
        MOV     WORD PTR DS:[ENTRYPOINT+1],OFFSET DOSGROUP:ENTRY
        MOV     WORD PTR DS:[ENTRYPOINT+3],AX
        MOV     WORD PTR DS:[0],OFFSET DOSGROUP:DIVOV   ;Set default divide trap address
        MOV     DS:[2],AX
        MOV     CX,9
        REP STOSW               ;Set 5 segments (skip 2 between each)
        MOV     WORD PTR DS:[INTBASE+4],OFFSET DOSGROUP:COMMAND
        MOV     WORD PTR DS:[INTBASE+12],OFFSET DOSGROUP:IRET   ;Ctrl-C exit
        MOV     WORD PTR DS:[INTBASE+16],OFFSET DOSGROUP:IRET   ;Fatal error exit
        MOV     AX,OFFSET BIOSREAD
        STOSW
        MOV     AX,BIOSSEG
        STOSW
        STOSW                   ;Add 2 to DI
        STOSW
        MOV     WORD PTR DS:[INTBASE+18H],OFFSET BIOSWRITE
        MOV     WORD PTR DS:[EXIT],100H
        MOV     WORD PTR DS:[EXIT+2],DX
        IF      NOT IBM
        MOV     SI,OFFSET DOSGROUP:HEADER
        CALL    OUTMES
        ENDIF
        PUSH    CS
        POP     DS
        PUSH    CS
        POP     ES
;Move the FATs into position
        MOV     AL,[NUMIO]
        CBW
        XCHG    AX,CX
        MOV     DI,OFFSET DOSGROUP:MEMSTRT.FAT
FATPOINT:
        MOV     SI,WORD PTR [DI]        ;Get address within FAT address table
        MOVSW                           ;Set address of this FAT
        ADD     DI,DPBSIZ-2             ;Point to next DPB
        LOOP    FATPOINT
        POP     CX                      ;True address of first FAT
        MOV     SI,OFFSET DOSGROUP:MEMSTRT      ;Place to move DPBs from
        MOV     DI,[DRVTAB]             ;Place to move DPBs to
        SUB     CX,DI                   ;Total length of DPBs
        CMP     DI,SI
        JBE     MOVJMP                  ;Are we moving to higher or lower memory?
        DEC     CX                      ;Move backwards to higher memory
        ADD     DI,CX
        ADD     SI,CX
        INC     CX
        STD
MOVJMP:
        MOV     ES,BP
        JMP     MOVFAT

FIGFATSIZ:
        MUL     ES:BYTE PTR[BP.FATCNT]
        ADD     AX,ES:[BP.FIRFAT]
        ADD     AX,ES:[BP.DIRSEC]
FIGMAX:
;AX has equivalent of FIRREC
        SUB     AX,ES:[BP.DSKSIZ]
        NEG     AX
        MOV     CL,ES:[BP.CLUSSHFT]
        SHR     AX,CL
        INC     AX
        MOV     CX,AX           ;MAXCLUS
        INC     AX
        MOV     DX,AX
        SHR     DX,1
        ADC     AX,DX           ;Size of FAT in bytes
        MOV     SI,ES:[BP.SECSIZ]
        ADD     AX,SI
        DEC     AX
        XOR     DX,DX
        DIV     SI
        RET

BADMES:
        DB      13,10,"INIT TABLE BAD",13,10,"$"

FATSIZTAB:
        DW      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

DRVCNT  DB      0

MEMSTRT LABEL   WORD
ADJFAC  EQU     DIRBUF-MEMSTRT
DATA    ENDS
        END