Updates and new folder structure

This commit is contained in:
Yufeng Gao
2026-02-04 21:28:47 +10:00
parent 8495cf296a
commit 78c5c9ae82
12 changed files with 5 additions and 5 deletions
+2259
View File
File diff suppressed because it is too large Load Diff
+3566
View File
File diff suppressed because it is too large Load Diff
+156
View File
@@ -0,0 +1,156 @@
;This is a disk boot routine for the 1771/1791 type disk
;controllers. It would normally reside on track 0,
;sector 1, to be loaded by the "B" command of the
;monitor at address 200H. By changing the equates
;below, it may be configured to load any size of
;program at any address. The program is assumed to
;occupy consecutive sectors starting at track 0, sector
;2, and will begin exection at its load address (which
;must be a 16-byte boundary) with the Instruction
;Pointer set to zero.
; Variations are available for the Cromemco 4FDC with
; large disks, the 4FDC with small disks, the Tarbell
; single-density controller, and the Tarbell double-
; density controller. Select one.
CROMEMCOSMALL: EQU 0
CROMEMCOLARGE: EQU 1
TARBELLSINGLE: EQU 0
TARBELLDOUBLE: EQU 0
LOAD: EQU 400H ;Address to load program
SEG: EQU 40H ;LOAD/10H
SECTOR: EQU 51 ;No. of 128-byte sectors to load
BOOTER: EQU 200H ;"B" command puts booter here
;**************************************************************
CROMEMCO: EQU CROMEMCOLARGE+CROMEMCOSMALL
TARBELL: EQU TARBELLSINGLE+TARBELLDOUBLE
WD1771: EQU CROMEMCO+TARBELLSINGLE
WD1791: EQU TARBELLDOUBLE
SMALL: EQU CROMEMCOSMALL
LARGE: EQU CROMEMCOLARGE+TARBELL
IF SMALL
MAXSECT:EQU 18
ENDIF
IF LARGE
MAXSECT:EQU 26
ENDIF
IF TARBELL
DISK: EQU 78H
ENDIF
IF CROMEMCO
DISK: EQU 30H
ENDIF
IF WD1771
READCOM:EQU 88H
ENDIF
IF WD1791
READCOM:EQU 80H
ENDIF
IF CROMEMCOLARGE
WAITBYTE:EQU 0B1H
ENDIF
IF CROMEMCOSMALL
WAITBYTE:EQU 0A1H
ENDIF
ORG BOOTER
PUT 100H
XOR AX,AX
MOV DS,AX
MOV ES,AX
MOV SS,AX
UP
MOV DI,LOAD
MOV DX,SECTOR
MOV BL,2
SECT:
MOV AL,BL
OUTB DISK+2
MOV CX,128
IF TARBELL
INB DISK ;Get head load status
ENDIF
IF CROMEMCO
INB DISK+4 ;Get head load status
ENDIF
TEST AL,20H
MOV AL,READCOM
JNZ OUTCOM
MOV AL,READCOM+4
OUTCOM:
OUTB DISK
IF CROMEMCO
MOV AL,WAITBYTE
OUT DISK+4 ;Turn on hardware wait
ENDIF
READ:
INB DISK+4
IF TARBELL
ROL AL
JNC DONE
ENDIF
IF CROMEMCO
ROR AL
JC DONE
ENDIF
INB DISK+3
STOB
LOOP READ
GETSTAT:
INB DISK+4
IF TARBELL
ROL AL
JC GETSTAT
ENDIF
IF CROMEMCO
ROR AL
JNC GETSTAT
ENDIF
DONE:
IN DISK
AND AL,9CH
JNZ SECT
DEC DX
JZ BOOT
INC BL
CMP BL,MAXSECT+1
JNZ SECT
XOR BL,BL
INC DX
MOV AL,58H ;Step in with update
OUTB DISK
JP GETSTAT
BOOT:
MOV AX,SEG
MOV SS,AX
MOV ES,AX
MOV DS,AX
JMP 0,SEG

