home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
ftp.barnyard.co.uk
/
2015.02.ftp.barnyard.co.uk.tar
/
ftp.barnyard.co.uk
/
cpm
/
walnut-creek-CDROM
/
CPM
/
ZCPR33
/
A-R
/
EASE20.LBR
/
EASE.ZZ0
/
EASE.Z80
Wrap
Text File
|
2000-06-30
|
42KB
|
2,364 lines
; PROGRAM: Error And Shell Editor
; AUTHOR: Paul Pomerleau and Jay Sage
; DATE: October 23, 1987
; VERSION: 2.0
; Copyright 1987, Paul Pomerleau
; This program provides a history shell and error handler for ZCPR3.3
; A complex line editor is used to edit command lines.
; Run EASEDOC.COM to get a listing of Key-Command Bindings.
; This file assembles with SLR's Z80ASM
; =====================================================
;
; D E F I N I T I O N S S E C T I O N
;
; =====================================================
version equ 20
betastage equ ' '
no equ 0
yes equ 0ffh
cr equ 0dh
lf equ 0ah
bell equ 07h
tab equ 09h
bdos equ 0005h
bios equ 0000h
secbuf equ 0080h
sectop equ 0100h
killlen equ 300
maxsec equ 8
public cout,ccout,print,pstr,crlf
extrn acase2,sua,gua ; SYSLIB
extrn getmsg,getcst,putcst,putzex ; Z3LIB
extrn z3init,getquiet
extrn erradr,getcl1,z3log
extrn getwhl,getduok,dutdir
extrn getsh,qshell,shpush,shpop,putreg,getreg
extrn qerror,getsrun,haltsub
extrn z33chk,stopxsub,subon ; Z33LIB
extrn getzrun,stopzex,haltzex
extrn getefcb,parse2
; ==========================================================
;
; S T A N D A R D P R O G R A M H E A D E R
;
; ==========================================================
ENTRY:
jp START
defb 'Z3ENV'
defb 3 ; Type-3 environment
ENVADDR:
dw 0f300h
dw ENTRY
defb version
; To go to the Error Handler, just
; go to START with error flag set.
; ======================================================
;
; C O N F I G U R A T I O N A R E A
;
; ======================================================
NAME: db 'EASE VAR' ; Command history file
WIDTH: dw 80 ; Length of line
TOOSHORT:
dw 02 ; Don't store in history
; if shorter than...
GOBEGFLG:
db yes
BEEPFLG:
db yes
SMARTSAV:
db yes ; No causes penny pinching.
USEMEM: db no ; Use memory (vs. registers)
MEMLOC: dw 47h ; Memory location (3 free ones)
STARTREG: ; for EASE to use always.
db 7 ; First register to use
USE6: db no ; Set to TRUE to use
; BDOS 6 for input.
TABLE: db [[LASTCASE - VECTOR] / 3] ; Number of cases
dw BEEP ; Default case ring bell
VECTOR: db 'Q'
dw SHIFTED ; Meta Key
db 'D'
dw FCHR ; Right Char
db 'S'
dw BCHR ; Left Char
db 'E'
dw UP ; Up line
db 'X'
dw DOWN ; Down line
db 'A'
dw MBWORD ; Left word
db 'F'
dw MFWORD ; Right word
db 'S'+80h
dw GOBOLN ; Start of line
db 'D'+80h
dw GOEOLN ; End of line
db 'G'
dw FDEL ; Del char right
db 'H'
dw DELCHR ; Del char left
db 127
dw DELCHR ; Del char left
db 'T'
dw FDWORD ; Del word right
db 127 + 80h
dw BDWORD ; Del word left
db 'R'
dw CMDKILL ; Kill to semi-colon
db 'Y'+80h
dw DELTOEND ; Delete to end of line
db 'Y'
dw DELLIN ; Delete line
db 'U'
dw UNDO ; Reinsert deleted text
db 'B'
dw BACKLINE ; Back in history shell
db 'N'
dw NEXTLINE ; Forward in history shell
db 'O'
dw BSEARCH ; Search for first char
db 'V'
dw TOGLIN ; Toggle insert
CCOMP: db 'I'
dw COMPLETE ; Complete filename
db 'P'
dw QINSERT ; Insert any char
db 'W'
dw REPLOT ; Redraw line
db 'C'
dw WARM ; Warm Boot
db 'M'
dw DONE ; End edit
db '_'+80h
dw QUITSH ; End EASE
LASTCASE:
PUNC: db ',.:!#%^&<>[]{}()_+-=`~/\|; ',tab
PUNCLEN equ $ - PUNC
SEP: db ' ,=/<>|',tab
SEPLEN equ $ - SEP
; ===================================================
;
; M A I N C O D E S E C T I O N
;
; ===================================================
RESTORE_STACK:
ld sp,(SAVED_STACK)
ret
START:
ld hl,(envaddr) ; Get environment address
call z3init ; Initialize library routines
call z33chk
ret nz
call SETCPM3
ld (SAVED_STACK),sp
ld hl,STACK
ld sp,hl
ld hl,RESTORE_STACK
push hl
ld a,(5dh)
push af
call GETSEC ; Get the sector number
call EASERUN
jr z,FPFINE
ld hl,BUFFER
ld (POS),hl
call SETFILE
call RECOVER
call PUTSEC
FPFINE: ld c,19h ; Get current disk
call ADOS
inc a
ld (OLDDRIVE),a
pop af
ld (5dh),a
call qerror ; See if error handler invocation
jp z,errorh ; If so, branch to error processing
call qshell
jp z,RUNSH ; Yes, don't install
;=============================================================================
;
; I N S T A L L A T I O N C O D E
;
;=============================================================================
; Program was invoked manually, so we need to set it up shell and error handler.
;----------------------------------------
; Subtask 1 -- determine whether to use a DU or a DIR prefix
;
; The program can examine the ZCPR33 option bytes to determine what features
; are supported (DU and/or DIR forms, which one first, wheel control over DU
; use, etc.). For now we will just assume that a DU prefix will be used and
; will omit coding this block.
;----------------------------------------
; Get user option: if null, do both. If E, then install the error handler
; else install the shell.
ld a,(5dh)
cp 'C'
jp z,RUNSHNP
call header
ld a,(5dh)
cp ' ' ; Error handler and shell
jr z,BOTH
cp 'E' ; Only error handler
jr z,ERRONLY
jr ISHELL ; Only the shell
BOTH: call ISHELL
;----------------------------------------
; Subtask 2 -- build error handling command line including directory prefix
; using data from the external FCB. We use the fact that the drive and user
; where the program was actually found along the path are stored in the
; command file control block. The user number is kept in the usual place;
; the drive is kept in the following byte. The drive is in the range 1..16
; (unless the command is resident, in which case the drive byte is 0).
ERRONLY:
call getmsg ; Get pointer to error command line
ld de,10h ; ..in message buffer
add hl,de
call PUT_NAME_TO_HL
call getquiet
ret nz
call CLPRINT
dc ' Error Handler'
jr P_CLST
ISHELL: ld hl,BUFFER
call PUT_NAME_TO_HL
call SHPUSH ; Store the shell name
jr nz,SHBAD ; Push to deep? Then abort
push hl
call SETFILE
call RECOVER ; Use existing file
call PUTSEC
pop hl
call getquiet
ret nz
PRWELC: call CLPRINT
dc ' Shell'
P_CLST: call PRINT
dc ': '
jp PSTR ; PRINT the string there and quit
SHBAD: call CLPRINT
SHERR: dc 'Shell Error'
ret
RECOVER:
ld hl,SEC
ld bc,BUFFER-SEC-1
call ZERO
call SET
call OPEN
ret z
; jr z,DELSET
DOFNO: call FNOWRITE
jr nz,DOFNO
call FNOWRITE
jr nz,DOFNO
jp BNOWRITE
DELSET:
ld c,19 ; Delete
call FBDOS
SET: xor a
ld (SEC),a ; First sector
ld hl,SECBUF + 1 ; +1==So no long pause -- at least at first.
ld (FP),hl
jp PUTSEC
PUT_NAME_TO_HL:
push hl ; Save pointer for way below
ex de,hl ; Switch pointer into DE
call getefcb ; Get address of the command FCB
inc hl ; Advance pointer to name of program
; Get drive user from Z33's FCB.
push hl
ld bc,13 ; Offset to drive number
add hl,bc ; HL now points to the drive number
; Here we get the drive where the program was found. Since we know that this
; is not a resident program, there is no need to check for a zero value.
ld a,(hl) ; Get it and
add a,'A'-1 ; ..convert to a letter
ld (de),a ; Save in error command line
inc de ; Increment command line pointer
dec hl ; Back up to user number
ld a,(hl) ; Get it and
call mafdc ; ..convert to decimal in command line
ld a,':' ; Put in the colon
ld (de),a
inc de
cont1:
pop hl ; Restore the pointer to the command name
ld bc,8 ; Copy 8 characters of name
ldir ; ..into error command line
xor a ; Store terminating null
ld (de),a
pop hl
ret
;=============================================================================
;
; E R R O R H A N D L I N G C O D E
;
;=============================================================================
; This is the main entry point for error handling
errorh:
ld a,(BEEPFLG) ; Did the user want a Beep?
or a
call nz,BEEP
;----------------------------------------
; Subtask 1 -- Display program signon message
task1:
call header
;----------------------------------------
; Subtask 2 -- Display system status
; This task determines whether ZEX and/or SUBMIT are running. Input
; redirection from either of them is turned off while error handling is
; performed (so user can provide the input).
task2:
call stopzex ; Stop ZEX input redirection
call CLPRINT
dc lf,tab,'(ZEX '
call getzrun ; Find out if ZEX is running
ld e,a
ld (ZEXORSUB),a
call ponoff ; Print on/off
call subon
jr z,task2a ; Branch if submit not supported
call PRINT
dc ', SUBMIT '
; See if submit is supported by the command processor
call stopxsub ; Stop XSUB input redirection
call getsrun ; Get submit running flag
call ponoff ; PRINT on/off
or e
ld (ZEXORSUB),a
; See if wheel byte is on or off
task2a:
call PRINT
dc ', WHEEL '
call getwhl
call ponoff
ld a,')'
call COUT
;----------------------------------------
; Subtask 3 -- Determine source of the error (internal or external) and
; display that information.
task3:
call CLPRINT
dc tab
call getcst ; Get command status flag
bit 3,a ; See if external command bit is set
jr nz,external ; Branch if external error
call PRINT ; "IN"ternal
dc 'In'
jr task3a
external:
call PRINT ; "EX"ternal
dc 'Ex'
task3a:
call PRINT ; "TERNAL ERROR"
dc 'ternal error #'
call xcmdoff ; Clear the external command bit (and ECP bit)
;----------------------------------------
; Subtask 4 -- Determine the error return code and display information about
; the nature of the error. This section of the code can be expanded to cover
; more error types as they are defined.
task4:
call getmsg
ld a,(hl) ; Get the error return code
push af ; Save for use below
call pafdc ; Display the number
call PRINT
dc ' -- '
pop af ; Get error code back
cp 22
jr c,OKERR
ld a,4
OKERR: dec a
ld b,a
ld hl,DUCHANGE
or a
jr z,PRINTERR
SKIPERR:
ld a,(hl)
inc hl
and 10000000b
jr z,SKIPERR
djnz SKIPERR
PRINTERR:
call PSTR
call CRLF
;----------------------------------------
; Subtask 5 -- Display bad command line
;
; In the final code, much more elaborate error processing would be performed
; here (or more likely, the code here will be used as a framework for existing
; error handlers).
task5:
call erradr ; Get pointer to bad command line
push hl ; Save for reuse below
ld de,BUFFER
scan: ; Find end of this command
ld a,(hl)
ld (de),a
or a ; See if end of command line buffer
jr z,GOTEND
cp ';' ; See if at command separator
jr z,task5a
inc hl ; Point to next character
inc de
jr scan ; Continue scanning
task5a:
push af
push hl
FILLREST:
inc hl
inc de
ld a,(hl)
ld (de),a
or a
jr nz,FILLREST
pop hl
pop af
GOTEND:
OKT5A: ld a,(hl)
ld (hl),0 ; Mark end of string
ld (delimptr),hl ; Save ptr to bad command's delimiter
ld (delim),a ; Store delimiter
push af
ld a,(ZEXORSUB)
or a
jp z,ERREDIT
call CLPRINT
dc tab,'Bad Command:',tab
pop af
pop hl ; Restore pointer to beginning of command
push af ; Save delimiting character
call PSTR ; Display the bad command
pop af
or a
jr z,task6 ; If no rest of line, get out without output
push hl ; Save pointer to rest of command line
call CLPRINT
dc tab,'Rest of Line:',tab
pop hl
task5b:
dec hl ; Pt back to bad command delimiter
ld (hl),a ; Put semicolon back
inc hl
call PSTR ; PRINT rest of command line
; AND RETURN!
;----------------------------------------
; Subtask 6 -- Deal with the bad command
; This is where the real error handling is performed. Here we just flush
; the entire command line and abort any submit job, but in a real error
; handler, several other functions would be performed. With normal command
; lines (ZEX and SUBMIT not running), the user has the following three basic
; choices: fix the bad command, skip the bad command, or abort the entire
; command line. If ZEX is running, there is an additional choice that should
; be available: abort the entire ZEX script. Similarly, if SUBMIT is running,
; the user must be given the option to abort the entire submit job.
; This code implements all of the above with the additional feature
; that if the bad command is the last on the line, the option to skip
; to next command is not presented as it would be meaningless.
task6:
call CLPRINT
dc cr,lf,tab,'(E)dit/(A)bort'
ld a,(delim) ; Get bad command delimiter
or a
jr z,task6a ; No trailing commands; skip next option
call PRINT
dc '/(C)ontinue'
task6a:
call PRINT
dc ': '
task6c: call capin ; get response
ld b,a ; Save for a moment
ld a,(delim) ; Get command delimiter again
or a
ld a,b ; Response back in A
jr z,task6b ; Don't allow 's' choice if no trailing command
cp 'C' ; Continue?
jr z,skip
task6b:
cp 'A' ; Abort?
jr z,abort
cp 'E' ; Edit?
jp z,edit
call beep ; Bad input
jr task6c
;-----------------------------------------------------------------------------
; Skip over bad command and resume with next in line
skip:
call getcl1 ; Pt to command line buffer
ld de,(delimptr) ; DE pts to bad command's delimiter
inc de ; Now pointing to next command
ld (hl),e ; Stuff address in
inc hl ; ..first two bytes
ld (hl),d ; ..of multiple command line buffer
call PRINT
defb 'Continuing...',1
ret ; Resume command execution with next command
;-----------------------------------------------------------------------------
; Abort (flush) command line
abort:
call abortmsg
call getzrun ; See if ZEX is running
jr z,abort2 ; Branch if not
; Deal with running ZEX script
call CLPRINT
dc tab,'Abort ZEX script (Y/N)? '
call getyesno ; Get user's answer
jr nz,abort1 ; Branch if negative response
call haltzex ; Abort ZEX
call abortmsg
jr abort2
abort1:
call abort3
; Deal with running SUBMIT job
abort2:
call getsrun ; Is a submit job running
ret z ; If not, return to command processor
call CLPRINT
dc tab,'Abort SUBMIT job (Y/N)? '
call getyesno ; Get user's answer
jr nz,abort3 ; Branch if negative response
call haltsub ; Abort SUBMIT
abortmsg:
call PRINT
defb 'Aborted',1
ret
abort3:
call PRINT
defb ' No',1
ret ; Back to command processor
;-----------------------------------------------------------------------------
; XCMDOFF -- turn off external command flag
; This routine turns off the external command bit and the ECP bit in the
; command status flag.
xcmdoff:
call getcst ; Get the command status flag
and 11110011b
; ..the error handler on return
jp putcst ; Put new value back and return
;-----------------------------------------------------------------------------
; GETYESNO -- get yes/no answer from user
; Only 'Y' or 'y' accepted as affirmative answers. Routine returns Z if
; affirmative, NZ otherwise.
getyesno:
call capin ; Get user response
cp 'Y'
ret
;-----------------------------------------------------------------------------
; PONOFF -- PRINT ON or OFF in message
;
; If the Z flag is set on entry, 'OFF' is displayed; otherwize 'ON' is
; displayed.
ponoff:
jr z,poff
call PRINT
dc 'ON'
ret
poff:
call PRINT
dc 'OFF'
ret
; ------------------------------
; header -- PRINT program name and version
;
header: call CLPRINT
defb 'Z33 Error And Shell Editor, Vers. '
defb version / 10 + '0'
defb '.'
defb version mod 10 + '0'
dc betastage
ret
; ------------------------------
; CLPRINT -- PRINT CR LF and then following string.
CLPRINT:
call CRLF
jp PRINT
;-----------------------------------------------------------------------------
; Prompt -- PRINT a DU/DIR prompt.
;
PROMPT: call QPROMPT ; PRINT the DU:DIR
ld a,(INSFLG)
INSPROMPT:
or a
ld a,'>' ; For insert
jr nz,INSOK
ld a,'}' ; For no insert
INSOK: call COUT
ld a,'>'
jp COUT
QPROMPT:
call QERROR
jr nz,NOTERR
call PRINT
dc '[Error] '
NOTERR: call getmsg
ld bc,2eh
add hl,bc
ld c,(hl)
inc hl
ld b,(hl)
call getduok
jr z,NODU
ld a,b
add a,'A' ; Make it a letter
call COUT ; Write it
ld a,c
call pafdc ; Write it as a number
NODU: call dutdir ; Get the NDR
ret z
push hl
call getduok
ld a,':'
call nz,COUT ; And the colon to separate
pop hl
ld b,8 ; Eight chars max
NAMELOOP:
ld a,(hl) ; Get the first char
cp ' ' ; Is it the last
ret z ; YUP. done
call COUT ; Write it
inc hl
djnz NAMELOOP ; Repeat
ret
; -----------------------------------------------------------
; FillLine
; Check length of the new, edited, command line. If it will
; fit, copy it to the Z3 multiple command line buffer and
; return to the CPR to execute it. Otherwise, display error
; message and branch back to the editor.
GETLEN: ld hl,BUFFER
push hl
xor a
ld bc,killlen + 2
cpir ; Find the ZERO
dec hl
pop de
push hl
sbc hl,de ; Get the length
ld b,h
ld c,l
pop hl
ret
FILL: xor a
call putcst ; No errors
call getcl1 ; Get Z3 command line addr in hl,
; ..length in a
cp c ; Compare with length of new line
jr c,FILLERR ; Branch if new line too long
ld a,b ; High order byte of length should be 0
or a
jr nz,FILLERR ; Branch if not
push hl ; Save Z3CL
ld de,4 ; Offset to first character in buffer
add hl,de
ex de,hl ; First char address in DE
pop hl ; Z3CL address in HL
ld (hl),e ; Store ptr to first command
inc hl ; At Z3CL
ld (hl),d
ld hl,BUFFER ; Get back pointer to new command
push hl
inc bc ; Adjust length to include trailing null
ldir ; Copy to system command line
call EASERUN
pop hl
ret nz ; Return if it was an error
ld a,(SAVFLG)
or a
ret z ; Didn't change from read: Don't save
push hl
call GETLEN ; Get length again
ld hl,(TOOSHORT)
sbc hl,bc
pop hl
ret nc ; Too short to save
push hl
call OPEN ; Open 'er up
call GETSEC ; Get the intitial position
call RRAND ; Read in the current record
xor a
call WFFILE ; Put the null to space the lines
pop hl
FILLWRITE:
ld a,(hl) ; Loop to put in the whole line
push hl
call WFFILE ; Put in the next char of the line
pop hl
ld a,(hl)
inc hl
or a
jr nz,FILLWRITE
call BNOWRITE
call PUTSEC
xor a
call WFFILE ; Write final spacer null
xor a
call WFFILE ; Put the null to space the lines
FLUSH: call WRAND
CLOSE: ld c,16 ; Close the file
FBDOS: ld de,FCB
jp BDOS ; Go back to CPR to execute it
FILLERR: ; To long for CCP to digest
call CLPRINT
defb bell,tab
defb 'Too long!',1
jp EDIT2
EASERUN:
ld b,0
call GET
cp 'E'
ret
GET: ld a,(USEMEM) ; B = Location 0..2
or a
jr z,GREGS
push hl
push de
ld d,0
ld e,b
ld hl,(MEMLOC)
add hl,de
ld a,(hl)
pop de
pop hl
ret
GREGS: ld a,(STARTREG)
push bc
add b
ld b,a
call getreg
pop bc
ret
PUT: ld c,a ; A = Data, B = location 0..2
ld a,(USEMEM)
or a
jr z,PREGS
push hl
push de
ld d,0
ld e,b
ld hl,(MEMLOC)
add hl,de
ld (hl),c
pop de
pop hl
ret
PREGS: ld a,(STARTREG)
push bc
add b
ld b,a
ld a,c
call putreg
pop bc
ret
GETSEC: ld b,1
call GET
ld (SEC),a
inc b
call GET
ld h,0
ld l,a
ld (FP),hl ; Put the File Pointer to saved FP
ret
PUTSEC: ld a,'E'
ld b,0
call PUT
ld a,(SEC)
call INCPUT
ld de,(FP) ; Get SEC & FP
ld a,e
INCPUT: inc b
jp PUT
;-----------------------------------------------------------------------------
; Edit -- He, He, He...
;
ERREDIT:
pop af
pop hl
jr EDITNOE
EDIT: call PRINT
db 'Edit',1 ; PRINT the 'E' for edit choice
EDITNOE:
call CRLF
ld bc,BUFFER - ENDFLG - 1 ; Setup for zeroing out
jr ESETUP
;--------------------------
; Run Shell (RUNSH) -- clear out the buffers and go to the editor.
RUNSH:
RUNSHNP:
call GETSEC
ld a,1 ; Z3 Cmd line for ZEX
call putzex ; Make ZEX think we are Z3
ld bc,BUFFER - ENDFLG
ESETUP: call SETUP
EDIT2:
call OUTPUT1
ELOOP: xor a
ld (NOOUT+1),a ; OK for output
call GETKEY
ld b,a
ld a,(SHIFT) ; Get shift mask
or b
push af
xor a
ld (SHIFT),a ; Clear shift mask
pop af
cp ' '
jr c,CONTROL ; Yes, it's a command
cp 127
jr nc,CONTROL
call SAVECMD
call INSERT ; No, it's just a letter
jr ELOOP
CONTROL:
ld hl,ELOOP ; Return to...
push hl
ld de,TABLE ; Go to proper command
call UCASE
call SAVECMD
call acase2
SAVECMD:
push af
ld a,(JUSTCMD)
ld (LASTCMD),a
pop af
ld (JUSTCMD),a
ret
SHIFTED:
ld a,10000000b ; Make shift mask set high bit
ld (SHIFT),a
ret
DELCHR: call DPOS ; Back up and delete forward
ret z
call DELETE
jp SHOWTOEND
FCHR: call FWRAP ; Go ahead a char and wrap if EOL
jp IPOS
FWRAP: ld hl,(POS) ; Check for forward wrap
ld a,(hl)
or a
ret nz
pop hl
jp GOBOLN
BCHR: call BWRAP ; Go back and wrap if BOL
jp DPOS
BWRAP: ld hl,(POS) ; Check for back wrap
dec hl
ld a,(hl)
or a
ret nz
pop hl
jp GOEOLN
MBWORD: call BWRAP ; Word forward with wrap
BWORD: call DPOS ; Word forward without
ret z
inc de
call PUNCCP ; Looking for punctuation
jr z,BWORD ; Skip punct
BWORD2: call DPOS
ret z
inc de
call PUNCCP ; Go till we hit punct
jr nz,BWORD2
dec de
jp IPOS
PUNCCP: ld hl,PUNC ; Check for punctuation
ld bc,PUNCLEN
cpir
ret
FDWORD: ld de,0 ; Delete forward a word
call FWORD ; Word forward
push de
FDWBACK:
ld a,d
or e
jr z,FDWENDBACK
dec de
call DPOS ; Back up same number of Chars
jr FDWBACK
FDWENDBACK
pop de ; Delete same number of chars
jr BDWRD1
BDWORD: ld de,0 ; Delete a word backwards
call BWORD
BDWRD1: call SETKILL
BDWRD2: ld a,d
or e
jp z,BDWRDEND
dec de
push de
push hl
call DELETE ; Delete same number
pop hl
inc hl
pop de
jr BDWRD2
BDWRDEND:
ld (hl),0
jp SHOWTOEND
MFWORD: call FWRAP ; Forward word with wrap
FWORD: call IPOS
ret z
inc de
call PUNCCP ; Skip until punct
jr nz,FWORD
FWORD2: call IPOS
ret z
inc de
call PUNCCP ; Skip punct
jr z,FWORD2
dec de
jp DPOS ; Back up one
UP: ld hl,(WIDTH) ; Back 80 chars
BACKUP: ld a,h
or l
ret z
dec hl
push hl
call DPOS ; back up that many
pop hl
ret z
cp ' '
jr nc,BACKUP ; Control chars count double
ld a,h
or l
ret z
dec hl
jr BACKUP
DOWN: ld hl,(WIDTH) ; Go down a line
DOWNLOOP:
ld a,h
or l
ret z
dec hl
push hl
call IPOS ; Forward 'til hl = zero
pop hl
ret z
cp ' ' ; Control chars count double
jr nc,DOWNLOOP
ld a,h
or l
ret z
dec hl
jr DOWNLOOP
COMPLETE:
xor a
cpl
ld (NOOUT+1),a ; NO output
ld hl,LASTCMD
ld a,(CCOMP)
cp (hl)
jr z,COMP2OK
call ISOLATE_NAME
call GET_FCB
COMPL3: push af
xor a
ld (NOOUT+1),a
pop af
jp z,NOT_FOUND
call BACK_UP_AND_REDISPLAY
ret
COMP2OK:
call GET_NEXT
ld hl,(POS)
jr COMPL3
ISOLATE_NAME:
ld hl,(POS)
push hl
COMPLOOP:
call DPOS
jr z,COMPDONE
ld hl,SEP
ld bc,SEPLEN
cpir
jr z,COMP2DONE
jr COMPLOOP
COMP2DONE:
call IPOS
COMPDONE:
ld hl,(POS)
pop de
push de
ld a,(de)
push af
xor a
ld (de),a
ld de,TBUF
ld (STARTNAME),hl
MLOOP: ld a,(hl)
call UPCASE
ld (de),a
inc de
inc hl
cp ':'
jr nz,NOCOLON
ld (STARTNAME),hl
NOCOLON:
or a
jr nz,MLOOP
ld hl,STARDOTSTAR
dec de
ld bc,4
ldir
pop af
pop hl
ld (hl),a
ret
GET_FCB:
push hl
ld hl,TBUF
push hl
ld de,5ch
call parse2
ld a,(5ch+15)
or a
jr nz,MISSION_ABORT
pop de ; DMA at TBUF
call DMA
ld de,5ch
call PUTUD
call DZ3LOG
ld a,(5ch+13)
ld (SEARCH_USER),a
ld c,17
call ADOS
NEXT_NAME:
inc a
jr z,NOGO
push af
call SETDMA
call GETUD
pop af
or a
NOGO: pop hl
ret
MISSION_ABORT:
xor a
pop hl
pop hl
ret
GET_NEXT:
push hl
ld de,TBUF
call DMA
ld de,5ch
call PUTUD
ld a,(SEARCH_USER)
ld (5ch+13),a
call DZ3LOG
ld c,18
call ADOS
jr NEXT_NAME
NOT_FOUND:
xor a
ld (JUSTCMD),a
ld (POS),hl
jp beep
BACK_UP_AND_REDISPLAY:
push af
ld de,(STARTNAME)
ld (POS),hl
jr DEL_CHK_LOOP
DEL_LOOP:
push de
call DELCHR
pop de
DEL_CHK_LOOP:
ld hl,(POS)
or a
sbc hl,de
jr nz,DEL_LOOP
pop af
dec a
add a,a
add a,a
add a,a
add a,a
add a,a
ld e,a
ld d,0
ld hl,TBUF + 1
add hl,de
ld b,8
FNLOOP:
ld a,(hl)
and 1111111b
cp ' '
push hl
push bc
call nz,INSERT
pop bc
pop hl
inc hl
djnz FNLOOP
FIRSTNAME:
push hl
ld a,'.'
call INSERT
pop hl
ld b,3
TYPLOOP:
ld a,(hl)
and 1111111b
cp ' '
jr z,LASTNAME
push hl
push bc
call INSERT
pop bc
pop hl
inc hl
djnz TYPLOOP
LASTNAME:
call SHOWTOEND
ret
WARM: call DONEOUT
jp 0
DONE: pop hl ; Save it and run it
call DONEOUT
call GETLEN ; Get the length in BC
ld a,(BUFFER)
cp ';' ; Comment?
jr z,JRUNSH
or a ; Empty?
jp nz,FILL ; Stuff the buffer
JRUNSH: call qerror
ret z
call qshell
ret nz
call CRLF
jp RUNSHNP
FDEL: call DELETE ; Delete forward a char
ret z
jp SHOWTOEND ; Redisplay
QINSERT:
call GETKEY ; Get a key and insert it -- whatever it is
or a
ret z
jp INSERT
TOGLIN: ; And Diagnostic Key (sometimes...)
; ld b,0
; call GET
; call pa2hc
; call print
; db ', ',0
; ld b,1
; call GET
; call pa2hc
; call print
; db ', ',0
; ld b,2
; call GET
; call pa2hc
; call print
; db 13,10,'FP:',0
; ld a,(FP)
; call pa2hc
; call print
; db ', SEC:',0
; ld a,(SEC)
; call pa2hc
; call print
; db ', BACK:',0
; ld a,(BACKFLG)
; call pa2hc
; call print
; db ', END:',0
; ld a,(ENDFLG)
; call pa2hc
; call print
; db ' ',0
; ret
ld hl,INSFLG ; Toggle the insert flag
ld a,(hl)
cpl
ld (hl),a
ld hl,(POS)
push hl
push af
call GOBOLN
call BACK
call BACK ; Back up to the begining and back to ICHAR
pop af
call INSPROMPT
pop de
TOGLP: ld hl,(POS) ; Go fwd to where we were
sbc hl,de
ret z
call IPOS
jr TOGLP
CMDKILL:
call SETKILL
CKL: push hl
call DELETE ; Delete to a semi-colon
pop hl
inc hl
cp ';'
jr z,CKDONE
or a ; Or a NULL
jr nz,CKL
CKDONE: ld (hl),0
jp SHOWTOEND ; Redisplay
DELLN1: call GOBOLN
jr NSDELTOEND
DELLIN:
call GOBOLN ; Go to start
DELTOEND:
call SETKILL
NSDELTOEND:
call CLRTOEND ; Wipe everything on screen
ld hl,(POS)
ld (hl),0 ; Put a null at the start
ret
GOEOLN: call IPOS ; Move to end of line
jr nz,GOEOLN
ret
GOBOLN: call DPOS ; Move to start of line
jr nz,GOBOLN
ret
REPLOT: ld hl,(POS) ; RePRINT entire line
push hl
call GOEOLN ; Go to end and give us a CR LF
REPLT1: call CRLF
call OUTPUT ; Redisplay
pop de
GOTOPOS:
or a
call IPOS ; Move fwd to old position
sbc hl,de
ret z
jr c,GOTOPOS
GP2: call DPOS
ret z
sbc hl,de ; Done?
ret z
jr GP2
CAPIN: call cin
; Fall through to UPCASE
UCASE: push bc ; Upcase A
push af
and 80h
ld b,a
pop af
and 7fh ; Keep high bit
call UCASE2 ; Real upcase
or b
pop bc
ret
UCASE2:
cp ' ' ; Standard blah blah upcase funct
jr nc,NOTCTL
add '@'
NOTCTL: cp 'a'
ret c ; Not a lowercase
cp 'z'+1
ret nc ; Not a lowercase
sub ' ' ; Yes, a lowercase
ret
UPCASE: ; More standard upcase
cp 'z' + 1
ret nc
cp 'a'
ret c
sub a,'a'-'A'
ret
BSEARCH:
call OPEN ; Check for open, etc.
ld hl,(FP) ; Get our locations
ld a,(SEC)
push af
push hl
ld a,(ENDFLG) ; Did we hit the end?
or a
jr z,BBDONE
ld a,(BACKFLG) ; Did we back up right before this?
or a
jr nz,BBDONE
call BNOWRITE
jr z,BSRCHNO1
BBACK: call BNOWRITE ; Find the NULL
jr nz,BBACK
BBDONE: ld bc,BUFFER
push bc
BSRCHL: call BNOWRITE ; Is this the end?
BSRCHL2:
call BNOWRITE
jr z,BSRCHNO
call FNOWRITE ; No, Place us properly
BSRCL1: call BNOWRITE
jr nz,BSRCL1
call FNOWRITE
ld c,0
pop de
push de
BSRCHECKING:
inc c
call UCASE
ld b,a
ld a,(de)
ld hl,(POS)
sbc hl,de
jr z,BSRGOTIT
inc de
call UCASE ; Make all upcase
cp b
jr nz,BSRGOTIT ; Same?
push de
push bc
call FNOWRITE
pop bc
pop de
jr BSRCHECKING
BSRGOTIT:
push af
ld b,c
BSR_BACKING_UP:
push bc
call BNOWRITE
pop bc
djnz BSR_BACKING_UP
pop af
jr nz,BSRCHL2
call NSDELTOEND
xor a
call BESET ; We went back -- Indicate it
cpl
ld de,(POS)
ld (NOOUT+1),a
pop bc
pop hl
pop af
push de
call GETLINE ; Get a whole line in
pop hl
ld (POS),hl
call NOSAV
; xor a ; Getline always ends with a null
ld (NOOUT+1),a
jp SHOWTOEND
BSRCHNO:
pop bc
BSRCHNO1:
call BEEP ; Not found do the beep thing
PUTBACK:
pop hl
pop af
ld (FP),hl ; Restore our pointers
ld (SEC),a
RRAND: ld c,21h
call DORAND ; Read that first one back in
or a
ret z
ZBUF: push de
ld hl,SECBUF ; Zero out our record
ld bc,127
call ZERO
pop de
ret
QUITSH: call qerror ; Pop the shell stack
; ret z ; Unless we're in the error handler.
pop hl
call nz,SHPOP
call EASERUN
ld a,0
ld b,0
call z,PUT
DONEOUT:
call GOEOLN ; Go to the end and CR
ld a,13
JCOUT: jp COUT
BEEP: ld a,bell
jr JCOUT
BACKLINE: ; Go to previous command line
call OPEN
ld a,(ENDFLG)
or a
call z,EZER ; Till we get to start
BGET: call BNOWRITE
call z,FNOWRITE
jr z,BEEP ; No command line before
ld hl,TBUF
ld (hl),0
inc hl
BINSERT: ; Insert the line backing up
ld (hl),a
inc hl
push hl
call BNOWRITE
pop hl
jr nz,BINSERT
push hl
ld hl,BACKFLG ; Did we just go backwards?
ld a,(hl)
ld (hl),0ffh
or a
pop hl
jr z,BGET
push hl
call DELLN1 ; Kill existing line
pop hl
dec hl
BIN2: ld a,(hl)
dec hl
or a
jr z,GOBEGINOPTION ; Put her there
push hl
call INSERT
pop hl
jr BIN2
GOBEGINOPTION:
push af
ld a,(GOBEGFLG)
or a
call nz,GOBOLN
call NOSAV
pop af
ret
NEXTLINE:
ld a,(ENDFLG) ; Are we at the end?
or a
ret z
call OPEN ; Open the sucker if it ain't already
GETLINE:
FGET: call FNOWRITE
jr z,CHKTOP ; At the end?
push af
call NOTTOP ; Set flag
pop af
ld hl,TBUF
FINSERT:
ld (hl),a
inc hl
push hl
call FNOWRITE ; Bring 'em in
pop hl
jr nz,FINSERT
ld (hl),0
ld hl,BACKFLG ; Did we go back?
ld a,(hl)
ld (hl),0
or a
jr nz,FGET
call DELLN1 ; Delete the line
ld hl,TBUF
FIN2: ld a,(hl)
inc hl
or a
jr z,GOBEGINOPTION
push hl
call INSERT ; Push the chars in
pop hl
jr FIN2
CHKTOP: call DELLN1 ; Clean out existing line
call BNOWRITE
xor a
jr ESET ; Fix End Flag
NOTTOP: xor a
cpl
jr ESET
EZER: xor a ; Set the lot of them
cpl
BESET: ld (BACKFLG),a
ESET: ld (ENDFLG),a
ret
; ---------------------------------------
; Support routines for the commands above
;
SETSCAN:
push af ; Delete line and quiet terminal
call DELLN1
xor a
cpl
ld (NOOUT+1),a
pop af
ret
INSERT: call DOSAV
ld e,a ; Put the char in
ld a,(INSFLG)
or a
jr nz,YAINS
ld hl,(POS)
ld a,(hl)
or a
ld a,e
jr nz,OVERWRITE ; Do we insert?
YAINS: xor a
ld b,a
push de
call MOVEUP ; Push them up
pop de
jp z,BEEP ; No room
ld a,e
OVERWRITE:
ld hl,(POS)
ld (hl),a
call IPOS ; Skip over it (PRINTing it)
jp SHOWTOEND ; Redisplay
DELETE: call DOSAV
ld de,(POS) ; Kill a char quiet-like
ld a,(de)
or a
ret z
push af
ld hl,DELETED
inc (hl)
cp ' '
jr nc,NOINC2 ; Increment DELETED as neccessary
inc (hl)
NOINC2: call MOVEDOWN
pop af
or a
ret
SETKILL:
push de
ld hl,(POS)
ld de,KILL
push de
ld bc,killlen ; Stop before NULL in KILL
ldir ; Move it
pop hl
pop de
ret
OUTPUT: call crlf ; New line
OUTPUT1:
call PROMPT ; Redisplay prompt
OUTPUT2:
ld hl,BUFFER ; And command line
ld (POS),hl
jp SHOWTOEND
CLRTOEND:
ld hl,(POS) ; Wipe out command line from cursor to right
ld de,0
call DOSAV
CLRLOOP:
ld a,(hl) ; Loop until NULL
or a
jr z,NOWBACK
cp ' '
jr nc,CLR2
inc de
call SPACE ; Two for Control Chars
CLR2: call SPACE ; Overwrite it
inc hl
inc de
jr CLRLOOP
NOWBACK:
ld a,d
or e
ret z
dec de
call BACK ; And return to old location
jr NOWBACK
IPOS: ld hl,(POS) ; Get current char and PRINT it
ld a,(hl)
or a
ret z ; Return zero if NULL
push af
inc hl
ld (POS),hl
push bc
ld b,a
ld a,(NOOUT + 1) ; Silence?
or a
ld a,b
pop bc
call z,CCOUT
pop af
ret
DPOS: ld hl,(POS) ; Back up (^H)
dec hl
ld a,(hl)
or a
ret z
push af
ld (POS),hl
cp ' '
call c,BACK ; Two for Control Char
call BACK
pop af
ret
SHOWTOEND:
call PRINTHL ; Show line to end
jr nz,SHOWLP
ld hl,DELETED ; With spaces for deleted text
ld a,(hl)
or a
jr z,SHOWLP
SHW1: push af
call SPACE
pop af
dec a
jr nz,SHW1
SHW2: call BACK
dec (hl)
jr nz,SHW2
SHOWLP: ld a,d
or e
ret z
dec de
call DPOS
jr SHOWLP
PRINTHL:
ld de,0 ; Show text at HL to NULL
PHLOOP: call IPOS
ret z
inc de
KILLFLG:
ld a,0 ; Check for UNDO
or a
ret nz
push bc
ld c,11 ; Check for console in
call ADOS
pop bc
or a
jr z,PHLOOP
call cin ; Check for previous input
ld (GETKEY+1),a
cp ' '
jr c,PHLOOP
cp 127 ; If it's an input, don't redisplay
ret nz
jr PHLOOP
GETKEY: ld b,0
xor a
ld (GETKEY+1),a ; Save the previous key
ld a,b
or a
call z,cin
ret
MOVEUP: ld hl,(POS) ; Move the text up to accept new char
ld a,' '
UPLOOP: ld b,(hl)
ld (hl),a
inc hl
ld a,b
or a
jr nz,UPLOOP
ld (hl),a
ld de,BUFFER + killlen
sbc hl,de ; Until the end
jr z,MOVEDOWN ; No good, move it back
or 1
ret
MOVEDOWN: ; Move a char out -- Delete
ld hl,(POS)
ld d,h
ld e,l
DNLOOP: inc hl
ld a,(hl) ; Pull them down till we find a NULL
ld (de),a
or a
inc de
jr nz,DNLOOP
ret
UNDO: ld hl,KILL ; Insert Kill buffer
xor a
cpl
ld (KILLFLG + 1),a
call UNDO1
xor a
ld (KILLFLG + 1),a
jp SHOWTOEND
UNDO1: ld a,(hl) ; insert at HL until NULL
inc hl
or a
ret z
push hl
call INSERT
pop hl
jr UNDO1
WFFILE: call RCHECK ; Forward a char in the file with write
ld de,(FP)
ld (de),a
ld hl,SECTOP-1
sbc hl,de
jr nz,FNOWRITE
call WRAND
FNOWRITE: ; Forward a char
call RCHECK
ld de,(FP)
inc de
ld hl,SECTOP
sbc hl,de
jr nz,NOREAD
ld hl,SEC
inc (hl)
call RRAND
ld de,SECBUF
NOREAD: ld a,(de)
ld (FP),de
or a
ret
WBFILE: call RCHECK ; Back a char in file with write
ld de,(FP)
ld (de),a
ld hl,SECBUF
sbc hl,de
jr nz,BNOWRITE
call WRAND
BNOWRITE: ; Back a char
call RCHECK
or a
ld de,(FP)
dec de
ld hl,SECBUF-1
sbc hl,de
jr nz,NOREAD
ld hl,SEC
dec (hl) ; Should never get to be ZERO... Honest.
jr nc,BNOZERO
ld (hl),0 ; But, what the hell, it's free.
BNOZERO:
call RRAND
ld de,SECTOP-1
jr NOREAD
WRAND: ld c,22h ; Write random
call DORAND
or a
ret z
jp nz,WMERR
DORAND: ld a,(SEC) ; Put random record in right place in FCB
ld hl,FCB+33 ; Set the DMA and call BDOS
ld (hl),a
inc hl
xor a
ld (hl),a
inc hl
ld (hl),a
push de
call SETDMA
call FBDOS
pop de
ret
SETDMA: push bc ; Set the DMA to the SECBUF
ld de,SECBUF
call DMA
pop bc
ret
DMA: ld c,26
jp ADOS
BCD2: push bc ; Format two digit numbers
ld c,0ffh
BCD2A: inc c
sub 10
jr nc,BCD2A ; Put them in BCD (??) form
add a,10
ld b,a
ld a,c
rlca
rlca
rlca
rlca
or b
pop bc
ret
PAFDC: ld d,0 ; PRINT them out
MAFDC: push af ; Put them in a memory location
call BCD2
push af
rra
rra
rra
rra
and 1111b
call nz,DEPUT ; Output tens
pop af
call DEPUT ; Output ones
pop af
ret
DEPUT: and 1111b
add '0'
inc d
dec d ; Check for output
jp z,COUT
ld (de),a ; Else memory stuff
inc de
ret
SETCPM3:
ld a,(USE6)
or a
jr nz,SETCINFN6
ld hl,CINFN1 ; .. set vector to
ld (cinjmp),hl ; .. function 6 routine
ld c,12 ; if CP/M Plus
call BDOS
cp 30h
ret c
SETCINFN6:
ld hl,CINFN6 ; .. set vector to
ld (cinjmp),hl ; .. function 6 routine
ret
;
cinjmp equ $+1
CIN: jp 0 ;vector to console input routine
;
;
; Bdos console in, fn 1--no echo.
;
CINFN1:
push hl
push de
push bc
ld hl,(1) ; patch bios conout
ld de,9
add hl,de
ld e,(hl) ; save bios byte (might not be JP)
ld (hl),0c9h ; .. to RET to prevent echo
ld c,1 ; get char from bdos
call ADOS
ld (hl),e ; restore bios conout byte
pop bc
pop de
pop hl
ret
;
; Bdos console in, fn 6--no echo.
;
CINFN6:
push de
push bc
CINF60: ld c,6
ld e,0ffh
call ADOS
or a
jr z,CINF60 ;..wait for input
pop bc
pop de
ret
RCHECK: push af ; Have we read already?
ld a,(RDFLG)
or a
jr nz,RCK1 ; Yes
cpl
ld (RDFLG),a ; No, now yes
push hl
push bc
call RRAND ; And read
pop bc
pop hl
RCK1: pop af
ret
SETFILE: ; Make FCB ok w/respect to Z33 FCB
ld hl,FCB
ld bc,35 ; Zero out FCB and DMA.
call ZERO
ld hl,SECBUF
ld bc,80h
call ZERO
ld hl,NAME
ld de,FCB+1
ld bc,11
ldir
call getefcb
ld bc,14 ; Offset to drive number
add hl,bc ; HL now points to the drive number
; Here we get the drive where the program was found. Since we know that this
; is not a resident program, there is no need to check for a zero value.
ld a,(hl) ; Get it and
ld de,FCB
ld (de),a
dec hl ; Back up to user number
ld a,(hl) ; Get it and
ld (FCB+13),a ; put it in our FCB
ld de,FCB
jp z3log
OPEN: call EASERUN
ret nz ; Don't perform any file operations!
ld hl,OPENFLG ; Open the file
ld a,(hl)
or a
ret nz
ld (hl),0ffh
OKFP: call SETFILE
ld c,15 ; Open
call FBDOS
inc a
ret nz
YANEW: call DELSET
ld c,22 ; Make
call FBDOS
inc a
jr z,WMERR
call ZBUF
call SETDMA
xor a
ret
SETUP: ld hl,INSFLG ; Fill and Zap
ld (hl),0ffh
inc hl
ld (hl),0ffh ; BACKFLG
inc hl
jp ZERO ; Zero out to exhaustion of bc
NOSAV: push af
xor a
SAVSTO: push bc
ld b,a
ld a,(SMARTSAV)
or b
ld (SAVFLG),a
pop bc
pop af
ret
DOSAV: push af
xor a
cpl
jr SAVSTO
ZERO: ld d,h ; Fill and area with zeros
ld e,l
inc de
ld (hl),0
ldir
ret
WMERR: call GOEOLN ; Write and error message
call crlf
ld hl,DISKFULL
call PSTR
ld a,'!'
ld (OPENFLG),a
call COUT
pop hl
jp REPLOT
DZ3LOG: ld a,(de)
or a
ld a,(OLDDRIVE)
jp nz,z3log
ld (de),a
jp z3log
PUTUD: push bc
push af
call GUA
ld (SUSER),a
ld c,19h
call ADOS
ld (SDRIVE),a
pop af
pop bc
ret
GETUD: push de
push bc
push af
ld a,(SUSER)
call SUA
ld a,(SDRIVE)
call SETDRIVE
pop af
pop bc
pop de
ret
SETDRIVE:
ld e,a
ld c,0eh
ADOS: push bc
push de
push hl
call BDOS
pop hl
pop de
pop bc
ret
PRINT: ex (sp),hl ; PRINT a string
call PSTR
ex (sp),hl
ret
PSTR: push af ; PRINT a string at HL
ld a,(hl)
inc hl
or a
jr z,PSTR1
cp 1
jr z,DCRLF ; If 1, then end with a CRLF
push af
and 01111111b
call COUT
pop af
and 10000000b
jr nz,PSTR1
pop af
jr PSTR
DCRLF: call CRLF
PSTR1: pop af
ret
CCOUT: push af
; cp 8 ; For valid CCOUT, these are needed...
; jr z,OK ; But who's gonna know?
; cp 13
; jr z,OK
; cp 10
; jr z,OK
cp ' '
jr nc,OK
push af
ld a,'^'
call COUT
pop af
add '@'
OK: call COUT
pop af
ret
SPACE: ld a,' ' ; PRINT a space
jr COUT
BACK: ld a,8 ; PRINT a ^H
COUT: push af ; Output
push bc
push de
push hl
ld e,a
NOOUT: ld a,0 ; Being quiet
or a
ld c,6
call z,pbdos ; And the real PRINT
pop hl
pop de
pop bc
CPOP: pop af
ret
PBDOS: ld a,e
ld hl,SPOS
cp 8
jr z,BACKP
cp 13
jr z,ZEROP
cp 7
jr z,NOIP
cp 10
jr z,NOIP
cp 9
jr z,TABCHR
inc (hl)
NOIP: jp BDOS ; BIOS COUT
ZEROP: ld (hl),1
BACKP: dec (hl)
jr NOIP
TABCHR: ld a,' ' ; Expand Tab
call COUT
ld a,7
and (hl)
ret z
jr TABCHR
CRLF: call PRINT ; PRINT a CRLF
dc cr,lf
ret
;=============================================================================
; C O N S T A N T S
;=============================================================================
DUCHANGE:
dc 'Illegal attempt to change directory'
BADDU:
dc 'Invalid directory'
BADPW:
dc 'Incorrect password'
UNKNOWN:
dc 'Unknown error'
BADFORM:
dc 'Bad command name (file type or wild card used)'
BADECP:
dc 'Command not found (even by ECP)'
BADCMD:
dc 'Requested load file not found on disk'
AMBIG:
dc 'Ambiguous or missing file name'
BADNUM:
dc 'Bad numerical expression'
NOFILE:
dc 'Source file not found'
DISKFULL:
dc 'Disk full'
OVERFLOW:
dc 'TPA overflow'
DUPLICATE:
dc 'Duplicate file specifications'
dc 'Segment too large'
dc 'Bad segment address'
dc 'Command line overflow'
dc 'Duplicate file specification'
dc '7'
dc '8' ; 17...19 not yet in use
dc '9'
dc 'Can''t load rsx'
dc 'Can''t remove rsx'
STARDOTSTAR:
db '*.*',0
; B U F F E R S
; -------------
STACK equ entry + 1310h
SAVED_STACK equ stack + 2
FCB equ saved_stack + 2
OLDDRIVE equ fcb + 36
STARTNAME equ olddrive + 1
SEARCH_USER equ startname + 2
LASTCMD equ search_user + 1
JUSTCMD equ lastcmd + 1
SUSER equ justcmd + 1
SDRIVE equ suser + 1
SEC equ sdrive + 1
FP equ sec + 2
POS equ fp + 2
DELIMPTR equ pos + 2
DELIM equ delimptr + 2
ZEXORSUB equ delim + 2
INSFLG equ zexorsub + 1
BACKFLG equ insflg + 1
ENDFLG equ backflg + 1
RDFLG equ endflg + 1
OPENFLG equ rdflg + 1
SHIFT equ openflg + 1
SAVFLG equ shift + 1
SPOS equ savflg + 1
DELETED equ spos + 1
TBUF equ deleted + 2
KILL equ tbuf + killlen + 2
BUFFER equ kill + killlen + 2
DEFAULT_TOP_OF_BUFFER equ buffer + killlen
end
equ d