eaw/RFS
1
0
Fork 0
Code Issues Packages Projects Releases 1 Wiki Activity
Files
314e4e09661f28f7745a9ad287a61305fdf7d77a
RFS/asm/cpm22.asm

3765 lines
109 KiB
NASM
Raw Blame History

;**************************************************************
;*
;* C P / M version 2 . 2
;*
;* Reconstructed from memory image on February 27, 1981
;*
;* by Clark A. Calkins
;*
;**************************************************************
; Bring in definitions and macros.
INCLUDE "cpm_buildversion.asm"
INCLUDE "cpm_definitions.asm"
INCLUDE "macros.asm"
;
; Set memory limit here. This is the amount of contigeous
; ram starting from 0000. CP/M will reside at the end of this space.
;
IOBYTE EQU 3 ;i/o definition byte.
TDRIVE EQU 4 ;current drive name and user number.
ENTRY EQU 5 ;entry point for the cp/m bdos.
TFCB EQU 5CH ;default file control block.
TBUFF EQU 80H ;i/o buffer and command line storage.
TBASE EQU 100H ;transiant program storage area.
;
; Set control character equates.
;
CNTRLC EQU 3 ;control-c
CNTRLE EQU 05H ;control-e
BS EQU 08H ;backspace
;TAB EQU 09H ;tab
;LF EQU 0AH ;line feed
;FF EQU 0CH ;form feed
;CR EQU 0DH ;carriage return
CNTRLP EQU 10H ;control-p
CNTRLR EQU 12H ;control-r
CNTRLS EQU 13H ;control-s
CNTRLU EQU 15H ;control-u
CNTRLX EQU 18H ;control-x
CNTRLZ EQU 1AH ;control-z (end-of-file mark)
DEL EQU 7FH ;rubout
; CP/M addresses
;CBASE EQU 09C00H
;CCP EQU CBASE ; CP/M System entry
;BDOS EQU CCP + 0806H ; BDOS entry
;BIOS EQU CCP + 01600H ; BIOS entry
CCPLEN EQU CBASE + 7 ; Address of current number of chars into the CCP input buffer
CCPFIRS EQU CBASE + 8 ; Address of the first charater of the CCP input buffer
;
; Set origin for CP/M
;
ORG CBASE ; Origin for the Sharp MZ-80A version
;
JP COMMAND ;execute command processor (ccp).
JP CLEARBUF ;entry to empty input buffer before starting ccp.
;
; Standard cp/m ccp input buffer. Format is (max length),
; (actual length), (char #1), (char #2), (char #3), etc.
;
INBUFF: DB 127 ;length of input buffer.
DB 0 ;current length of contents.
IF BUILD_80C = 1
DB "CP/M v2.23 (48K) Copyright(c) 1979 by Digital Research", 00DH, 00AH, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ; 68 chars
ELSE
DB "CP/M v2.23 (c) 1979 by Digital Research", 00DH, 00AH, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ; 68 chars
ENDIF
;DB "Copyright"
;DB " 1979 (c) by Digital Research "
DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
INPOINT:DW INBUFF+2 ;input line pointer
NAMEPNT:DW 0 ;input line pointer used for error message. Points to
; ;start of name in error.
;
; Routine to print (A) on the console. All registers used.
;
PRINT: LD E,A ;setup bdos call.
LD C,2
JP ENTRY
;
; Routine to print (A) on the console and to save (BC).
;
PRINTB: PUSH BC
CALL PRINT
POP BC
RET
;
; Routine to send a carriage return, line feed combination
; to the console.
;
CRLF: LD A,CR
CALL PRINTB
LD A,LF
JP PRINTB
;
; Routine to send one space to the console and save (BC).
;
PRTSPACE: LD A,' '
JP PRINTB
;
; Routine to print character string pointed to be (BC) on the
; console. It must terminate with a null byte.
;
PLINE: PUSH BC
CALL CRLF
POP HL
PLINE2: LD A,(HL)
OR A
RET Z
INC HL
PUSH HL
CALL PRINT
POP HL
JP PLINE2
;
; Routine to reset the disk system.
;
RESDSK: LD C,13
JP ENTRY
;
; Routine to select disk (A).
;
DSKSEL: LD E,A
LD C,14
JP ENTRY
;
; Routine to call bdos and save the return code. The zero
; flag is set on a return of 0ffh.
;
ENTRY1: CALL ENTRY
LD (RTNCODE),A ;save return code.
INC A ;set zero if 0ffh returned.
RET
;
; Routine to open a file. (DE) must point to the FCB.
;
OPEN: LD C,15
JP ENTRY1
;
; Routine to open file at (FCB).
;
OPENFCB:XOR A ;clear the record number byte at fcb+32
LD (FCB+32),A
LD DE,FCB
JP OPEN
;
; Routine to close a file. (DE) points to FCB.
;
CLOSE: LD C,16
JP ENTRY1
;
; Routine to search for the first file with ambigueous name
; (DE).
;
SRCHFST:LD C,17
JP ENTRY1
;
; Search for the next ambigeous file name.
;
SRCHNXT:LD C,18
JP ENTRY1
;
; Search for file at (FCB).
;
SRCHFCB:LD DE,FCB
JP SRCHFST
;
; Routine to delete a file pointed to by (DE).
;
DELETEFILE: LD C,19
JP ENTRY
;
; Routine to call the bdos and set the zero flag if a zero
; status is returned.
;
ENTRY2: CALL ENTRY
OR A ;set zero flag if appropriate.
RET
;
; Routine to read the next record from a sequential file.
; (DE) points to the FCB.
;
RDREC: LD C,20
JP ENTRY2
;
; Routine to read file at (FCB).
;
READFCB:LD DE,FCB
JP RDREC
;
; Routine to write the next record of a sequential file.
; (DE) points to the FCB.
;
WRTREC: LD C,21
JP ENTRY2
;
; Routine to create the file pointed to by (DE).
;
CREATE: LD C,22
JP ENTRY1
;
; Routine to rename the file pointed to by (DE). Note that
; the new name starts at (DE+16).
;
RENAM: LD C,23
JP ENTRY
;
; Get the current user code.
;
GETUSR: LD E,0FFH
;
; Routne to get or set the current user code.
; If (E) is FF then this is a GET, else it is a SET.
;
GETSETUC: LD C,32
JP ENTRY
;
; Routine to set the current drive byte at (TDRIVE).
;
SETCDRV:CALL GETUSR ;get user number
ADD A,A ;and shift into the upper 4 bits.
ADD A,A
ADD A,A
ADD A,A
LD HL,CDRIVE ;now add in the current drive number.
OR (HL)
LD (TDRIVE),A ;and save.
RET
;
; Move currently active drive down to (TDRIVE).
;
MOVECD: LD A,(CDRIVE)
LD (TDRIVE),A
RET
;
; Routine to convert (A) into upper case ascii. Only letters
; are affected.
;
UPPER: CP 'a' ;check for letters in the range of 'a' to 'z'.
RET C
CP '{'
RET NC
AND 5FH ;convert it if found.
RET
;
; Routine to get a line of input. We must check to see if the
; user is in (BATCH) mode. If so, then read the input from file
; ($$$.SUB). At the end, reset to console input.
;
GETINP: LD A,(BATCH) ;if =0, then use console input.
OR A
JP Z,GETINP1
;
; Use the submit file ($$$.sub) which is prepared by a
; SUBMIT run. It must be on drive (A) and it will be deleted
; if and error occures (like eof).
;
LD A,(CDRIVE) ;select drive 0 if need be.
OR A
LD A,0 ;always use drive A for submit.
CALL NZ,DSKSEL ;select it if required.
LD DE,BATCHFCB
CALL OPEN ;look for it.
JP Z,GETINP1 ;if not there, use normal input.
LD A,(BATCHFCB+15) ;get last record number+1.
DEC A
LD (BATCHFCB+32),A
LD DE,BATCHFCB
CALL RDREC ;read last record.
JP NZ,GETINP1 ;quit on end of file.
;
; Move this record into input buffer.
;
LD DE,INBUFF+1
LD HL,TBUFF ;data was read into buffer here.
LD B,128 ;all 128 characters may be used.
CALL HL2DE ;(HL) to (DE), (B) bytes.
LD HL,BATCHFCB+14
LD (HL),0 ;zero out the 's2' byte.
INC HL ;and decrement the record count.
DEC (HL)
LD DE,BATCHFCB ;close the batch file now.
CALL CLOSE
JP Z,GETINP1 ;quit on an error.
LD A,(CDRIVE) ;re-select previous drive if need be.
OR A
CALL NZ,DSKSEL ;don't do needless selects.
;
; Print line just read on console.
;
LD HL,INBUFF+2
CALL PLINE2
CALL CHKCON ;check console, quit on a key.
JP Z,GETINP2 ;jump if no key is pressed.
;
; Terminate the submit job on any keyboard input. Delete this
; file such that it is not re-started and jump to normal keyboard
; input section.
;
CALL DELBATCH ;delete the batch file.
JP CMMND1 ;and restart command input.
;
; Get here for normal keyboard input. Delete the submit file
; incase there was one.
;
GETINP1:CALL DELBATCH ;delete file ($$$.sub).
CALL SETCDRV ;reset active disk.
LD C,10 ;get line from console device.
LD DE,INBUFF
CALL ENTRY
CALL MOVECD ;reset current drive (again).
;
; Convert input line to upper case.
;
GETINP2:LD HL,INBUFF+1
LD B,(HL) ;(B)=character counter.
GETINP3:INC HL
LD A,B ;end of the line?
OR A
JP Z,GETINP4
LD A,(HL) ;convert to upper case.
CALL UPPER
LD (HL),A
DEC B ;adjust character count.
JP GETINP3
GETINP4:LD (HL),A ;add trailing null.
LD HL,INBUFF+2
LD (INPOINT),HL ;reset input line pointer.
RET
;
; Routine to check the console for a key pressed. The zero
; flag is set is none, else the character is returned in (A).
;
CHKCON: LD C,11 ;check console.
CALL ENTRY
OR A
RET Z ;return if nothing.
LD C,1 ;else get character.
CALL ENTRY
OR A ;clear zero flag and return.
RET
;
; Routine to get the currently active drive number.
;
GETDSK: LD C,25
JP ENTRY
;
; Set the stabdard dma address.
;
STDDMA: LD DE,TBUFF
;
; Routine to set the dma address to (DE).
;
DMASET: LD C,26
JP ENTRY
;
; Delete the batch file created by SUBMIT.
;
DELBATCH: LD HL,BATCH ;is batch active?
LD A,(HL)
OR A
RET Z
LD (HL),0 ;yes, de-activate it.
XOR A
CALL DSKSEL ;select drive 0 for sure.
LD DE,BATCHFCB ;and delete this file.
CALL DELETEFILE
LD A,(CDRIVE) ;reset current drive.
JP DSKSEL
;
; Check to two strings at (PATTRN1) and (PATTRN2). They must be
; the same or we halt....
;
VERIFY: LD DE,PATTRN1 ;these are the serial number bytes.
LD HL,PATTRN2 ;ditto, but how could they be different?
LD B,6 ;6 bytes each.
VERIFY1:LD A,(DE)
CP (HL)
JP NZ,HALTCPM ;jump to halt routine.
INC DE
INC HL
DEC B
JP NZ,VERIFY1
RET
;
; Print back file name with a '?' to indicate a syntax error.
;
SYNERR: CALL CRLF ;end current line.
LD HL,(NAMEPNT) ;this points to name in error.
SYNERR1:LD A,(HL) ;print it until a space or null is found.
CP ' '
JP Z,SYNERR2
OR A
JP Z,SYNERR2
PUSH HL
CALL PRINT
POP HL
INC HL
JP SYNERR1
SYNERR2:LD A,'?' ;add trailing '?'.
CALL PRINT
CALL CRLF
CALL DELBATCH ;delete any batch file.
JP CMMND1 ;and restart from console input.
;
; Check character at (DE) for legal command input. Note that the
; zero flag is set if the character is a delimiter.
;
CHECK: LD A,(DE)
OR A
RET Z
CP ' ' ;control characters are not legal here.
JP C,SYNERR
RET Z ;check for valid delimiter.
CP '='
RET Z
CP '_'
RET Z
CP '.'
RET Z
CP ':'
RET Z
CP 03BH ; ';'
RET Z
CP '<'
RET Z
CP '>'
RET Z
RET
;
; Get the next non-blank character from (DE).
;
NONBLANK: LD A,(DE)
OR A ;string ends with a null.
RET Z
CP ' '
RET NZ
INC DE
JP NONBLANK
;
; Add (HL)=(HL)+(A)
;
ADDHL: ADD A,L
LD L,A
RET NC ;take care of any carry.
INC H
RET
;
; Convert the first name in (FCB).
;
CONVFST:LD A,0
;
; Format a file name (convert * to '?', etc.). On return,
; (A)=0 is an unambigeous name was specified. Enter with (A) equal to
; the position within the fcb for the name (either 0 or 16).
;
CONVERT:LD HL,FCB
CALL ADDHL
PUSH HL
PUSH HL
XOR A
LD (CHGDRV),A ;initialize drive change flag.
LD HL,(INPOINT) ;set (HL) as pointer into input line.
EX DE,HL
CALL NONBLANK ;get next non-blank character.
EX DE,HL
LD (NAMEPNT),HL ;save pointer here for any error message.
EX DE,HL
POP HL
LD A,(DE) ;get first character.
OR A
JP Z,CONVRT1
SBC A,'A'-1 ;might be a drive name, convert to binary.
LD B,A ;and save.
INC DE ;check next character for a ':'.
LD A,(DE)
CP ':'
JP Z,CONVRT2
DEC DE ;nope, move pointer back to the start of the line.
CONVRT1:LD A,(CDRIVE)
LD (HL),A
JP CONVRT3
CONVRT2:LD A,B
LD (CHGDRV),A ;set change in drives flag.
LD (HL),B
INC DE
;
; Convert the basic file name.
;
CONVRT3:LD B,08H
CONVRT4:CALL CHECK
JP Z,CONVRT8
INC HL
CP '*' ;note that an '*' will fill the remaining
JP NZ,CONVRT5 ;field with '?'.
LD (HL),'?'
JP CONVRT6
CONVRT5:LD (HL),A
INC DE
CONVRT6:DEC B
JP NZ,CONVRT4
CONVRT7:CALL CHECK ;get next delimiter.
JP Z,GETEXT
INC DE
JP CONVRT7
CONVRT8:INC HL ;blank fill the file name.
LD (HL),' '
DEC B
JP NZ,CONVRT8
;
; Get the extension and convert it.
;
GETEXT: LD B,03H
CP '.'
JP NZ,GETEXT5
INC DE
GETEXT1:CALL CHECK
JP Z,GETEXT5
INC HL
CP '*'
JP NZ,GETEXT2
LD (HL),'?'
JP GETEXT3
GETEXT2:LD (HL),A
INC DE
GETEXT3:DEC B
JP NZ,GETEXT1
GETEXT4:CALL CHECK
JP Z,GETEXT6
INC DE
JP GETEXT4
GETEXT5:INC HL
LD (HL),' '
DEC B
JP NZ,GETEXT5
GETEXT6:LD B,3
GETEXT7:INC HL
LD (HL),0
DEC B
JP NZ,GETEXT7
EX DE,HL
LD (INPOINT),HL ;save input line pointer.
POP HL
;
; Check to see if this is an ambigeous file name specification.
; Set the (A) register to non zero if it is.
;
LD BC,11 ;set name length.
GETEXT8:INC HL
LD A,(HL)
CP '?' ;any question marks?
JP NZ,GETEXT9
INC B ;count them.
GETEXT9:DEC C
JP NZ,GETEXT8
LD A,B
OR A
RET
;
; CP/M command table. Note commands can be either 3 or 4 characters long.
;
NUMCMDS EQU 6 ;number of commands
CMDTBL: DB "DIR "
DB "ERA "
DB "TYPE"
DB "SAVE"
DB "REN "
DB "USER"
;
; The following six bytes must agree with those at (PATTRN2)
; or cp/m will HALT. Why?
;
PATTRN1:DB 0,22,0,0,0,0 ;(* serial number bytes *).
;
; Search the command table for a match with what has just
; been entered. If a match is found, then we jump to the
; proper section. Else jump to (UNKNOWN).
; On return, the (C) register is set to the command number
; that matched (or NUMCMDS+1 if no match).
;
SEARCH: LD HL,CMDTBL
LD C,0
SEARCH1:LD A,C
CP NUMCMDS ;this commands exists.
RET NC
LD DE,FCB+1 ;check this one.
LD B,4 ;max command length.
SEARCH2:LD A,(DE)
CP (HL)
JP NZ,SEARCH3 ;not a match.
INC DE
INC HL
DEC B
JP NZ,SEARCH2
LD A,(DE) ;allow a 3 character command to match.
CP ' '
JP NZ,SEARCH4
LD A,C ;set return register for this command.
RET
SEARCH3:INC HL
DEC B
JP NZ,SEARCH3
SEARCH4:INC C
JP SEARCH1
;
; Set the input buffer to empty and then start the command
; processor (ccp).
;
CLEARBUF: XOR A
LD (INBUFF+1),A ;second byte is actual length.
;
;**************************************************************
;*
;*
;* C C P - C o n s o l e C o m m a n d P r o c e s s o r
;*
;**************************************************************
;*
COMMAND:LD SP,CCPSTACK ;setup stack area.
PUSH BC ;note that (C) should be equal to:
LD A,C ;(uuuudddd) where 'uuuu' is the user number
RRA ;and 'dddd' is the drive number.
RRA
RRA
RRA
AND 0FH ;isolate the user number.
LD E,A
CALL GETSETUC ;and set it.
CALL RESDSK ;reset the disk system.
LD (BATCH),A ;clear batch mode flag.
POP BC
LD A,C
AND 0FH ;isolate the drive number.
LD (CDRIVE),A ;and save.
CALL DSKSEL ;...and select.
LD A,(INBUFF+1)
OR A ;anything in input buffer already?
JP NZ,CMMND2 ;yes, we just process it.
;
; Entry point to get a command line from the console.
;
CMMND1: LD SP,CCPSTACK ;set stack straight.
CALL CRLF ;start a new line on the screen.
CALL GETDSK ;get current drive.
ADD A,'A'
CALL PRINT ;print current drive.
LD A,'>'
CALL PRINT ;and add prompt.
CALL GETINP ;get line from user.
;
; Process command line here.
;
CMMND2: LD DE,TBUFF
CALL DMASET ;set standard dma address.
CALL GETDSK
LD (CDRIVE),A ;set current drive.
CALL CONVFST ;convert name typed in.
CALL NZ,SYNERR ;wild cards are not allowed.
LD A,(CHGDRV) ;if a change in drives was indicated,
OR A ;then treat this as an unknown command
JP NZ,UNKNOWN ;which gets executed.
CALL SEARCH ;else search command table for a match.
;
; Note that an unknown command returns
; with (A) pointing to the last address
; in our table which is (UNKNOWN).
;
LD HL,CMDADR ;now, look thru our address table for command (A).
LD E,A ;set (DE) to command number.
LD D,0
ADD HL,DE
ADD HL,DE ;(HL)=(CMDADR)+2*(command number).
LD A,(HL) ;now pick out this address.
INC HL
LD H,(HL)
LD L,A
JP (HL) ;now execute it.
;
; CP/M command address table.
;
CMDADR: DW DIRECT,ERASE,TYPE,SAVE
DW RENAME,USER,UNKNOWN
;
; Halt the system. Reason for this is unknown at present.
;
HALTCPM: LD HL,76F3H ;'DI HLT' instructions.
LD (CBASE),HL
LD HL,CBASE
JP (HL)
;
; Read error while TYPEing a file.
;
RDERROR:LD BC,RDERR
JP PLINE
RDERR: DB "Read error"
DB 0
;
; Required file was not located.
;
NONE: LD BC,NOFILE
JP PLINE
NOFILE: DB "No file"
DB 0
;
; Decode a command of the form 'A>filename number{ filename}.
; Note that a drive specifier is not allowed on the first file
; name. On return, the number is in register (A). Any error
; causes 'filename?' to be printed and the command is aborted.
;
DECODE: CALL CONVFST ;convert filename.
LD A,(CHGDRV) ;do not allow a drive to be specified.
OR A
JP NZ,SYNERR
LD HL,FCB+1 ;convert number now.
LD BC,11 ;(B)=sum register, (C)=max digit count.
DECODE1:LD A,(HL)
CP ' ' ;a space terminates the numeral.
JP Z,DECODE3
INC HL
SUB '0' ;make binary from ascii.
CP 10 ;legal digit?
JP NC,SYNERR
LD D,A ;yes, save it in (D).
LD A,B ;compute (B)=(B)*10 and check for overflow.
AND 0E0H
JP NZ,SYNERR
LD A,B
RLCA
RLCA
RLCA ;(A)=(B)*8
ADD A,B ;.......*9
JP C,SYNERR
ADD A,B ;.......*10
JP C,SYNERR
ADD A,D ;add in new digit now.
DECODE2:JP C,SYNERR
LD B,A ;and save result.
DEC C ;only look at 11 digits.
JP NZ,DECODE1
RET
DECODE3:LD A,(HL) ;spaces must follow (why?).
CP ' '
JP NZ,SYNERR
INC HL
DECODE4:DEC C
JP NZ,DECODE3
LD A,B ;set (A)=the numeric value entered.
RET
;
; Move 3 bytes from (HL) to (DE). Note that there is only
; one reference to this at (A2D5h).
;
MOVE3: LD B,3
;
; Move (B) bytes from (HL) to (DE).
;
HL2DE: LD A,(HL)
LD (DE),A
INC HL
INC DE
DEC B
JP NZ,HL2DE
RET
;
; Compute (HL)=(TBUFF)+(A)+(C) and get the byte that's here.
;
EXTRACT:LD HL,TBUFF
ADD A,C
CALL ADDHL
LD A,(HL)
RET
;
; Check drive specified. If it means a change, then the new
; drive will be selected. In any case, the drive byte of the
; fcb will be set to null (means use current drive).
;
DSELECT:XOR A ;null out first byte of fcb.
LD (FCB),A
LD A,(CHGDRV) ;a drive change indicated?
OR A
RET Z
DEC A ;yes, is it the same as the current drive?
LD HL,CDRIVE
CP (HL)
RET Z
JP DSKSEL ;no. Select it then.
;
; Check the drive selection and reset it to the previous
; drive if it was changed for the preceeding command.
;
RESETDR:LD A,(CHGDRV) ;drive change indicated?
OR A
RET Z
DEC A ;yes, was it a different drive?
LD HL,CDRIVE
CP (HL)
RET Z
LD A,(CDRIVE) ;yes, re-select our old drive.
JP DSKSEL
;
;**************************************************************
;*
;* D I R E C T O R Y C O M M A N D
;*
;**************************************************************
;
DIRECT: CALL CONVFST ;convert file name.
CALL DSELECT ;select indicated drive.
LD HL,FCB+1 ;was any file indicated?
LD A,(HL)
CP ' '
JP NZ,DIRECT2
LD B,11 ;no. Fill field with '?' - same as *.*.
DIRECT1:LD (HL),'?'
INC HL
DEC B
JP NZ,DIRECT1
DIRECT2:LD E,0 ;set initial cursor position.
PUSH DE
CALL SRCHFCB ;get first file name.
CALL Z,NONE ;none found at all?
DIRECT3:JP Z,DIRECT9 ;terminate if no more names.
LD A,(RTNCODE) ;get file's position in segment (0-3).
RRCA
RRCA
RRCA
AND 60H ;(A)=position*32
LD C,A
LD A,10
CALL EXTRACT ;extract the tenth entry in fcb.
RLA ;check system file status bit.
JP C,DIRECT8 ;we don't list them.
POP DE
LD A,E ;bump name count.
INC E
PUSH DE
IF BUILD_80C = 1
AND 03H ;at end of line?
ELSE
AND 01H ;at end of line?
ENDIF
PUSH AF
JP NZ,DIRECT4
CALL CRLF ;yes, end this line and start another.
PUSH BC
CALL GETDSK ;start line with ('A:').
POP BC
ADD A,'A'
CALL PRINTB
LD A,':'
CALL PRINTB
JP DIRECT5
DIRECT4:CALL PRTSPACE ;add seperator between file names.
LD A,':'
CALL PRINTB
DIRECT5:CALL PRTSPACE
LD B,1 ;'extract' each file name character at a time.
DIRECT6:LD A,B
CALL EXTRACT
AND 7FH ;strip bit 7 (status bit).
CP ' ' ;are we at the end of the name?
JP NZ,DRECT65
POP AF ;yes, don't print spaces at the end of a line.
PUSH AF
CP 3
JP NZ,DRECT63
LD A,9 ;first check for no extension.
CALL EXTRACT
AND 7FH
CP ' '
JP Z,DIRECT7 ;don't print spaces.
DRECT63:LD A,' ' ;else print them.
DRECT65:CALL PRINTB
INC B ;bump to next character psoition.
LD A,B
CP 12 ;end of the name?
JP NC,DIRECT7
CP 9 ;nope, starting extension?
JP NZ,DIRECT6
CALL PRTSPACE ;yes, add seperating space.
JP DIRECT6
DIRECT7:POP AF ;get the next file name.
DIRECT8:CALL CHKCON ;first check console, quit on anything.
JP NZ,DIRECT9
CALL SRCHNXT ;get next name.
JP DIRECT3 ;and continue with our list.
DIRECT9:POP DE ;restore the stack and return to command level.
JP GETBACK
;
;**************************************************************
;*
;* E R A S E C O M M A N D
;*
;**************************************************************
;
ERASE: CALL CONVFST ;convert file name.
CP 11 ;was '*.*' entered?
JP NZ,ERASE1
LD BC,YESNO ;yes, ask for confirmation.
CALL PLINE
CALL GETINP
LD HL,INBUFF+1
DEC (HL) ;must be exactly 'y'.
JP NZ,CMMND1
INC HL
LD A,(HL)
CP 'Y'
JP NZ,CMMND1
INC HL
LD (INPOINT),HL ;save input line pointer.
ERASE1: CALL DSELECT ;select desired disk.
LD DE,FCB
CALL DELETEFILE ;delete the file.
INC A
CALL Z,NONE ;not there?
JP GETBACK ;return to command level now.
YESNO: DB "All (y/n)?"
DB 0
;
;**************************************************************
;*
;* T Y P E C O M M A N D
;*
;**************************************************************
;
TYPE: CALL CONVFST ;convert file name.
JP NZ,SYNERR ;wild cards not allowed.
CALL DSELECT ;select indicated drive.
CALL OPENFCB ;open the file.
JP Z,TYPE5 ;not there?
CALL CRLF ;ok, start a new line on the screen.
LD HL,NBYTES ;initialize byte counter.
LD (HL),0FFH ;set to read first sector.
TYPE1: LD HL,NBYTES
TYPE2: LD A,(HL) ;have we written the entire sector?
CP 128
JP C,TYPE3
PUSH HL ;yes, read in the next one.
CALL READFCB
POP HL
JP NZ,TYPE4 ;end or error?
XOR A ;ok, clear byte counter.
LD (HL),A
TYPE3: INC (HL) ;count this byte.
LD HL,TBUFF ;and get the (A)th one from the buffer (TBUFF).
CALL ADDHL
LD A,(HL)
CP CNTRLZ ;end of file mark?
JP Z,GETBACK
CALL PRINT ;no, print it.
CALL CHKCON ;check console, quit if anything ready.
JP NZ,GETBACK
JP TYPE1
;
; Get here on an end of file or read error.
;
TYPE4: DEC A ;read error?
JP Z,GETBACK
CALL RDERROR ;yes, print message.
TYPE5: CALL RESETDR ;and reset proper drive
JP SYNERR ;now print file name with problem.
;
;**************************************************************
;*
;* S A V E C O M M A N D
;*
;**************************************************************
;
SAVE: CALL DECODE ;get numeric number that follows SAVE.
PUSH AF ;save number of pages to write.
CALL CONVFST ;convert file name.
JP NZ,SYNERR ;wild cards not allowed.
CALL DSELECT ;select specified drive.
LD DE,FCB ;now delete this file.
PUSH DE
CALL DELETEFILE
POP DE
CALL CREATE ;and create it again.
JP Z,SAVE3 ;can't create?
XOR A ;clear record number byte.
LD (FCB+32),A
POP AF ;convert pages to sectors.
LD L,A
LD H,0
ADD HL,HL ;(HL)=number of sectors to write.
LD DE,TBASE ;and we start from here.
SAVE1: LD A,H ;done yet?
OR L
JP Z,SAVE2
DEC HL ;nope, count this and compute the start
PUSH HL ;of the next 128 byte sector.
LD HL,128
ADD HL,DE
PUSH HL ;save it and set the transfer address.
CALL DMASET
LD DE,FCB ;write out this sector now.
CALL WRTREC
POP DE ;reset (DE) to the start of the last sector.
POP HL ;restore sector count.
JP NZ,SAVE3 ;write error?
JP SAVE1
;
; Get here after writing all of the file.
;
SAVE2: LD DE,FCB ;now close the file.
CALL CLOSE
INC A ;did it close ok?
JP NZ,SAVE4
;
; Print out error message (no space).
;
SAVE3: LD BC,NOSPACE
CALL PLINE
SAVE4: CALL STDDMA ;reset the standard dma address.
JP GETBACK
NOSPACE:DB "No space"
DB 0
;
;**************************************************************
;*
;* R E N A M E C O M M A N D
;*
;**************************************************************
;
RENAME: CALL CONVFST ;convert first file name.
JP NZ,SYNERR ;wild cards not allowed.
LD A,(CHGDRV) ;remember any change in drives specified.
PUSH AF
CALL DSELECT ;and select this drive.
CALL SRCHFCB ;is this file present?
JP NZ,RENAME6 ;yes, print error message.
LD HL,FCB ;yes, move this name into second slot.
LD DE,FCB+16
LD B,16
CALL HL2DE
LD HL,(INPOINT) ;get input pointer.
EX DE,HL
CALL NONBLANK ;get next non blank character.
CP '=' ;only allow an '=' or '_' seperator.
JP Z,RENAME1
CP '_'
JP NZ,RENAME5
RENAME1:EX DE,HL
INC HL ;ok, skip seperator.
LD (INPOINT),HL ;save input line pointer.
CALL CONVFST ;convert this second file name now.
JP NZ,RENAME5 ;again, no wild cards.
POP AF ;if a drive was specified, then it
LD B,A ;must be the same as before.
LD HL,CHGDRV
LD A,(HL)
OR A
JP Z,RENAME2
CP B
LD (HL),B
JP NZ,RENAME5 ;they were different, error.
RENAME2:LD (HL),B ; reset as per the first file specification.
XOR A
LD (FCB),A ;clear the drive byte of the fcb.
RENAME3:CALL SRCHFCB ;and go look for second file.
JP Z,RENAME4 ;doesn't exist?
LD DE,FCB
CALL RENAM ;ok, rename the file.
JP GETBACK
;
; Process rename errors here.
;
RENAME4:CALL NONE ;file not there.
JP GETBACK
RENAME5:CALL RESETDR ;bad command format.
JP SYNERR
RENAME6:LD BC,EXISTS ;destination file already exists.
CALL PLINE
JP GETBACK
EXISTS: DB "File exists"
DB 0
;
;**************************************************************
;*
;* U S E R C O M M A N D
;*
;**************************************************************
;
USER: CALL DECODE ;get numeric value following command.
CP 16 ;legal user number?
JP NC,SYNERR
LD E,A ;yes but is there anything else?
LD A,(FCB+1)
CP ' '
JP Z,SYNERR ;yes, that is not allowed.
CALL GETSETUC ;ok, set user code.
JP GETBACK1
;
;**************************************************************
;*
;* T R A N S I A N T P R O G R A M C O M M A N D
;*
;**************************************************************
;
UNKNOWN:CALL VERIFY ;check for valid system (why?).
LD A,(FCB+1) ;anything to execute?
CP ' '
JP NZ,UNKWN1
LD A,(CHGDRV) ;nope, only a drive change?
OR A
JP Z,GETBACK1 ;neither???
DEC A
LD (CDRIVE),A ;ok, store new drive.
CALL MOVECD ;set (TDRIVE) also.
CALL DSKSEL ;and select this drive.
JP GETBACK1 ;then return.
;
; Here a file name was typed. Prepare to execute it.
;
UNKWN1: LD DE,FCB+9 ;an extension specified?
LD A,(DE)
CP ' '
JP NZ,SYNERR ;yes, not allowed.
UNKWN2: PUSH DE
CALL DSELECT ;select specified drive.
POP DE
LD HL,COMFILE ;set the extension to 'COM'.
CALL MOVE3
CALL OPENFCB ;and open this file.
JP Z,UNKWN9 ;not present?
;
; Load in the program.
;
LD HL,TBASE ;store the program starting here.
UNKWN3: PUSH HL
EX DE,HL
CALL DMASET ;set transfer address.
LD DE,FCB ;and read the next record.
CALL RDREC
JP NZ,UNKWN4 ;end of file or read error?
POP HL ;nope, bump pointer for next sector.
LD DE,128
ADD HL,DE
LD DE,CBASE ;enough room for the whole file?
LD A,L
SUB E
LD A,H
SBC A,D
JP NC,UNKWN0 ;no, it can't fit.
JP UNKWN3
;
; Get here after finished reading.
;
UNKWN4: POP HL
DEC A ;normal end of file?
JP NZ,UNKWN0
CALL RESETDR ;yes, reset previous drive.
CALL CONVFST ;convert the first file name that follows
LD HL,CHGDRV ;command name.
PUSH HL
LD A,(HL) ;set drive code in default fcb.
LD (FCB),A
LD A,16 ;put second name 16 bytes later.
CALL CONVERT ;convert second file name.
POP HL
LD A,(HL) ;and set the drive for this second file.
LD (FCB+16),A
XOR A ;clear record byte in fcb.
LD (FCB+32),A
LD DE,TFCB ;move it into place at(005Ch).
LD HL,FCB
LD B,33
CALL HL2DE
LD HL,INBUFF+2 ;now move the remainder of the input
UNKWN5: LD A,(HL) ;line down to (0080h). Look for a non blank.
OR A ;or a null.
JP Z,UNKWN6
CP ' '
JP Z,UNKWN6
INC HL
JP UNKWN5
;
; Do the line move now. It ends in a null byte.
;
UNKWN6: LD B,0 ;keep a character count.
LD DE,TBUFF+1 ;data gets put here.
UNKWN7: LD A,(HL) ;move it now.
LD (DE),A
OR A
JP Z,UNKWN8
INC B
INC HL
INC DE
JP UNKWN7
UNKWN8: LD A,B ;now store the character count.
LD (TBUFF),A
CALL CRLF ;clean up the screen.
CALL STDDMA ;set standard transfer address.
CALL SETCDRV ;reset current drive.
CALL TBASE ;and execute the program.
;
; Transiant programs return here (or reboot).
;
LD SP,BATCH ;set stack first off.
CALL MOVECD ;move current drive into place (TDRIVE).
CALL DSKSEL ;and reselect it.
JP CMMND1 ;back to comand mode.
;
; Get here if some error occured.
;
UNKWN9: CALL RESETDR ;inproper format.
JP SYNERR
UNKWN0: LD BC,BADLOAD ;read error or won't fit.
CALL PLINE
JP GETBACK
BADLOAD:DB "Bad load"
DB 0
COMFILE:DB "COM" ;command file extension.
;
; Get here to return to command level. We will reset the
; previous active drive and then either return to command
; level directly or print error message and then return.
;
GETBACK:CALL RESETDR ;reset previous drive.
GETBACK1: CALL CONVFST ;convert first name in (FCB).
LD A,(FCB+1) ;if this was just a drive change request,
SUB ' ' ;make sure it was valid.
LD HL,CHGDRV
OR (HL)
JP NZ,SYNERR
JP CMMND1 ;ok, return to command level.
;
; ccp stack area.
;
DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
CCPSTACK EQU $ ;end of ccp stack area.
;
; Batch (or SUBMIT) processing information storage.
;
BATCH: DB 0 ;batch mode flag (0=not active).
BATCHFCB: DB 0
DB "$$$ SUB"
DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
;
; File control block setup by the CCP.
;
FCB: DB 0
DB " "
DB 0,0,0,0,0
DB " "
DB 0,0,0,0,0
RTNCODE:DB 0 ;status returned from bdos call.
CDRIVE: DB 0 ;currently active drive.
CHGDRV: DB 0 ;change in drives flag (0=no change).
NBYTES: DW 0 ;byte counter used by TYPE.
;
; Room for expansion?
;
DB 0,0,0,0,0,0,0,0,0,0,0,0,0
;
; Note that the following six bytes must match those at
; (PATTRN1) or cp/m will HALT. Why?
;
PATTRN2:DB 0,22,0,0,0,0 ;(* serial number bytes *).
;
;**************************************************************
;*
;* B D O S E N T R Y
;*
;**************************************************************
;
FBASE: JP FBASE1
;
; Bdos error table.
;
BADSCTR:DW ERROR1 ;bad sector on read or write.
BADSLCT:DW ERROR2 ;bad disk select.
RODISK: DW ERROR3 ;disk is read only.
ROFILE: DW ERROR4 ;file is read only.
;
; Entry into bdos. (DE) or (E) are the parameters passed. The
; function number desired is in register (C).
;
FBASE1:
EX DE,HL ;save the (DE) parameters.
LD (PARAMS),HL
EX DE,HL
LD A,E ;and save register (E) in particular.
LD (EPARAM),A
LD HL,0
LD (STATUS),HL ;clear return status.
ADD HL,SP
LD (USRSTACK),HL ;save users stack pointer.
LD SP,STKAREA ;and set our own.
XOR A ;clear auto select storage space.
LD (AUTOFLAG),A
LD (AUTO),A
LD HL,GOBACK ;set return address.
PUSH HL
LD A,C ;get function number.
CP NFUNCTS ;valid function number?
RET NC
LD C,E ;keep single register function here.
LD HL,FUNCTNS ;now look thru the function table.
LD E,A
LD D,0 ;(DE)=function number.
ADD HL,DE
ADD HL,DE ;(HL)=(start of table)+2*(function number).
LD E,(HL)
INC HL
LD D,(HL) ;now (DE)=address for this function.
LD HL,(PARAMS) ;retrieve parameters.
EX DE,HL ;now (DE) has the original parameters.
JP (HL) ;execute desired function.
;
; BDOS function jump table.
;
NFUNCTS EQU 41 ;number of functions in followin table.
;
FUNCTNS:DW WBOOT,GETCON,OUTCON,GETRDR,PUNCH,LIST,DIRCIO,GETIOB
DW SETIOB,PRTSTR,RDBUFF,GETCSTS,GETVER,RSTDSK,SETDSK,OPENFIL
DW CLOSEFIL,GETFST,GETNXT,DELFILE,READSEQ,WRTSEQ,FCREATE
DW RENFILE,GETLOG,GETCRNT,PUTDMA,GETALOC,WRTPRTD,GETROV,SETATTR
DW GETPARM,GETUSER,RDRANDOM,WTRANDOM,FILESIZE,SETRAN,LOGOFF,RTN
DW RTN,WTSPECL
;
; Bdos error message section.
;
ERROR1: LD HL,BADSEC ;bad sector message.
CALL PRTERR ;print it and get a 1 char responce.
CP CNTRLC ;re-boot request (control-c)?
JP Z,0 ;yes.
RET ;no, return to retry i/o function.
;
ERROR2: LD HL,BADSEL ;bad drive selected.
JP ERROR5
;
ERROR3: LD HL,DISKRO ;disk is read only.
JP ERROR5
;
ERROR4: LD HL,FILERO ;file is read only.
;
ERROR5: CALL PRTERR
JP 0 ;always reboot on these errors.
;
BDOSERR:DB "Bdos Err On "
BDOSDRV:DB " : $"
BADSEC: DB "Bad Sector$"
BADSEL: DB "Select$"
FILERO: DB "File "
DISKRO: DB "R/O$"
;
; Print bdos error message.
;
PRTERR: PUSH HL ;save second message pointer.
CALL OUTCRLF ;send (cr)(lf).
LD A,(ACTIVE) ;get active drive.
ADD A,'A' ;make ascii.
LD (BDOSDRV),A ;and put in message.
LD BC,BDOSERR ;and print it.
CALL PRTMESG
POP BC ;print second message line now.
CALL PRTMESG
;
; Get an input character. We will check our 1 character
; buffer first. This may be set by the console status routine.
;
GETCHAR:LD HL,CHARBUF ;check character buffer.
LD A,(HL) ;anything present already?
LD (HL),0 ;...either case clear it.
OR A
RET NZ ;yes, use it.
JP CONIN ;nope, go get a character responce.
;
; Input and echo a character.
;
GETECHO:CALL GETCHAR ;input a character.
CALL CHKCHAR ;carriage control?
RET C ;no, a regular control char so don't echo.
PUSH AF ;ok, save character now.
LD C,A
CALL OUTCON ;and echo it.
POP AF ;get character and return.
RET
;
; Check character in (A). Set the zero flag on a carriage
; control character and the carry flag on any other control
; character.
;
CHKCHAR:CP CR ;check for carriage return, line feed, backspace,
RET Z ;or a tab.
CP LF
RET Z
CP TAB
RET Z
CP BS
RET Z
CP ' ' ;other control char? Set carry flag.
RET
;
; Check the console during output. Halt on a control-s, then
; reboot on a control-c. If anything else is ready, clear the
; zero flag and return (the calling routine may want to do
; something).
;
CKCONSOL: LD A,(CHARBUF) ;check buffer.
OR A ;if anything, just return without checking.
JP NZ,CKCON2
CALL CONST ;nothing in buffer. Check console.
AND 01H ;look at bit 0.
RET Z ;return if nothing.
CALL CONIN ;ok, get it.
CP CNTRLS ;if not control-s, return with zero cleared.
JP NZ,CKCON1
CALL CONIN ;halt processing until another char
CP CNTRLC ;is typed. Control-c?
JP Z,0 ;yes, reboot now.
XOR A ;no, just pretend nothing was ever ready.
RET
CKCON1: LD (CHARBUF),A ;save character in buffer for later processing.
CKCON2: LD A,1 ;set (A) to non zero to mean something is ready.
RET
;
; Output (C) to the screen. If the printer flip-flop flag
; is set, we will send character to printer also. The console
; will be checked in the process.
;
OUTCHAR:LD A,(OUTFLAG) ;check output flag.
OR A ;anything and we won't generate output.
JP NZ,OUTCHR1
PUSH BC
CALL CKCONSOL ;check console (we don't care whats there).
POP BC
PUSH BC
CALL CONOUT ;output (C) to the screen.
POP BC
PUSH BC
LD A,(PRTFLAG) ;check printer flip-flop flag.
OR A
CALL NZ,LIST ;print it also if non-zero.
POP BC
OUTCHR1:LD A,C ;update cursors position.
LD HL,CURPOS
CP DEL ;rubouts don't do anything here.
RET Z
INC (HL) ;bump line pointer.
CP ' ' ;and return if a normal character.
RET NC
DEC (HL) ;restore and check for the start of the line.
LD A,(HL)
OR A
RET Z ;ingnore control characters at the start of the line.
LD A,C
CP BS ;is it a backspace?
JP NZ,OUTCHR2
DEC (HL) ;yes, backup pointer.
RET
OUTCHR2:CP LF ;is it a line feed?
RET NZ ;ignore anything else.
LD (HL),0 ;reset pointer to start of line.
RET
;
; Output (A) to the screen. If it is a control character
; (other than carriage control), use ^x format.
;
SHOWIT: LD A,C
CALL CHKCHAR ;check character.
JP NC,OUTCON ;not a control, use normal output.
PUSH AF
LD C,'^' ;for a control character, preceed it with '^'.
CALL OUTCHAR
POP AF
OR '@' ;and then use the letter equivelant.
LD C,A
;
; Function to output (C) to the console device and expand tabs
; if necessary.
;
OUTCON: LD A,C
CP TAB ;is it a tab?
JP NZ,OUTCHAR ;use regular output.
OUTCON1:LD C,' ' ;yes it is, use spaces instead.
CALL OUTCHAR
LD A,(CURPOS) ;go until the cursor is at a multiple of 8
AND 07H ;position.
JP NZ,OUTCON1
RET
;
; Echo a backspace character. Erase the prevoius character
; on the screen.
;
BACKUP: CALL BACKUP1 ;backup the screen 1 place.
LD C,' ' ;then blank that character.
CALL CONOUT
BACKUP1:LD C,BS ;then back space once more.
JP CONOUT
;
; Signal a deleted line. Print a '#' at the end and start
; over.
;
NEWLINE:LD C,'#'
CALL OUTCHAR ;print this.
CALL OUTCRLF ;start new line.
NEWLN1: LD A,(CURPOS) ;move the cursor to the starting position.
LD HL,STARTING
CP (HL)
RET NC ;there yet?
LD C,' '
CALL OUTCHAR ;nope, keep going.
JP NEWLN1
;
; Output a (cr) (lf) to the console device (screen).
;
OUTCRLF:LD C,CR
CALL OUTCHAR
LD C,LF
JP OUTCHAR
;
; Print message pointed to by (BC). It will end with a '$'.
;
PRTMESG:LD A,(BC) ;check for terminating character.
CP '$'
RET Z
INC BC
PUSH BC ;otherwise, bump pointer and print it.
LD C,A
CALL OUTCON
POP BC
JP PRTMESG
;
; Function to execute a buffered read.
;
RDBUFF: LD A,(CURPOS) ;use present location as starting one.
LD (STARTING),A
LD HL,(PARAMS) ;get the maximum buffer space.
LD C,(HL)
INC HL ;point to first available space.
PUSH HL ;and save.
LD B,0 ;keep a character count.
RDBUF1: PUSH BC
PUSH HL
RDBUF2: CALL GETCHAR ;get the next input character.
AND 7FH ;strip bit 7.
POP HL ;reset registers.
POP BC
CP CR ;en of the line?
JP Z,RDBUF17
CP LF
JP Z,RDBUF17
CP BS ;how about a backspace?
JP NZ,RDBUF3
LD A,B ;yes, but ignore at the beginning of the line.
OR A
JP Z,RDBUF1
DEC B ;ok, update counter.
LD A,(CURPOS) ;if we backspace to the start of the line,
LD (OUTFLAG),A ;treat as a cancel (control-x).
JP RDBUF10
RDBUF3: CP DEL ;user typed a rubout?
JP NZ,RDBUF4
LD A,B ;ignore at the start of the line.
OR A
JP Z,RDBUF1
LD A,(HL) ;ok, echo the prevoius character.
DEC B ;and reset pointers (counters).
DEC HL
JP RDBUF15
RDBUF4: CP CNTRLE ;physical end of line?
JP NZ,RDBUF5
PUSH BC ;yes, do it.
PUSH HL
CALL OUTCRLF
XOR A ;and update starting position.
LD (STARTING),A
JP RDBUF2
RDBUF5: CP CNTRLP ;control-p?
JP NZ,RDBUF6
PUSH HL ;yes, flip the print flag filp-flop byte.
LD HL,PRTFLAG
LD A,1 ;PRTFLAG=1-PRTFLAG
SUB (HL)
LD (HL),A
POP HL
JP RDBUF1
RDBUF6: CP CNTRLX ;control-x (cancel)?
JP NZ,RDBUF8
POP HL
RDBUF7: LD A,(STARTING) ;yes, backup the cursor to here.
LD HL,CURPOS
CP (HL)
JP NC,RDBUFF ;done yet?
DEC (HL) ;no, decrement pointer and output back up one space.
CALL BACKUP
JP RDBUF7
RDBUF8: CP CNTRLU ;cntrol-u (cancel line)?
JP NZ,RDBUF9
CALL NEWLINE ;start a new line.
POP HL
JP RDBUFF
RDBUF9: CP CNTRLR ;control-r?
JP NZ,RDBUF14
RDBUF10:PUSH BC ;yes, start a new line and retype the old one.
CALL NEWLINE
POP BC
POP HL
PUSH HL
PUSH BC
RDBUF11:LD A,B ;done whole line yet?
OR A
JP Z,RDBUF12
INC HL ;nope, get next character.
LD C,(HL)
DEC B ;count it.
PUSH BC
PUSH HL
CALL SHOWIT ;and display it.
POP HL
POP BC
JP RDBUF11
RDBUF12:PUSH HL ;done with line. If we were displaying
LD A,(OUTFLAG) ;then update cursor position.
OR A
JP Z,RDBUF2
LD HL,CURPOS ;because this line is shorter, we must
SUB (HL) ;back up the cursor (not the screen however)
LD (OUTFLAG),A ;some number of positions.
RDBUF13:CALL BACKUP ;note that as long as (OUTFLAG) is non
LD HL,OUTFLAG ;zero, the screen will not be changed.
DEC (HL)
JP NZ,RDBUF13
JP RDBUF2 ;now just get the next character.
;
; Just a normal character, put this in our buffer and echo.
;
RDBUF14:INC HL
LD (HL),A ;store character.
INC B ;and count it.
RDBUF15:PUSH BC
PUSH HL
LD C,A ;echo it now.
CALL SHOWIT
POP HL
POP BC
LD A,(HL) ;was it an abort request?
CP CNTRLC ;control-c abort?
LD A,B
JP NZ,RDBUF16
CP 1 ;only if at start of line.
JP Z,0
RDBUF16:CP C ;nope, have we filled the buffer?
JP C,RDBUF1
RDBUF17:POP HL ;yes end the line and return.
LD (HL),B
LD C,CR
JP OUTCHAR ;output (cr) and return.
;
; Function to get a character from the console device.
;
GETCON: CALL GETECHO ;get and echo.
JP SETSTAT ;save status and return.
;
; Function to get a character from the tape reader device.
;
GETRDR: CALL READER ;get a character from reader, set status and return.
JP SETSTAT
;
; Function to perform direct console i/o. If (C) contains (FF)
; then this is an input request. If (C) contains (FE) then
; this is a status request. Otherwise we are to output (C).
;
DIRCIO: LD A,C ;test for (FF).
INC A
JP Z,DIRC1
INC A ;test for (FE).
JP Z,CONST
JP CONOUT ;just output (C).
DIRC1: CALL CONST ;this is an input request.
OR A
JP Z,GOBACK1 ;not ready? Just return (directly).
CALL CONIN ;yes, get character.
JP SETSTAT ;set status and return.
;
; Function to return the i/o byte.
;
GETIOB: LD A,(IOBYTE)
JP SETSTAT
;
; Function to set the i/o byte.
;
SETIOB: LD HL,IOBYTE
LD (HL),C
RET
;
; Function to print the character string pointed to by (DE)
; on the console device. The string ends with a '$'.
;
PRTSTR: EX DE,HL
LD C,L
LD B,H ;now (BC) points to it.
JP PRTMESG
;
; Function to interigate the console device.
;
GETCSTS:CALL CKCONSOL
;
; Get here to set the status and return to the cleanup
; section. Then back to the user.
;
SETSTAT:LD (STATUS),A
RTN: RET
;
; Set the status to 1 (read or write error code).
;
IOERR1: LD A,1
JP SETSTAT
;
OUTFLAG:DB 0 ;output flag (non zero means no output).
STARTING: DB 2 ;starting position for cursor.
CURPOS: DB 0 ;cursor position (0=start of line).
PRTFLAG:DB 0 ;printer flag (control-p toggle). List if non zero.
CHARBUF:DB 0 ;single input character buffer.
;
; Stack area for BDOS calls.
;
USRSTACK: DW 0 ;save users stack pointer here.
;
DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
STKAREA EQU $ ;end of stack area.
;
USERNO: DB 0 ;current user number.
ACTIVE: DB 0 ;currently active drive.
PARAMS: DW 0 ;save (DE) parameters here on entry.
STATUS: DW 0 ;status returned from bdos function.
;
; Select error occured, jump to error routine.
;
SLCTERR:LD HL,BADSLCT
;
; Jump to (HL) indirectly.
;
JUMPHL: LD E,(HL)
INC HL
LD D,(HL) ;now (DE) contain the desired address.
EX DE,HL
JP (HL)
;
; Block move. (DE) to (HL), (C) bytes total.
;
DE2HL: INC C ;is count down to zero?
DE2HL1: DEC C
RET Z ;yes, we are done.
LD A,(DE) ;no, move one more byte.
LD (HL),A
INC DE
INC HL
JP DE2HL1 ;and repeat.
;
; Select the desired drive.
;
SELECT: LD A,(ACTIVE) ;get active disk.
LD C,A
CALL SELDSK ;select it.
LD A,H ;valid drive?
OR L ;valid drive?
RET Z ;return if not.
;
; Here, the BIOS returned the address of the parameter block
; in (HL). We will extract the necessary pointers and save them.
;
LD E,(HL) ;yes, get address of translation table into (DE).
INC HL
LD D,(HL)
INC HL
LD (SCRATCH1),HL ;save pointers to scratch areas.
INC HL
INC HL
LD (SCRATCH2),HL ;ditto.
INC HL
INC HL
LD (SCRATCH3),HL ;ditto.
INC HL
INC HL
EX DE,HL ;now save the translation table address.
LD (XLATE),HL
LD HL,DIRBUF ;put the next 8 bytes here.
LD C,8 ;they consist of the directory buffer
CALL DE2HL ;pointer, parameter block pointer,
LD HL,(DISKPB) ;check and allocation vectors.
EX DE,HL
LD HL,SECTORS ;move parameter block into our ram.
LD C,15 ;it is 15 bytes long.
CALL DE2HL
LD HL,(DSKSIZE) ;check disk size.
LD A,H ;more than 256 blocks on this?
LD HL,BIGDISK
LD (HL),0FFH ;set to samll.
OR A
JP Z,SELECT1
LD (HL),0 ;wrong, set to large.
SELECT1:LD A,0FFH ;clear the zero flag.
OR A
RET
;
; Routine to home the disk track head and clear pointers.
;
HOMEDRV:CALL HOME ;home the head.
XOR A
LD HL,(SCRATCH2) ;set our track pointer also.
LD (HL),A
INC HL
LD (HL),A
LD HL,(SCRATCH3) ;and our sector pointer.
LD (HL),A
INC HL
LD (HL),A
RET
;
; Do the actual disk read and check the error return status.
;
DOREAD: CALL READ
JP IORET
;
; Do the actual disk write and handle any bios error.
;
DOWRITE:CALL WRITE
IORET: OR A
RET Z ;return unless an error occured.
LD HL,BADSCTR ;bad read/write on this sector.
JP JUMPHL
;
; Routine to select the track and sector that the desired
; block number falls in.
;
TRKSEC: LD HL,(FILEPOS) ;get position of last accessed file
LD C,2 ;in directory and compute sector #.
CALL SHIFTR ;sector #=file-position/4.
LD (BLKNMBR),HL ;save this as the block number of interest.
LD (CKSUMTBL),HL ;what's it doing here too?
;
; if the sector number has already been set (BLKNMBR), enter
; at this point.
;
TRKSEC1:LD HL,BLKNMBR
LD C,(HL) ;move sector number into (BC).
INC HL
LD B,(HL)
LD HL,(SCRATCH3) ;get current sector number and
LD E,(HL) ;move this into (DE).
INC HL
LD D,(HL)
LD HL,(SCRATCH2) ;get current track number.
LD A,(HL) ;and this into (HL).
INC HL
LD H,(HL)
LD L,A
TRKSEC2:LD A,C ;is desired sector before current one?
SUB E
LD A,B
SBC A,D
JP NC,TRKSEC3
PUSH HL ;yes, decrement sectors by one track.
LD HL,(SECTORS) ;get sectors per track.
LD A,E
SUB L
LD E,A
LD A,D
SBC A,H
LD D,A ;now we have backed up one full track.
POP HL
DEC HL ;adjust track counter.
JP TRKSEC2
TRKSEC3:PUSH HL ;desired sector is after current one.
LD HL,(SECTORS) ;get sectors per track.
ADD HL,DE ;bump sector pointer to next track.
JP C,TRKSEC4
LD A,C ;is desired sector now before current one?
SUB L
LD A,B
SBC A,H
JP C,TRKSEC4
EX DE,HL ;not yes, increment track counter
POP HL ;and continue until it is.
INC HL
JP TRKSEC3
;
; here we have determined the track number that contains the
; desired sector.
;
TRKSEC4:POP HL ;get track number (HL).
PUSH BC
PUSH DE
PUSH HL
EX DE,HL
LD HL,(OFFSET) ;adjust for first track offset.
ADD HL,DE
LD B,H
LD C,L
CALL SETTRK ;select this track.
POP DE ;reset current track pointer.
LD HL,(SCRATCH2)
LD (HL),E
INC HL
LD (HL),D
POP DE
LD HL,(SCRATCH3) ;reset the first sector on this track.
LD (HL),E
INC HL
LD (HL),D
POP BC
LD A,C ;now subtract the desired one.
SUB E ;to make it relative (1-# sectors/track).
LD C,A
LD A,B
SBC A,D
LD B,A
LD HL,(XLATE) ;translate this sector according to this table.
EX DE,HL
CALL SECTRN ;let the bios translate it.
LD C,L
LD B,H
JP SETSEC ;and select it.
;
; Compute block number from record number (SAVNREC) and
; extent number (SAVEXT).
;
GETBLOCK: LD HL,BLKSHFT ;get logical to physical conversion.
LD C,(HL) ;note that this is base 2 log of ratio.
LD A,(SAVNREC) ;get record number.
GETBLK1:OR A ;compute (A)=(A)/2^BLKSHFT.
RRA
DEC C
JP NZ,GETBLK1
LD B,A ;save result in (B).
LD A,8
SUB (HL)
LD C,A ;compute (C)=8-BLKSHFT.
LD A,(SAVEXT)
GETBLK2:DEC C ;compute (A)=SAVEXT*2^(8-BLKSHFT).
JP Z,GETBLK3
OR A
RLA
JP GETBLK2
GETBLK3:ADD A,B
RET
;
; Routine to extract the (BC) block byte from the fcb pointed
; to by (PARAMS). If this is a big-disk, then these are 16 bit
; block numbers, else they are 8 bit numbers.
; Number is returned in (HL).
;
EXTBLK: LD HL,(PARAMS) ;get fcb address.
LD DE,16 ;block numbers start 16 bytes into fcb.
ADD HL,DE
ADD HL,BC
LD A,(BIGDISK) ;are we using a big-disk?
OR A
JP Z,EXTBLK1
LD L,(HL) ;no, extract an 8 bit number from the fcb.
LD H,0
RET
EXTBLK1:ADD HL,BC ;yes, extract a 16 bit number.
LD E,(HL)
INC HL
LD D,(HL)
EX DE,HL ;return in (HL).
RET
;
; Compute block number.
;
COMBLK: CALL GETBLOCK
LD C,A
LD B,0
CALL EXTBLK
LD (BLKNMBR),HL
RET
;
; Check for a zero block number (unused).
;
CHKBLK: LD HL,(BLKNMBR)
LD A,L ;is it zero?
OR H
RET
;
; Adjust physical block (BLKNMBR) and convert to logical
; sector (LOGSECT). This is the starting sector of this block.
; The actual sector of interest is then added to this and the
; resulting sector number is stored back in (BLKNMBR). This
; will still have to be adjusted for the track number.
;
LOGICAL:LD A,(BLKSHFT) ;get log2(physical/logical sectors).
LD HL,(BLKNMBR) ;get physical sector desired.
LOGICL1:ADD HL,HL ;compute logical sector number.
DEC A ;note logical sectors are 128 bytes long.
JP NZ,LOGICL1
LD (LOGSECT),HL ;save logical sector.
LD A,(BLKMASK) ;get block mask.
LD C,A
LD A,(SAVNREC) ;get next sector to access.
AND C ;extract the relative position within physical block.
OR L ;and add it too logical sector.
LD L,A
LD (BLKNMBR),HL ;and store.
RET
;
; Set (HL) to point to extent byte in fcb.
;
SETEXT: LD HL,(PARAMS)
LD DE,12 ;it is the twelth byte.
ADD HL,DE
RET
;
; Set (HL) to point to record count byte in fcb and (DE) to
; next record number byte.
;
SETHLDE:LD HL,(PARAMS)
LD DE,15 ;record count byte (#15).
ADD HL,DE
EX DE,HL
LD HL,17 ;next record number (#32).
ADD HL,DE
RET
;
; Save current file data from fcb.
;
STRDATA:CALL SETHLDE
LD A,(HL) ;get and store record count byte.
LD (SAVNREC),A
EX DE,HL
LD A,(HL) ;get and store next record number byte.
LD (SAVNXT),A
CALL SETEXT ;point to extent byte.
LD A,(EXTMASK) ;get extent mask.
AND (HL)
LD (SAVEXT),A ;and save extent here.
RET
;
; Set the next record to access. If (MODE) is set to 2, then
; the last record byte (SAVNREC) has the correct number to access.
; For sequential access, (MODE) will be equal to 1.
;
SETNREC:CALL SETHLDE
LD A,(MODE) ;get sequential flag (=1).
CP 2 ;a 2 indicates that no adder is needed.
JP NZ,STNREC1
XOR A ;clear adder (random access?).
STNREC1:LD C,A
LD A,(SAVNREC) ;get last record number.
ADD A,C ;increment record count.
LD (HL),A ;and set fcb's next record byte.
EX DE,HL
LD A,(SAVNXT) ;get next record byte from storage.
LD (HL),A ;and put this into fcb as number of records used.
RET
;
; Shift (HL) right (C) bits.
;
SHIFTR: INC C
SHIFTR1:DEC C
RET Z
LD A,H
OR A
RRA
LD H,A
LD A,L
RRA
LD L,A
JP SHIFTR1
;
; Compute the check-sum for the directory buffer. Return
; integer sum in (A).
;
CHECKSUM: LD C,128 ;length of buffer.
LD HL,(DIRBUF) ;get its location.
XOR A ;clear summation byte.
CHKSUM1:ADD A,(HL) ;and compute sum ignoring carries.
INC HL
DEC C
JP NZ,CHKSUM1
RET
;
; Shift (HL) left (C) bits.
;
SHIFTL: INC C
SHIFTL1:DEC C
RET Z
ADD HL,HL ;shift left 1 bit.
JP SHIFTL1
;
; Routine to set a bit in a 16 bit value contained in (BC).
; The bit set depends on the current drive selection.
;
SETBIT: PUSH BC ;save 16 bit word.
LD A,(ACTIVE) ;get active drive.
LD C,A
LD HL,1
CALL SHIFTL ;shift bit 0 into place.
POP BC ;now 'or' this with the original word.
LD A,C
OR L
LD L,A ;low byte done, do high byte.
LD A,B
OR H
LD H,A
RET
;
; Extract the write protect status bit for the current drive.
; The result is returned in (A), bit 0.
;
GETWPRT:LD HL,(WRTPRT) ;get status bytes.
LD A,(ACTIVE) ;which drive is current?
LD C,A
CALL SHIFTR ;shift status such that bit 0 is the
LD A,L ;one of interest for this drive.
AND 01H ;and isolate it.
RET
;
; Function to write protect the current disk.
;
WRTPRTD:LD HL,WRTPRT ;point to status word.
LD C,(HL) ;set (BC) equal to the status.
INC HL
LD B,(HL)
CALL SETBIT ;and set this bit according to current drive.
LD (WRTPRT),HL ;then save.
LD HL,(DIRSIZE) ;now save directory size limit.
INC HL ;remember the last one.
EX DE,HL
LD HL,(SCRATCH1) ;and store it here.
LD (HL),E ;put low byte.
INC HL
LD (HL),D ;then high byte.
RET
;
; Check for a read only file.
;
CHKROFL:CALL FCB2HL ;set (HL) to file entry in directory buffer.
CKROF1: LD DE,9 ;look at bit 7 of the ninth byte.
ADD HL,DE
LD A,(HL)
RLA
RET NC ;return if ok.
LD HL,ROFILE ;else, print error message and terminate.
JP JUMPHL
;
; Check the write protect status of the active disk.
;
CHKWPRT:CALL GETWPRT
RET Z ;return if ok.
LD HL,RODISK ;else print message and terminate.
JP JUMPHL
;
; Routine to set (HL) pointing to the proper entry in the
; directory buffer.
;
FCB2HL: LD HL,(DIRBUF) ;get address of buffer.
LD A,(FCBPOS) ;relative position of file.
;
; Routine to add (A) to (HL).
;
ADDA2HL:ADD A,L
LD L,A
RET NC
INC H ;take care of any carry.
RET
;
; Routine to get the 's2' byte from the fcb supplied in
; the initial parameter specification.
;
GETS2: LD HL,(PARAMS) ;get address of fcb.
LD DE,14 ;relative position of 's2'.
ADD HL,DE
LD A,(HL) ;extract this byte.
RET
;
; Clear the 's2' byte in the fcb.
;
CLEARS2:CALL GETS2 ;this sets (HL) pointing to it.
LD (HL),0 ;now clear it.
RET
;
; Set bit 7 in the 's2' byte of the fcb.
;
SETS2B7:CALL GETS2 ;get the byte.
OR 80H ;and set bit 7.
LD (HL),A ;then store.
RET
;
; Compare (FILEPOS) with (SCRATCH1) and set flags based on
; the difference. This checks to see if there are more file
; names in the directory. We are at (FILEPOS) and there are
; (SCRATCH1) of them to check.
;
MOREFLS:LD HL,(FILEPOS) ;we are here.
EX DE,HL
LD HL,(SCRATCH1) ;and don't go past here.
LD A,E ;compute difference but don't keep.
SUB (HL)
INC HL
LD A,D
SBC A,(HL) ;set carry if no more names.
RET
;
; Call this routine to prevent (SCRATCH1) from being greater
; than (FILEPOS).
;
CHKNMBR:CALL MOREFLS ;SCRATCH1 too big?
RET C
INC DE ;yes, reset it to (FILEPOS).
LD (HL),D
DEC HL
LD (HL),E
RET
;
; Compute (HL)=(DE)-(HL)
;
SUBHL: LD A,E ;compute difference.
SUB L
LD L,A ;store low byte.
LD A,D
SBC A,H
LD H,A ;and then high byte.
RET
;
; Set the directory checksum byte.
;
SETDIR: LD C,0FFH
;
; Routine to set or compare the directory checksum byte. If
; (C)=0ffh, then this will set the checksum byte. Else the byte
; will be checked. If the check fails (the disk has been changed),
; then this disk will be write protected.
;
CHECKDIR: LD HL,(CKSUMTBL)
EX DE,HL
LD HL,(ALLOC1)
CALL SUBHL
RET NC ;ok if (CKSUMTBL) > (ALLOC1), so return.
PUSH BC
CALL CHECKSUM ;else compute checksum.
LD HL,(CHKVECT) ;get address of checksum table.
EX DE,HL
LD HL,(CKSUMTBL)
ADD HL,DE ;set (HL) to point to byte for this drive.
POP BC
INC C ;set or check ?
JP Z,CHKDIR1
CP (HL) ;check them.
RET Z ;return if they are the same.
CALL MOREFLS ;not the same, do we care?
RET NC
CALL WRTPRTD ;yes, mark this as write protected.
RET
CHKDIR1:LD (HL),A ;just set the byte.
RET
;
; Do a write to the directory of the current disk.
;
DIRWRITE: CALL SETDIR ;set checksum byte.
CALL DIRDMA ;set directory dma address.
LD C,1 ;tell the bios to actually write.
CALL DOWRITE ;then do the write.
JP DEFDMA
;
; Read from the directory.
;
DIRREAD:CALL DIRDMA ;set the directory dma address.
CALL DOREAD ;and read it.
;
; Routine to set the dma address to the users choice.
;
DEFDMA: LD HL,USERDMA ;reset the default dma address and return.
JP DIRDMA1
;
; Routine to set the dma address for directory work.
;
DIRDMA: LD HL,DIRBUF
;
; Set the dma address. On entry, (HL) points to
; word containing the desired dma address.
;
DIRDMA1:LD C,(HL)
INC HL
LD B,(HL) ;setup (BC) and go to the bios to set it.
JP SETDMA
;
; Move the directory buffer into user's dma space.
;
MOVEDIR:LD HL,(DIRBUF) ;buffer is located here, and
EX DE,HL
LD HL,(USERDMA) ; put it here.
LD C,128 ;this is its length.
JP DE2HL ;move it now and return.
;
; Check (FILEPOS) and set the zero flag if it equals 0ffffh.
;
CKFILPOS: LD HL,FILEPOS
LD A,(HL)
INC HL
CP (HL) ;are both bytes the same?
RET NZ
INC A ;yes, but are they each 0ffh?
RET
;
; Set location (FILEPOS) to 0ffffh.
;
STFILPOS: LD HL,0FFFFH
LD (FILEPOS),HL
RET
;
; Move on to the next file position within the current
; directory buffer. If no more exist, set pointer to 0ffffh
; and the calling routine will check for this. Enter with (C)
; equal to 0ffh to cause the checksum byte to be set, else we
; will check this disk and set write protect if checksums are
; not the same (applies only if another directory sector must
; be read).
;
NXENTRY:LD HL,(DIRSIZE) ;get directory entry size limit.
EX DE,HL
LD HL,(FILEPOS) ;get current count.
INC HL ;go on to the next one.
LD (FILEPOS),HL
CALL SUBHL ;(HL)=(DIRSIZE)-(FILEPOS)
JP NC,NXENT1 ;is there more room left?
JP STFILPOS ;no. Set this flag and return.
NXENT1: LD A,(FILEPOS) ;get file position within directory.
AND 03H ;only look within this sector (only 4 entries fit).
LD B,5 ;convert to relative position (32 bytes each).
NXENT2: ADD A,A ;note that this is not efficient code.
DEC B ;5 'ADD A's would be better.
JP NZ,NXENT2
LD (FCBPOS),A ;save it as position of fcb.
OR A
RET NZ ;return if we are within buffer.
PUSH BC
CALL TRKSEC ;we need the next directory sector.
CALL DIRREAD
POP BC
JP CHECKDIR
;
; Routine to to get a bit from the disk space allocation
; map. It is returned in (A), bit position 0. On entry to here,
; set (BC) to the block number on the disk to check.
; On return, (D) will contain the original bit position for
; this block number and (HL) will point to the address for it.
;
CKBITMAP: LD A,C ;determine bit number of interest.
AND 07H ;compute (D)=(E)=(C and 7)+1.
INC A
LD E,A ;save particular bit number.
LD D,A
;
; compute (BC)=(BC)/8.
;
LD A,C
RRCA ;now shift right 3 bits.
RRCA
RRCA
AND 1FH ;and clear bits 7,6,5.
LD C,A
LD A,B
ADD A,A ;now shift (B) into bits 7,6,5.
ADD A,A
ADD A,A
ADD A,A
ADD A,A
OR C ;and add in (C).
LD C,A ;ok, (C) ha been completed.
LD A,B ;is there a better way of doing this?
RRCA
RRCA
RRCA
AND 1FH
LD B,A ;and now (B) is completed.
;
; use this as an offset into the disk space allocation
; table.
;
LD HL,(ALOCVECT)
ADD HL,BC
LD A,(HL) ;now get correct byte.
CKBMAP1:RLCA ;get correct bit into position 0.
DEC E
JP NZ,CKBMAP1
RET
;
; Set or clear the bit map such that block number (BC) will be marked
; as used. On entry, if (E)=0 then this bit will be cleared, if it equals
; 1 then it will be set (don't use anyother values).
;
STBITMAP: PUSH DE
CALL CKBITMAP ;get the byte of interest.
AND 0FEH ;clear the affected bit.
POP BC
OR C ;and now set it acording to (C).
;
; entry to restore the original bit position and then store
; in table. (A) contains the value, (D) contains the bit
; position (1-8), and (HL) points to the address within the
; space allocation table for this byte.
;
STBMAP1:RRCA ;restore original bit position.
DEC D
JP NZ,STBMAP1
LD (HL),A ;and stor byte in table.
RET
;
; Set/clear space used bits in allocation map for this file.
; On entry, (C)=1 to set the map and (C)=0 to clear it.
;
SETFILE:CALL FCB2HL ;get address of fcb
LD DE,16
ADD HL,DE ;get to block number bytes.
PUSH BC
LD C,17 ;check all 17 bytes (max) of table.
SETFL1: POP DE
DEC C ;done all bytes yet?
RET Z
PUSH DE
LD A,(BIGDISK) ;check disk size for 16 bit block numbers.
OR A
JP Z,SETFL2
PUSH BC ;only 8 bit numbers. set (BC) to this one.
PUSH HL
LD C,(HL) ;get low byte from table, always
LD B,0 ;set high byte to zero.
JP SETFL3
SETFL2: DEC C ;for 16 bit block numbers, adjust counter.
PUSH BC
LD C,(HL) ;now get both the low and high bytes.
INC HL
LD B,(HL)
PUSH HL
SETFL3: LD A,C ;block used?
OR B
JP Z,SETFL4
LD HL,(DSKSIZE) ;is this block number within the
LD A,L ;space on the disk?
SUB C
LD A,H
SBC A,B
CALL NC,STBITMAP ;yes, set the proper bit.
SETFL4: POP HL ;point to next block number in fcb.
INC HL
POP BC
JP SETFL1
;
; Construct the space used allocation bit map for the active
; drive. If a file name starts with '$' and it is under the
; current user number, then (STATUS) is set to minus 1. Otherwise
; it is not set at all.
;
BITMAP: LD HL,(DSKSIZE) ;compute size of allocation table.
LD C,3
CALL SHIFTR ;(HL)=(HL)/8.
INC HL ;at lease 1 byte.
LD B,H
LD C,L ;set (BC) to the allocation table length.
;
; Initialize the bitmap for this drive. Right now, the first
; two bytes are specified by the disk parameter block. However
; a patch could be entered here if it were necessary to setup
; this table in a special mannor. For example, the bios could
; determine locations of 'bad blocks' and set them as already
; 'used' in the map.
;
LD HL,(ALOCVECT) ;now zero out the table now.
BITMAP1:LD (HL),0
INC HL
DEC BC
LD A,B
OR C
JP NZ,BITMAP1
LD HL,(ALLOC0) ;get initial space used by directory.
EX DE,HL
LD HL,(ALOCVECT) ;and put this into map.
LD (HL),E
INC HL
LD (HL),D
;
; End of initialization portion.
;
CALL HOMEDRV ;now home the drive.
LD HL,(SCRATCH1)
LD (HL),3 ;force next directory request to read
INC HL ;in a sector.
LD (HL),0
CALL STFILPOS ;clear initial file position also.
BITMAP2:LD C,0FFH ;read next file name in directory
CALL NXENTRY ;and set checksum byte.
CALL CKFILPOS ;is there another file?
RET Z
CALL FCB2HL ;yes, get its address.
LD A,0E5H
CP (HL) ;empty file entry?
JP Z,BITMAP2
LD A,(USERNO) ;no, correct user number?
CP (HL)
JP NZ,BITMAP3
INC HL
LD A,(HL) ;yes, does name start with a '$'?
SUB '$'
JP NZ,BITMAP3
DEC A ;yes, set atatus to minus one.
LD (STATUS),A
BITMAP3:LD C,1 ;now set this file's space as used in bit map.
CALL SETFILE
CALL CHKNMBR ;keep (SCRATCH1) in bounds.
JP BITMAP2
;
; Set the status (STATUS) and return.
;
STSTATUS: LD A,(FNDSTAT)
JP SETSTAT
;
; Check extents in (A) and (C). Set the zero flag if they
; are the same. The number of 16k chunks of disk space that
; the directory extent covers is expressad is (EXTMASK+1).
; No registers are modified.
;
SAMEXT: PUSH BC
PUSH AF
LD A,(EXTMASK) ;get extent mask and use it to
CPL ;to compare both extent numbers.
LD B,A ;save resulting mask here.
LD A,C ;mask first extent and save in (C).
AND B
LD C,A
POP AF ;now mask second extent and compare
AND B ;with the first one.
SUB C
AND 1FH ;(* only check buts 0-4 *)
POP BC ;the zero flag is set if they are the same.
RET ;restore (BC) and return.
;
; Search for the first occurence of a file name. On entry,
; register (C) should contain the number of bytes of the fcb
; that must match.
;
FINDFST:LD A,0FFH
LD (FNDSTAT),A
LD HL,COUNTER ;save character count.
LD (HL),C
LD HL,(PARAMS) ;get filename to match.
LD (SAVEFCB),HL ;and save.
CALL STFILPOS ;clear initial file position (set to 0ffffh).
CALL HOMEDRV ;home the drive.
;
; Entry to locate the next occurence of a filename within the
; directory. The disk is not expected to have been changed. If
; it was, then it will be write protected.
;
FINDNXT:LD C,0 ;write protect the disk if changed.
CALL NXENTRY ;get next filename entry in directory.
CALL CKFILPOS ;is file position = 0ffffh?
JP Z,FNDNXT6 ;yes, exit now then.
LD HL,(SAVEFCB) ;set (DE) pointing to filename to match.
EX DE,HL
LD A,(DE)
CP 0E5H ;empty directory entry?
JP Z,FNDNXT1 ;(* are we trying to reserect erased entries? *)
PUSH DE
CALL MOREFLS ;more files in directory?
POP DE
JP NC,FNDNXT6 ;no more. Exit now.
FNDNXT1:CALL FCB2HL ;get address of this fcb in directory.
LD A,(COUNTER) ;get number of bytes (characters) to check.
LD C,A
LD B,0 ;initialize byte position counter.
FNDNXT2:LD A,C ;are we done with the compare?
OR A
JP Z,FNDNXT5
LD A,(DE) ;no, check next byte.
CP '?' ;don't care about this character?
JP Z,FNDNXT4
LD A,B ;get bytes position in fcb.
CP 13 ;don't care about the thirteenth byte either.
JP Z,FNDNXT4
CP 12 ;extent byte?
LD A,(DE)
JP Z,FNDNXT3
SUB (HL) ;otherwise compare characters.
AND 7FH
JP NZ,FINDNXT ;not the same, check next entry.
JP FNDNXT4 ;so far so good, keep checking.
FNDNXT3:PUSH BC ;check the extent byte here.
LD C,(HL)
CALL SAMEXT
POP BC
JP NZ,FINDNXT ;not the same, look some more.
;
; So far the names compare. Bump pointers to the next byte
; and continue until all (C) characters have been checked.
;
FNDNXT4:INC DE ;bump pointers.
INC HL
INC B
DEC C ;adjust character counter.
JP FNDNXT2
FNDNXT5:LD A,(FILEPOS) ;return the position of this entry.
AND 03H
LD (STATUS),A
LD HL,FNDSTAT
LD A,(HL)
RLA
RET NC
XOR A
LD (HL),A
RET
;
; Filename was not found. Set appropriate status.
;
FNDNXT6:CALL STFILPOS ;set (FILEPOS) to 0ffffh.
LD A,0FFH ;say not located.
JP SETSTAT
;
; Erase files from the directory. Only the first byte of the
; fcb will be affected. It is set to (E5).
;
ERAFILE:CALL CHKWPRT ;is disk write protected?
LD C,12 ;only compare file names.
CALL FINDFST ;get first file name.
ERAFIL1:CALL CKFILPOS ;any found?
RET Z ;nope, we must be done.
CALL CHKROFL ;is file read only?
CALL FCB2HL ;nope, get address of fcb and
LD (HL),0E5H ;set first byte to 'empty'.
LD C,0 ;clear the space from the bit map.
CALL SETFILE
CALL DIRWRITE ;now write the directory sector back out.
CALL FINDNXT ;find the next file name.
JP ERAFIL1 ;and repeat process.
;
; Look through the space allocation map (bit map) for the
; next available block. Start searching at block number (BC-1).
; The search procedure is to look for an empty block that is
; before the starting block. If not empty, look at a later
; block number. In this way, we return the closest empty block
; on either side of the 'target' block number. This will speed
; access on random devices. For serial devices, this should be
; changed to look in the forward direction first and then start
; at the front and search some more.
;
; On return, (DE)= block number that is empty and (HL) =0
; if no empry block was found.
;
FNDSPACE: LD D,B ;set (DE) as the block that is checked.
LD E,C
;
; Look before target block. Registers (BC) are used as the lower
; pointer and (DE) as the upper pointer.
;
FNDSPA1:LD A,C ;is block 0 specified?
OR B
JP Z,FNDSPA2
DEC BC ;nope, check previous block.
PUSH DE
PUSH BC
CALL CKBITMAP
RRA ;is this block empty?
JP NC,FNDSPA3 ;yes. use this.
;
; Note that the above logic gets the first block that it finds
; that is empty. Thus a file could be written 'backward' making
; it very slow to access. This could be changed to look for the
; first empty block and then continue until the start of this
; empty space is located and then used that starting block.
; This should help speed up access to some files especially on
; a well used disk with lots of fairly small 'holes'.
;
POP BC ;nope, check some more.
POP DE
;
; Now look after target block.
;
FNDSPA2:LD HL,(DSKSIZE) ;is block (DE) within disk limits?
LD A,E
SUB L
LD A,D
SBC A,H
JP NC,FNDSPA4
INC DE ;yes, move on to next one.
PUSH BC
PUSH DE
LD B,D
LD C,E
CALL CKBITMAP ;check it.
RRA ;empty?
JP NC,FNDSPA3
POP DE ;nope, continue searching.
POP BC
JP FNDSPA1
;
; Empty block found. Set it as used and return with (HL)
; pointing to it (true?).
;
FNDSPA3:RLA ;reset byte.
INC A ;and set bit 0.
CALL STBMAP1 ;update bit map.
POP HL ;set return registers.
POP DE
RET
;
; Free block was not found. If (BC) is not zero, then we have
; not checked all of the disk space.
;
FNDSPA4:LD A,C
OR B
JP NZ,FNDSPA1
LD HL,0 ;set 'not found' status.
RET
;
; Move a complete fcb entry into the directory and write it.
;
FCBSET: LD C,0
LD E,32 ;length of each entry.
;
; Move (E) bytes from the fcb pointed to by (PARAMS) into
; fcb in directory starting at relative byte (C). This updated
; directory buffer is then written to the disk.
;
UPDATE: PUSH DE
LD B,0 ;set (BC) to relative byte position.
LD HL,(PARAMS) ;get address of fcb.
ADD HL,BC ;compute starting byte.
EX DE,HL
CALL FCB2HL ;get address of fcb to update in directory.
POP BC ;set (C) to number of bytes to change.
CALL DE2HL
UPDATE1:CALL TRKSEC ;determine the track and sector affected.
JP DIRWRITE ;then write this sector out.
;
; Routine to change the name of all files on the disk with a
; specified name. The fcb contains the current name as the
; first 12 characters and the new name 16 bytes into the fcb.
;
CHGNAMES: CALL CHKWPRT ;check for a write protected disk.
LD C,12 ;match first 12 bytes of fcb only.
CALL FINDFST ;get first name.
LD HL,(PARAMS) ;get address of fcb.
LD A,(HL) ;get user number.
LD DE,16 ;move over to desired name.
ADD HL,DE
LD (HL),A ;keep same user number.
CHGNAM1:CALL CKFILPOS ;any matching file found?
RET Z ;no, we must be done.
CALL CHKROFL ;check for read only file.
LD C,16 ;start 16 bytes into fcb.
LD E,12 ;and update the first 12 bytes of directory.
CALL UPDATE
CALL FINDNXT ;get te next file name.
JP CHGNAM1 ;and continue.
;
; Update a files attributes. The procedure is to search for
; every file with the same name as shown in fcb (ignoring bit 7)
; and then to update it (which includes bit 7). No other changes
; are made.
;
SAVEATTR: LD C,12 ;match first 12 bytes.
CALL FINDFST ;look for first filename.
SAVATR1:CALL CKFILPOS ;was one found?
RET Z ;nope, we must be done.
LD C,0 ;yes, update the first 12 bytes now.
LD E,12
CALL UPDATE ;update filename and write directory.
CALL FINDNXT ;and get the next file.
JP SAVATR1 ;then continue until done.
;
; Open a file (name specified in fcb).
;
OPENIT: LD C,15 ;compare the first 15 bytes.
CALL FINDFST ;get the first one in directory.
CALL CKFILPOS ;any at all?
RET Z
OPENIT1:CALL SETEXT ;point to extent byte within users fcb.
LD A,(HL) ;and get it.
PUSH AF ;save it and address.
PUSH HL
CALL FCB2HL ;point to fcb in directory.
EX DE,HL
LD HL,(PARAMS) ;this is the users copy.
LD C,32 ;move it into users space.
PUSH DE
CALL DE2HL
CALL SETS2B7 ;set bit 7 in 's2' byte (unmodified).
POP DE ;now get the extent byte from this fcb.
LD HL,12
ADD HL,DE
LD C,(HL) ;into (C).
LD HL,15 ;now get the record count byte into (B).
ADD HL,DE
LD B,(HL)
POP HL ;keep the same extent as the user had originally.
POP AF
LD (HL),A
LD A,C ;is it the same as in the directory fcb?
CP (HL)
LD A,B ;if yes, then use the same record count.
JP Z,OPENIT2
LD A,0 ;if the user specified an extent greater than
JP C,OPENIT2 ;the one in the directory, then set record count to 0.
LD A,128 ;otherwise set to maximum.
OPENIT2:LD HL,(PARAMS) ;set record count in users fcb to (A).
LD DE,15
ADD HL,DE ;compute relative position.
LD (HL),A ;and set the record count.
RET
;
; Move two bytes from (DE) to (HL) if (and only if) (HL)
; point to a zero value (16 bit).
; Return with zero flag set it (DE) was moved. Registers (DE)
; and (HL) are not changed. However (A) is.
;
MOVEWORD: LD A,(HL) ;check for a zero word.
INC HL
OR (HL) ;both bytes zero?
DEC HL
RET NZ ;nope, just return.
LD A,(DE) ;yes, move two bytes from (DE) into
LD (HL),A ;this zero space.
INC DE
INC HL
LD A,(DE)
LD (HL),A
DEC DE ;don't disturb these registers.
DEC HL
RET
;
; Get here to close a file specified by (fcb).
;
CLOSEIT:XOR A ;clear status and file position bytes.
LD (STATUS),A
LD (FILEPOS),A
LD (FILEPOS+1),A
CALL GETWPRT ;get write protect bit for this drive.
RET NZ ;just return if it is set.
CALL GETS2 ;else get the 's2' byte.
AND 80H ;and look at bit 7 (file unmodified?).
RET NZ ;just return if set.
LD C,15 ;else look up this file in directory.
CALL FINDFST
CALL CKFILPOS ;was it found?
RET Z ;just return if not.
LD BC,16 ;set (HL) pointing to records used section.
CALL FCB2HL
ADD HL,BC
EX DE,HL
LD HL,(PARAMS) ;do the same for users specified fcb.
ADD HL,BC
LD C,16 ;this many bytes are present in this extent.
CLOSEIT1: LD A,(BIGDISK) ;8 or 16 bit record numbers?
OR A
JP Z,CLOSEIT4
LD A,(HL) ;just 8 bit. Get one from users fcb.
OR A
LD A,(DE) ;now get one from directory fcb.
JP NZ,CLOSEIT2
LD (HL),A ;users byte was zero. Update from directory.
CLOSEIT2: OR A
JP NZ,CLOSEIT3
LD A,(HL) ;directories byte was zero, update from users fcb.
LD (DE),A
CLOSEIT3: CP (HL) ;if neither one of these bytes were zero,
JP NZ,CLOSEIT7 ;then close error if they are not the same.
JP CLOSEIT5 ;ok so far, get to next byte in fcbs.
CLOSEIT4: CALL MOVEWORD ;update users fcb if it is zero.
EX DE,HL
CALL MOVEWORD ;update directories fcb if it is zero.
EX DE,HL
LD A,(DE) ;if these two values are no different,
CP (HL) ;then a close error occured.
JP NZ,CLOSEIT7
INC DE ;check second byte.
INC HL
LD A,(DE)
CP (HL)
JP NZ,CLOSEIT7
DEC C ;remember 16 bit values.
CLOSEIT5: INC DE ;bump to next item in table.
INC HL
DEC C ;there are 16 entries only.
JP NZ,CLOSEIT1 ;continue if more to do.
LD BC,0FFECH ;backup 20 places (extent byte).
ADD HL,BC
EX DE,HL
ADD HL,BC
LD A,(DE)
CP (HL) ;directory's extent already greater than the
JP C,CLOSEIT6 ;users extent?
LD (HL),A ;no, update directory extent.
LD BC,3 ;and update the record count byte in
ADD HL,BC ;directories fcb.
EX DE,HL
ADD HL,BC
LD A,(HL) ;get from user.
LD (DE),A ;and put in directory.
CLOSEIT6: LD A,0FFH ;set 'was open and is now closed' byte.
LD (CLOSEFLG),A
JP UPDATE1 ;update the directory now.
CLOSEIT7: LD HL,STATUS ;set return status and then return.
DEC (HL)
RET
;
; Routine to get the next empty space in the directory. It
; will then be cleared for use.
;
GETEMPTY: CALL CHKWPRT ;make sure disk is not write protected.
LD HL,(PARAMS) ;save current parameters (fcb).
PUSH HL
LD HL,EMPTYFCB ;use special one for empty space.
LD (PARAMS),HL
LD C,1 ;search for first empty spot in directory.
CALL FINDFST ;(* only check first byte *)
CALL CKFILPOS ;none?
POP HL
LD (PARAMS),HL ;restore original fcb address.
RET Z ;return if no more space.
EX DE,HL
LD HL,15 ;point to number of records for this file.
ADD HL,DE
LD C,17 ;and clear all of this space.
XOR A
GETMT1: LD (HL),A
INC HL
DEC C
JP NZ,GETMT1
LD HL,13 ;clear the 's1' byte also.
ADD HL,DE
LD (HL),A
CALL CHKNMBR ;keep (SCRATCH1) within bounds.
CALL FCBSET ;write out this fcb entry to directory.
JP SETS2B7 ;set 's2' byte bit 7 (unmodified at present).
;
; Routine to close the current extent and open the next one
; for reading.
;
GETNEXT:XOR A
LD (CLOSEFLG),A ;clear close flag.
CALL CLOSEIT ;close this extent.
CALL CKFILPOS
RET Z ;not there???
LD HL,(PARAMS) ;get extent byte.
LD BC,12
ADD HL,BC
LD A,(HL) ;and increment it.
INC A
AND 1FH ;keep within range 0-31.
LD (HL),A
JP Z,GTNEXT1 ;overflow?
LD B,A ;mask extent byte.
LD A,(EXTMASK)
AND B
LD HL,CLOSEFLG ;check close flag (0ffh is ok).
AND (HL)
JP Z,GTNEXT2 ;if zero, we must read in next extent.
JP GTNEXT3 ;else, it is already in memory.
GTNEXT1:LD BC,2 ;Point to the 's2' byte.
ADD HL,BC
INC (HL) ;and bump it.
LD A,(HL) ;too many extents?
AND 0FH
JP Z,GTNEXT5 ;yes, set error code.
;
; Get here to open the next extent.
;
GTNEXT2:LD C,15 ;set to check first 15 bytes of fcb.
CALL FINDFST ;find the first one.
CALL CKFILPOS ;none available?
JP NZ,GTNEXT3
LD A,(RDWRTFLG) ;no extent present. Can we open an empty one?
INC A ;0ffh means reading (so not possible).
JP Z,GTNEXT5 ;or an error.
CALL GETEMPTY ;we are writing, get an empty entry.
CALL CKFILPOS ;none?
JP Z,GTNEXT5 ;error if true.
JP GTNEXT4 ;else we are almost done.
GTNEXT3:CALL OPENIT1 ;open this extent.
GTNEXT4:CALL STRDATA ;move in updated data (rec #, extent #, etc.)
XOR A ;clear status and return.
JP SETSTAT
;
; Error in extending the file. Too many extents were needed
; or not enough space on the disk.
;
GTNEXT5:CALL IOERR1 ;set error code, clear bit 7 of 's2'
JP SETS2B7 ;so this is not written on a close.
;
; Read a sequential file.
;
RDSEQ: LD A,1 ;set sequential access mode.
LD (MODE),A
RDSEQ1: LD A,0FFH ;don't allow reading unwritten space.
LD (RDWRTFLG),A
CALL STRDATA ;put rec# and ext# into fcb.
LD A,(SAVNREC) ;get next record to read.
LD HL,SAVNXT ;get number of records in extent.
CP (HL) ;within this extent?
JP C,RDSEQ2
CP 128 ;no. Is this extent fully used?
JP NZ,RDSEQ3 ;no. End-of-file.
CALL GETNEXT ;yes, open the next one.
XOR A ;reset next record to read.
LD (SAVNREC),A
LD A,(STATUS) ;check on open, successful?
OR A
JP NZ,RDSEQ3 ;no, error.
RDSEQ2: CALL COMBLK ;ok. compute block number to read.
CALL CHKBLK ;check it. Within bounds?
JP Z,RDSEQ3 ;no, error.
CALL LOGICAL ;convert (BLKNMBR) to logical sector (128 byte).
CALL TRKSEC1 ;set the track and sector for this block #.
CALL DOREAD ;and read it.
JP SETNREC ;and set the next record to be accessed.
;
; Read error occured. Set status and return.
;
RDSEQ3: JP IOERR1
;
; Write the next sequential record.
;
WTSEQ: LD A,1 ;set sequential access mode.
LD (MODE),A
WTSEQ1: LD A,0 ;allow an addition empty extent to be opened.
LD (RDWRTFLG),A
CALL CHKWPRT ;check write protect status.
LD HL,(PARAMS)
CALL CKROF1 ;check for read only file, (HL) already set to fcb.
CALL STRDATA ;put updated data into fcb.
LD A,(SAVNREC) ;get record number to write.
CP 128 ;within range?
JP NC,IOERR1 ;no, error(?).
CALL COMBLK ;compute block number.
CALL CHKBLK ;check number.
LD C,0 ;is there one to write to?
JP NZ,WTSEQ6 ;yes, go do it.
CALL GETBLOCK ;get next block number within fcb to use.
LD (RELBLOCK),A ;and save.
LD BC,0 ;start looking for space from the start
OR A ;if none allocated as yet.
JP Z,WTSEQ2
LD C,A ;extract previous block number from fcb
DEC BC ;so we can be closest to it.
CALL EXTBLK
LD B,H
LD C,L
WTSEQ2: CALL FNDSPACE ;find the next empty block nearest number (BC).
LD A,L ;check for a zero number.
OR H
JP NZ,WTSEQ3
LD A,2 ;no more space?
JP SETSTAT
WTSEQ3: LD (BLKNMBR),HL ;save block number to access.
EX DE,HL ;put block number into (DE).
LD HL,(PARAMS) ;now we must update the fcb for this
LD BC,16 ;newly allocated block.
ADD HL,BC
LD A,(BIGDISK) ;8 or 16 bit block numbers?
OR A
LD A,(RELBLOCK) ;(* update this entry *)
JP Z,WTSEQ4 ;zero means 16 bit ones.
CALL ADDA2HL ;(HL)=(HL)+(A)
LD (HL),E ;store new block number.
JP WTSEQ5
WTSEQ4: LD C,A ;compute spot in this 16 bit table.
LD B,0
ADD HL,BC
ADD HL,BC
LD (HL),E ;stuff block number (DE) there.
INC HL
LD (HL),D
WTSEQ5: LD C,2 ;set (C) to indicate writing to un-used disk space.
WTSEQ6: LD A,(STATUS) ;are we ok so far?
OR A
RET NZ
PUSH BC ;yes, save write flag for bios (register C).
CALL LOGICAL ;convert (BLKNMBR) over to loical sectors.
LD A,(MODE) ;get access mode flag (1=sequential,
DEC A ;0=random, 2=special?).
DEC A
JP NZ,WTSEQ9
;
; Special random i/o from function #40. Maybe for M/PM, but the
; current block, if it has not been written to, will be zeroed
; out and then written (reason?).
;
POP BC
PUSH BC
LD A,C ;get write status flag (2=writing unused space).
DEC A
DEC A
JP NZ,WTSEQ9
PUSH HL
LD HL,(DIRBUF) ;zero out the directory buffer.
LD D,A ;note that (A) is zero here.
WTSEQ7: LD (HL),A
INC HL
INC D ;do 128 bytes.
JP P,WTSEQ7
CALL DIRDMA ;tell the bios the dma address for directory access.
LD HL,(LOGSECT) ;get sector that starts current block.
LD C,2 ;set 'writing to unused space' flag.
WTSEQ8: LD (BLKNMBR),HL ;save sector to write.
PUSH BC
CALL TRKSEC1 ;determine its track and sector numbers.
POP BC
CALL DOWRITE ;now write out 128 bytes of zeros.
LD HL,(BLKNMBR) ;get sector number.
LD C,0 ;set normal write flag.
LD A,(BLKMASK) ;determine if we have written the entire
LD B,A ;physical block.
AND L
CP B
INC HL ;prepare for the next one.
JP NZ,WTSEQ8 ;continue until (BLKMASK+1) sectors written.
POP HL ;reset next sector number.
LD (BLKNMBR),HL
CALL DEFDMA ;and reset dma address.
;
; Normal disk write. Set the desired track and sector then
; do the actual write.
;
WTSEQ9: CALL TRKSEC1 ;determine track and sector for this write.
POP BC ;get write status flag.
PUSH BC
CALL DOWRITE ;and write this out.
POP BC
LD A,(SAVNREC) ;get number of records in file.
LD HL,SAVNXT ;get last record written.
CP (HL)
JP C,WTSEQ10
LD (HL),A ;we have to update record count.
INC (HL)
LD C,2
;
;* This area has been patched to correct disk update problem
;* when using blocking and de-blocking in the BIOS.
;
WTSEQ10:NOP ;was 'dcr c'
NOP ;was 'dcr c'
LD HL,0 ;was 'jnz wtseq99'
;
; * End of patch.
;
PUSH AF
CALL GETS2 ;set 'extent written to' flag.
AND 7FH ;(* clear bit 7 *)
LD (HL),A
POP AF ;get record count for this extent.
WTSEQ99:CP 127 ;is it full?
JP NZ,WTSEQ12
LD A,(MODE) ;yes, are we in sequential mode?
CP 1
JP NZ,WTSEQ12
CALL SETNREC ;yes, set next record number.
CALL GETNEXT ;and get next empty space in directory.
LD HL,STATUS ;ok?
LD A,(HL)
OR A
JP NZ,WTSEQ11
DEC A ;yes, set record count to -1.
LD (SAVNREC),A
WTSEQ11:LD (HL),0 ;clear status.
WTSEQ12:JP SETNREC ;set next record to access.
;
; For random i/o, set the fcb for the desired record number
; based on the 'r0,r1,r2' bytes. These bytes in the fcb are
; used as follows:
;
; fcb+35 fcb+34 fcb+33
; | 'r-2' | 'r-1' | 'r-0' |
; |7 0 | 7 0 | 7 0|
; |0 0 0 0 0 0 0 0 | 0 0 0 0 0 0 0 0 | 0 0 0 0 0 0 0 0|
; | overflow | | extra | extent | record # |
; | ______________| |_extent|__number___|_____________|
; also 's2'
;
; On entry, register (C) contains 0ffh if this is a read
; and thus we can not access unwritten disk space. Otherwise,
; another extent will be opened (for writing) if required.
;
POSITION: XOR A ;set random i/o flag.
LD (MODE),A
;
; Special entry (function #40). M/PM ?
;
POSITN1:PUSH BC ;save read/write flag.
LD HL,(PARAMS) ;get address of fcb.
EX DE,HL
LD HL,33 ;now get byte 'r0'.
ADD HL,DE
LD A,(HL)
AND 7FH ;keep bits 0-6 for the record number to access.
PUSH AF
LD A,(HL) ;now get bit 7 of 'r0' and bits 0-3 of 'r1'.
RLA
INC HL
LD A,(HL)
RLA
AND 1FH ;and save this in bits 0-4 of (C).
LD C,A ;this is the extent byte.
LD A,(HL) ;now get the extra extent byte.
RRA
RRA
RRA
RRA
AND 0FH
LD B,A ;and save it in (B).
POP AF ;get record number back to (A).
INC HL ;check overflow byte 'r2'.
LD L,(HL)
INC L
DEC L
LD L,6 ;prepare for error.
JP NZ,POSITN5 ;out of disk space error.
LD HL,32 ;store record number into fcb.
ADD HL,DE
LD (HL),A
LD HL,12 ;and now check the extent byte.
ADD HL,DE
LD A,C
SUB (HL) ;same extent as before?
JP NZ,POSITN2
LD HL,14 ;yes, check extra extent byte 's2' also.
ADD HL,DE
LD A,B
SUB (HL)
AND 7FH
JP Z,POSITN3 ;same, we are almost done then.
;
; Get here when another extent is required.
;
POSITN2:PUSH BC
PUSH DE
CALL CLOSEIT ;close current extent.
POP DE
POP BC
LD L,3 ;prepare for error.
LD A,(STATUS)
INC A
JP Z,POSITN4 ;close error.
LD HL,12 ;put desired extent into fcb now.
ADD HL,DE
LD (HL),C
LD HL,14 ;and store extra extent byte 's2'.
ADD HL,DE
LD (HL),B
CALL OPENIT ;try and get this extent.
LD A,(STATUS) ;was it there?
INC A
JP NZ,POSITN3
POP BC ;no. can we create a new one (writing?).
PUSH BC
LD L,4 ;prepare for error.
INC C
JP Z,POSITN4 ;nope, reading unwritten space error.
CALL GETEMPTY ;yes we can, try to find space.
LD L,5 ;prepare for error.
LD A,(STATUS)
INC A
JP Z,POSITN4 ;out of space?
;
; Normal return location. Clear error code and return.
;
POSITN3:POP BC ;restore stack.
XOR A ;and clear error code byte.
JP SETSTAT
;
; Error. Set the 's2' byte to indicate this (why?).
;
POSITN4:PUSH HL
CALL GETS2
LD (HL),0C0H
POP HL
;
; Return with error code (presently in L).
;
POSITN5:POP BC
LD A,L ;get error code.
LD (STATUS),A
JP SETS2B7
;
; Read a random record.
;
READRAN:LD C,0FFH ;set 'read' status.
CALL POSITION ;position the file to proper record.
CALL Z,RDSEQ1 ;and read it as usual (if no errors).
RET
;
; Write to a random record.
;
WRITERAN: LD C,0 ;set 'writing' flag.
CALL POSITION ;position the file to proper record.
CALL Z,WTSEQ1 ;and write as usual (if no errors).
RET
;
; Compute the random record number. Enter with (HL) pointing
; to a fcb an (DE) contains a relative location of a record
; number. On exit, (C) contains the 'r0' byte, (B) the 'r1'
; byte, and (A) the 'r2' byte.
;
; On return, the zero flag is set if the record is within
; bounds. Otherwise, an overflow occured.
;
COMPRAND: EX DE,HL ;save fcb pointer in (DE).
ADD HL,DE ;compute relative position of record #.
LD C,(HL) ;get record number into (BC).
LD B,0
LD HL,12 ;now get extent.
ADD HL,DE
LD A,(HL) ;compute (BC)=(record #)+(extent)*128.
RRCA ;move lower bit into bit 7.
AND 80H ;and ignore all other bits.
ADD A,C ;add to our record number.
LD C,A
LD A,0 ;take care of any carry.
ADC A,B
LD B,A
LD A,(HL) ;now get the upper bits of extent into
RRCA ;bit positions 0-3.
AND 0FH ;and ignore all others.
ADD A,B ;add this in to 'r1' byte.
LD B,A
LD HL,14 ;get the 's2' byte (extra extent).
ADD HL,DE
LD A,(HL)
ADD A,A ;and shift it left 4 bits (bits 4-7).
ADD A,A
ADD A,A
ADD A,A
PUSH AF ;save carry flag (bit 0 of flag byte).
ADD A,B ;now add extra extent into 'r1'.
LD B,A
PUSH AF ;and save carry (overflow byte 'r2').
POP HL ;bit 0 of (L) is the overflow indicator.
LD A,L
POP HL ;and same for first carry flag.
OR L ;either one of these set?
AND 01H ;only check the carry flags.
RET
;
; Routine to setup the fcb (bytes 'r0', 'r1', 'r2') to
; reflect the last record used for a random (or other) file.
; This reads the directory and looks at all extents computing
; the largerst record number for each and keeping the maximum
; value only. Then 'r0', 'r1', and 'r2' will reflect this
; maximum record number. This is used to compute the space used
; by a random file.
;
RANSIZE:LD C,12 ;look thru directory for first entry with
CALL FINDFST ;this name.
LD HL,(PARAMS) ;zero out the 'r0, r1, r2' bytes.
LD DE,33
ADD HL,DE
PUSH HL
LD (HL),D ;note that (D)=0.
INC HL
LD (HL),D
INC HL
LD (HL),D
RANSIZ1:CALL CKFILPOS ;is there an extent to process?
JP Z,RANSIZ3 ;no, we are done.
CALL FCB2HL ;set (HL) pointing to proper fcb in dir.
LD DE,15 ;point to last record in extent.
CALL COMPRAND ;and compute random parameters.
POP HL
PUSH HL ;now check these values against those
LD E,A ;already in fcb.
LD A,C ;the carry flag will be set if those
SUB (HL) ;in the fcb represent a larger size than
INC HL ;this extent does.
LD A,B
SBC A,(HL)
INC HL
LD A,E
SBC A,(HL)
JP C,RANSIZ2
LD (HL),E ;we found a larger (in size) extent.
DEC HL ;stuff these values into fcb.
LD (HL),B
DEC HL
LD (HL),C
RANSIZ2:CALL FINDNXT ;now get the next extent.
JP RANSIZ1 ;continue til all done.
RANSIZ3:POP HL ;we are done, restore the stack and
RET ;return.
;
; Function to return the random record position of a given
; file which has been read in sequential mode up to now.
;
SETRAN: LD HL,(PARAMS) ;point to fcb.
LD DE,32 ;and to last used record.
CALL COMPRAND ;compute random position.
LD HL,33 ;now stuff these values into fcb.
ADD HL,DE
LD (HL),C ;move 'r0'.
INC HL
LD (HL),B ;and 'r1'.
INC HL
LD (HL),A ;and lastly 'r2'.
RET
;
; This routine select the drive specified in (ACTIVE) and
; update the login vector and bitmap table if this drive was
; not already active.
;
LOGINDRV: LD HL,(LOGIN) ;get the login vector.
LD A,(ACTIVE) ;get the default drive.
LD C,A
CALL SHIFTR ;position active bit for this drive
PUSH HL ;into bit 0.
EX DE,HL
CALL SELECT ;select this drive.
POP HL
CALL Z,SLCTERR ;valid drive?
LD A,L ;is this a newly activated drive?
RRA
RET C
LD HL,(LOGIN) ;yes, update the login vector.
LD C,L
LD B,H
CALL SETBIT
LD (LOGIN),HL ;and save.
JP BITMAP ;now update the bitmap.
;
; Function to set the active disk number.
;
SETDSK: LD A,(EPARAM) ;get parameter passed and see if this
LD HL,ACTIVE ;represents a change in drives.
CP (HL)
RET Z
LD (HL),A ;yes it does, log it in.
JP LOGINDRV
;
; This is the 'auto disk select' routine. The firsst byte
; of the fcb is examined for a drive specification. If non
; zero then the drive will be selected and loged in.
;
AUTOSEL:LD A,0FFH ;say 'auto-select activated'.
LD (AUTO),A
LD HL,(PARAMS) ;get drive specified.
LD A,(HL)
AND 1FH ;look at lower 5 bits.
DEC A ;adjust for (1=A, 2=B) etc.
LD (EPARAM),A ;and save for the select routine.
CP 1EH ;check for 'no change' condition.
JP NC,AUTOSL1 ;yes, don't change.
LD A,(ACTIVE) ;we must change, save currently active
LD (OLDDRV),A ;drive.
LD A,(HL) ;and save first byte of fcb also.
LD (AUTOFLAG),A ;this must be non-zero.
AND 0E0H ;whats this for (bits 6,7 are used for
LD (HL),A ;something)?
CALL SETDSK ;select and log in this drive.
AUTOSL1:LD A,(USERNO) ;move user number into fcb.
LD HL,(PARAMS) ;(* upper half of first byte *)
OR (HL)
LD (HL),A
RET ;and return (all done).
;
; Function to return the current cp/m version number.
;
GETVER: LD A,022H ;version 2.2
JP SETSTAT
;
; Function to reset the disk system.
;
RSTDSK: LD HL,0 ;clear write protect status and log
LD (WRTPRT),HL ;in vector.
LD (LOGIN),HL
XOR A ;select drive 'A'.
LD (ACTIVE),A
LD HL,TBUFF ;setup default dma address.
LD (USERDMA),HL
CALL DEFDMA
JP LOGINDRV ;now log in drive 'A'.
;
; Function to open a specified file.
;
OPENFIL:CALL CLEARS2 ;clear 's2' byte.
CALL AUTOSEL ;select proper disk.
JP OPENIT ;and open the file.
;
; Function to close a specified file.
;
CLOSEFIL: CALL AUTOSEL ;select proper disk.
JP CLOSEIT ;and close the file.
;
; Function to return the first occurence of a specified file
; name. If the first byte of the fcb is '?' then the name will
; not be checked (get the first entry no matter what).
;
GETFST: LD C,0 ;prepare for special search.
EX DE,HL
LD A,(HL) ;is first byte a '?'?
CP '?'
JP Z,GETFST1 ;yes, just get very first entry (zero length match).
CALL SETEXT ;get the extension byte from fcb.
LD A,(HL) ;is it '?'? if yes, then we want
CP '?' ;an entry with a specific 's2' byte.
CALL NZ,CLEARS2 ;otherwise, look for a zero 's2' byte.
CALL AUTOSEL ;select proper drive.
LD C,15 ;compare bytes 0-14 in fcb (12&13 excluded).
GETFST1:CALL FINDFST ;find an entry and then move it into
JP MOVEDIR ;the users dma space.
;
; Function to return the next occurence of a file name.
;
GETNXT: LD HL,(SAVEFCB) ;restore pointers. note that no
LD (PARAMS),HL ;other dbos calls are allowed.
CALL AUTOSEL ;no error will be returned, but the
CALL FINDNXT ;results will be wrong.
JP MOVEDIR
;
; Function to delete a file by name.
;
DELFILE:CALL AUTOSEL ;select proper drive.
CALL ERAFILE ;erase the file.
JP STSTATUS ;set status and return.
;
; Function to execute a sequential read of the specified
; record number.
;
READSEQ:CALL AUTOSEL ;select proper drive then read.
JP RDSEQ
;
; Function to write the net sequential record.
;
WRTSEQ: CALL AUTOSEL ;select proper drive then write.
JP WTSEQ
;
; Create a file function.
;
FCREATE:CALL CLEARS2 ;clear the 's2' byte on all creates.
CALL AUTOSEL ;select proper drive and get the next
JP GETEMPTY ;empty directory space.
;
; Function to rename a file.
;
RENFILE:CALL AUTOSEL ;select proper drive and then switch
CALL CHGNAMES ;file names.
JP STSTATUS
;
; Function to return the login vector.
;
GETLOG: LD HL,(LOGIN)
JP GETPRM1
;
; Function to return the current disk assignment.
;
GETCRNT:LD A,(ACTIVE)
JP SETSTAT
;
; Function to set the dma address.
;
PUTDMA: EX DE,HL
LD (USERDMA),HL ;save in our space and then get to
JP DEFDMA ;the bios with this also.
;
; Function to return the allocation vector.
;
GETALOC:LD HL,(ALOCVECT)
JP GETPRM1
;
; Function to return the read-only status vector.
;
GETROV: LD HL,(WRTPRT)
JP GETPRM1
;
; Function to set the file attributes (read-only, system).
;
SETATTR:CALL AUTOSEL ;select proper drive then save attributes.
CALL SAVEATTR
JP STSTATUS
;
; Function to return the address of the disk parameter block
; for the current drive.
;
GETPARM:LD HL,(DISKPB)
GETPRM1:LD (STATUS),HL
RET
;
; Function to get or set the user number. If (E) was (FF)
; then this is a request to return the current user number.
; Else set the user number from (E).
;
GETUSER:LD A,(EPARAM) ;get parameter.
CP 0FFH ;get user number?
JP NZ,SETUSER
LD A,(USERNO) ;yes, just do it.
JP SETSTAT
SETUSER:AND 1FH ;no, we should set it instead. keep low
LD (USERNO),A ;bits (0-4) only.
RET
;
; Function to read a random record from a file.
;
RDRANDOM: CALL AUTOSEL ;select proper drive and read.
JP READRAN
;
; Function to compute the file size for random files.
;
WTRANDOM: CALL AUTOSEL ;select proper drive and write.
JP WRITERAN
;
; Function to compute the size of a random file.
;
FILESIZE: CALL AUTOSEL ;select proper drive and check file length
JP RANSIZE
;
; Function #37. This allows a program to log off any drives.
; On entry, set (DE) to contain a word with bits set for those
; drives that are to be logged off. The log-in vector and the
; write protect vector will be updated. This must be a M/PM
; special function.
;
LOGOFF: LD HL,(PARAMS) ;get drives to log off.
LD A,L ;for each bit that is set, we want
CPL ;to clear that bit in (LOGIN)
LD E,A ;and (WRTPRT).
LD A,H
CPL
LD HL,(LOGIN) ;reset the login vector.
AND H
LD D,A
LD A,L
AND E
LD E,A
LD HL,(WRTPRT)
EX DE,HL
LD (LOGIN),HL ;and save.
LD A,L ;now do the write protect vector.
AND E
LD L,A
LD A,H
AND D
LD H,A
LD (WRTPRT),HL ;and save. all done.
RET
;
; Get here to return to the user.
;
GOBACK: LD A,(AUTO) ;was auto select activated?
OR A
JP Z,GOBACK1
LD HL,(PARAMS) ;yes, but was a change made?
LD (HL),0 ;(* reset first byte of fcb *)
LD A,(AUTOFLAG)
OR A
JP Z,GOBACK1
LD (HL),A ;yes, reset first byte properly.
LD A,(OLDDRV) ;and get the old drive and select it.
LD (EPARAM),A
CALL SETDSK
GOBACK1:LD HL,(USRSTACK) ;reset the users stack pointer.
LD SP,HL
LD HL,(STATUS) ;get return status.
LD A,L ;force version 1.4 compatability.
LD B,H
RET ;and go back to user.
;
; Function #40. This is a special entry to do random i/o.
; For the case where we are writing to unused disk space, this
; space will be zeroed out first. This must be a M/PM special
; purpose function, because why would any normal program even
; care about the previous contents of a sector about to be
; written over.
;
WTSPECL:CALL AUTOSEL ;select proper drive.
LD A,2 ;use special write mode.
LD (MODE),A
LD C,0 ;set write indicator.
CALL POSITN1 ;position the file.
CALL Z,WTSEQ1 ;and write (if no errors).
RET
;
;**************************************************************
;*
;* BDOS data storage pool.
;*
;**************************************************************
;
EMPTYFCB: DB 0E5H ;empty directory segment indicator.
WRTPRT: DW 0 ;write protect status for all 16 drives.
LOGIN: DW 0 ;drive active word (1 bit per drive).
USERDMA:DW 080H ;user's dma address (defaults to 80h).
;
; Scratch areas from parameter block.
;
SCRATCH1: DW 0 ;relative position within dir segment for file (0-3).
SCRATCH2: DW 0 ;last selected track number.
SCRATCH3: DW 0 ;last selected sector number.
;
; Disk storage areas from parameter block.
;
DIRBUF: DW 0 ;address of directory buffer to use.
DISKPB: DW 0 ;contains address of disk parameter block.
CHKVECT:DW 0 ;address of check vector.
ALOCVECT: DW 0 ;address of allocation vector (bit map).
;
; Parameter block returned from the bios.
;
SECTORS:DW 0 ;sectors per track from bios.
BLKSHFT:DB 0 ;block shift.
BLKMASK:DB 0 ;block mask.
EXTMASK:DB 0 ;extent mask.
DSKSIZE:DW 0 ;disk size from bios (number of blocks-1).
DIRSIZE:DW 0 ;directory size.
ALLOC0: DW 0 ;storage for first bytes of bit map (dir space used).
ALLOC1: DW 0
OFFSET: DW 0 ;first usable track number.
XLATE: DW 0 ;sector translation table address.
;
;
CLOSEFLG: DB 0 ;close flag (=0ffh is extent written ok).
RDWRTFLG: DB 0 ;read/write flag (0ffh=read, 0=write).
FNDSTAT:DB 0 ;filename found status (0=found first entry).
MODE: DB 0 ;I/o mode select (0=random, 1=sequential, 2=special random).
EPARAM: DB 0 ;storage for register (E) on entry to bdos.
RELBLOCK: DB 0 ;relative position within fcb of block number written.
COUNTER:DB 0 ;byte counter for directory name searches.
SAVEFCB:DW 0,0 ;save space for address of fcb (for directory searches).
BIGDISK:DB 0 ;if =0 then disk is > 256 blocks long.
AUTO: DB 0 ;if non-zero, then auto select activated.
OLDDRV: DB 0 ;on auto select, storage for previous drive.
AUTOFLAG: DB 0 ;if non-zero, then auto select changed drives.
SAVNXT: DB 0 ;storage for next record number to access.
SAVEXT: DB 0 ;storage for extent number of file.
SAVNREC:DW 0 ;storage for number of records in file.
BLKNMBR:DW 0 ;block number (physical sector) used within a file or logical sect
LOGSECT:DW 0 ;starting logical (128 byte) sector of block (physical sector).
FCBPOS: DB 0 ;relative position within buffer for fcb of file of interest.
FILEPOS:DW 0 ;files position within directory (0 to max entries -1).
;
; Disk directory buffer checksum bytes. One for each of the
; 16 possible drives.
;
CKSUMTBL: DB 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
;
; Extra space ?
;
DB 0,0,0,0
;
;**************************************************************
;*
;* B I O S J U M P T A B L E
;*
;**************************************************************
;
ALIGN_NOPS CPMBIOS
;-----------------------------------------------------------------------
; MZ-80A CPM BIOS STUB - Main Logic in CBIOS.ASM
;-----------------------------------------------------------------------
; Bring in the CBIOS stub, has the bootstrap code and DPB place markers.
INCLUDE "cpm22-bios.asm"
ALIGN_NOPS CBIOSSTART
;*
;****************** E N D O F C P / M *****************
Reference in New Issue View Git Blame Copy Permalink