+2401
View File
File diff suppressed because it is too large Load Diff
+20
View File
@@ -0,0 +1,20 @@
This chess game uses algebraic chess notation. The files are lettered
"a" to "h" and the ranks are numbered 1 to 8. The lower left-hand corner
(from White's viewpoint) is a1.
Moves are entered as ff-tt (f=from, t=to), so to play the white king's
pawn up two squares you would enter E2-E4. You must enter your file
letters in upper case, while the computer will always use lower case.
To castle, enter only the king's move. The computer castles the same way.
To capture En Passant, enter your pawn's actual move.
Ply depth is the number of half-turns the computer looks ahead. For
example, with a ply depth of 3, the computer will consider
1. All of his possible moves
2. All of your responses to those moves.
3. All of his possible replies to your responses.
Start at ply depth 2 to get the feel for it.
A move of "R" will restart the game.

+479
View File
@@ -0,0 +1,479 @@
FCB: EQU 5CH
DSKRESET:EQU 13
SETBASE:EQU 38
SRCHFRST:EQU 17
SRCHNXT:EQU 18
RENAM: EQU 23
INCHAR: EQU 1
GETFAT: EQU 27
OPEN: EQU 15
CLOSE: EQU 16
MAKE: EQU 22
DELETE: EQU 19
RDBLK: EQU 39
WRBLK: EQU 40
SETDMA: EQU 26
SELDRV: EQU 14
GETDRV: EQU 25
PRINTBUF:EQU 9
OUTCH: EQU 2
INBUF: EQU 10
RR: EQU 33
SYSTEM: EQU 5
ORG 100H
PUT 100H
MOV SP,STACK
CLD
MOV DL,0 ;Start with drive A
SETDRV:
MOV CL,SELDRV
CALL SYSTEM
COMMAND:
MOV SP,STACK
CLD
MOV AX,CS
MOV SS,AX
MOV ES,AX
MOV DS,AX
MOV CX,[6]
SUB CX,TPA
AND CL,80H ;Round down
ROL CX
XCHG CH,CL
MOV [NUMREC],CX ;Number of records each time
MOV DX,CRLF
MOV CL,PRINTBUF
CALL SYSTEM
MOV DX,COMMAND
MOV AX,2522H ;Set vector 34 (terminate)
INT 33
MOV AX,2523H ;Set vector 35 (CTRL-C)
INT 33
GETCOM:
MOV CL,GETDRV
CALL SYSTEM
ADD AL,"A"
MOV CL,OUTCH
MOV DL,AL
CALL SYSTEM ;Print drive letter
MOV DL,":"
MOV CL,OUTCH
CALL SYSTEM ;Print ":"
MOV DX,LINBUF
MOV CL,INBUF
CALL SYSTEM
MOV DL,10
MOV CL,OUTCH
CALL SYSTEM ;New line
MOV CH,0
MOV SI,FILIFO ;8 spaces
MOV DI,ID
CALL FILLBUF
MOV DI,FCB
CALL FILLBUF
MOV SI,LINBUF+2
MOV DI,ID
CALL FILEDRV ;Get COM drive
MOV [SPECDRV],AL
MOV CX,8
CALL COPYNAM ;Copy file name
MOV AL,9
SUB AL,CL
MOV [IDLEN],AL
MOV DI,81H
MOV CX,0
PUSH SI
COMTAIL:
LODB
STOB ;Move command tail to 80H
CMP AL,13
LOOPNZ COMTAIL
NOT CL
MOV [80H],CL
POP SI
MOV DI,FCB
CALL PARSENAM
MOV DI,FCB+10H
CALL PARSENAM
MOV AL,[IDLEN]
MOV DL,[SPECDRV]
OR DL,DL ;Check if drive was specified
JNZ DRVCHK
DEC AL ;Check for null command
JZ GETCOM
MOV SI,COMTAB
FINDCOM:
MOV DI,IDLEN
MOV CL,[SI]
JCXZ EXTERNAL
REPE
CMPB
LAHF
ADD SI,CX ;Bump to next position without affecting flags
SAHF
LODW ;Get address of command
JNZ FINDCOM
CALL AX ;Call command
JMP COMMAND
SETDRVJ:JMP SETDRV
DRVCHK:
DEC DL ;Adjust for correct drive number
DEC AL ;Check if anything else is on line
JZ SETDRVJ
EXTERNAL:
MOV AL,[SPECDRV]
MOV [IDLEN],AL
PUSH DS
MOV DX,TPA
ADD DX,0FH ;Round to next paragraph
SHR DX
SHR DX
SHR DX
SHR DX ;Divide 16
MOV CX,CS
ADD DX,CX ;New segment
MOV DS,DX
MOV AH,SETBASE
INT 33
MOV DX,100H
MOV CL,SETDMA
CALL SYSTEM
MOV BX,DS ;New segment into BX
POP DS
MOV DX,IDLEN
MOV AH,OPEN
INT 33
OR AL,AL
JNZ BADCOM
MOV [IDLEN+RR],0
MOV CX,512 ;512 records
MOV AH,RDBLK
INT 33
MOV DS,BX
MOV ES,BX
MOV SS,BX
MOV SP,40H
MOV AX,0
PUSH AX
MOV AX,100H
PUSH BX
PUSH AX
MOV CL,SETDMA
MOV DX,80H
CALL SYSTEM
RET L
BADCOM:
MOV DX,BADNAM
MOV CL,PRINTBUF
CALL SYSTEM
JMP COMMAND
NEXTCHR:
;Convert lower case input to upper case
LODB
CMP AL,"a"-1
JB DELIM
CMP AL,"z"
JA DELIM
SUB AL,20H ;Lower-case changed to upper-case
DELIM:
CMP AL," "
JZ RET
CMP AL,"="
JZ RET
CMP AL,","
JZ RET
CMP AL,";"
JZ RET
CMP AL,9 ;Check for TAB character
RET
FILEDRV:
CALL NEXTCHR
JZ FILEDRV ;Skip delim
CMP AL,13
JZ NOMATCH
CMP B,[SI],":"
JNZ NOMATCH
SUB AL,40H ;Convert to drive number
INC SI
RET
PARSENAM:
CALL NEXTCHR
JZ ISDELIM
CMP AL,13
JNZ PARSENAM
DEC SI
ISDELIM:
CALL FILEDRV
STOB
MOV CX,11
CALL COPYNAM
ADD DI,CX
CMP CX,3
JB RET
SUB DI,3
CMP AL,"."
JNZ NOMATCH
MOV CX,3
COPYNAM:
CALL NEXTCHR
JZ NOMATCH
CMP AL,13
JZ NOMATCH
CMP AL,"."
JZ RET
STOB
LOOP COPYNAM
NOMATCH:
XOR AL,AL
DEC SI
RET
FILLBUF:
LODB
MOV CL,AL
JCXZ RET
LODB
REP
STOB
JP FILLBUF
DIR:
CMP B,[FCB+1]," "
JNZ HASNAME
MOV SI,FCBFIL
MOV DI,FCB+1
CALL FILLBUF ;Fill 11 bytes with "?"
HASNAME:
MOV DX,LINBUF+2+1
MOV CL,SETDMA
CALL SYSTEM
MOV CL,SRCHFRST
MOV DX,FCB
EACHFILE:
CALL SYSTEM
INC AL ;FF = file not found
JZ RET
MOV SI,LINBUF+2+1
MOV CX,8
CALL OUTCNT ;Print 8 chars (name)
MOV CL,OUTCH
MOV DL," "
CALL SYSTEM ;Print space
MOV SI,LINBUF+2+9
MOV CX,3
CALL OUTCNT ;Print 3 chars (ext)
MOV DX,CRLF
MOV CL,PRINTBUF
CALL SYSTEM ;Print new line
MOV CL,SRCHNXT
JP EACHFILE
OUTCNT:
LODB
PUSH CX
PUSH SI
MOV DL,AL
MOV CL,OUTCH
CALL SYSTEM
POP SI
POP CX
LOOP OUTCNT
RET
RENAME:
MOV CL,RENAM
MOV DX,FCB
JMP 5
ERASE:
MOV CL,DELETE
MOV DX,FCB
JMP 5
CREATE:
MOV CL,MAKE
MOV DX,FCB
JMP 5
TYPE:
MOV DX,TPA
MOV CL,SETDMA
CALL SYSTEM
MOV DX,FCB
MOV AH,OPEN
INT 33
OR AL,AL
JNZ RET ;Not found
MOV [FCB+RR],0
MOV CX,512
MOV AH,RDBLK
INT 33
MOV SI,TPA
OUTLP:
LODB
CMP AL,1AH ;Is EOF?
JZ RET
MOV CL,OUTCH
MOV DL,AL
CALL SYSTEM
JP OUTLP
RET
CLEAR:
MOV DX,ERAMES
MOV CL,PRINTBUF
CALL SYSTEM ;Confirm erase
MOV CL,INCHAR
CALL SYSTEM
CMP AL,"Y"
JZ DOCLEAR
CMP AL,"y"
JZ DOCLEAR
RET
DOCLEAR:
MOV DL,[FCB]
OR DL,DL
JZ CLRDSK
DEC DL
MOV CL,SELDRV
CALL SYSTEM
CLRDSK:
MOV CL,GETFAT
CALL SYSTEM
MOV CX,DX
INC DX
SHR DX
ADD CX,DX
MOV AX,DS
MOV ES,AX
MOV DI,BX
MOV AX,0FFFFH
STOW
STOB ;Fill first 3 bytes with FF
INC AX ;AX = 0
SHR CX
JNC DOFILL
STOB ;Odd byte
DOFILL:
REP
STOW
MOV AX,CS
MOV DS,AX
MOV ES,AX
MOV SI,FCBFIL
MOV DI,FCB+1
CALL FILLBUF
MOV DX,FCB
MOV CL,DELETE
CALL SYSTEM ;Delete all files
MOV CL,DSKRESET
JMP 5
COPY:
MOV SI,FCB+10H
MOV DI,DSTFCB
MOVB
CMP B,[SI]," " ;Has file name?
JNZ HASDSTNAM
MOV SI,FCB+1
HASDSTNAM:
MOVB
MOV CX,7
REP
MOVW
MOV DX,FCB
MOV AH,OPEN
INT 33
OR AL,AL
JNZ NOSRC
MOV DX,DSTFCB
MOV AH,DELETE
INT 33
MOV AH,MAKE
INT 33
MOV DX,TPA
MOV AH,SETDMA
INT 33
MOV [FCB+RR],0
MOV [DSTFCB+RR],0
CPYBLK:
MOV DX,FCB
MOV CX,[NUMREC]
MOV AH,RDBLK
INT 33
JCXZ CPYDONE
MOV DX,DSTFCB
MOV AH,WRBLK
INT 33
OR AL,AL
JZ CPYBLK
MOV DX,NOSPCE
MOV AH,PRINTBUF
INT 33
CPYDONE:
MOV DX,DSTFCB
MOV AH,CLOSE
INT 33
RET
NOSRC:
MOV DX,NOTFND
MOV AH,PRINTBUF
INT 33
RET
DS 40
STACK:
BADNAM: DB "Bad command or file name"
CRLF: DB 13,10,"$"
ERAMES: DB "Erase all files (Y/N)? $"
NOTFND: DB "Source file not found$"
NOSPCE: DB "Insufficient disk space$"
FCBFIL: DB 11,"?"
DB 0
SPECDRV:DS 1
NUMREC: DS 2
IDLEN: DS 1
ID: DS 8
COM: DB "COM"
DSTFCB: DS 36
LINBUF:
DB 80H,1,13
DS 80H
FILIFO:
DB 8," "
DB 0
DB 12," ",4,0
DB 12," ",8,0
DB 0
COMTAB:
DB 4,"DIR"
DW DIR
DB 7,"RENAME"
DW RENAME
DB 6,"ERASE"
DW ERASE
DB 7,"CREATE"
DW CREATE
DB 5,"TYPE"
DW TYPE
DB 6,"CLEAR"
DW CLEAR
DB 5,"COPY"
DW COPY
DB 0
TPA:

+605
View File
@@ -0,0 +1,605 @@
; I/O System for 86-DOS.
; Assumes a CPU Support card at F0 hex for character I/O,
; with disk drivers for Tarbell or Cromemco controllers.
; Select disk controller here
TARBELL:EQU 0
CROMEMCO:EQU 1
; For either disk controller, a custom drive table may be defined
CUSTOM: EQU 0
; If Tarbell disk controller, select one-sided or two-sided drives
; and single or double density controller
DOUB1SIDE:EQU 0
DOUB2SIDE:EQU 0
SNGL1SIDE:EQU 0
; If Cromemco disk controller, select drive configuration
SMALLCRO:EQU 0 ;3 small drives
COMBCRO:EQU 1 ;2 large drives and 1 small one
LARGECRO:EQU 0 ;4 large drives
WD1791: EQU DOUB1SIDE+DOUB2SIDE
WD1771: EQU CROMEMCO+SNGL1SIDE
IF WD1791
READCOM:EQU 80H
WRITECOM:EQU 0A0H
ENDIF
IF WD1771
READCOM:EQU 88H
WRITECOM:EQU 0A8H
ENDIF
IF TARBELL
DONEBIT:EQU 80H
DISK: EQU 78H
ENDIF
IF CROMEMCO
DONEBIT:EQU 1
DISK: EQU 30H
ENDIF
DOSSEG: EQU 80H
ORG 0
PUT 100H
BASE: EQU 0F0H
STAT: EQU BASE+7
DAV: EQU 2
TBMT: EQU 1
DATA: EQU BASE+6
PSTAT: EQU BASE+0DH
PDATA: EQU BASE+0CH
JMP INIT
JMP STATUS
JMP INP
JMP OUTP
JMP PRINT
JMP AUXIN
JMP AUXOUT
JMP READ
JMP WRITE
JMP RETL ;Flush buffers
INIT:
MOV AX,CS
MOV DS,AX
MOV SS,AX
MOV SP,STACK
MOV SI,INITTAB
CALL 0,DOSSEG
MOV DX,100H
MOV AH,26 ;Set DMA address
INT 21H
MOV BX,DS
MOV AX,CS
MOV DS,AX
MOV DX,FCB
MOV AH,15
INT 21H
OR AL,AL
JNZ COMERR
MOV [FCB+33],0
MOV CX,200H
MOV AH,39 ;Load file
INT 21H
JCXZ COMERR
CMP AL,1
JNZ COMERR
MOV DS,BX
MOV ES,BX
MOV SS,BX
MOV SP,40H
XOR AX,AX
PUSH AX
MOV DX,80H
MOV AH,26
INT 21H
PUSH BX
MOV AX,100H
PUSH AX
RET L
COMERR:
MOV DX,BADCOM
MOV AH,9 ;Print string
INT 21H
EI
STALL: JP STALL
BADCOM: DB 13,10,"Bad or missing Command Interpreter",13,10,"$"
FCB: DB 1,"COMMAND COM"
DS 24
STATUS:
IN STAT
AND AL,DAV
RET L
AUXIN:
INP:
IN STAT
AND AL,DAV
JZ INP
IN DATA
AND AL,7FH
RET L
AUXOUT:
OUTP:
PUSH AX
OUTLP:
IN STAT
AND AL,TBMT
JZ OUTLP
POP AX
OUT DATA
RET L
PRINT:
PUSH AX
PRINLP:
IN PSTAT
AND AL,TBMT
JZ PRINLP
POP AX
OUT PDATA
RET L
READ:
CALL SEEK
RDLP:
PUSH CX
CALL READSECT
POP CX
JC ERROR
INC DH
ADD SI,128
LOOP RDLP
OR AL,AL
RETL: RET L
WRITE:
CALL SEEK
WRTLP:
PUSH CX
CALL WRITESECT
POP CX
JC ERROR
INC DH
ADD SI,128
LOOP WRTLP
OR AL,AL
RET L
ERROR:
SEG CS
MOV B,[DI],-1
RET L
SEEK:
; Inputs:
; AL = Drive number
; BX = Disk transfer address in DS
; CX = Number of sectors to transfer
; DX = Logical record number of transfer
; Function:
; Seeks to proper track.
; Outputs:
; AH = Drive select byte
; DL = Track number
; DH = Sector number
; SI = Disk transfer address in DS
; DI = pointer to drive's track counter in CS
; CX unchanged.
MOV SI,BX ; Save transfer address
CBW
MOV BX,AX ; Prepare to index on drive number
SEG CS
MOV AL,[BX+DRVTAB]
OUT DISK+4 ; Select drive
IF CROMEMCO
OR AL,80H ;Set auto-wait bit
ENDIF
MOV AH,AL ;Save for later
XCHG AX,DX
MOV DL,26 ;26 sectors per track
IF CROMEMCO
TEST DH,10H ;Check if small disk
JNZ BIGONE
MOV DL,18 ;18 sectors on small disk track
BIGONE:
ENDIF
DIV AL,DL ;Compute track and sector
XCHG AX,DX
INC DH ;First sector is 1, not zero
SEG CS
MOV BL,[BX+TRKPT] ;Get this drive's displacement into track table
ADD BX,TRKTAB ;BX now points to track counter for this drive
MOV DI,BX
MOV AL,DL
SEG CS
XCHG AL,[DI] ;Xchange current track with desired track
OUT DISK+1 ;Inform controller chip of current track
CMP AL,DL
JZ ONTRK
MOV BH,3 ;Seek retry count
CMP AL,-1 ;Head position known?
JNZ NOHOME ;If not, home head
TRYSK:
CALL HOME
NOHOME:
MOV AL,DL
OUT DISK+3
MOV AL,1CH
CALL MOVHEAD
AND AL,98H
JZ ONTRK
DEC BH
JNZ TRYSK
STC
ONTRK:
RET
SETUP:
IF CROMEMCO
TEST AH,10H ;Check for small disk
JNZ CHKSTP
CMP DH,18 ;Only 18 sectors/track on small ones
JA STEP
CHKSTP:
ENDIF
CMP DH,26 ;Check for overflow onto next track
JBE PUTSEC
STEP:
INC DL
MOV DH,1
MOV AL,58H ;Step in with update, no verify
CALL DCOM
SEG CS
INC B,[DI] ;Update track counter
PUTSEC:
MOV AL,DH
OUT DISK+2
MOV CX,80H
IF TARBELL
IN DISK ;Get head load bit
ENDIF
IF CROMEMCO
IN DISK+4 ;Get head load bit
XCHG AL,AH
OUT DISK+4 ;Turn on auto-wait
XCHG AL,AH
ENDIF
NOT AL
AND AL,20H ;Check head load status
JZ CHKDRV
MOV AL,4
CHKDRV:
; Turn on 15ms head load delay if selecting a different drive
SEG CS
CMP AH,[CURDRV]
SEG CS
MOV [CURDRV],AH
JZ RET
OR AL,4
RET
READSECT:
CALL SETUP
JC RET
MOV BL,10
RDAGN:
OR AL,READCOM
OUT DISK
PUSH SI
RLOOP:
IN DISK+4
TEST AL,DONEBIT
IF TARBELL
JZ RDONE
ENDIF
IF CROMEMCO
JNZ RDONE
ENDIF
IN DISK+3
MOV [SI],AL
INC SI
LOOP RLOOP
RDONE:
POP SI
CALL GETSTAT
AND AL,9CH
JZ RET
MOV AL,0
DEC BL
JNZ RDAGN
STC
RET
WRITESECT:
CALL SETUP
JC RET
MOV BL,10
WRTAGN:
OR AL,WRITECOM
OUT DISK
PUSH SI
WRLOOP:
IN DISK+4
TEST AL,DONEBIT
IF TARBELL
JZ WRDONE
ENDIF
IF CROMEMCO
JNZ WRDONE
ENDIF
LODB
OUT DISK+3
LOOP WRLOOP
WRDONE:
POP SI
CALL GETSTAT
AND AL,09CH
JZ RET
MOV AL,0
DEC BL
JNZ WRTAGN
STC
RET
HOME:
IF CROMEMCO
TEST AH,10H ;Check 8" (PerSci) bit
JNZ RESTORE
ENDIF
MOV BL,3
TRYHOM:
MOV AL,0CH
CALL DCOM
AND AL,98H
JZ RET
MOV AL,58H ;Step in with update
CALL DCOM
DEC BL
JNZ TRYHOM
RET
MOVHEAD:
IF CROMEMCO
TEST AH,10H ;Check 8" (PerSci) bit
JNZ FASTSK
ENDIF
DCOM:
OUT DISK
MOV AL,50
DELAY:
DEC AL
JNZ DELAY ;Delay 100 microseconds
GETSTAT:
IN DISK+4
TEST AL,DONEBIT
IF TARBELL
JNZ GETSTAT
ENDIF
IF CROMEMCO
JZ GETSTAT
ENDIF
IN DISK
RET
IF CROMEMCO
RESTORE:
MOV AL,0C4H ;READ ADDRESS command to keep head loaded
OUT DISK
MOV AL,77H
OUT 4
CHKRES:
IN 4
AND AL,40H
JZ RESDONE
IN DISK+4
TEST AL,DONEBIT
JZ CHKRES
IN DISK
JP RESTORE ;Reload head
RESDONE:
MOV AL,7FH
OUT 4
CALL GETSTAT
MOV AL,0
OUT DISK+1 ;Tell 1771 we're now on track 0
RET
FASTSK:
MOV AL,6FH
OUT 4
MOV AL,18H
CALL DCOM
SKWAIT:
IN 4
TEST AL,40H
JNZ SKWAIT
MOV AL,7FH
OUT 4
MOV AL,0
RET
ENDIF
DS 20H
STACK:
LFAT: EQU 300H
SFAT: EQU 200H
CURDRV: DS 1
LDRIVE:
DB 1 ;Records/sector
DB 4 ;Records/cluster
DW 52 ;Reserved records
DB 6 ;FAT size (records)
DB 2 ;Number of FATs
DB 8 ;Number of directory records
DW 482 ;Number of clusters on drive
SDRIVE:
DB 1
DB 2
DW 54
DB 4
DB 2
DB 8
DW 330
IF DOUB1SIDE
DRVTAB: DB 0,10H,20H,30H
TRKPT: DB 0,1,2,3
TRKTAB: DB -1,-1,-1,-1
ENDIF
IF DOUB2SIDE
DRVTAB: DB 0,40H,10H,50H
TRKPT: DB 0,0,1,1
TRKTAB: DB -1,-1
ENDIF
IF SNGL1SIDE
DRVTAB: DB 0F2H,0E2H,0D2H,0C0H
TRKPT: DB 0,1,2,3
TRKTAB: DB -1,-1,-1,-1
ENDIF
IF TARBELL
INITTAB:DB 4 ;Number of drives
DW LDRIVE
DW FAT0
DW LDRIVE
DW FAT1
DW LDRIVE
DW FAT2
DW LDRIVE
DW FAT3
ORG 0
FAT0: DS LFAT
FAT1: DS LFAT
FAT2: DS LFAT
FAT3: DS LFAT
ENDIF
; Cromemco drive select byte is derived as follows:
; Bit 7 = 0
; Bit 6 = X (unassigned)
; Bit 5 = 1 (motor on)
; Bit 4 = 0 for 5", 1 for 8" drives
; Bit 3 = 1 for drive 3
; Bit 2 = 1 for drive 2
; Bit 1 = 1 for drive 1
; Bit 0 = 1 for drive 0
IF LARGECRO
; Table for four large drives
DRVTAB: DB 31H,32H,34H,38H
TRKPT: DB 0,0,1,1
TRKTAB: DB -1,-1
INITTAB:DB 4 ;Number of drives
DW LDRIVE
DW FAT0
DW LDRIVE
DW FAT1
DW LDRIVE
DW FAT2
DW LDRIVE
DW FAT3
ORG 0
FAT0: DS LFAT
FAT1: DS LFAT
FAT2: DS LFAT
FAT3: DS LFAT
ENDIF
IF COMBCRO
; Table for two large drives and one small one
DRVTAB: DB 31H,32H,24H
TRKPT: DB 0,0,1
TRKTAB: DB -1,-1
INITTAB:DB 3 ;Number of drives
DW LDRIVE
DW FAT0
DW LDRIVE
DW FAT1
DW SDRIVE
DW FAT2
ORG 0
FAT0: DS LFAT
FAT1: DS LFAT
FAT2: DS SFAT
ENDIF
IF SMALLCRO
; Table for 3 small drives
DRVTAB: DB 21H,22H,24H
TRKPT: DB 0,1,2
TRKTAB: DB -1,-1,-1
INITTAB:DB 3
DW SDRIVE
DW FAT0
DW SDRIVE
DW FAT1
DW SDRIVE
DW FAT2
ORG 0
FAT0: DS SFAT
FAT1: DS SFAT
FAT2: DS SFAT
ENDIF
IF CUSTOM
; Table for 2 large drives
DRVTAB: DB 31H,32H
TRKPT: DB 0,1
TRKTAB: DB -1,-1
INITTAB:DB 2
DW LDRIVE
DW FAT0
DW LDRIVE
DW FAT1
ORG 0
FAT0: DS LFAT
FAT1: DS LFAT
ENDIF

+678
View File
@@ -0,0 +1,678 @@
FCB: EQU 5CH
RENAM: EQU 23
OPEN: EQU 15
CLOSE: EQU 16
MAKE: EQU 22
DELFIL: EQU 19
RDBLK: EQU 39
WRBLK: EQU 40
SETDMA: EQU 26
PRINTBUF:EQU 9
OUTCH: EQU 2
INBUF: EQU 10
RR: EQU 33
PROMPT: EQU "*"
ORG 100H
PUT 100H
MOV SP,STACK
MOV DX,BREAK
MOV AX,2523H
INT 33
MOV SI,BAK
MOV DI,FCB+9
MOV CX,3
;File must not have .BAK extension
REPE
CMPB
JZ NOTBAK
;Open input file
MOV AH,OPEN
MOV DX,FCB
INT 33
MOV [HAVEOF],AL
OR AL,AL
JZ HAVFIL
MOV DX,NEWFIL
MOV AH,PRINTBUF
INT 33
HAVFIL:
MOV SI,FCB
MOV DI,FCB2
MOV CX,9
REP
MOVB
MOV SI,BAK
MOVW
MOVB
MOV AH,DELFIL
MOV DX,FCB2
INT 33
MOV AL,"$"
MOV DI,FCB2+9
STOB
STOB
STOB
MOV AH,DELFIL
INT 33
;Create .$$$ file to make sure directory has room
MOV AH,MAKE
INT 33
OR AL,AL
JZ SETUP
MOV DX,NODIR
JMP ERROR
NOTBAK:
MOV DX,NOBAK
JMP ERROR
TOOBIG:
MOV DX,TOBIG
JMP ERROR
NOTEOF:
MOV DX,NOEOF
JMP ERROR
SETUP:
MOV DX,START
MOV AH,SETDMA
INT 33
MOV CX,[6]
SUB CX,80H
MOV [LAST],CX
MOV DI,START-1
TEST B,[HAVEOF],-1
JNZ SAVEND
CALL NUMRECS
MOV [FCB+RR],0
MOV DX,FCB
MOV AH,RDBLK
INT 33
CMP AL,2
JZ TOOBIG
JCXZ SAVEND
ROR CX
XCHG CL,CH
ADD DI,CX ;Point to last byte
DOWN
MOV AL,1AH
REPNE
SCAB
JNZ NOTEOF
REPE
SCAB
INC DI
SAVEND:
CLD
INC DI
MOV B,[DI],1AH
MOV [ENDTXT],DI
MOV B,[COMBUF],128
MOV B,[EDITBUF],255
MOV [POINTER],START
MOV [CURRENT],1
COMMAND:
MOV SP,STACK
MOV AL,PROMPT
CALL OUT
MOV DX,COMBUF
MOV AH,INBUF
INT 33
MOV AL,10
CALL OUT
MOV [PARAM2],0
MOV B,[QFLG],0
MOV SI,2+COMBUF
CALL GETNUM
MOV [PARAM1],DX
CALL SKIP1
CMP AL,","
JNZ CHKNXT
INC SI
CHKNXT:
DEC SI
CALL GETNUM
MOV [PARAM2],DX
CALL SKIP1
CMP AL,"?"
JNZ DISPATCH
MOV [QFLG],AL
CALL SKIP
DISPATCH:
AND AL,5FH
MOV DI,COMTAB
MOV CX,NUMCOM
REPNE
SCAB
JNZ COMERR
MOV BX,CX
SHL BX
CALL [BX+TABLE]
JMP COMMAND
SKIP:
LODB
SKIP1:
CMP AL," "
JZ SKIP
RET
COMERR:
MOV DX,BADCOM
MOV AH,PRINTBUF
INT 33
JP COMMAND
GETNUM:
CALL SKIP
CMP AL,"."
JZ CURLIN
CMP AL,"#"
JZ MAXLIN
MOV DX,0
NUMLP:
CMP AL,"0"
JB RET
CMP AL,"9"
JA RET
SUB AL,"0"
MOV BX,DX
SHL DX
SHL DX
ADD DX,BX
SHL DX
CBW
ADD DX,AX
LODB
JP NUMLP
CURLIN:
MOV DX,[CURRENT]
LODB
RET
MAXLIN:
MOV DX,-1
LODB
RET
COMTAB: DB "SFDLIE",13
NUMCOM: EQU $-COMTAB
TABLE:
DW NOCOM ;No command--edit line
DW ENDED
DW INSERT
DW LIST
DW DELETE
DW COMERR
DW COMERR
FINDLIN:
; Inputs
; BX = Line number to be located in buffer (0 means last line)
; Outputs:
; DX = Actual line found
; DI = Pointer to start of line DX
; Zero set if BX = DX
; AL,CX destroyed. No other registers affected.
MOV DX,[CURRENT]
MOV DI,[POINTER]
CMP BX,DX
JZ RET
JA FINDIT
MOV DX,1
MOV DI,START
CMP BX,DX
JZ RET
FINDIT:
MOV CX,[ENDTXT]
SUB CX,DI
MOV AL,10
OR AL,AL ;Clear zero flag
FINLIN:
JCXZ RET
REPNE
SCAB
INC DX
CMP BX,DX
JNZ FINLIN
RET
SHOWNUM:
; Inputs:
; BX = Line number to be displayed
; Function:
; Displays line number on terminal in 8-character
; format, suppressing leading zeros.
; AX, CX, DX destroyed. No other registers affected.
PUSH BX
MOV AL," "
CALL OUT
CALL CONV10
MOV AL,":"
CALL OUT
MOV AL," "
CALL OUT
POP BX
RET
CONV10:
;Inputs:
; BX = Binary number to be displayed
; Function:
; Ouputs binary number. Five digits with leading
; zero suppression. Zero prints 5 blanks.
XOR AX,AX
MOV DL,AL
MOV CX,16
CONV:
SHL BX
ADC AL,AL
DAA
XCHG AL,AH
ADC AL,AL
DAA
XCHG AL,AH
ADC DL,DL
LOOP CONV
MOV BL,"0"-" "
XCHG AX,DX
CALL LDIG
MOV AL,DH
CALL DIGITS
MOV AL,DL
DIGITS:
MOV DH,AL
SHR AL
SHR AL
SHR AL
SHR AL
CALL LDIG
MOV AL,DH
LDIG:
AND AL,0FH
JZ ZERDIG
MOV BL,0
ZERDIG:
ADD AL,"0"
SUB AL,BL
JMP OUT
LIST:
MOV BX,[PARAM1]
OR BX,BX
JNZ CHKP2
MOV BX,[CURRENT]
SUB BX,10
JA CHKP2
MOV BX,1
CHKP2:
CALL FINDLIN
JNZ RET
MOV SI,DI
MOV DI,[PARAM2]
INC DI
SUB DI,BX
JA DISPLAY
MOV DI,21
JP DISPLAY
DISPONE:
MOV DI,1
DISPLAY:
; Inputs:
; BX = Line number
; SI = Pointer to text buffer
; DI = No. of lines
; Function:
; Ouputs specified no. of line to terminal, each
; with leading line number.
; Outputs:
; BX = Last line output.
; All registers destroyed.
MOV CX,[ENDTXT]
SUB CX,SI
JZ RET
MOV BP,[CURRENT]
DISPLN:
PUSH CX
CALL SHOWNUM
POP CX
OUTLN:
LODB
CALL OUT
CMP AL,10
LOOPNZ OUTLN
JCXZ RET
DEC DI
JZ RET
CMP BX,BP
LAHF
INC BX
SAHF
JZ OUTLF
CMP BX,BP
JNZ DISPLN
OUTLF:
MOV AL,10
CALL OUT
JP DISPLN
RET: RET
NOCOM:
MOV BX,[PARAM1]
OR BX,BX
JNZ HAVLIN
MOV BX,[CURRENT]
INC BX ;Default is current line plus one
HAVLIN:
CALL FINDLIN
MOV SI,DI
MOV [CURRENT],DX
MOV [POINTER],SI
JNZ RET
CMP SI,[ENDTXT]
JZ RET
MOV DI,2+EDITBUF
MOV CX,254
MOV DL,-1
LOADLP:
LODB
STOB
INC DL
CMP AL,13
LOOPNZ LOADLP
MOV [EDITBUF+1],DL
MOV [OLDLEN],DL
MOV SI,[POINTER]
CALL DISPONE
CALL SHOWNUM
MOV AH,INBUF ;Get input buffer
MOV DX,EDITBUF
INT 33
MOV AL,10
CALL OUT
MOV CL,[EDITBUF+1]
MOV CH,0
JCXZ RET
MOV DL,[OLDLEN]
MOV DH,0
MOV SI,2+EDITBUF
MOV DI,[POINTER]
REPLACE:
; Inputs:
; CX = Length of new text
; DX = Length of original text
; SI = Pointer to new text
; DI = Pointer to old text in buffer
; Function:
; New text replaces old text in buffer and buffer
; size is adjusted. CX or DX may be zero.
; CX, SI, DI all destroyed. No other registers affected.
CMP CX,DX
JZ COPYIN
PUSH SI
PUSH DI
PUSH CX
MOV SI,DI
ADD SI,DX
ADD DI,CX
MOV AX,[ENDTXT]
SUB AX,DX
ADD AX,CX
CMP AX,[LAST]
JAE MEMERR
XCHG AX,[ENDTXT]
MOV CX,AX
SUB CX,SI
CMP SI,DI
JA DOMOV
ADD SI,CX
ADD DI,CX
STD
DOMOV:
INC CX
REP
MOVB
CLD
POP CX
POP DI
POP SI
COPYIN:
REP
MOVB
RET
DELETE:
MOV BX,[PARAM1]
OR BX,BX
JNZ DELFIN1
MOV BX,[CURRENT]
DELFIN1:
CALL FINDLIN
JNZ RET
MOV [CURRENT],BX
MOV [POINTER],DI
PUSH DI
MOV BX,[PARAM2]
OR BX,BX
JNZ DELFIN2
MOV BX,DX
DELFIN2:
INC BX
CALL FINDLIN
MOV DX,DI
POP DI
SUB DX,DI
XOR CX,CX
JP REPLACE
GETTEXT:
; Inputs:
; SI points into command line buffer
; DI points to result buffer
; Function:
; Moves [SI] to [DI] until ctrl-Z (1AH) or
; RETURN (0DH) is found. Termination char not moved.
; Outputs:
; AL = Termination character
; CX = No of characters moved.
; SI points one past termination character
; DI points to next free location
XOR CX,CX
GETIT:
LODB
CMP AL,1AH
JZ RET
CMP AL,0DH
JZ RET
STOB
INC CX
JP GETIT
MEMERR:
MOV DX,MEMFUL
MOV AH,PRINTBUF
INT 33
JMP COMMAND
INSERT:
MOV BX,[PARAM1]
OR BX,BX
JNZ INS
MOV BX,[CURRENT]
INC BX
INS:
CALL FINDLIN
MOV CX,[ENDTXT] ;Get End-of-text marker
MOV SI,CX
SUB CX,DI ;Calculate number of bytes to copy
INC CX
MOV DI,[LAST]
DOWN
REP
MOVB
XCHG SI,DI
UP
INC DI
MOV BP,SI
MOV BX,DX
INLP:
CALL SHOWNUM
MOV DX,EDITBUF
MOV AH,INBUF
INT 33
MOV AL,10
CALL OUT
MOV SI,EDITBUF+2
CMP B,[SI],1AH
JZ ENDINS
MOV CL,[SI-1]
MOV CH,0
MOV DX,SI
ADD DX,CX
INC DX
CMP DX,BP ;Will it fit?
JNC MEMERR
REP
MOVB
MOVB
MOV AL,10
STOB
INC BX
JP INLP
ENDINS:
MOV [POINTER],DI
MOV [CURRENT],BX
MOV SI,BP
INC SI
MOV CX,[LAST]
SUB CX,BP
REP
MOVB
DEC DI
MOV [ENDTXT],DI
RET
ENDED:
;Write text out to .$$$ file
MOV DI,[ENDTXT]
MOV CX,128
MOV AL,1AH
REP
STOB
MOV CX,[ENDTXT]
CALL NUMRECS
INC CX
MOV [FCB2+RR],0
MOV DX,FCB2
MOV AH,WRBLK
INT 33
OR AL,AL
JNZ WRTERR
;Close .$$$ file
MOV AH,CLOSE
INT 33
MOV SI,FCB
LEA DI,[SI+16]
MOV DX,SI
MOV CX,9
REP
MOVB
MOV SI,BAK
MOVW
MOVB
;Rename original file .BAK
MOV AH,RENAM
INT 33
MOV SI,FCB
MOV DI,FCB2+16
MOV CX,6
REP
MOVW
;Rename .$$$ file to original name
MOV DX,FCB2
INT 33
JMP 0
WRTERR:
MOV DX,DSKFUL
ERROR:
MOV AH,PRINTBUF
INT 33
JMP 0
NUMRECS:
SUB CX,START
AND CL,80H
ROL CX
XCHG CL,CH
RET
OUT:
PUSH DX
XCHG AX,DX
MOV AH,OUTCH
INT 33
XCHG AX,DX
POP DX
RET
BREAK:
IRET
BAK: DB "BAK"
NOBAK: DB "Cannot edit .BAK file--rename file$"
NODIR: DB "No room in directory for file$"
TOBIG: DB "File too big to fit into memory$"
NOEOF: DB "No end-of-file mark found in file$"
DSKFUL: DB "Disk full--file write not completed$"
MEMFUL: DB 13,10,"Memory full",13,10,"$"
BADCOM: DB "Entry error",13,10,"$"
NEWFIL: DB "New file",13,10,"$"
FCB2: DS 36
PARAM1: DS 2
PARAM2: DS 2
QFLG: DS 1
HAVEOF: DS 1
OLDLEN: DS 1
CURRENT:DS 2
POINTER:DS 2
LAST: DS 2
ENDTXT: DS 2
COMBUF: DS 2+128
EDITBUF:DS 2+255
DS 40
ALIGN
STACK:
START:

+155
View File
@@ -0,0 +1,155 @@
; HEX2BIN
; Converts Intel hex format files to straight binary
FCB: EQU 5CH
READ: EQU 20
SETDMA: EQU 26
OPEN: EQU 15
CLOSE: EQU 16
CREATE: EQU 22
DELETE: EQU 19
BLKWRT: EQU 40
BUFFER: EQU 80H
BUFSIZ: EQU 128
ORG 100H
PUT 100H
HEX2BIN:
MOV DI,FCB+9
CMP B,[DI]," "
JNZ HAVEXT
MOV SI,HEX
MOVB
MOVW
HAVEXT:
;Get load offset (default is -100H)
MOV AH,OPEN
MOV DX,FCB
INT 33
OR AL,AL
JNZ NOFIL
MOV B,[FCB+32],0
MOV AH,READ
MOV BP,START
MOV SI,BUFFER+BUFSIZ ;Flag input buffer as empty
READHEX:
CALL GETCH
CMP AL,":" ;Search for : to start line
JNZ READHEX
CALL GETBYT ;Get byte count
MOV CL,AL
MOV CH,0
JCXZ DONE
CALL GETBYT ;Get high byte of load address
MOV BH,AL
CALL GETBYT ;Get low byte of load address
MOV BL,AL
ADD BX,START-100H ;Add in offset
MOV DI,BX
CALL GETBYT ;Throw away type byte
READLN:
CMP DI,[6]
JAE ADERR
CMP DI,START
JB ADERR
CALL GETBYT ;Get data byte
STOB
LOOP READLN
CMP DI,BP ;Check if this is the largest address so far
JBE READHEX
MOV BP,DI ;Save new largest
JP READHEX
NOFIL:
MOV DX,NOFILE
QUIT:
MOV AH,9
INT 33
INT 32
ADERR:
MOV DX,ADDR
JMP ERROR
GETCH:
CMP SI,BUFFER+BUFSIZ
JNZ NOREAD
INT 33
OR AL,AL
JNZ ERROR
MOV SI,BUFFER
NOREAD:
LODB
CMP AL,1AH
JZ DONE
RET
GETBYT:
CALL HEXDIG
MOV BL,AL
CALL HEXDIG
SHL BL
SHL BL
SHL BL
SHL BL
OR AL,BL
RET
HEXDIG:
CALL GETCH
SUB AL,"0"
JC ERROR
CMP AL,9
JBE RET
SUB AL,"A"-"0"-10
JC ERROR
CMP AL,15
JBE RET
ERROR:
MOV DX,ERRMES
MOV AH,9
INT 33
DONE:
MOV DI,FCB+9
MOV SI,COM
MOVB
MOVW
MOV DX,FCB
MOV AH,DELETE
INT 33
MOV AH,CREATE
INT 33
OR AL,AL
JNZ NOROOM
MOV W,[FCB+33],0
MOV DX,START
MOV AH,SETDMA
INT 33
MOV CX,BP
SUB CX,START-7FH
AND CL,80H
JCXZ EXIT
ROL CX
XCHG CL,CH
MOV AH,BLKWRT
MOV DX,FCB
INT 33
MOV AH,CLOSE
INT 33
EXIT:
INT 32
NOROOM:
MOV DX,DIRFUL
JMP QUIT
HEX: DB "HEX"
COM: DB "COM"
ERRMES: DB "Error in HEX file--conversion aborted$"
NOFILE: DB "File not found$"
ADDR: DB "Address out of range--conversion aborted$"
DIRFUL: DB "Disk directory full$"
START:

+260
View File
@@ -0,0 +1,260 @@
FCB: EQU 5CH
FCB2: EQU 6CH
OPEN: EQU 15
CLOSE: EQU 16
MAKE: EQU 22
DELETE: EQU 19
SEQWRT: EQU 21
SETDMA: EQU 26
GETDRV: EQU 25
PRINTBUF:EQU 9
SYSTEM: EQU 5
ORG 100H
PUT 100H
JMP RDCPM
CPMTAB:
DW IBM,IBM,IBM,IBM
DW 0,0,0,0
DW 0,0,0,0
DW 0,0,0,0
INVSRC:
MOV DX,BADSRC
JMP EXIT
NONAME:
MOV DX,BADFN
JMP EXIT
RDCPM:
MOV SP,100H
CMP B,[FCB+1]," "
JZ NONAME
XOR AL,AL
XCHG AL,[FCB]
OR AL,AL
JNZ HASDRV
MOV CL,GETDRV
CALL SYSTEM
INC AX
HASDRV:
DEC AX
MOV [DRIVE],AL
CMP AL,15
JA INVSRC ;Invalid drive number
CBW
MOV BX,AX
SHL BX
MOV BP,[BX+CPMTAB]
OR BP,BP
JZ INVSRC
MOV SI,FCB2
MOV DI,DSTFCB
MOVB
CMP B,[FCB2+1]," "
JNZ HASDST
MOV SI,FCB+1
HASDST:
MOV CX,11
REP
MOVB ;Copy file name
MOV AL,[DSTFCB]
OR AL,AL
JNZ DSTDRV
MOV CL,GETDRV
CALL SYSTEM ;Use default drive
INC AX
DSTDRV:
DEC AX
CMP AL,[DRIVE]
JZ BADPARM
MOV CL,DELETE
MOV DX,DSTFCB
CALL SYSTEM
MOV CL,MAKE
MOV DX,DSTFCB
CALL SYSTEM
MOV CL,SETDMA
MOV DX,SECBUF
CALL SYSTEM
BEGDIR:
XOR AX,AX
MOV BX,[BP+NUMENT]
READDIR:
MOV DI,DIRBUF
PUSH AX
PUSH BX
CALL READSEC
POP BX
POP AX
MOV SI,DIRBUF
ENUMDIR:
MOV DI,FCB
MOV CX,13
REPE
CMPB
JZ RDENTRY
ADD SI,CX
ADD SI,19 ;Point to next entry
DEC BX
JS DONE
CMP SI,DIRBUF+128
JB ENUMDIR
INC AX
JP READDIR
BADPARM:
MOV DX,SAMDSK
JMP EXIT
RDENTRY:
ADD SI,3 ;Point to AL array
MOV CX,16 ;16 AL bytes per entry
RDNXTAL:
LODB
MOV AH,0
TEST B,[BP+DSISIZ+1],0FFH
JZ SMALDSK
MOV AH,[SI] ;Big disk, use words instead
INC SI
DEC CX
SMALDSK:
OR AX,AX
JZ DONE
PUSH CX
MOV CH,0
PUSH SI
MOV CL,[BP+BLKSFT]
SHL AX,CL
RDALOC:
PUSH AX
OR AL,CH
PUSH CX
MOV DI,SECBUF
CALL READSEC
MOV CL,SEQWRT
MOV DX,DSTFCB
CALL SYSTEM
POP CX
POP AX
INC CH
CMP CH,[BP+BLKMSK]
JBE RDALOC
POP SI
POP CX
LOOP RDNXTAL
INC B,[FCB+12] ;Increment extent counter
JMP BEGDIR ;Scan from beginning of directory
DONE:
MOV CL,CLOSE
MOV DX,DSTFCB
CALL SYSTEM
JMP 0
;Read allocation block
READSEC:
XOR DX,DX
MOV BX,[BP+SPT]
DIV AX,BX
ADD AX,[BP+RESTRK]
MOV CX,DX
MUL AX,BX ;Tracks in sectors
MOV DX,AX
OR BH,BH ;Check for >255 sectors per track
JNZ BIGTRK ;Use words instead of bytes for xlat table
MOV AX,CX
MOV BX,[BP+XLTTBL]
XLAT
ADD DX,AX ;Logical sector number
READABS:
MOV CX,1
MOV BX,DI
MOV AL,[DRIVE]
PUSH BP
INT 37
POP AX
POP BP
JNC RDDONE
MOV DX,DSKERR
EXIT:
MOV CL,PRINTBUF
CALL SYSTEM
JMP 0
;Translation table made up of WORDs
BIGTRK:
MOV BX,CX
SHL BX
ADD BX,[BP+XLTTBL]
ADD DX,[BX]
JP READABS
RDDONE:
RET
DSKERR: DB 13,10,"HARD DISK ERROR",13,10,"$"
SAMDSK: DB 13,10,"Source and destination drives must not be the same",13,10,"$"
BADSRC: DB 13,10,"Bad source drive",13,10,"$"
BADFN: DB 13,10,"Bad file name",13,10,"$"
DRIVE: DS 1
DSTFCB: DS 32
DB 0
DIRBUF: DS 128
SECBUF: DS 128
SPT: EQU 0
BLKSFT: EQU 2
BLKMSK: EQU 3
EXTMSK: EQU 4
DSISIZ: EQU 5
NUMENT: EQU 7
ALBMP0: EQU 9
ALBMP1: EQU 10
DIRCKS: EQU 11
RESTRK: EQU 13
XLTTBL: EQU 15
;Below is the definition for standard single-density 8" drives
IBM:
DW 26 ;Sectors per track
DB 3 ;Block shift
DB 7 ;Block mask
DB 0 ;Extent mask
DW 242 ;Disk size - 1
DW 63 ;Directory entries - 1
DB 0C0H ;Directory allocation bitmap 0
DB 0 ;Directory allocation bitmap 1
DW 16 ;Directory check vector size
DW 2 ;Tracks to skip
DW MOD6 ;Modulo-6 sector translate table
MOD6:
DB 0,6,12,18,24
DB 4,10,16,22
DB 2,8,14,20
DB 1,7,13,19,25
DB 5,11,17,23
DB 3,9,15,21
CPMTAB2:
DW 0,0,0,0
DW 0,0,0,0
DW 0,0,0,0
DW 0,0,0,0

+56
View File
@@ -0,0 +1,56 @@
FCB: EQU 5CH
ORG 100H
PUT 100H
JMP START
SECS: DW 52 ;Patch for different configs
START:
MOV AL,[FCB]
OR AL,AL
JZ BADDRV
DEC AL
JZ BADDRV
MOV [FCB],AL
MOV CX,[SECS]
MOV DX,0
MOV BX,END
MOV AL,0
INT 37
JC RDERR
POPF
MOV CX,[SECS]
MOV DX,0
MOV BX,END
MOV AL,[FCB]
MOV AH,1
INT 38
JC WRERR
MOV DX,SYSOK
JP QUIT
RDERR:
MOV DX,ERREAD
QUIT:
MOV AH,9
INT 33
INT 32
WRERR:
MOV DX,ERWRIT
JP QUIT
BADDRV:
MOV DX,DRVBAD
JP QUIT
SYSOK: DB "System transfered$"
ERREAD: DB "Disk read error$"
ERWRIT: DB "Disk write error$"
DRVBAD: DB "Bad drive specification"
END:

+1210
View File
File diff suppressed because it is too large Load Diff