; 86-DOS  High-performance operating system for the 8086  version 1.00 04/28/81
;	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
;
; *************************************************************

; Use the switch below to generate code to accept the old 16-byte
; directory entry as well as the new 32-byte entry.

SMALLDIR:	EQU	1	;1 to enable, 0 to disable


; Turn on switch below to allow testing disk code with DEBUG. It sets
; up a different stack for disk I/O (functions > 11) than that used for
; character I/O which effectively makes the DOS re-entrant.

DSKTEST:	EQU	0	;1 to enable, 0 to disable


; 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


MAXCALL:EQU	36
MAXCOM:	EQU	41
ESCCH:	EQU	1BH
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

	ORG	0
	DS	12		;Drive code and name
EXTENT:	DS	2
RECSIZ:	DS	2		;Size of record (user settable)
FILSIZ:	DS	4		;Size of file in bytes
FDATE:	DS	2		;Date of last writing
FILDIRBLK:DS	2		;Location in directory
FIRCLUS:DS	2		;First cluster of file
LSTCLUS:DS	2		;Last cluster accessed
CLUSPOS:DS	2		;Position of last cluster accessed
DIRTYFIL:DS	1		;File has been written to if <>0
	ORG	32
NR:	DS	1		;Next record
RR:	DS	3		;Random record


; 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		13	Zero field (for expansion)
;   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

	ORG	0
DRVNUM:	DS	1		;Drive number
SECSIZ:	DS	2		;Size of physical sector in bytes
CLUSMSK:DS	1		;Sectors/cluster - 1
CLUSSHFT:DS	1		;Log2 of sectors/cluster
FIRFAT:	DS	2		;Starting record of FATs
FATCNT:	DS	1		;Number of FATs for this drive
MAXENT:	DS	2		;Number of directory entries
DIRSEC:				;Number of dir. sectors (init temporary)
FIRREC:	DS	2		;First sector of first cluster
DSKSIZ:				;Size of disk (temp used during init only)
MAXCLUS:DS	2		;Number of clusters on drive + 1
FATSIZ:	DS	1		;Number of records occupied by FAT
FIRDIR:	DS	2		;Starting record of directory

	IF	SMALLDIR
FIRREC1:DS	2		;First data sector with 16-byte dir. entries
MAXCLUS1:DS	2		;No. of clusters + 1 with 16-byte dir. entries
FIRREC2:DS	2		;First data sector with 32-byte dir. entries
MAXCLUS2:DS	2		;No. of clusters + 1 with 32-byte dir entries
	ENDIF

DIRTYFAT:DS	1		;1=FAT has been changed, -1=never been read
FAT:				;Start of FAT
DIRSIZ:				;-1=small dir. entry, else large


; BIOS entry point defintions

BIOSSEG:	EQU	40H
		ORG	0
		DS	3
BIOSSTAT:	DS	3
BIOSIN:		DS	3
BIOSOUT:	DS	3
BIOSPRINT:	DS	3
BIOSAUXIN:	DS	3
BIOSAUXOUT:	DS	3
BIOSREAD:	DS	3
BIOSWRITE:	DS	3
BIOSDSKCHG:	DS	3


; Location of user registers relative user stack pointer

	ORG	0
AXSAVE:	DS	2
BXSAVE:	DS	2
CXSAVE:	DS	2
DXSAVE:	DS	2
SISAVE:	DS	2
DISAVE:	DS	2
BPSAVE:	DS	2
DSSAVE:	DS	2
ESSAVE:	DS	2
IPSAVE:	DS	2
CSSAVE:	DS	2
FSAVE:	DS	2


; Start of code

	ORG	0
	PUT	100H

	JMP	DOSINIT

ESCTAB:	
	DB	"SC"	;Copy one char
	DB	"VN"	;Skip one char
	DB	"TA"	;Copy to char
	DB	"WB"	;Skip to char
	DB	"UH"	;Copy line
	DB	"HH"	;Kill line (no change in template)
	DB	"RM"	;Reedit line (new template)
	DB	"DD"	;Backspace
	DB	"P@"	;Enter insert mode
	DB	"QL"	;Exit insert mode
	DB	ESCCH,ESCCH	;Escape character
	DB	ESCCH,ESCCH	;End of table

ESCTABLEN:EQU	$-ESCTAB

HEADER:	DB	13,10,"86-DOS version 1.00"

	IF	DSKTEST
	DB	"D"
	ENDIF

	DB	13,10
	DB	"Copyright 1980,81 Seattle Computer Products, Inc.",13,10,"$"

