dos.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      IBMVER
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     47
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      IBMVER
BIOSSEG EQU     60H
	ENDIF
	IF      NOT IBMVER
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 IBMVER
	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      IBMVER
	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 IBMVER
HEADER  DB      13,10,"MS-DOS version 1.25C"
	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
	DW      GETDMA

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      IBMVER
	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:
IFDEF NEWVER
	MOV     AH,BYTE PTR [BX]
	OR      AH,AH   		;End of directory?
	JZ      FREE
	CMP     AH,[DELALL]     	;Free entry?
	JZ      FREE
ELSE
	CMP     BYTE PTR [BX], 0E5H
	JZ      FREE
ENDIF
	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?
IFDEF NEWVER
	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
ELSE
	JNZ     NEXTENT
	MOV     CX,[LASTENT]
	MOV     [ENTFREE],CX
	JMP     NEXTENT
ENDIF
 
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
IFDEF NEWVER
	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
ELSE
	CALL    GETNAME
	MOV     AL,-1
	JC      RET4
	OR      BH,BH
	JS      RET4
DELFILE:
	MOV     BYTE PTR [DIRTYDIR],-1
	MOV     BYTE PTR [BX],0E5H
ENDIF
	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

IFDEF NEWVER
	MOV     CS:WORD PTR [CREATING],0E500H   ;Not creating, not DEL *.*
ELSE
	MOV     CS:BYTE PTR [EXTFCB+1],0
ENDIF
	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

GETDMA: ;System call 47
	MOV     BX,CS:[DMAADD]
	MOV     ES,CS:[DMAADD+2]
	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      IBMVER
	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      IBMVER
DELIM:
	ENDIF
	CMP     AL,":"  	;Allow ":" as separator in IBM version
	JZ      RET21
	IF      NOT IBMVER
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 IBMVER
	DB      "PRN ","LST ","NUL ","AUX ","CON "
	ENDIF
	IF      IBMVER
	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      ?
IFDEF NEWVER
;WARNING - the following two items are accessed as a word
CREATING DB     ?
DELALL  DB      ?
ELSE
CREATING DB     ?
ENDIF
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 IBMVER
	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