;
; Program: SH
; Author: Richard Conn
; Version: 1.0
; Date: 5 Mar 84
;
;
; This program illustrates the design of a simple shell under ZCPR3
; using Z3LIB. This program is transportable from one ZCPR3 system to another
; provided it is reassembled with the correct address for the ZCPR3
; Environment Descriptor (Z3ENV) or DDT is used to patch this address
; (which is the first two bytes after the opening JMP). If an external
; ZCPR3 Environment Descriptor is not available, one will have to be
; provided by setting the Z3ENV equate to 0 and providing SYSENV.LIB in
; the current directory at assembly time.
;
;
; Equates for Key Values
;
z3env SET 0f400h ;address of ZCPR3 environment
lecnt equ 20 ;number of pointers on String Ptr Stack
ctrlz equ 'Z'-'@' ;^Z for EOF
cmdch equ '!' ;in comment mode, invoke following text as command
cmtch equ ';' ;comment character
subch equ '%' ;substitution flag
fcb equ 5ch
tbuff equ 80h
cr equ 0dh
lf equ 0ah
;
; Environment Definition
;
if z3env ne 0
;
; External ZCPR3 Environment Descriptor
;
jmp start
db 'Z3ENV' ;This is a ZCPR3 Utility
db 1 ;External Environment Descriptor
z3eadr:
dw z3env
start:
lhld z3eadr ;pt to ZCPR3 environment
;
else
;
; Internal ZCPR3 Environment Descriptor
;
MACLIB Z3BASE.LIB
MACLIB SYSENV.LIB
z3eadr:
jmp start
SYSENV
start:
lxi h,z3eadr ;pt to ZCPR3 environment
endif
;
; Start of Program -- Initialize ZCPR3 Environment
;
call z3init ;initialize the ZCPR3 Environment
;
; Set Pointers
;
call codend ;find scratch area
shld intline ;set ptr to internal line buffer
lxi d,200H ;reserve 200H bytes
dad d
shld varlist ;set ptr to variable list
xra a
sta loadfl ;say variables not loaded
;
; Check for Shell Stack
;
call getsh2 ;get shell status
jnz start0 ;skip over shell init
call print
db 'No Shell Stack',0
ret
;
; See if this program was invoked as a shell
;
start0:
call qshell ;find out from ZCPR3 environment
jz shell ;do not push onto stack if invoked as a shell
start1:
;
; Clear Shell Message for Comment Flag
;
mvi b,0 ;message 0
xra a ;A=0 to clear
call putshm ;set message
;
; Set Name of Shell Variable File if One is Given
;
call getfn1 ;pt to buffer in env
lxi d,fcb+1 ;pt to name
xchg ;copy from name
mvi b,11 ;11 bytes
mov a,m ;check for name
cpi ' ' ;no name if space
jz defname
call moveb ;copy if name present
call setshdef ;set default file type
jmp setshn
;
; Set Name of SH.VAR File
;
defname:
call getfn1 ;get name
lxi d,shvfcb+1 ;pt to FCB
xchg
mvi b,11 ;11 chars
call moveb
;
; Set Name of Shell from External FCB if Possible or From Default if Not
;
setshn:
call root ;get root address
lxi h,shdisk ;pt to shell disk
mov a,b ;get disk
adi 'A' ;convert to letter
mov m,a ;set disk letter
inx h ;pt to user 10's
mov a,c ;get user number
mvi b,10 ;subtract 10's
mvi d,'0' ;set char
setshn1:
sub b ;subtract
jc setshn2
inr d ;increment digit
jmp setshn1
setshn2:
add b ;get 1's
mov m,d ;set 10's digit for user
inx h ;pt to 1's digit
adi '0' ;compute 1's digit
mov m,a ;set 1's digit
call getefcb ;get ptr to external fcb
jz start2 ;no external FCB, so use default name
inx h ;pt to program name
lxi d,shname ;pt to string
mvi b,8 ;8 chars
call moveb ;copy into buffer
;
; Push Name of Shell onto Stack
;
start2:
lxi h,shdisk ;pt to name of shell
call shpush ;push shell onto stack
jnz start3
;
; Shell Successfully Installed
;
call print
db 'Shell Installed',0
ret
;
; Shell Stack Push Error
;
start3:
cpi 2 ;shell stack full?
jnz start4
;
; Shell Stack is Full
;
call print
db 'Shell Stack Full',0
ret
;
; Shell Stack Entry Size is too small for command line
;
start4:
call print
db 'Shell Stack Entry Size',0
ret
;
; Restart on Empty Line
;
shellr:
call crlf ;new line
;
; Print Shell Prompt
;
shell:
call retud ;get current user and disk
mov a,b ;save disk
adi 'A'
call cout ;print disk letter
mov a,c ;get user
call pafdc ;print A as floating decimal
call dutdir ;convert into DIR reference if possible
jz shell1 ;no match
mvi a,':' ;print colon
call cout
mvi b,8 ;8 chars max
shell0:
mov a,m ;get char
inx h ;pt to next
cpi ' ' ;space?
cnz cout
jnz shell0
shell1:
mvi b,0 ;get shell message 0
call getshm
ani 1 ;test for prompt
jz shell2 ;print normal prompt
call print ;comment format
db '; ',0 ;comment
jmp shell3
shell2:
call print ;normal format
db '>> ',0 ;double prompt
;
; Accept User Input
;
shell3:
mvi a,1 ;tell ZEX that prompt is up
call putzex
xra a ;don't capitalize
call bbline
mvi a,0 ;say that normal processing is running now
call putcst
call putzex
call sksp ;skip over leading spaces
mvi b,0 ;get shell message 0
call getshm
ani 1 ;test for comment
jz shell4 ;process normally
;
; Process Shell Input as Comment
;
mov a,m ;get char
cpi cmdch ;command override?
jnz shellr ;continue with next line if not
inx h ;pt to command and fall thru to process
;
; Process Shell Command
;
shell4:
mov a,m ;get first char
ora a ;no line?
jz shellr
cpi cmtch ;comment line?
jz shellr
;
; Check for and Process Shell-Resident Command
;
push h ;save HL
call shcommand ;check for shell command
pop h ;restore HL
;
; Expand Shell Command Line
;
call expand ;expand line pted to by HL
jz clovfl ;abort if overflow
;
; Load Multiple Command Line
;
call putcl ;place command line pted to by HL into CL Buffer
rnz ;resume ZCPR3 processing
;
; Input Line is Longer than Command Line Buffer
;
clovfl:
call print ;command line buffer has overflowed
db cr,lf,'CL Ovfl ',0
jmp shellr
;
; Expand Shell Command Line (pted to by HL), performing variable
; Substitutions
;
; On exit, Z=command line overflow and Line Pted to by HL
;
expand:
push b ;save counter
mvi b,0 ;get shell register 0
call getshm
ani 2 ;test for echo
cnz crlf ;new line if SHECHO is ON
pop b ;get counter
xchg ;DE pts to line
;
; Init String Pointer Stack
;
mvi a,lecnt ;set local element count
sta locelt
lxi h,locstk ;set local stack
shld locadr
lxi h,0 ;set done code on stack
call locpush ;push HL
;
; Set Ptrs
;
lhld intline ;pt to internal line
xchg ;DE pts to internal line, HL pt next char
mvi b,0 ;256 chars max
;
; Analyze Next Char
;
exp1:
mov a,m ;get next char
cpi subch ;substitution char?
jnz exp2 ;handle normally
;
; Process Shell Variable
;
call expvar ;resolve variable
dcr c ;error?
jz exp1 ;resume if none
;
; Store Next Char
;
exp2:
stax d ;store char
;
; Print Char if SHECHO is ON
;
push b ;save counter
mov c,a ;save char
mvi b,0 ;get shell message 0
call getshm ;determines if display is on
ani 2 ;test for echo
jz exp3
mov a,c ;get char
ani 7FH ;mask and don't output null
cnz cout ;echo char
;
; Advance to Next Char
;
exp3:
mov a,c ;get char
pop b ;get counter
inx h ;pt to next
inx d
dcr b ;count down
jz experr ;error if at 0
ora a ;done?
jnz exp1
inr b ;increment count (not counting last 0)
dcx d ;pt to 0 in case of abort
;
; Pop String Ptr Stack and Check for Analysis Complete
;
call locpop ;get ptr to previous string
mov a,h ;done?
ora l
jnz exp1 ;resume
dcr a ;set NZ
;
; Expansion Complete
; On entry, Z Flag is Set Accordingly (Z=Error)
;
experr:
lhld intline ;pt to internal line
ret
;
; Expand Variable
; Return with HL pting to next char, A=char, C=1 if OK, C=2 if error
;
expvar:
shld varptr ;save ptr to variable
inx h ;get next char
mvi c,2 ;prep for error return
mov a,m ;get it
ora a ;EOL?
rz
cpi subch ;double sub char?
rz ;place one sub char in line if so
;
; Place Variable Into SHVAR
;
push b ;save counter
push d ;save ptr to next char
push h ;save ptr to shell variable
lxi h,shvar ;pt to shell variable buffer
mvi b,8 ;8 chars max
mvi a,' ' ;space fill
call fillb
xchg ;DE pts to shell variable buffer
pop h ;pt to shell variable
mvi b,8 ;8 chars max
;
; Place Shell Variable into Buffer
;
expv1:
mov a,m ;get char
call delck ;check for delimiter
jz expv3 ;done if delimiter
stax d ;save char
inx h ;pt to next
inx d
dcr b ;count down
jnz expv1
;
; Flush Overflow of Shell Variable
;
expv2:
mov a,m ;get char
inx h ;pt to next
call delck ;check for delimiter
jnz expv2
dcx h ;pt to delimiter
;
; Shell Variable in buffer SHVAR
; HL pts to delimiter after variable in user line
;
expv3:
call locpush ;stack ptr to next char in current string
jz expv4 ;error in stack
call varload ;load shell variable list
jz expv4 ;failure
call namer ;resolve named variable reference
mvi c,1 ;OK
jz expv5 ;name found - resolve
;
; Shell Variable Not Resolved - Restore Ptr to It
;
expv4:
call locpop ;restore ptr
mvi c,2 ;error
lhld varptr ;pt to variable
;
; Entry Point for OK Return
;
expv5:
mov a,m ;get char
pop d ;pt to target
pop b ;get counter
ret
;
; Push HL onto String Ptr Stack
; Return with Z if Stack Overflow
;
locpush:
lda locelt ;get count
dcr a ;full?
rz
sta locelt ;set count
push d ;save DE
xchg ;DE pts to old string
lhld locadr ;get ptr to top of stack
mov m,e ;store low
inx h
mov m,d ;store high
inx h ;pt to next
shld locadr
xchg ;restore HL
pop d ;restore DE
xra a ;return NZ
dcr a
ret
;
; Pop HL from String Ptr Stack
;
locpop:
push d
lda locelt ;increment element count
inr a
sta locelt
lhld locadr ;get address
dcx h ;pt to high
mov d,m ;get high
dcx h ;pt to low
mov e,m ;get low
shld locadr ;set address
xchg ;restore ptr
pop d
ret
;
; Load Shell Variable List
;
varload:
push h ;save regs
push d
push b
lda loadfl ;already loaded?
ora a ;NZ=yes
jnz varl3
lhld varlist ;clear varlist in case of error
mvi m,ctrlz
;
; Look for Variable File
;
call getfn1 ;pt to file name of SH.VAR
lxi d,shvfcb+1
mvi b,11 ;11 bytes
call moveb
call putud ;save current location
call root ;determine DU of root
call logud ;goto root
lhld varlist ;pt to named variable list
lxi d,shvfcb ;try to open file
call initfcb ;init FCB
call f$open
jz varl1
;
; Variable File Not Found
;
call getud ;return home
xra a ;set not found code
pop b ;restore regs
pop d
pop h
ret
;
; Read in Variable File
;
varl1:
lxi d,shvfcb ;read in file
call f$read
jnz varl2
lxi d,tbuff ;pt to data
xchg ;copy into memory
mvi b,128 ;128 bytes
call hmovb
xchg
jmp varl1
varl2:
lxi d,shvfcb ;close file
call f$close
call getud ;return home
;
; Say List is Already Loaded
;
varl3:
xra a ;return NZ for OK
dcr a
sta loadfl ;set loaded flag
pop b ;restore regs
pop d
pop h
ret
;
; Resolve Named Variable Reference
; On input, SHVAR contains the shell variable name and
; CODEND pts to the list of shell variables, terminated by ^Z;
; if found, return with HL pting to name and Z
;
namer:
lhld varlist ;pt to variable list
namer1:
mov a,m ;get char
cpi ctrlz ;end of list?
jz namex
lxi d,shvar ;pt to shell variable name
mvi b,8 ;8 chars
namer2:
ldax d ;get name
cmp m ;match?
jnz nomatch
inx h ;pt to next
inx d
dcr b ;count down
jnz namer2
ret ;found!
nomatch:
mov a,m ;flush to end of string
inx h ;pt to next
ora a
jnz nomatch
jmp namer1 ;resume search
;
; Search Failed
;
namex:
ora a ;return NZ (^Z in A)
ret
;
; Check to see if char in A is a delimiter
; Return with Z if so
;
delck:
push h ;pt to table
push b ;save BC
call caps ;capitalize char
mov b,a ;char in B
lxi h,dtable ;pt to delimiter table
delck1:
mov a,m ;get delimiter
ora a ;done?
jz notdel
cmp b ;compare
jz yesdel
inx h ;pt to next
jmp delck1
notdel:
mov a,b ;get char
ora a ;set Z if null, else NZ
yesdel:
mov a,b ;restore char
pop b ;restore regs
pop h
ret
;
; Delimiter Table
;
dtable:
db '<>;:,.=-_ ',0
;
; Check for Shell Command and Process if Found
; HL pts to command line
;
shcommand:
xra a ;DIR before DU
call parser ;parse command line pted to by HL
inx d ;pt to name
lxi h,ctable ;pt to command table
shcmd:
mov a,m ;get first char of next entry
ora a ;done?
rz
mvi b,8 ;commands are 8 chars long
push h ;save ptr to FCB
push d ;save ptr to table entry
shcmd1:
ldax d ;compare
cmp m
jnz shcmd2
inx h ;pt to next
inx d
dcr b ;count down
jnz shcmd1
;
; Command Found - Get Address
;
mov a,m
inx h
mov h,m
mov l,a ;HL is address
;
; Clear Stack and Run
;
pop psw ;clear stack
pop psw
pop psw ;clear return address
pop psw ;clear pushed HL
pchl ;"run" command
;
; Command Not Found Yet
;
shcmd2:
pop d ;restore ptrs
pop h
lxi b,10 ;advance to next command
dad b
jmp shcmd ;resume search
;
; If File Type not Specified, Set Default
;
setshdef:
call getfn1 ;check for file type
lxi d,8 ;pt to file byte
dad d
xchg
lxi h,shvtype ;default file type
mvi b,3 ;3 chars
ldax d ;get char
cpi ' ' ;set if space
cz moveb ;copy
ret
;
; Pop Current Shell
;
shexit:
call print
db cr,lf,'Exiting Shell',0
jmp shpop ;clear shell stack entry
;
; Toggle Shell Comment Mode
;
shcomment:
mvi b,0 ;access shell register 0
call getshm
mov c,a ;save in C
ani 0FEH ;all bits but comment bit
mov d,a
mov a,c ;get comment bit
cma ;flip comment bit (other bits are 1)
ani 1 ;select just comment bit
ora d ;OR in other bits
call putshm ;set new value
jmp shellr ;resume
;
; Toggle Shell Echo Mode
;
shecho:
call print
db cr,lf,' Echo of Shell Commands is O',0
mvi b,0 ;access shell register 0
call getshm
mov c,a ;save in C
ani 0FDH ;all bits but echo bit
mov d,a
mov a,c ;get comment bit
cma ;flip comment bit (other bits are 1)
ani 2 ;select just echo bit
ora d ;OR in other bits
call putshm ;set new value
ani 2 ;test echo bit
jz shecho1
call print
db 'N',0
jmp shellr
shecho1:
call print
db 'FF',0
jmp shellr ;resume
;
; Print Names of SH Commands
;
shhelp:
call print
db cr,lf,'SH Commands --',cr,lf,0
lxi h,ctable ;pt to table
mvi c,0 ;set count
shh1:
mov a,m ;done?
ora a
jz shellr
call print
db ' ',0
mvi b,8 ;8 chars
shh2:
mov a,m ;get char
call cout
inx h ;pt to next
dcr b ;count down
jnz shh2
inr c ;increment count
mov a,c
ani 3 ;new line?
cz crlf
inx h ;skip address
inx h
jmp shh1 ;next
;
; Command Table
;
ctable:
db '? ' ;help
dw shhelp
db 'SHCMT ' ;comment mode
dw shcomment
db 'SHECHO ' ;echo input
dw shecho
db 'SHEXIT ' ;exit shell
dw shexit
db 0 ;end of table
;
; Buffers
;
shvfcb:
db 0
db 'SH ' ;name of shell variable file
shvtype:
db 'VAR'
ds 24 ;36 bytes total
shdisk:
db 'A' ;disk letter
db '00' ;user number
db ':' ;separator
shname:
db 'SH ',0 ;name of shell to go onto stack
shvar:
db ' ' ;shell variable
locelt:
ds 1 ;string stack element count
locadr:
ds 2 ;ptr to next entry on stack
locstk:
ds lecnt*2 ;string ptr stack
varptr:
ds 2 ;ptr to current variable in line
varlist:
ds 2 ;ptr to named variable list
intline:
ds 2 ;ptr internal expansion line
loadfl:
ds 1 ;variables loaded flag