QUIT:
	MOV	AH,0
	JP	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
	SEG	CS
	POP	[TEMP]		;IP from the CALL 5
	PUSHF			;Start re-ordering the stack
	DI
	PUSH	AX		;Save segment
	SEG	CS
	PUSH	[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
	SEG	CS
	MOV	AX,[SPSAVE]
	SEG	CS
	MOV	[NSP],AX
	SEG	CS
	MOV	AX,[SSSAVE]
	SEG	CS
	MOV	[NSS],AX
	POP	AX
	PUSH	AX
	ENDIF

	SEG	CS
	MOV	[SPSAVE],SP
	SEG	CS
	MOV	[SSSAVE],SS
	MOV	BP,SP
	MOV	BX,[BP+CSSAVE]
	SEG	CS
	MOV	[CSLOC],BX
	MOV	SP,CS
	MOV	SS,SP
	MOV	SP,STACK
	EI			;Stack OK now
	SEG	CS
	MOV	[FUNC],AH
	MOV	BL,AH
	MOV	BH,0
	SHL	BX
	UP

	IF	DSKTEST
	CMP	AH,12
	JL	SAMSTK
	MOV	SP,TESTSTK
SAMSTK:
	ENDIF

	SEG	CS
	CALL	[BX+DISPATCH]
LEAVE:
	DI
	SEG	CS
	MOV	SP,[SPSAVE]
	SEG	CS
	MOV	SS,[SSSAVE]
	MOV	BP,SP
	MOV	[BP+AXSAVE],AL

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

	POP	AX
	POP	BX
	POP	CX
	POP	DX
	POP	SI
	POP	DI
	POP	BP
	POP	DS
	POP	ES
	IRET

DISPATCH:
; Standard Functions
	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	VERSION
	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	CURDRV		;25
	DW	SETDMA
	DW	GETFATPT
	DW	WRTPROT
	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

VERSION:
GETIO:
SETIO:
WRTPROT:
GETRDONLY:
SETATTRIB:
USERCODE:
	MOV	AL,0
	RET


READER:
	CALL	BIOSAUXIN,BIOSSEG
	RET

PUNCH:
	MOV	AL,DL
	CALL	BIOSAUXOUT,BIOSSEG
	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
	MOV	DI,[DI+BX]
	JNC	HAVCLUS
	SHR	DI
	SHR	DI
	SHR	DI
	SHR	DI
	STC
HAVCLUS:
	RCL	BX
	AND	DI,0FFFH
	RET
HURTFAT:
	MOV	SI,BADMES
	CALL	OUTMES
	JMP	ERROR


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
	ADD	BX,SI
	ADD	BX,DI
	SHR	DI
	MOV	DI,[BX]
	JNC	ALIGNED
	SHL	DX
	SHL	DX
	SHL	DX
	SHL	DX
	AND	DI,0FH
	JP	PACKIN
ALIGNED:
	AND	DI,0F000H
PACKIN:
	OR	DI,DX
	MOV	[BX],DI
	RET

IOCHK:
	MOV	CX,5		;Check rest of name but not extension
	CMP	B,[DI],":"
	JNZ	NOCOL
	INC	DI		;Skip over colon
	DEC	CX
NOCOL:
	MOV	AL," "
	REPE
	SCAB			;Make sure rest of name is blanks
	JNZ	FILSRCH
	DEC	BL
	RET

GETFILE:

; 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
;	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	RET		;Bad file name?
FINDNAME:
	MOV	AX,CS
	MOV	DS,AX
	MOV	SI,IONAME	;List of I/O devices with file names
	MOV	BX,0FF04H	;BL = number of devices
LOOKIO:
	MOV	DI,NAME1
	MOV	CX,3		;All device names are 3 letters
	REPE
	CMPB			;Check for name in list
	JZ	IOCHK		;If first 3 letters OK, check the rest
	ADD	SI,CX		;Point to next device name
	DEC	BL
	JNZ	LOOKIO
FILSRCH:			;Not a device name
	CALL	STARTSRCH
CONTSRCH:
	CALL	GETENTRY
	JC	RET
SRCH:
	CMP	B,[BX],0E5H
	JZ	NEXTENT
	MOV	SI,BX
	MOV	DI,NAME1
	MOV	CX,11
WILDCRD:
	REPE
	CMPB
	JZ	FOUND
	CMP	B,[DI-1],"?"
	JZ	WILDCRD
NEXTENT:
	CALL	NEXTENTRY
	JNC	SRCH
	RET

FOUND:
	IF	SMALLDIR
	CMP	B,[BP+DIRSIZ],-1
	JZ	RET
	ENDIF

	ADD	SI,15	
	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
	MOV	[LASTENT],AX
	MOV	CL,4
	SHL	AX,CL
	XOR	DX,DX

	IF	SMALLDIR
	CMP	B,[BP+DIRSIZ],-1
	JZ	SMALENT1
	ENDIF

	SHL	AX
	RCL	DX			;Account for overflow in last shift
SMALENT1:
	MOV	BX,[BP+SECSIZ]
	AND	BL,255-31		;Must be multiple of 32
	DIV	AX,BX
	MOV	BX,DX			;Position within sector
	MOV	AH,[BP+DRVNUM]		;AL=Directory sector no.
	CMP	AX,[DIRBUFID]
	JZ	HAVDIRBUF
	PUSH	BX
	CALL	DIRREAD
	POP	BX
HAVDIRBUF:
	MOV	DX,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

	IF	SMALLDIR
	CMP	B,[BP+DIRSIZ],-1
	JNZ	BIGENT3
	SUB	BX,16
BIGENT3:
	ENDIF

	CMP	BX,DX
	JB	HAVIT
	INC	AL			;Next directory sector
	PUSH	DX			;Save limit
	CALL	DIRREAD
	POP	DX
	MOV	BX,DIRBUF
HAVIT:
	CLC
	RET

NONE:
	CALL	CHKDIRWRITE
	STC
	RET


DELETE:	; System call 19
	CALL	GETFILE
	JC	ERRET
	CMP	BH,-1		;Check if device name
	JZ	ERRET		;Can't delete I/O devices
DELFILE:
	MOV	B,[DIRTYDIR],-1
	MOV	B,[BX],0E5H
	MOV	BX,[SI]
	LEA	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
	CMP	BH,-1		;Check if I/O device name
	JZ	ERRET		;If so, can't rename it
	ADD	SI,5
	MOV	DI,NAME2
	CALL	LODNAME
	CALL	FINDNAME
	JC	ERRET
RENFIL:
	MOV	B,[DIRTYDIR],-1
	MOV	DI,BX
	MOV	SI,NAME2
	MOV	CX,11
NEWNAM:
	LODB
	CMP	AL,"?"
	JZ	NOCHG
	MOV	[DI],AL
NOCHG:
	INC	DI
	LOOP	NEWNAM
	CALL	CONTSRCH
	JNC	RENFIL
	CALL	CHKDIRWRITE
	XOR	AL,AL
	RET

ERRET:
	MOV	AL,-1
	RET


MOVNAME:

; Inputs:
;	DS, DX point to FCB
; Outputs:
;	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	AX,CS
	MOV	ES,AX
	MOV	DI,NAME1
	MOV	SI,DX
	LODB
	CALL	GETBP
	JB	RET
LODNAME:
; This entry point copies a file name from DS,SI
; to ES,DI converting to upper case.
	MOV	CX,11
MOVCHK:
	LODB
	AND	AL,7FH
	CMP	AL,60H
	JLE	CASEOK
	AND	AL,5FH
CASEOK:
	CMP	AL,20H
	JC	RET
	STOB
	LOOP	MOVCHK
	RET

GETBP:
	SEG	CS
	CMP	[NUMDRV],AL
	JC	RET
	CBW
	XCHG	BP,AX
	SHL	BP
	MOV	BP,[BP+CURDRVPT]
	RET


OPEN:	;System call 15
	PUSH	DX
	PUSH	DS
	CALL	GETFILE
DOOPEN:
; Enter here to perform OPEN on file already found
; in directory. DS=ES=CS, BX points to directory
; entry in DIRBUF, SI points to First Cluster field, and
; the top of the stack has the address and segment
; of the FCB to be opened. This entry point is used
; by CREATE.
	POP	ES
	POP	DI
	JC	ERRET
	CMP	BH,-1		;Check if file is I/O device
	JZ	OPENDEV		;Special handler if so
	MOV	AL,[BP+DRVNUM]
	INC	AL
	STOB
	ADD	DI,11		;Point to extent field
	XOR	AX,AX
	STOW			;Set extent field to 0
	MOV	AX,128		;Default record size
	STOW			;Set record size
	LODW			;Get starting cluster
	MOV	DX,AX		;Save it for the moment
	MOVW			;Transfer size to FCB
	MOVW
	MOV	AX,[SI-8]	;Get date

	IF	SMALLDIR
	CMP	B,[BP+DIRSIZ],-1
	JNZ	BIGENT10
	SEG	ES
	MOV	[DI-1],0
	XOR	AX,AX		;Date not available in small entry
BIGENT10:
	ENDIF

	STOW			;Save date in FCB
	MOV	AX,[LASTENT]
	STOW			;directory location
	MOV	AX,DX		;Restore starting cluster
	STOW			; first cluster
	STOW			; last cluster accessed
	XOR	AX,AX
	STOW			; position of last cluster
	STOB			; dirty flag
	RET

OPENDEV:
	SEG	ES
	MOV	[DI+FILDIRBLK],BX ;Use dir. entry number as flag
	XOR	AL,AL
	RET


STARTSRCH:
	MOV	[LASTENT],-1
FATREAD:

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

	MOV	AL,[BP+DRVNUM]
	CALL	BIOSDSKCHG,BIOSSEG	;See what BIOS has to say
	MOV	AL,[BP+DRVNUM]
	OR	AH,[BP+DIRTYFAT]
	JS	NEWDSK		;If either say new disk, then it's so
	DEC	AH		;Check for AH=1 (disk not changed)
	JZ	RET
	MOV	AH,1
	CMP	AX,[BUFDRVNO]	;Does buffer have dirty sector of this drive?
	JZ	RET		;If so, disk has not been changed
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	[BUFDRVNO],00FFH
BUFOK:
	MOV	[DIRBUFID],-1
	CALL	FIGFAT
NEXTFAT:
	PUSH	DX
	PUSH	CX
	PUSH	BX
	PUSH	AX
	CALL	DREAD
	OR	AL,AL
	POP	AX
	POP	BX
	POP	CX
	POP	DX
	JNZ	BADFAT

	IF	SMALLDIR
	MOV	DL,AL
	LEA	SI,[BP+FIRREC1]	;FIRREC and MAXCLUS for 16-byte dir entries
	CMP	B,[BP+DIRSIZ],-1
	JZ	SETSIZ
	ADD	SI,4		;FIRREC and MAXCLUS for 32-byte entries
SETSIZ:
	LODW
	MOV	[BP+FIRREC],AX
	LODW
	MOV	[BP+MAXCLUS],AX
	MOV	AL,DL
	ENDIF

	SUB	AL,[BP+FATCNT]
	JZ	RET
	NEG	AL
;{Insert error code here. AL=number of bad fats.
;Since one good FAT was read, should include option
;to rewrite all FATs.}
	JMP	FATWRT

BADFAT:
	ADD	DX,CX
	DEC	AL
	JNZ	NEXTFAT
	POP	BP
;{Insert error code here. All FATs on drive are bad.}
	MOV	SI,BADFATMES
	CALL	HARDERR
	JP	FATREAD

OKRET1:
	MOV	AL,0
	RET

CLOSE:	;System call 16
	MOV	DI,DX
	CMP	B,[DI+FILDIRBLK],-1  ;Check for I/O device
	JZ	OKRET1		;Can't close I/O device
	TEST	B,[DI+DIRTYFIL],-1
	JZ	OKRET1		;If not written to, do nothing
	MOV	AL,[DI]		;Get drive number
	CALL	GETBP		;Get base of drive parameters
	JC	BADCLOSEJ
	MOV	AL,[BP+DRVNUM]
	MOV	AH,1		;Look for dirty buffer
	SEG	CS
	CMP	AX,[BUFDRVNO]
	JNZ	FNDDIR
;Write back dirty buffer if on same drive
	PUSH	DX
	PUSH	DS
	PUSH	CS
	POP	DS
	MOV	B,[DIRTYBUF],0
	MOV	BX,[BUFFER]
	MOV	CX,1
	MOV	DX,[BUFSECNO]
	CALL	DWRITE
	POP	DS
	POP	DX
FNDDIR:
	PUSH	DX
	PUSH	DS
	CALL	GETFILE
	POP	ES
	POP	DI
BADCLOSEJ:
	JC	BADCLOSE
	MOV	AX,[LASTENT]
	SEG	ES
	CMP	AX,[DI+FILDIRBLK]
	JNZ	BADCLOSE
	SEG	ES
	MOV	CX,[DI+FIRCLUS]
	MOV	[SI],CX
	SEG	ES
	MOV	DX,[DI+FILSIZ]
	MOV	[SI+2],DX
	SEG	ES
	MOV	DX,[DI+FILSIZ+2]

	IF	SMALLDIR
	CMP	B,[BP+DIRSIZ],-1
	JNZ	BIGENT11
	MOV	[SI+4],DL
	JP	SMALLENT2
BIGENT11:
	ENDIF

	MOV	[SI+4],DX
	SEG	ES
	MOV	DX,[DI+FDATE]
	MOV	[SI-2],DX
SMALLENT2:
	CALL	DIRWRITE

CHKFATWRT:
; Do FATWRT only if FAT is dirty

	CMP	B,[BP+DIRTYFAT],1
	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

	MOV	B,[BP+DIRTYFAT],0
	CALL	FIGFAT
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	B,[BP+DIRTYFAT],0
	MOV	AL,-1
	RET


FIGFAT:
; Loads registers with values needed to read or
; write a FAT.
	MOV	AL,[BP+FATCNT]
	LEA	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,DIRBUF
	MOV	CX,1
	RET


CREATE:	;System call 22
	CALL	MOVNAME
	JC	ERRET3
	MOV	DI,NAME1
	MOV	CX,11
	MOV	AL,"?"
	REPNE
	SCAB
	JZ	ERRET3
	PUSH	DX
	PUSH	DS
	CALL	FINDNAME
	JNC	EXISTENT
	CALL	STARTSRCH
	CALL	GETENTRY
LOOKFRE:
	CMP	B,[BX],0E5H
	JZ	FREESPOT
	CALL	NEXTENTRY
	JNC	LOOKFRE
	POP	DS
	POP	DX
ERRET3:
	MOV	AL,-1
	RET

EXISTENT:
	CMP	BH,-1		;Check if file is I/O device
	JZ	OPENJMP		;If so, no action
	XOR	CX,CX
	MOV	[SI+2],CX
	MOV	AX,[DATE]

	IF	SMALLDIR
	MOV	[SI+4],CL
	CMP	B,[BP+DIRSIZ],-1
	JZ	SMLENT
	MOV	[SI+5],CL
	MOV	[SI-2],AX
SMLENT:
	ENDIF

	IF	1-SMALLDIR
	MOV	[SI+4],CX
	MOV	[SI-2],AX
	ENDIF

	XCHG	CX,[SI]
	PUSH	SI
	PUSH	BX
	JCXZ	WRTBACK
	CMP	CX,[BP+MAXCLUS]
	JA	WRTBACK
	MOV	BX,CX
	LEA	SI,[BP+FAT]
	CALL	RELEASE
	CALL	FATWRT
	JP	WRTBACK

FREESPOT:
	MOV	DI,BX
	MOV	SI,NAME1
	MOV	CX,5
	MOVB
	REP
	MOVW
	XOR	AX,AX

	IF	SMALLDIR
	CMP	B,[BP+DIRSIZ],-1
	JNZ	BIGENT4
	PUSH	DI
	MOV	CL,5
	JP	SMALLENT
BIGENT4:
	ENDIF

	MOV	CL,13
	REP
	STOB
	MOV	AX,[DATE]
	STOW
	XOR	AX,AX
	PUSH	DI
	MOV	CL,6
SMALLENT:
	REP
	STOB
	PUSH	BX
WRTBACK:
	CALL	DIRWRITE
	POP	BX
	POP	SI
OPENJMP:
	CLC			;Clear carry so OPEN won't fail
	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+DRVNUM]
	MOV	[DIRBUFID],AX
	CALL	DIRCOMP
	CALL	DREAD
	POP	AX
	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.
; Outputs:
;	AL = 0 if no error, otherwise non-zero
; BP preserved. All other registers destroyed.

	MOV	AL,[BP+DRVNUM]
	PUSH	BP
	PUSH	BX
	PUSH	CX
	PUSH	DX
	CALL	BIOSREAD,BIOSSEG
	POP	DX
	POP	DI
	POP	BX
	POP	BP
	JC	HARDREAD
	XOR	AL,AL
	RET

HARDREAD:
	MOV	SI,RDERRMES
	CALL	HARDERR
	JP	DREAD


CHKDIRWRITE:
	TEST	B,[DIRTYDIR],-1
	JZ	RET

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	B,[DIRTYDIR],0
	MOV	AL,[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.
; Outputs:
;	AL = 0 if no error, otherwise non-zero
; BP preserved. All other registers destroyed.

	MOV	AL,[BP+DRVNUM]
WRTDRV:
	PUSH	AX
	PUSH	BP
	PUSH	BX
	PUSH	CX
	PUSH	DX
	CALL	BIOSWRITE,BIOSSEG
	POP	DX
	POP	DI
	POP	BX
	POP	BP
	POP	AX
	JC	HARDWRITE
	XOR	AL,AL
	RET
HARDWRITE:
	MOV	SI,WRTERRMES
	CALL	HARDERR
	JP	WRTDRV


HARDERR:
	SUB	DI,CX
	ADD	DX,DI
	CALL	SHFTDI7
	ADD	BX,DI
	MOV	AH,AL		;Save drive number
	CALL	OUTMES
GETINSTR:
	CALL	IN
	OR	AL,20H
	CMP	AL,"a"
	JZ	ERROR
	CMP	AL,"r"
	JZ	RETRY
	CMP	AL,"i"
	JZ	IGNORE
	CMP	AL,"c"
	JNZ	GETINSTR
CONTINUE:
	POP	AX
	MOV	AL,1
	RET
IGNORE:
	POP	AX
	MOV	AL,0
	RET
RETRY:
	MOV	AL,AH		;Restore drive number
	RET


ABORT:
	SEG	CS
	MOV	DS,[CSLOC]
	XOR	AX,AX
	MOV	ES,AX
	MOV	SI,SAVEXIT
	MOV	DI,EXIT
	MOVW
	MOVW
	MOVW
	MOVW
ERROR:
	MOV	AX,CS
	MOV	DS,AX
	MOV	ES,AX
	CALL	WRTFATS
	XOR	AX,AX
	DI
	MOV	SS,[SSSAVE]
	MOV	SP,[SPSAVE]
	MOV	DS,AX
	MOV	SI,EXIT
	MOV	DI,EXITHOLD
	MOVW
	MOVW
	POP	AX
	POP	BX
	POP	CX
	POP	DX
	POP	SI
	POP	DI
	POP	BP
	POP	DS
	POP	ES
	EI			;Stack OK now
	SEG	CS
	JMP	L,[EXITHOLD]


SEQRD:	;System call 20
	CALL	GETREC
	CALL	LOAD
	JP	FINSEQ

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

RNDRD:	;System call 33
	CALL	GETRRPOS1
	CALL	LOAD
	JP	FINRND

RNDWRT:	;System call 34
	CALL	GETRRPOS1
	CALL	STORE
	JP	FINRND

BLKRD:	;System call 39
	CALL	GETRRPOS
	CALL	LOAD
	JP	FINBLK

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

GETRRPOS1:
	MOV	CX,1
GETRRPOS:
	MOV	DI,DX
	MOV	AX,[DI+RR]
	MOV	DX,[DI+RR+2]
	RET

NOFILERR:
	XOR	CX,CX
	MOV	B,[DSKERR],-2
	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
;	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)
; If SETUP detects no records will be transfered, it returns 1 level up 
; with CX = 0.

	PUSH	AX
	MOV	AL,[DI]
	MOV	SI,[DI+RECSIZ]
	OR	SI,SI
	JNZ	HAVRECSIZ
	MOV	SI,128
	MOV	[DI+RECSIZ],SI
HAVRECSIZ:
	MOV	BX,DS
	MOV	ES,BX
	MOV	BX,CS
	MOV	DS,BX
	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	[RECPOS],AX
	MOV	[RECPOS+2],DX
	MOV	[FCB],DI
	MOV	BX,[DMAADD]
	MOV	[NEXTADD],BX
	MOV	B,[DSKERR],0
	MOV	B,[TRANS],0
	MOV	BX,DX
	MUL	AX,SI
	MOV	[BYTPOS],AX
	PUSH	DX
	MOV	AX,BX
	MUL	AX,SI
	POP	BX
	ADD	AX,BX
	ADC	DX,0		;Ripple carry
	JNZ	EOFERR
	MOV	[BYTPOS+2],AX
	MOV	DX,AX
	MOV	AX,[BYTPOS]
	DIV	AX,[BP+SECSIZ]
	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	AX,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 stay within 64K
	MOV	AX,[DMAADD]
	NEG	AX		;Amount of room left in segment
	XOR	DX,DX
	DIV	AX,SI		;How many records will fit?
	MUL	AX,SI		;Translate that back into bytes
	MOV	B,[DSKERR],2	;Flag that trimming took place
	MOV	CX,AX
	JCXZ	NOROOM
OK:
	LEA	SI,[BP+FAT]
	RET

EOFERR:
	MOV	B,[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	AX,[BP+SECSIZ]	;How many whole sectors?
	MOV	[SECCNT],AX
	MOV	[BYTCNT2],DX	;Bytes remaining for last sector
	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.

	SEG	ES
	MOV	BX,[DI+LSTCLUS]
	SEG	ES
	MOV	DX,[DI+CLUSPOS]
	OR	BX,BX
	JZ	NOCLUS
	SUB	CX,DX
	JNB	FINDIT
	ADD	CX,DX
	XOR	DX,DX
	SEG	ES
	MOV	BX,[DI+FIRCLUS]
FINDIT:
	JCXZ	RET
SKPCLP:
	CALL	UNPACK
	CMP	DI,0FF8H
	JAE	RET
	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
	OR	AL,AL
	JNZ	SETBUF
	CMP	DX,[BUFSECNO]
	JNZ	GETSEC
	MOV	AL,[BUFDRVNO]
	CMP	AL,[BP+DRVNUM]
	JZ	FINBUF		;Already have it?
GETSEC:
	TEST	B,[DIRTYBUF],-1
	JZ	RDSEC
	PUSH	DX
	MOV	AL,[BUFDRVNO]
	MOV	BX,[BUFFER]
	MOV	CX,1
	MOV	DX,[BUFSECNO]
	CALL	WRTDRV
	POP	DX
RDSEC:
	MOV	BX,[BUFFER]
	MOV	CX,1
	PUSH	DX
	CALL	DREAD
	POP	DX
SETBUF:
	MOV	[BUFSECNO],DX
	MOV	AL,[BP+DRVNUM]
	MOV	AH,0
	MOV	[BUFDRVNO],AX
FINBUF:
	MOV	B,[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
	JNC	EVENRD
	MOVB
EVENRD:
	REP
	MOVW
	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
	JNC	EVENWRT
	MOVB
EVENWRT:
	REP
	MOVW
	POP	ES
	POP	DS
	MOV	B,[DIRTYBUF],1
	RET

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

TRANBUF:
	LODB
	STOB
	CMP	AL,13		;Check for carriage return
	JNZ	NORMCH
	MOV	[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]
	SEG	ES
	OR	B,[DI+FILDIRBLK],80H	;Mark as no more data available
SETFCBJ:
	JMP	SETFCB

READDEV:
	PUSH	ES
	LES	DI,[DMAADD]
	OR	BL,BL
	JZ	READCON
	DEC	BL
	JNZ	ENDRDDEV
READAUX:
	CALL	BIOSAUXIN,BIOSSEG
	STOB
	CMP	AL,1AH
	LOOPNZ	READAUX
	JP	ENDRDDEV

READCON:
	PUSH	CS
	POP	DS
	MOV	SI,[CONTPOS]
	OR	SI,SI
	JNZ	TRANBUF
	CMP	B,[CONBUF],128
	JZ	GETBUF
	MOV	[CONBUF],0FF80H	;Set up 128-byte buffer with no template
GETBUF:
	PUSH	CX
	PUSH	ES
	PUSH	DI
	MOV	DX,CONBUF
	CALL	BUFIN		;Get input buffer
	POP	DI
	POP	ES
	POP	CX
	MOV	SI,CONBUF+2
	CMP	B,[SI],1AH	;Check for Ctrl-Z in first character
	JNZ	TRANBUF
	MOV	AL,1AH
	STOB
	MOV	AL,10
	CALL	OUT		;Send linefeed
	XOR	SI,SI
	JP	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
	SEG	ES
	MOV	BX,[DI+FILDIRBLK]
	CMP	BH,-1		;Check for named device I/O
	JZ	READDEV
	SEG	ES
	MOV	AX,[DI+FILSIZ]
	SEG	ES
	MOV	BX,[DI+FILSIZ+2]
	SUB	AX,[BYTPOS]
	SBC	BX,[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	B,[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]
	CALL	DREAD
	POP	DS
	POP	CX
	POP	BX
	JCXZ	RDLAST
	CMP	BX,0FF8H
	JAE	SETFCB
	MOV	DL,0
	INC	[LASTPOS]	;We'll be using next cluster
	JP	RDLP

SETFCB:
	MOV	SI,[FCB]
	MOV	AX,[NEXTADD]
	MOV	DI,AX
	SUB	AX,[DMAADD]	;Number of bytes transfered
	XOR	DX,DX
	SEG	ES
	MOV	CX,[SI+RECSIZ]
	DIV	AX,CX		;Number of records
	CMP	AX,[RECCNT]	;Check if all records transferred
	JZ	FULLREC
	MOV	B,[DSKERR],1
	OR	DX,DX
	JZ	FULLREC		;If remainder 0, then full record transfered
	MOV	B,[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
	JNC	EVENFIL
	STOB
EVENFIL:
	REP
	STOW
	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]
	SEG	ES
	MOV	[DI+LSTCLUS],AX
	MOV	AX,[LASTPOS]
	SEG	ES
	MOV	[DI+CLUSPOS],AX
ADDREC:
	MOV	AX,[RECPOS]
	MOV	DX,[RECPOS+2]
	DEC	CX
	ADD	AX,CX		;Update current record position
	ADC	DX,0
	INC	CX	
	RET

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

WRTDEV:
	PUSH	DS
	LDS	SI,[DMAADD]
	AND	BL,7FH
	OR	BL,BL
	JZ	WRTCON
	DEC	BL
	JZ	WRTAUX
WRTLST:
	LODB
	CMP	AL,1AH
	JZ	ENDWRDEV
	CALL	BIOSPRINT,BIOSSEG
	LOOP	WRTLST
	JP	ENDWRDEV

WRTAUX:
	LODB
	CALL	BIOSAUXOUT,BIOSSEG
	CMP	AL,1AH
	LOOPNZ	WRTAUX
	JP	ENDWRDEV

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

HAVSTART:
	MOV	CX,AX
	CALL	SKPCLP
	JCXZ	DOWRTJ
	CALL	ALLOCATE
	JNC	DOWRTJ
WRTERR:
	MOV	B,[DSKERR],1
LVDSK:
	MOV	AX,[RECPOS]
	MOV	DX,[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

	MOV	B,[DI+DIRTYFIL],1
	SEG	CS
	MOV	BX,[DATE]
	MOV	[DI+FDATE],BX
	CALL	SETUP
	SEG	ES
	MOV	BX,[DI+FILDIRBLK]
	CMP	BH,-1
	JZ	WRTDEV
	CALL	BREAKDOWN
	MOV	AX,[BYTPOS]
	MOV	DX,[BYTPOS+2]
	JCXZ	WRTEOFJ
	DEC	CX
	ADD	AX,CX
	ADC	DX,0		;AX:DX=last byte accessed
	DIV	AX,[BP+SECSIZ]	;AX=last sector accessed
	MOV	CL,[BP+CLUSSHFT]
	SHR	AX,CL		;Last cluster to be accessed
	PUSH	AX
	SEG	ES
	MOV	AX,[DI+FILSIZ]
	SEG	ES
	MOV	DX,[DI+FILSIZ]
	DIV	AX,[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
	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	B,[TRANS],1	;A transfer is taking place
	MOV	DL,[SECCLUSPOS]
	MOV	BX,[CLUSNUM]
	MOV	CX,[SECCNT]
WRTLP:
	CALL	OPTIMIZE
	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
	JP	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,[BYTPOS]
	MOV	DX,[BYTPOS+2]
	ADC	DX,0
	MOV	CX,DX
	MOV	DI,[FCB]
	SEG	ES
	CMP	AX,[DI+FILSIZ]
	SEG	ES
	SBB	CX,[DI+FILSIZ+2]
	JB	SAMSIZ
	SEG	ES
	MOV	[DI+FILSIZ],AX
	SEG	ES
	MOV	[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
	SBC	DX,0
	DIV	AX,[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,[BYTPOS]
	SEG	ES
	MOV	[DI+FILSIZ],AX
	MOV	AX,[BYTPOS+2]
	SEG	ES
	MOV	[DI+FILSIZ+2],AX
	XOR	CX,CX
	RET

RELFILE:
	MOV	DX,0FFFH
	CALL	RELBLKS
SETDIRT:
	MOV	B,[BP+DIRTYFAT],1
	JP	UPDATE

KILLFIL:
	XOR	BX,BX
	SEG	ES
	XCHG	BX,[DI+FIRCLUS]
	OR	BX,BX
	JZ	UPDATE
	CALL	RELEASE
	JP	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
;	[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
	LEA	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	AX,[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
	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
	JP	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
	MOV	CX,1
	MOV	AL,[DI+NR]
	MOV	DX,[DI+EXTENT]
	SHL	AL
	SHR	DX
	RCR	AL
	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	AX,DX		;AX=max no. of records in file
	MOV	CX,AX
	SUB	CX,[RECPOS]	;CX=max no. of records that could be written
	JA	MAXREC
	XOR	CX,CX		;If CX was negative, zero it
MAXREC:
	STC
	RET

TRYOUT:
	CALL	UNPACK
	JZ	HAVFRE
TRYIN:
	DEC	AX
	JLE	FINDFRE
	XCHG	AX,BX
	CALL	UNPACK
	JZ	HAVFRE
	XCHG	AX,BX
	JP	FINDFRE
HAVFRE:
	XCHG	BX,DX
	MOV	AX,DX
	CALL	PACK
	MOV	BX,AX
	LOOP	ALLOC
	MOV	DX,0FFFH
	CALL	PACK
	MOV	B,[BP+DIRTYFAT],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	RET
	MOV	DI,[FCB]
	SEG	ES
	MOV	[DI+FIRCLUS],BX
	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	RET
	MOV	AX,DI
	CALL	PACK
	CMP	AX,0FF8H
	MOV	BX,AX
	JB	RELEASE
	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	RET
	MOV	BX,DI
	JP	GETEOF


SRCHFRST: ;System call 17
	PUSH	DX
	PUSH	DS
	CALL	GETFILE
SAVPLCE:
; Search-for-next enters here to save place and report
; findings.
	POP	ES
	POP	DI
	JC	KILLSRCH
	CMP	BH,-1
	JZ	SRCHDEV
	MOV	AX,[LASTENT]
	SEG	ES
	MOV	[DI+FILDIRBLK],AX
;Information in directory entry must be copied into the first
; 33 bytes starting at the disk transfer address.
	MOV	SI,BX
	LES	DI,[DMAADD]
	MOV	AL,[BP+DRVNUM]
	INC	AL
	STOB		;Set drive number
	MOVB		;Copy first character of name
	MOV	CX,5
	REP
	MOVW		;Copy remaining 10 characters of name
	XOR	AX,AX

	IF	SMALLDIR
	CMP	B,[BP+DIRSIZ],-1
	JNZ	BIGENT5
	STOB		;Zero out unused portion
	MOV	CX,7
	REP
	STOW		;Zero a total of 15 bytes
	MOVW		;Copy first cluster pointer
	MOVW		;Copy low word of length
	MOVB		;Copy 3rd byte of length
	STOB		;4th byte of length must be zero
	RET
BIGENT5:
	ENDIF

	MOV	CX,10
	REP
	MOVW
	MOVB
	RET

KILLSRCH:
	SEG	ES
KILLSRCH1:
	MOV	[DI+FILDIRBLK],-2
	MOV	AL,-1
	RET

SRCHDEV:
	SEG	ES
	MOV	[DI+FILDIRBLK],BX
	LES	DI,[DMAADD]
	XOR	AX,AX
	STOB			;Zero drive byte
	SUB	SI,3		;Point to device name
	MOVW
	MOVB
	MOV	AX,2020H
	MOV	CX,4
	REP
	STOW			;Fill with 8 blanks
	XOR	AX,AX
	MOV	CX,10
	REP
	STOW
	STOB
	RET

SRCHNXT: ;System call 18
	CALL	MOVNAME
	MOV	DI,DX
	JC	KILLSRCH1
	PUSH	DX
	PUSH	DS
	MOV	AX,[DI+FILDIRBLK]
	PUSH	CS
	POP	DS
	MOV	[LASTENT],AX
	CALL	CONTSRCH
	JMP	SAVPLCE


FILESIZE: ;System call 35
	PUSH	DS
	PUSH	DX
	CALL	GETFILE
	POP	DI
	POP	ES
	MOV	AL,-1
	JC	RET
	ADD	DI,33		;Write size in RR field
	SEG	ES
	MOV	CX,[DI-33+RECSIZ]
	OR	CX,CX
	JNZ	RECOK
	MOV	CX,128
RECOK:
	XOR	AX,AX
	XOR	DX,DX		;Intialize size to zero
	CMP	BH,-1		;Check for named I/O device
	JZ	DEVSIZ
	INC	SI
	INC	SI		;Point to length field
	MOV	AX,[SI+2]	;Get high word of size

	IF	SMALLDIR
	CMP	B,[BP+DIRSIZ],-1
	JNZ	BIGSIZ
	MOV	AH,0
BIGSIZ:
	ENDIF

	DIV	AX,CX
	PUSH	AX		;Save high part of result
	LODW			;Get low word of size
	DIV	AX,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:
	STOW
	MOV	AX,DX
	STOB
	MOV	AL,0
	CMP	CX,64
	JAE	RET		;Only 3-byte field if RECSIZ >= 64
	SEG	ES
	MOV	[DI],AH
	RET


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


GETFATPT: ;System call 27
	MOV	AX,CS
	MOV	DS,AX
	MOV	BP,[CURDRVPT]
	CALL	FATREAD
	LEA	BX,[BP+FAT]
	MOV	AL,[BP+CLUSMSK]
	INC	AL
	MOV	DX,[BP+MAXCLUS]
	DEC	DX
	MOV	B,[BP+DIRTYFAT],1
	MOV	CX,[BP+SECSIZ]
	LDS	SI,[SPSAVE]
	MOV	[SI+BXSAVE],BX
	MOV	[SI+DXSAVE],DX
	MOV	[SI+CXSAVE],CX
	MOV	[SI+DSSAVE],CS
	RET


GETDSKPT: ;System call 31
	SEG	CS
	MOV	BX,[CURDRVPT]
	SEG	CS
	LDS	SI,[SPSAVE]
	MOV	[SI+BXSAVE],BX
	MOV	[SI+DSSAVE],CS
	RET


DSKRESET: ;System call 13
	SEG	CS
	MOV	[DMAADD+2],DS
	MOV	AX,CS
	MOV	DS,AX
	MOV	[DMAADD],80H
	MOV	AX,[CURDRVPT+2]
	MOV	[CURDRVPT],AX
WRTFATS:
; DS=CS. Writes back all dirty FATs. All registers destroyed.
	MOV	CL,[NUMDRV]
	MOV	CH,0
	MOV	SI,CURDRVPT+2
WRTFAT:
	LODW
	PUSH	CX
	PUSH	SI
	MOV	BP,AX
	CALL	CHKFATWRT
	POP	SI
	POP	CX
	LOOP	WRTFAT
	MOV	AX,[BUFDRVNO]
	OR	AH,AH
	JZ	RET
	CBW
	MOV	BX,AX
	SHL	BX
	MOV	BP,[BX+DRVTAB]
	MOV	B,[DIRTYBUF],0
	MOV	DX,[BUFSECNO]
	MOV	BX,BUFFER
	MOV	CX,1
	JMP	DWRITE


CURDRV:	;System call 25
	SEG	CS
	MOV	BP,[CURDRVPT]
	MOV	AL,[BP+DRVNUM]
	RET


INUSE:	;System call 24
	MOV	AX,CS
	MOV	DS,AX
	MOV	CL,[NUMDRV]
	MOV	CH,0
	MOV	SI,CX
	SHL	SI
	ADD	SI,CURDRVPT
	MOV	BX,0
	DOWN
CHKUSE:
	LODW
	MOV	BP,AX
	CMP	B,[BP+DIRTYFAT],-1	;Carry set if not equal
	RCL	BX
	LOOP	CHKUSE
	MOV	AL,BL
	RET


SETRNDREC: ;System call 36
	CALL	GETREC
	MOV	[DI+33],AX
	MOV	[DI+35],DL
	RET


SELDSK:	;System call 14
	MOV	DH,0
	MOV	BX,DX
	PUSH	CS
	POP	DS
	MOV	AL,[NUMDRV]
	CMP	BL,AL
	JNB	RET
	SHL	BX
	MOV	DX,[BX+CURDRVPT+2]
	MOV	[CURDRVPT],DX
	RET


BUFIN:	;System call 10
	MOV	AX,CS
	MOV	ES,AX
	MOV	SI,DX
	MOV	CH,0
	LODW
	OR	AL,AL
	JZ	RET
	MOV	BL,AH
	MOV	BH,CH
	CMP	AL,BL
	JBE	NOEDIT
	CMP	B,[BX+SI],0DH
	JZ	EDITON
NOEDIT:
	MOV	BL,CH
EDITON:
	MOV	DL,AL
	DEC	DX
NEWLIN:
	SEG	CS
	MOV	AL,[CARPOS]
	SEG	CS
	MOV	[STARTPOS],AL
	PUSH	SI
	MOV	DI,INBUF
	MOV	AH,CH
	MOV	BH,CH
	MOV	DH,CH
GETCH:
	CALL	IN
	CMP	AL,7FH
	JZ	BACKSP
	CMP	AL,8
	JZ	BACKSP
	CMP	AL,13
	JZ	ENDLIN
	CMP	AL,10
	JZ	PHYCRLF
	CMP	AL,"X"-"@"
	JZ	KILNEW
	CMP	AL,ESCCH
	JZ	ESC
SAVCH:
	CMP	DH,DL
	JAE	GETCH
	STOB
	INC	DH
	CALL	BUFOUT
	OR	AH,AH
	JNZ	GETCH
	CMP	BH,BL
	JAE	GETCH
	INC	SI
	INC	BH
	JP	GETCH

ESC:
	CALL	IN
	MOV	CL,ESCTABLEN
	PUSH	DI
	MOV	DI,ESCTAB
	REPNE
	SCAB
	POP	DI
	AND	CL,0FEH
	MOV	BP,CX
	SEG	CS		;To work in init
	JMP	[BP+ESCFUNC]

ENDLIN:
	STOB
	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,INBUF
	MOV	CL,DH
	REP
	MOVB
	RET
CRLF:
	MOV	AL,13
	CALL	OUT
	MOV	AL,10
	JMP	OUT

PHYCRLF:
	CALL	CRLF
	JP	GETCH

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

BACKSP:
	OR	DH,DH
	JZ	OLDBAK
	CALL	BACKUP
	SEG	ES
	MOV	AL,[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
	DOWN
	MOV	CL,DH
	MOV	AL," "
	PUSH	BX
	MOV	BL,7
	JCXZ	FIGTAB
FNDPOS:
	SCAB
	JNA	CHKCNT
	SEG	ES
	CMP	B,[DI+1],9
	JZ	HAVTAB
	DEC	BL
CHKCNT:
	LOOP	FNDPOS
FIGTAB:
	SEG	CS
	SUB	BL,[STARTPOS]
HAVTAB:
	SUB	BL,DH
	ADD	CL,BL
	AND	CL,7
	UP
	POP	BX
	POP	DI
	JZ	OLDBAK
TABBAK:
	CALL	BACKMES
	LOOP	TABBAK
	JP	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
	JP	COPYEACH

COPYSTR:
	CALL	FINDOLD
	JP	COPYEACH

COPYONE:
	MOV	CL,1
COPYEACH:
	CMP	DH,DL
	JZ	GETCH2
	CMP	BH,BL
	JZ	GETCH2
	LODB
	STOB
	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
	SCAB
	POP	DI
	POP	ES
	JNZ	NOTFND
	NOT	CL
	ADD	CL,BL
	SUB	CL,BH
	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:
	MOV	AH,-1
	JMP	GETCH

EXITINS:
	MOV	AH,0
	JMP	GETCH

ESCFUNC:
	DW	GETCH
	DW	TWOESC
	DW	EXITINS
	DW	ENTERINS
	DW	BACKSP
	DW	REEDIT
	DW	KILNEW
	DW	COPYLIN
	DW	SKIPSTR
	DW	COPYSTR
	DW	SKIPONE
	DW	COPYONE

BUFOUT:
	CMP	AL," "
	JAE	OUT
	CMP	AL,9
	JZ	OUT
	PUSH	AX
	MOV	AL,"^"
	CALL	OUT
	POP	AX
	OR	AL,40H
	JP	OUT

CONOUT:	;System call 2
	MOV	AL,DL
OUT:
	CMP	AL,20H
	JB	CTRLOUT
	CMP	AL,7FH
	JZ	OUTCH
	SEG	CS
	INC	B,[CARPOS]
OUTCH:
	CALL	BIOSOUT,BIOSSEG
	SEG	CS
	TEST	B,[PFLAG],-1
	JZ	STATCHK
	CALL	BIOSPRINT,BIOSSEG
STATCHK:
	CALL	BIOSSTAT,BIOSSEG
	JZ	RET
INCHK:
	CALL	BIOSIN,BIOSSEG
	CMP	AL,'S'-'@'
	JNZ	NOSTOP
	CALL	BIOSIN,BIOSSEG
NOSTOP:
	CMP	AL,'P'-'@'
	JZ	PRINTON
	CMP	AL,'N'-'@'
	JZ	PRINTOFF
	CMP	AL,'C'-'@'
	JNZ	RET
; Ctrl-C handler.
; If function 9 or 10 was in progress, a backslash, CR, and LF are printed
; to show line is canceled. 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, except for console output (function 2), which has already output
; its character before the interrupt.
	SEG	CS
	MOV	AL,[FUNC]	;Get currently executing function
	CMP	AL,10		;Check if buffered line input
	JZ	CANLIN
	CMP	AL,9		;Check if buffered line output
	JNZ	RESTREG
CANLIN:
	MOV	AL,"\"		;Display cancel line symbol
	CALL	OUT
	CALL	CRLF
RESTREG:
	DI			;Prepare to play with stack
	SEG	CS
	MOV	SS,[SSSAVE]
	SEG	CS
	MOV	SP,[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
	CMP	AH,2		;Check if function was console output
	JZ	SETAL
	JMP	COMMAND		;Repeat command otherwise
SETAL:
	MOV	AL,DL
	IRET			;Return to user program

PRINTON:
	SEG	CS
	MOV	B,[PFLAG],1
	RET
PRINTOFF:
	SEG	CS
	MOV	B,[PFLAG],0
	RET
CTRLOUT:
	CMP	AL,13
	JZ	ZERPOS
	CMP	AL,8
	JZ	BACKPOS
	CMP	AL,9
	JNZ	OUTCHJ
	SEG	CS
	MOV	AL,[CARPOS]
	OR	AL,0F8H
	NEG	AL
TAB:
	PUSH	CX
	MOV	CL,AL
	MOV	CH,0
TABLP:
	MOV	AL," "
	CALL	OUT
	LOOP	TABLP
	POP	CX
	RET

ZERPOS:
	SEG	CS
	MOV	B,[CARPOS],0
OUTCHJ:	JMP	OUTCH

BACKPOS:
	SEG	CS
	DEC	B,[CARPOS]
	JMP	OUTCH


CONSTAT: ;System call 11
	CALL	BIOSSTAT,BIOSSEG
	JZ	RET
	OR	AL,-1
	RET


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


IN:	;Internal input routine
	CALL	INCHK
	JZ	IN
	RET

RAWIO:	;System call 6
	MOV	AL,DL
	CMP	AL,-1
	JNZ	RAWOUT
	CALL	BIOSSTAT,BIOSSEG
	JZ	RET
RAWINP:	;System call 7
	CALL	BIOSIN,BIOSSEG
	RET
RAWOUT:
	CALL	BIOSOUT,BIOSSEG
	RET

LIST:	;System call 5
	MOV	AL,DL
	CALL	BIOSPRINT,BIOSSEG
	RET

PRTBUF:	;System call 9
	MOV	SI,DX
OUTSTR:
	LODB
	CMP	AL,"$"
	JZ	RET
	CALL	OUT
	JP	OUTSTR

OUTMES:	;String output for internal messages
	SEG	CS
	LODB
	CMP	AL,"$"
	JZ	RET
	CALL	OUT
	JP	OUTMES


MAKEFCB: ;Interrupt call 41
	MOV	DL,0		;Flag--not ambiguous file name
	OR	AL,AL		;Scan off separators if not zero
	JZ	NOSCAN
SCAN:
	CALL	GETLET
	JZ	SCAN		;Get rid of leading separators (e.g., blanks)
	DEC	SI		;Point back to first non-separator
NOSCAN:
	CMP	B,[SI+1],":"	;Check for potential drive specifier
	JNZ	DEFAULT
	CALL	GETLET
	SUB	AL,"@"		;Convert drive letter to binary drive number
	JZ	NODRV		;Valid drive numbers are 1-15
	INC	SI
	CMP	AL,15
	JBE	HAVDRV
	DEC	SI
NODRV:
	DEC	SI		;Invalid drive specifier--back up pointer
DEFAULT:
	XOR	AL,AL
HAVDRV:
	STOB			;Put drive specifier in first byte
	MOV	CX,8
	CALL	GETWORD		;Get 8-letter file name
	CMP	B,[SI],"."
	JNZ	NODOT
	INC	SI		;Skip over dot if present
NODOT:
	MOV	CX,3		;Get 3-letter extension
	CALL	GETWORD
	SEG	CS
	LDS	BX,[SPSAVE]
	MOV	[BX+SISAVE],SI
	XOR	AX,AX
	STOW
	STOW
	MOV	AL,DL
	RET

GETWORD:
	CALL	GETLET
	JZ	FILLNAM		;Exit if invalid character
	CMP	AL," "
	JBE	FILLNAM
	CMP	AL,"*"		;Check for ambiguous file specifier
	JNZ	NOSTAR
	MOV	AL,"?"
	DEC	CX
	REP
	STOB			;Fill rest of word with "?"
	INC	CX
NOSTAR:
	STOB
	CMP	AL,"?"
	JNZ	NOTQ
	MOV	DL,1		;Flag ambiguous file name
NOTQ:
	LOOP	GETWORD
	INC	SI		;Point to "termination" character
FILLNAM:
	MOV	AL," "
	REP
	STOB
	DEC	SI
	RET

GETLET:
	LODB
	CMP	AL,"a"
	JB	CHK
	CMP	AL,"z"
	JA	CHK
	SUB	AL,20H		;Convert to upper case
CHK:
	CMP	AL," "
	JZ	RET
	CMP	AL,"="
	JZ	RET
	CMP	AL,","
	JZ	RET
	CMP	AL,";"
	JZ	RET
	CMP	AL,"."
	JZ	RET
	CMP	AL,":"
	JZ	RET
	CMP	AL,9		;Filter out TABs too
	RET


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


NEWBASE: ; Interrupt call 38
	MOV	ES,DX
	SEG	CS
	MOV	DS,[CSLOC]
	XOR	SI,SI
	MOV	DI,SI
	MOV	CX,80H
	REP
	MOVW

SETMEM:

; Inputs:
;	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)
; AX,DX,BP unchanged. All other registers destroyed.

	XOR	CX,CX
	MOV	DS,CX
	MOV	ES,DX
	MOV	SI,EXIT
	MOV	DI,SAVEXIT
	MOVW
	MOVW
	MOVW
	MOVW
	SEG	CS
	MOV	CX,[ENDMEM]
	SEG	ES
	MOV	[2],CX
	SUB	CX,DX
	CMP	CX,MAXDIF
	JBE	HAVDIF
	MOV	CX,MAXDIF
HAVDIF:
	MOV	BX,ENTRYPOINTSEG
	SUB	BX,CX
	SHL	CX
	SHL	CX
	SHL	CX
	SHL	CX
	MOV	DS,DX
	MOV	[6],CX
	MOV	[8],BX
	MOV	[0],20CDH	;"INT INTTAB"
	MOV	B,[5],LONGCALL
	RET


SHFTDI7:
	SHL	DI
	SHL	DI
	SHL	DI
	SHL	DI
	SHL	DI
	SHL	DI
	SHL	DI
	RET


; Default handler for division overflow trap
DIVOV:
	XOR	DX,DX		;Say no remainder
	MOV	AX,-1		;But large quotient
	IRET


;***** DATA AREA *****

BADMES:	DB	13,10,"Bad FAT",13,10,"$"
BADFATMES:DB	13,10,"All FATs on disk are bad",13,10,"$"
RDERRMES:DB	13,10,"Disk read error",13,10,"$"
WRTERRMES:DB	13,10,"Disk write error",13,10,"$"
IONAME:	DB	"PRN","LST","AUX","CON"

CARPOS:	DB	0
STARTPOS:DB	0
PFLAG:	DB	0
DIRTYDIR:DB	0	;Dirty buffer flag
NUMDRV:	DS	1	;Number of drives
CONTPOS:DW	0
DMAADD:	DW	80H	;User's disk transfer address (disp/seg)
	DS	2
ENDMEM:	DS	2
MAXSEC:	DW	0
BUFFER:	DS	2
BUFSECNO:DW	0
BUFDRVNO:DB	-1
DIRTYBUF:DB	0
DIRBUFID:DW	-1
DATE:	DS	2
CURDRVPT:DS	2
DRVTAB:	DS	30	;Enough for 15 drives
INBUF:	DS	15	;Only the first part

; Init code overlaps with data area below

INITCODE:

	DS	128-15	;More of INBUF
CONBUF:	DS	130	;The rest of INBUF and console buffer
FUNC:	DS	1	;Currently executing function code
LASTENT:DS	2
EXITHOLD:DS	4
FATBASE:DS	2
NAME1:	DS	11	;File name buffer
NAME2:	DS	11
TEMP:
CSLOC:	DS	2
SPSAVE:	DS	2
SSSAVE:	DS	2
SECCLUSPOS:DS	1	;Position of first sector within cluster
DSKERR:	DS	1
TRANS:	DS	1

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

	DS	60	;Stack space
STACK:

	IF	DSKTEST
NSS:	DS	2
NSP:	DS	2
	DS	60
TESTSTK:
	ENDIF

DIRBUF:

;Init code below overlaps with data area above

	ORG	INITCODE
	PUT	$+100H

MOVFAT:
;This section of code is safe from being overwritten by block move
	SEG	ES
	REP
	MOVB
	UP
FININIT:
	CALL	SETMEM		;Set up segment
	RET	L

DOSINIT:
	DI
	UP
	PUSH	CS
	POP	ES
	LODB
	SEG	ES
	MOV	[NUMDRV],AL
	MOV	BX,DRVTAB
	MOV	DI,MEMSTRT
PERDRV:
	SEG	ES
	MOV	[BX],DI
	MOV	BP,DI
	INC	BX
	INC	BX
	SEG	ES
	MOV	AL,[DRVCNT]
	STOB			;DRVNUM
	LODW			;Pointer to DPT
	PUSH	SI
	MOV	SI,AX
	LODW
	STOW			;SECSIZ
	MOV	DX,AX
	SEG	ES
	CMP	AX,[MAXSEC]
	JBE	NOTMAX
	SEG	ES
	MOV	[MAXSEC],AX
NOTMAX:
	LODB
	DEC	AL
	STOB			;CLUSMSK
	JZ	HAVSHFT
	CBW
FIGSHFT:
	INC	AH
	SAR	AL
	JNZ	FIGSHFT
	MOV	AL,AH
HAVSHFT:
	STOB			;CLUSSHFT
	MOVW			;FIRFAT (= number of reserved sectors)
	MOVB			;FATCNT
	MOVW			;MAXENT
	MOV	AX,DX		;SECSIZ again
	MOV	CL,5
	SHR	AX,CL
	MOV	CX,AX		;Directory entries per sector
	DEC	AX
	SEG	ES
	ADD	AX,[BP+MAXENT]
	XOR	DX,DX
	DIV	AX,CX
	STOW			;DIRSEC (temporarily)
	SHR	AX		;Divide by two
	ADC	AX,0		;Round up
	SEG	ES
	MOV	[SDIRSEC],AX	;Number of directory records for small entries
	MOVW			;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
	SEG	ES
	DEC	[BP+DSKSIZ]	;Damp those oscillations
	JP	FNDFATSIZ	;Try again
HAVFATSIZ:
	STOB			;FATSIZ
	SEG	ES
	MUL	AL,[BP+FATCNT]	;Space occupied by all FATs
	SEG	ES
	ADD	AX,[BP+FIRFAT]
	STOW			;FIRDIR

	IF	SMALLDIR-1
	SEG	ES
	ADD	AX,[BP+DIRSEC]
	SEG	ES
	MOV	[BP+FIRREC],AX	;Destroys DIRSEC
	CALL	FIGMAX
	SEG	ES
	MOV	[BP+MAXCLUS],CX
	ENDIF

	IF	SMALLDIR
	MOV	DX,AX		;Save FIRDIR momentarily
	SEG	ES
	ADD	AX,[SDIRSEC]	;Add number of dir. sectors for 16-byte entry
	STOW			;FIRREC1
	XCHG	AX,CX		;Previously computed MAXCLUS
	STOW			;MAXCLUS1
	XCHG	DX,AX
	SEG	ES
	ADD	AX,[BP+DIRSEC]	;Add number of dir. sectores for 32-byte entry
	STOW			;FIRREC2
	CALL	FIGMAX
	XCHG	AX,CX
	STOW			;MAXCLUS2
	ENDIF

	MOV	AX,0FFH
	STOB			;DIRTYFAT
	SEG	ES
	MOV	AL,[BP+FATSIZ]
	SEG	ES
	MUL	AX,[BP+SECSIZ]
	ADD	DI,AX		;Allocate FAT
	POP	SI		;Restore pointer to init. table
	SEG	ES
	MOV	AL,[DRVCNT]
	INC	AL
	SEG	ES
	MOV	[DRVCNT],AL
	SEG	ES
	CMP	AL,[NUMDRV]
	JAE	CONTINIT
	JMP	PERDRV	
CONTINIT:
	LODW			;Max. buffer size
	SEG	ES
	MOV	BX,[MAXSEC]
	MOV	AX,DIRBUF
	ADD	AX,BX
	SEG	ES
	MOV	[BUFFER],AX	;Start of buffer
	PUSH	DI		;Save ending location
	ADD	DI,BX		;Allocate directory buffer
	ADD	DI,BX		;Allocate buffer space
	ADD	DI,ADJFAC+15	;True start of free space
	MOV	CL,4
	SHR	DI,CL		;First free segment
	MOV	BP,DI
	XOR	AX,AX
	MOV	DS,AX
	MOV	ES,AX
	MOV	DI,INTBASE
	MOV	AX,QUIT
	STOW			;Set abort address--displacement
	MOV	AX,CS
	MOV	B,[ENTRYPOINT],LONGJUMP
	MOV	[ENTRYPOINT+1],ENTRY
	MOV	[ENTRYPOINT+3],AX
	MOV	[0],DIVOV	;Set default divide trap address
	MOV	[2],AX
	MOV	CX,9
	REP
	STOW				;Set 5 segments (skip 2 between each)
	MOV	[INTBASE+4],COMMAND
	MOV	[INTBASE+12],IRET	;CTRL-C exit
	MOV	[INTBASE+16],IRET	;Fatal error exit
	MOV	AX,BIOSREAD
	STOW
	MOV	AX,BIOSSEG
	STOW
	STOW	;Add 2 to DI
	STOW
	MOV	[INTBASE+18H],BIOSWRITE
	MOV	DX,CS
	MOV	DS,DX
	ADD	DX,BP
	MOV	[DMAADD],80H
	MOV	[DMAADD+2],DX
	MOV	AX,[DRVTAB]
	MOV	[CURDRVPT],AX
	MOV	CX,DX
	MOV	BX,0FH
MEMSCAN:
	INC	CX
	JZ	HAVMEM
	MOV	DS,CX
	MOV	AL,[BX]
	NOT	AL
	MOV	[BX],AL
	CMP	AL,[BX]
	NOT	AL
	MOV	[BX],AL
	JZ	MEMSCAN
HAVMEM:
	SEG	CS
	MOV	[ENDMEM],CX
	XOR	CX,CX
	MOV	DS,CX
	MOV	[EXIT],100H
	MOV	[EXIT+2],DX
	MOV	SI,HEADER
	CALL	OUTMES
	PUSH	CS
	POP	DS
	PUSH	CS
	POP	ES
	PUSH	DX
GETDAT:
	MOV	SI,DATMES
	CALL	OUTMES
	MOV	DX,DATBUF
	CALL	BUFIN
	CALL	CRLF
	MOV	SI,DATBUF+2
	MOV	DX,12
	CALL	MYD
	JC	GETDAT
	MOV	CL,5
	SHL	AX,CL
	MOV	[DATE],AX
	MOV	DX,31
	CALL	MYD
	JC	GETDAT
	OR	[DATE],AL
	MOV	DX,2100
	CALL	MYD
	JC	GETDAT
	SUB	AX,80
	JC	GETDAT
	CMP	AX,19
	JBE	SAVYR
	SUB	AX,1900
	JC	GETDAT
SAVYR:
	SHL	AL
	OR	[DATE+1],AL
;Move the FATs into position and adjust the drive pointer table
	POP	DX
	POP	SI
	MOV	AX,[MAXSEC]
	SHL	AX		;Allocate two buffers
	ADD	AX,ADJFAC
	JZ	FINJMP
	MOV	DI,DRVTAB
	MOV	CX,15
ADJLP:
	ADD	[DI],AX
	INC	DI
	INC	DI
	LOOP	ADJLP
	MOV	CX,SI
	MOV	SI,MEMSTRT	;Place to move FATs from
	SUB	CX,SI		;Total length of FATs
	MOV	DI,AX
	ADD	DI,SI		;Place to move FATs to
	OR	AX,AX
	JS	MOVJMP
	DEC	CX
	ADD	DI,CX
	ADD	SI,CX
	INC	CX
	DOWN
MOVJMP:
	JMP	MOVFAT
FINJMP:	JMP	FININIT

FIGFATSIZ:
	SEG	ES
	MUL	AL,[BP+FATCNT]
	SEG	ES
	ADD	AX,[BP+FIRFAT]
	SEG	ES
	ADD	AX,[SDIRSEC]	;Use small dir. entry to figure FAT size
FIGMAX:
;AX has equivalent of FIRREC
	SEG	ES
	SUB	AX,[BP+DSKSIZ]
	NEG	AX
	SEG	ES
	MOV	CL,[BP+CLUSSHFT]
	SHR	AX,CL
	INC	AX
	MOV	CX,AX		;MAXCLUS
	INC	AX
	MOV	DX,AX
	SHR	DX
	ADC	AX,DX		;Size of FAT in bytes
	SEG	ES
	MOV	SI,[BP+SECSIZ]
	ADD	AX,SI
	DEC	AX
	XOR	DX,DX
	DIV	AX,SI
	RET

MYD:
;SI points to input buffer. Get decimal number < DX and return it
;in AX. Carry set on error.
	XOR	BX,BX
	MOV	AH,0
GETDIG:
	LODB
	SUB	AL,"0"
	JC	CHKRET
	CMP	AL,10
	JNC	CHKRET
	SHL	BX
	MOV	CX,BX
	SHL	BX
	SHL	BX
	ADD	BX,CX
	ADD	BX,AX
	JP	GETDIG
CHKRET:
	MOV	AX,BX
	OR	AX,AX
	STC
	JZ	RET
	CMP	DX,AX
	RET

DRVCNT:	DB	0

DATMES:	DB	"Enter today's date (m-d-y): $"
DATBUF:	DB	12,8,"04-28-81",13
	DS	5

SDIRSEC:DS	2

MEMSTRT:
ADJFAC:	EQU	DIRBUF-MEMSTRT