1088 lines
33 KiB
NASM
1088 lines
33 KiB
NASM
TITLE PART1 - COMMAND Transient routines.
|
||
|
||
INCLUDE COMSW.ASM
|
||
|
||
.xlist
|
||
.xcref
|
||
INCLUDE DOSSYM.ASM
|
||
INCLUDE DEVSYM.ASM
|
||
INCLUDE COMSEG.ASM
|
||
.list
|
||
.cref
|
||
|
||
INCLUDE COMEQU.ASM
|
||
|
||
|
||
DATARES SEGMENT PUBLIC
|
||
EXTRN BATCH:WORD,BATLOC:DWORD,PARMBUF:BYTE
|
||
EXTRN RESTDIR:BYTE,EXTCOM:BYTE,ECHOFLAG:BYTE
|
||
EXTRN SINGLECOM:WORD,VERVAL:WORD,FORFLAG:BYTE
|
||
EXTRN RE_INSTR:BYTE,RE_OUT_APP:BYTE,PIPE1:BYTE,PIPE2:BYTE
|
||
EXTRN RE_OUTSTR:BYTE,PIPEFLAG:BYTE,PIPEFILES:BYTE,PIPEPTR:WORD
|
||
EXTRN INPIPEPTR:WORD,OUTPIPEPTR:WORD,EXEC_BLOCK:BYTE,ENVIRSEG:WORD
|
||
DATARES ENDS
|
||
|
||
TRANDATA SEGMENT PUBLIC
|
||
EXTRN BADBAT:BYTE,NEEDBAT:BYTE,BADNAM:BYTE
|
||
EXTRN SYNTMES:BYTE,BADDRV:BYTE,BYTMES_POST:BYTE
|
||
EXTRN DIRMES_PRE:BYTE,DIRMES_POST:BYTE,BYTMES_PRE:BYTE
|
||
EXTRN NOTFND:BYTE,PIPEEMES:BYTE,BADPMES:BYTE,COMTAB:BYTE
|
||
TRANDATA ENDS
|
||
|
||
TRANSPACE SEGMENT PUBLIC
|
||
EXTRN UCOMBUF:BYTE,COMBUF:BYTE,USERDIR1:BYTE,EXECPATH:BYTE
|
||
EXTRN DIRCHAR:BYTE,EXEC_ADDR:DWORD,RCH_ADDR:DWORD,CHKDRV:BYTE
|
||
EXTRN CURDRV:BYTE,PARM1:BYTE,PARM2:BYTE,COMSW:WORD,ARG1S:WORD
|
||
EXTRN ARG2S:WORD,ARGTS:WORD,SPECDRV:BYTE,BYTCNT:WORD,IDLEN:BYTE
|
||
EXTRN DIRBUF:BYTE,ID:BYTE,COM:BYTE,LINCNT:BYTE,INTERNATVARS:BYTE
|
||
EXTRN HEADCALL:DWORD,RESSEG:WORD,TPA:WORD,SWITCHAR:BYTE
|
||
EXTRN STACK:WORD,FILTYP:BYTE,FILECNT:WORD,LINLEN:BYTE
|
||
|
||
|
||
IF KANJI
|
||
EXTRN KPARSE:BYTE
|
||
ENDIF
|
||
TRANSPACE ENDS
|
||
|
||
; ********************************************************************
|
||
; START OF TRANSIENT PORTION
|
||
; This code is loaded at the end of memory and may be overwritten by
|
||
; memory-intensive user programs.
|
||
|
||
TRANCODE SEGMENT PUBLIC PARA
|
||
ASSUME CS:TRANGROUP,DS:NOTHING,ES:NOTHING,SS:NOTHING
|
||
|
||
|
||
EXTRN SCANOFF:NEAR,DELIM:NEAR,SAVUDIR:NEAR,SAVUDIR1:NEAR
|
||
EXTRN PATHCHRCMP:NEAR,PRINT:NEAR,RESTUDIR:NEAR
|
||
EXTRN CRLF2:NEAR,PRINT_PROMPT:NEAR,GETBATBYT:NEAR,PRESCAN:NEAR
|
||
EXTRN CRPRINT:NEAR,DISP32BITS:NEAR,FCB_TO_ASCZ:NEAR
|
||
EXTRN ERROR_PRINT:NEAR,FREE_TPA:NEAR,ALLOC_TPA:NEAR
|
||
EXTRN $EXIT:NEAR,FORPROC:NEAR,FIND_NAME_IN_ENVIRONMENT:NEAR
|
||
EXTRN UPCONV:NEAR,BATOPEN:NEAR,BATCLOSE:NEAR,IOSET:NEAR,FIND_PATH:NEAR
|
||
EXTRN TESTDOREIN:NEAR,TESTDOREOUT:NEAR
|
||
|
||
PUBLIC SWLIST,CERROR,SETREST1,DOCOM,DOCOM1,DRVBAD,NOTFNDERR
|
||
PUBLIC COMMAND,TCOMMAND,SWITCH,PIPEERRSYN,GETKEYSTROKE,SETREST
|
||
PUBLIC CHKCNT
|
||
|
||
|
||
IF KANJI
|
||
EXTRN TESTKANJ:NEAR
|
||
ENDIF
|
||
|
||
ORG 0
|
||
ZERO = $
|
||
|
||
ORG 100H ; Allow for 100H parameter area
|
||
|
||
SETDRV:
|
||
MOV AH,SET_DEFAULT_DRIVE
|
||
INT int_command
|
||
TCOMMAND:
|
||
MOV DS,[RESSEG]
|
||
ASSUME DS:RESGROUP
|
||
MOV AX,-1
|
||
XCHG AX,[VERVAL]
|
||
CMP AX,-1
|
||
JZ NOSETVER2
|
||
MOV AH,SET_VERIFY_ON_WRITE ; AL has correct value
|
||
INT int_command
|
||
NOSETVER2:
|
||
CALL [HEADCALL] ; Make sure header fixed
|
||
XOR BP,BP ; Flag transient not read
|
||
CMP [SINGLECOM],-1
|
||
JNZ COMMAND
|
||
$EXITPREP:
|
||
PUSH CS
|
||
POP DS
|
||
JMP $EXIT ; Have finished the single command
|
||
ASSUME DS:NOTHING
|
||
COMMAND:
|
||
CLD
|
||
MOV AX,CS
|
||
MOV SS,AX
|
||
ASSUME SS:TRANGROUP
|
||
MOV SP,OFFSET TRANGROUP:STACK
|
||
MOV ES,AX
|
||
ASSUME ES:TRANGROUP
|
||
MOV DS,[RESSEG]
|
||
ASSUME DS:RESGROUP
|
||
STI
|
||
|
||
MOV [UCOMBUF],COMBUFLEN ; Init UCOMBUF
|
||
MOV [COMBUF],COMBUFLEN ; Init COMBUF (Autoexec doing DATE)
|
||
OR BP,BP ; See if just read
|
||
JZ TESTRDIR ; Not read, check user directory
|
||
MOV WORD PTR [UCOMBUF+1],0D01H ; Reset buffer
|
||
JMP SHORT NOSETBUF
|
||
TESTRDIR:
|
||
CMP [RESTDIR],0
|
||
JZ NOSETBUF ; User directory OK
|
||
PUSH DS
|
||
PUSH CS
|
||
POP DS
|
||
ASSUME DS:TRANGROUP
|
||
MOV DX,OFFSET TRANGROUP:USERDIR1
|
||
MOV AH,CHDIR
|
||
INT int_command ; Restore users directory
|
||
POP DS
|
||
ASSUME DS:RESGROUP
|
||
NOSETBUF:
|
||
CMP [PIPEFILES],0
|
||
JZ NOPCLOSE ; Don't bother if they don't exist
|
||
CMP [PIPEFLAG],0
|
||
JNZ NOPCLOSE ; Don't del if still piping
|
||
CALL PIPEDEL
|
||
NOPCLOSE:
|
||
MOV [EXTCOM],0 ; Flag internal command
|
||
MOV [RESTDIR],0 ; Flag users dirs OK
|
||
MOV AX,CS ; Get segment we're in
|
||
MOV DS,AX
|
||
ASSUME DS:TRANGROUP
|
||
PUSH AX
|
||
MOV DX,OFFSET TRANGROUP:INTERNATVARS
|
||
MOV AX,INTERNATIONAL SHL 8
|
||
INT 21H
|
||
POP AX
|
||
SUB AX,[TPA] ; AX=size of TPA in paragraphs
|
||
MOV DX,16
|
||
MUL DX ; DX:AX=size of TPA in bytes
|
||
OR DX,DX ; See if over 64K
|
||
JZ SAVSIZ ; OK if not
|
||
MOV AX,-1 ; If so, limit to 65535 bytes
|
||
SAVSIZ:
|
||
MOV [BYTCNT],AX ; Max no. of bytes that can be buffered
|
||
MOV DS,[RESSEG] ; All batch work must use resident seg.
|
||
ASSUME DS:RESGROUP
|
||
TEST [ECHOFLAG],-1
|
||
JZ GETCOM ; Don't do the CRLF
|
||
CALL SINGLETEST
|
||
JB GETCOM
|
||
CALL CRLF2
|
||
GETCOM:
|
||
MOV AH,GET_DEFAULT_DRIVE
|
||
INT int_command
|
||
MOV [CURDRV],AL
|
||
TEST [ECHOFLAG],-1
|
||
JZ NOPDRV ; No prompt if echo off
|
||
CALL SINGLETEST
|
||
JB NOPDRV
|
||
CALL PRINT_PROMPT ; Prompt the user
|
||
NOPDRV:
|
||
TEST [PIPEFLAG],-1 ; Pipe has highest presedence
|
||
JZ NOPIPE
|
||
JMP PIPEPROC ; Continue the pipeline
|
||
NOPIPE:
|
||
TEST [FORFLAG],-1 ; FOR has next highest precedence
|
||
JZ TESTFORBAT
|
||
JMP FORPROC ; Continue the FOR
|
||
TESTFORBAT:
|
||
MOV [RE_INSTR],0 ; Turn redirection back off
|
||
MOV [RE_OUTSTR],0
|
||
MOV [RE_OUT_APP],0
|
||
TEST [BATCH],-1 ; Batch has lowest precedence
|
||
JZ ISNOBAT
|
||
JMP READBAT ; Continue BATCH
|
||
|
||
ISNOBAT:
|
||
CMP [SINGLECOM],0
|
||
JZ REGCOM
|
||
MOV SI,-1
|
||
XCHG SI,[SINGLECOM]
|
||
MOV DI,OFFSET TRANGROUP:COMBUF + 2
|
||
XOR CX,CX
|
||
SINGLELOOP:
|
||
LODSB
|
||
STOSB
|
||
INC CX
|
||
CMP AL,0DH
|
||
JNZ SINGLELOOP
|
||
DEC CX
|
||
PUSH CS
|
||
POP DS
|
||
ASSUME DS:TRANGROUP
|
||
MOV [COMBUF + 1],CL
|
||
JMP DOCOM
|
||
|
||
REGCOM:
|
||
PUSH CS
|
||
POP DS ; Need local segment to point to buffer
|
||
MOV DX,OFFSET TRANGROUP:UCOMBUF
|
||
MOV AH,STD_CON_STRING_INPUT
|
||
INT int_command ; Get a command
|
||
MOV CL,[UCOMBUF]
|
||
XOR CH,CH
|
||
ADD CX,3
|
||
MOV SI,OFFSET TRANGROUP:UCOMBUF
|
||
MOV DI,OFFSET TRANGROUP:COMBUF
|
||
REP MOVSB ; Transfer it to the cooked buffer
|
||
JMP DOCOM
|
||
|
||
; All batch proccessing has DS set to segment of resident portion
|
||
ASSUME DS:RESGROUP,ES:TRANGROUP
|
||
|
||
NEEDENV:
|
||
PUSH DS
|
||
PUSH SI
|
||
PUSH DI
|
||
|
||
MOV DI,OFFSET TRANGROUP:ID
|
||
ADD AL,"0"
|
||
STOSB
|
||
GETENV1:
|
||
CALL GETBATBYT
|
||
STOSB
|
||
CMP AL,13
|
||
JZ GETENV2
|
||
CMP AL,"%"
|
||
JNZ GETENV1
|
||
MOV BYTE PTR ES:[DI-1],"="
|
||
GETENV2:
|
||
MOV SI,OFFSET TRANGROUP:ID
|
||
PUSH CS
|
||
POP DS ; DS:SI POINTS TO NAME
|
||
ASSUME DS:TRANGROUP,ES:RESGROUP
|
||
CALL FIND_NAME_IN_environment
|
||
PUSH ES
|
||
POP DS
|
||
PUSH CS
|
||
POP ES
|
||
ASSUME DS:RESGROUP,ES:TRANGROUP
|
||
MOV SI,DI
|
||
POP DI ; get back pointer to command line
|
||
JNC GETENV4
|
||
|
||
GETENV3: ; Parameter not found
|
||
PUSH CS
|
||
POP DS
|
||
MOV SI,OFFSET TRANGROUP:ID
|
||
|
||
GETENV4:
|
||
LODSB ; From resident segment
|
||
OR AL,AL ; Check for end of parameter
|
||
JZ GETENV6
|
||
CMP AL,13
|
||
JZ GETENV6
|
||
CMP AL,"="
|
||
JZ GETENVX
|
||
STOSB
|
||
JMP GETENV4
|
||
|
||
GETENVX:
|
||
MOV AL,"%"
|
||
STOSB
|
||
GETENV6:
|
||
POP SI
|
||
POP DS
|
||
CMP AL,13
|
||
JZ SAVBATBYTJ
|
||
JMP RDBAT
|
||
|
||
NEEDPARM:
|
||
CALL GETBATBYT
|
||
CMP AL,"%" ; Check for two consecutive %
|
||
JZ SAVBATBYTJ
|
||
CMP AL,13 ; Check for end-of-line
|
||
JNZ PAROK
|
||
SAVBATBYTJ:
|
||
JMP SAVBATBYT
|
||
PAROK:
|
||
SUB AL,"0"
|
||
JB NEEDENV ; look for parameter in the environment
|
||
CMP AL,9
|
||
JA NEEDENV
|
||
|
||
CBW
|
||
MOV SI,AX
|
||
SHL SI,1 ; Two bytes per entry
|
||
PUSH ES
|
||
PUSH DI
|
||
MOV ES,[BATCH]
|
||
XOR CX,CX
|
||
MOV AX,CX
|
||
MOV DI,CX
|
||
DEC CX
|
||
REPNZ SCASB
|
||
ADD DI,SI
|
||
MOV SI,ES:[DI]
|
||
POP DI
|
||
POP ES
|
||
CMP SI,-1 ; Check if parameter exists
|
||
JZ RDBAT ; Ignore if it doesn't
|
||
RDPARM:
|
||
LODSB ; From resident segment
|
||
CMP AL,0DH ; Check for end of parameter
|
||
JZ RDBAT
|
||
STOSB
|
||
JMP RDPARM
|
||
|
||
PROMPTBAT:
|
||
MOV DX,OFFSET TRANGROUP:NEEDBAT
|
||
CALL [RCH_ADDR]
|
||
JZ AskForBat ; Media is removable
|
||
NoAskForBat:
|
||
MOV ES,[BATCH] ; Turn off batch
|
||
MOV AH,DEALLOC
|
||
INT int_command ; free up the batch piece
|
||
MOV [BATCH],0 ; AFTER DEALLOC in case of ^C
|
||
MOV [FORFLAG],0 ; Turn off for processing
|
||
MOV [PIPEFLAG],0 ; Turn off any pipe
|
||
PUSH CS
|
||
POP DS
|
||
MOV DX,OFFSET TRANGROUP:BADBAT
|
||
CALL ERROR_PRINT ; Tell user no batch file
|
||
JMP TCOMMAND
|
||
|
||
ASKFORBAT:
|
||
PUSH CS
|
||
POP DS
|
||
CALL ERROR_PRINT ; Prompt for batch file
|
||
CALL GetKeystroke
|
||
JMP TCOMMAND
|
||
;**************************************************************************
|
||
; read the next keystroke
|
||
|
||
GetKeystroke:
|
||
MOV AX,(STD_CON_INPUT_FLUSH SHL 8) OR STD_CON_INPUT_no_echo
|
||
INT int_command ; Get character with KB buffer flush
|
||
MOV AX,(STD_CON_INPUT_FLUSH SHL 8) + 0
|
||
INT int_command
|
||
return
|
||
|
||
READBAT:
|
||
CALL BATOPEN
|
||
JC PROMPTBAT
|
||
MOV DI,OFFSET TRANGROUP:COMBUF+2
|
||
TESTNOP:
|
||
CALL GETBATBYT
|
||
CMP AL,':' ; Label/Comment?
|
||
JNZ NOTLABEL
|
||
NOPLINE: ; Consume the line
|
||
CALL GETBATBYT
|
||
CMP AL,0DH
|
||
JNZ NOPLINE
|
||
CALL GETBATBYT ; Eat Linefeed
|
||
TEST [BATCH],-1
|
||
JNZ TESTNOP
|
||
JMP TCOMMAND ; Hit EOF
|
||
|
||
RDBAT:
|
||
CALL GETBATBYT
|
||
NOTLABEL:
|
||
CMP AL,"%" ; Check for parameter
|
||
JNZ SAVBATBYT
|
||
JMP NEEDPARM
|
||
SAVBATBYT:
|
||
STOSB
|
||
CMP AL,0DH
|
||
JNZ RDBAT
|
||
SUB DI,OFFSET TRANGROUP:COMBUF+3
|
||
MOV AX,DI
|
||
MOV ES:[COMBUF+1],AL ; Set length of line
|
||
CALL GETBATBYT ; Eat linefeed
|
||
CALL BATCLOSE
|
||
TEST [ECHOFLAG],-1
|
||
PUSH CS
|
||
POP DS ; Go back to local segment
|
||
JZ NOECHO2
|
||
ASSUME DS:TRANGROUP
|
||
MOV DX,OFFSET TRANGROUP:COMBUF+2
|
||
CALL CRPRINT
|
||
DOCOM:
|
||
; All segments are local for command line processing
|
||
CALL CRLF2
|
||
DOCOM1:
|
||
|
||
NOECHO2:
|
||
CALL PRESCAN ; Cook the input buffer
|
||
JZ NOPIPEPROC
|
||
JMP PIPEPROCSTRT ; Fire up the pipe
|
||
NOPIPEPROC:
|
||
MOV SI,OFFSET TRANGROUP:COMBUF+2
|
||
MOV DI,OFFSET TRANGROUP:IDLEN
|
||
MOV AX,(PARSE_FILE_DESCRIPTOR SHL 8) OR 01H ; Make FCB with blank scan-off
|
||
INT int_command
|
||
CMP AL,1 ; Check for ambiguous command name
|
||
JZ BADCOMJ1 ; Ambiguous commands not allowed
|
||
CMP AL,-1
|
||
JNZ DRVGD
|
||
JMP DRVBAD
|
||
|
||
BADCOMJ1:
|
||
JMP BADCOM
|
||
|
||
DRVGD:
|
||
MOV AL,[DI]
|
||
MOV [SPECDRV],AL
|
||
MOV AL," "
|
||
MOV CX,9
|
||
INC DI
|
||
REPNE SCASB ; Count no. of letters in command name
|
||
MOV AL,9
|
||
SUB AL,CL
|
||
MOV [IDLEN],AL
|
||
MOV DI,81H
|
||
XOR CX,CX
|
||
PUSH SI
|
||
COMTAIL:
|
||
LODSB
|
||
STOSB ; Move command tail to 80H
|
||
CMP AL,13
|
||
LOOPNZ COMTAIL
|
||
NOT CL
|
||
MOV BYTE PTR DS:[80H],CL
|
||
POP SI
|
||
; If the command has 0 parameters must check here for
|
||
; any switches that might be present.
|
||
; SI -> first character after the command.
|
||
CALL SWITCH ; Is the next character a SWITCHAR
|
||
MOV [COMSW],AX
|
||
MOV DI,FCB
|
||
MOV AX,(PARSE_FILE_DESCRIPTOR SHL 8) OR 01H
|
||
INT int_command
|
||
MOV [PARM1],AL ; Save result of parse
|
||
|
||
PRBEG:
|
||
LODSB
|
||
CMP AL,[SWITCHAR]
|
||
JZ PRFIN
|
||
CMP AL,13
|
||
JZ PRFIN
|
||
CALL DELIM
|
||
JNZ PRBEG
|
||
PRFIN:
|
||
DEC SI
|
||
CALL SWITCH
|
||
MOV [ARG1S],AX
|
||
MOV DI,FCB+10H
|
||
MOV AX,(PARSE_FILE_DESCRIPTOR SHL 8) OR 01H
|
||
INT int_command ; Parse file name
|
||
MOV [PARM2],AL ; Save result
|
||
CALL SWITCH
|
||
MOV [ARG2S],AX
|
||
OR AX,[ARG1S]
|
||
MOV [ARGTS],AX
|
||
SWTLP: ; Find any remaining switches
|
||
CMP BYTE PTR [SI],0DH
|
||
JZ GOTALLSW
|
||
INC SI
|
||
CALL SWITCH
|
||
OR [ARGTS],AX
|
||
JMP SHORT SWTLP
|
||
|
||
GOTALLSW:
|
||
MOV AL,[IDLEN]
|
||
MOV DL,[SPECDRV]
|
||
OR DL,DL ; Check if drive was specified
|
||
JZ OK
|
||
JMP DRVCHK
|
||
OK:
|
||
DEC AL ; Check for null command
|
||
JNZ FNDCOM
|
||
MOV DS,[RESSEG]
|
||
ASSUME DS:RESGROUP
|
||
CMP [SINGLECOM],-1
|
||
JZ EXITJ
|
||
JMP GETCOM
|
||
|
||
EXITJ:
|
||
JMP $EXITPREP
|
||
ASSUME DS:TRANGROUP
|
||
|
||
RETSW:
|
||
XCHG AX,BX ; Put switches in AX
|
||
return
|
||
|
||
SWITCH:
|
||
XOR BX,BX ; Initialize - no switches set
|
||
SWLOOP:
|
||
CALL SCANOFF ; Skip any delimiters
|
||
CMP AL,[SWITCHAR] ; Is it a switch specifier?
|
||
JNZ RETSW ; No -- we're finished
|
||
OR BX,GOTSWITCH ; Indicate there is a switch specified
|
||
INC SI ; Skip over the switch character
|
||
CALL SCANOFF
|
||
CMP AL,0DH
|
||
JZ RETSW ; Oops
|
||
INC SI
|
||
; Convert lower case input to upper case
|
||
CALL UPCONV
|
||
MOV DI,OFFSET TRANGROUP:SWLIST
|
||
MOV CX,SWCOUNT
|
||
REPNE SCASB ; Look for matching switch
|
||
JNZ BADSW
|
||
MOV AX,1
|
||
SHL AX,CL ; Set a bit for the switch
|
||
OR BX,AX
|
||
JMP SHORT SWLOOP
|
||
|
||
BADSW:
|
||
JMP SHORT SWLOOP
|
||
|
||
SWLIST DB "VBAPW"
|
||
SWCOUNT EQU $-SWLIST
|
||
|
||
DRVBAD:
|
||
MOV DX,OFFSET TRANGROUP:BADDRV
|
||
JMP CERROR
|
||
|
||
FNDCOM:
|
||
MOV SI,OFFSET TRANGROUP:COMTAB ; Prepare to search command table
|
||
MOV CH,0
|
||
FINDCOM:
|
||
MOV DI,OFFSET TRANGROUP:IDLEN
|
||
MOV CL,[SI]
|
||
JCXZ EXTERNAL
|
||
REPE CMPSB
|
||
LAHF
|
||
ADD SI,CX ; Bump to next position without affecting flags
|
||
SAHF
|
||
LODSB ; Get flag for drive check
|
||
MOV [CHKDRV],AL
|
||
LODSW ; Get address of command
|
||
JNZ FINDCOM
|
||
MOV DX,AX
|
||
CMP [CHKDRV],0
|
||
JZ NOCHECK
|
||
MOV AL,[PARM1]
|
||
OR AL,[PARM2] ; Check if either parm. had invalid drive
|
||
CMP AL,-1
|
||
JZ DRVBAD
|
||
NOCHECK:
|
||
CALL IOSET
|
||
CALL DX ; Call the internal
|
||
COMJMP:
|
||
JMP TCOMMAND
|
||
|
||
SETDRV1:
|
||
JMP SETDRV
|
||
|
||
DRVCHK:
|
||
DEC DL ; Adjust for correct drive number
|
||
DEC AL ; Check if anything else is on line
|
||
JZ SETDRV1
|
||
EXTERNAL:
|
||
MOV [FILTYP],0
|
||
MOV DL,[SPECDRV]
|
||
MOV [IDLEN],DL
|
||
CALL SAVUDIR ; Drive letter already checked
|
||
MOV AL,'?'
|
||
MOV DI,OFFSET TRANGROUP:COM
|
||
STOSB ; Look for any extension
|
||
STOSB
|
||
STOSB
|
||
MOV DX,OFFSET TRANGROUP:DIRBUF ; Command will end up here
|
||
MOV AH,SET_DMA
|
||
INT int_command
|
||
PUSH ES
|
||
CALL FIND_PATH
|
||
MOV SI,DI
|
||
POP ES
|
||
|
||
MOV DI,OFFSET TRANGROUP:EXECPATH
|
||
MOV BYTE PTR [DI],0 ; Initialize to current directory
|
||
RESEARCH:
|
||
MOV AH,DIR_SEARCH_FIRST
|
||
COMSRCH:
|
||
PUSH CS
|
||
POP DS
|
||
MOV DX,OFFSET TRANGROUP:IDLEN
|
||
INT int_command
|
||
OR AL,AL
|
||
MOV AH,DIR_SEARCH_NEXT ; Do search-next next
|
||
JNZ PATHCHK
|
||
CMP WORD PTR [DIRBUF+9],4F00H + "C"
|
||
JNZ CHKEXE
|
||
CMP [DIRBUF+11],"M"
|
||
JNZ CHKEXE
|
||
OR [FILTYP],4
|
||
JMP EXECUTE ; If we find a COM were done
|
||
|
||
CHKEXE:
|
||
CMP WORD PTR [DIRBUF+9],5800H + "E"
|
||
JNZ CHKBAT
|
||
CMP [DIRBUF+11],"E"
|
||
JNZ CHKBAT
|
||
OR [FILTYP],1 ; Flag an EXE found
|
||
JMP COMSRCH ; Continue search
|
||
|
||
CHKBAT:
|
||
CMP WORD PTR [DIRBUF+9],4100H + "B"
|
||
JNZ COMSRCH
|
||
CMP [DIRBUF+11],"T"
|
||
JNZ COMSRCH
|
||
OR [FILTYP],2 ; Flag BAT found
|
||
JMP COMSRCH ; Continue search
|
||
|
||
PATHCHK:
|
||
TEST [FILTYP],1
|
||
JZ TESTBAT
|
||
MOV WORD PTR [DIRBUF+9],5800H+"E"
|
||
MOV [DIRBUF+11],"E"
|
||
JMP EXECUTE ; Found EXE
|
||
|
||
TESTBAT:
|
||
TEST [FILTYP],2
|
||
JZ NEXTPATH ; Found nothing, try next path
|
||
MOV WORD PTR [DIRBUF+9],4100H+"B"
|
||
MOV [DIRBUF+11],"T"
|
||
MOV DX,OFFSET TRANGROUP:DIRBUF ; Found BAT
|
||
MOV AH,FCB_OPEN
|
||
INT int_command
|
||
OR AL,AL
|
||
JZ BATCOMJ ; Bat exists
|
||
CALL RESTUDIR
|
||
JMP BADCOM
|
||
|
||
BATCOMJ:
|
||
JMP BATCOM
|
||
|
||
NEXTPATH:
|
||
MOV DX,OFFSET TRANGROUP:USERDIR1 ; Restore users dir
|
||
MOV AH,CHDIR
|
||
INT int_command
|
||
MOV DS,[RESSEG]
|
||
ASSUME DS:RESGROUP
|
||
MOV [RESTDIR],0
|
||
BADPATHEL:
|
||
MOV DI,OFFSET TRANGROUP:EXECPATH ; Build a full path here
|
||
MOV DX,SI
|
||
MOV DS,[ENVIRSEG] ; Point into environment
|
||
ASSUME DS:NOTHING
|
||
LODSB
|
||
|
||
IF KANJI
|
||
MOV [KPARSE],0
|
||
ENDIF
|
||
|
||
OR AL,AL
|
||
JZ BADCOMJ ; NUL, command not found
|
||
XOR BL,BL ; Make BL a NUL
|
||
PSKIPLP: ; Get the path
|
||
STOSB
|
||
OR AL,AL
|
||
JZ LASTPATH
|
||
CMP AL,';'
|
||
JZ GOTNEXTPATH
|
||
CMP DI,15+DirStrLen+(OFFSET TRANGROUP:EXECPATH)
|
||
JB OKPath
|
||
SKIPPathElem:
|
||
LODSB ; scan to end of path element
|
||
OR AL,AL
|
||
JZ BadPathEl
|
||
CMP AL,';'
|
||
JZ BadPathEl
|
||
JMP SkipPathElem
|
||
|
||
OKPath:
|
||
IF KANJI
|
||
MOV [KPARSE],0
|
||
CALL TESTKANJ
|
||
JZ NXTPTCHR
|
||
INC [KPARSE]
|
||
MOVSB
|
||
NXTPTCHR:
|
||
ENDIF
|
||
|
||
LODSB
|
||
JMP SHORT PSKIPLP
|
||
|
||
BADCOMJ:
|
||
JMP BADCOM
|
||
|
||
LASTPATH:
|
||
MOV BYTE PTR ES:[DI-1],';' ; Fix up the NUL in EXECPATH
|
||
DEC SI ; Point to the NUL in PATHSTRING
|
||
MOV BL,[SI-1] ; Change substi char to char before NUL
|
||
|
||
GOTNEXTPATH:
|
||
DEC DI ; Point to the end of the dir
|
||
PUSH BX
|
||
PUSH SI
|
||
PUSH DX
|
||
MOV SI,DX
|
||
XOR DL,DL
|
||
CMP BYTE PTR [SI+1],DRVCHAR
|
||
JNZ DEFDRVPATH ; No drive spec
|
||
MOV DL,[SI]
|
||
SUB DL,'@'
|
||
DEFDRVPATH:
|
||
PUSH DS
|
||
PUSH CS
|
||
POP DS
|
||
ASSUME DS:TRANGROUP
|
||
MOV [IDLEN],DL ; New drive
|
||
PUSH DI
|
||
CALL SAVUDIR ; Save the users dir
|
||
POP DI
|
||
JNC PATHTRY
|
||
MOV DX,OFFSET TRANGROUP:BADPMES ; Tell the user bad stuff in path
|
||
CALL PRINT
|
||
PATHTRY:
|
||
POP DS
|
||
ASSUME DS:NOTHING
|
||
POP DX
|
||
POP SI
|
||
POP BX
|
||
XCHG BL,[SI-1] ; Stick in NUL, or same thing if LASTPATH
|
||
CDPATH:
|
||
MOV AH,CHDIR
|
||
INT int_command
|
||
MOV [SI-1],BL ; Fix the path string back up
|
||
MOV DS,[RESSEG]
|
||
ASSUME DS:RESGROUP
|
||
INC [RESTDIR] ; Say users dir needs restoring
|
||
JNC ResearchJ
|
||
JMP BADPATHEL ; Ignore a directory which doesn't exist
|
||
ResearchJ:
|
||
JMP RESEARCH ; Try looking in this one
|
||
|
||
BATCOM:
|
||
ASSUME DS:TRANGROUP
|
||
; Batch parameters are read with ES set to segment of resident part
|
||
CALL IOSET ; Set up any redirection
|
||
MOV ES,[RESSEG]
|
||
ASSUME ES:RESGROUP
|
||
;Since BATCH has lower precedence than PIPE or FOR. If a new BATCH file
|
||
;is being started it MUST be true that no FOR or PIPE is currently in
|
||
;progress.
|
||
MOV [FORFLAG],0 ; Turn off for processing
|
||
MOV [PIPEFLAG],0 ; Turn off any pipe
|
||
TEST [BATCH],-1
|
||
JNZ CHAINBAT ; Don't need allocation if chaining
|
||
CALL FREE_TPA
|
||
ASSUME ES:RESGROUP
|
||
MOV BX,6 ; 64 + 32 bytes
|
||
MOV AH,ALLOC
|
||
INT int_command ; Suck up a little piece for batch processing
|
||
MOV [BATCH],AX
|
||
CALL ALLOC_TPA
|
||
CHAINBAT:
|
||
PUSH ES
|
||
MOV ES,[BATCH]
|
||
ASSUME ES:NOTHING
|
||
MOV DL,[DIRBUF]
|
||
XOR DI,DI
|
||
CALL SAVUDIR1 ; ES:DI set up, get dir containing Batch file
|
||
XOR AX,AX
|
||
MOV CX,AX
|
||
DEC CX
|
||
REPNZ SCASB ; Find the NUL
|
||
DEC DI ; Point at the NUL
|
||
MOV AL,[DIRCHAR]
|
||
CMP AL,ES:[DI-1]
|
||
JZ NOPUTSLASH
|
||
STOSB
|
||
NOPUTSLASH:
|
||
MOV SI,OFFSET TRANGROUP:DIRBUF+1
|
||
CALL FCB_TO_ASCZ ; Tack on batch file name
|
||
MOV AX,-1
|
||
MOV BX,DI
|
||
MOV CX,10
|
||
REP STOSW ; Init Parmtab to no parms
|
||
POP ES
|
||
ASSUME ES:RESGROUP
|
||
CALL RESTUDIR
|
||
MOV SI,OFFSET TRANGROUP:COMBUF+2
|
||
MOV DI,OFFSET RESGROUP:PARMBUF
|
||
MOV CX,10
|
||
EACHPARM:
|
||
CALL SCANOFF
|
||
CMP AL,0DH
|
||
JZ HAVPARM
|
||
JCXZ MOVPARM ; Only first 10 parms get pointers
|
||
PUSH ES
|
||
MOV ES,[BATCH]
|
||
MOV ES:[BX],DI ; Set pointer table to point to actual parameter
|
||
POP ES
|
||
INC BX
|
||
INC BX
|
||
MOVPARM:
|
||
LODSB
|
||
CALL DELIM
|
||
JZ ENDPARM ; Check for end of parameter
|
||
STOSB
|
||
CMP AL,0DH
|
||
JZ HAVPARM
|
||
JMP SHORT MOVPARM
|
||
ENDPARM:
|
||
MOV AL,0DH
|
||
STOSB ; End-of-parameter marker
|
||
JCXZ EACHPARM
|
||
DEC CX
|
||
JMP SHORT EACHPARM
|
||
HAVPARM:
|
||
XOR AL,AL
|
||
STOSB ; Nul terminate the parms
|
||
XOR AX,AX
|
||
PUSH ES
|
||
POP DS ; Simply batch FCB setup
|
||
ASSUME DS:RESGROUP
|
||
MOV WORD PTR [BATLOC],AX ; Start at beginning of file
|
||
MOV WORD PTR [BATLOC+2],AX
|
||
CMP [SINGLECOM],-1
|
||
JNZ NOBATSING
|
||
MOV [SINGLECOM],0FFF0H ; Flag single command BATCH job
|
||
NOBATSING:
|
||
JMP TCOMMAND
|
||
ASSUME DS:TRANGROUP,ES:TRANGROUP
|
||
|
||
EXECUTE:
|
||
CALL RESTUDIR
|
||
NeoExecute:
|
||
CMP BYTE PTR [DI],0 ; Command in current directory
|
||
JZ NNSLSH
|
||
MOV AL,[DI-1]
|
||
|
||
IF KANJI
|
||
CMP [KPARSE],0
|
||
JNZ StuffPath ; Last char is second KANJI byte, might be '\'
|
||
ENDIF
|
||
|
||
CALL PATHCHRCMP
|
||
JZ HAVEXP ; Don't double slash
|
||
StuffPath:
|
||
MOV AL,[DIRCHAR]
|
||
STOSB
|
||
JMP SHORT HAVEXP
|
||
|
||
NNSLSH:
|
||
MOV AL,[DIRBUF] ; Specify a drive
|
||
ADD AL,'@'
|
||
STOSB
|
||
MOV AL,DRVCHAR
|
||
STOSB
|
||
HAVEXP:
|
||
MOV SI,OFFSET TRANGROUP:DIRBUF+1
|
||
CALL FCB_TO_ASCZ ; Tack on the filename
|
||
CALL IOSET
|
||
MOV ES,[TPA]
|
||
MOV AH,DEALLOC
|
||
INT int_command ; Now running in "free" space
|
||
MOV ES,[RESSEG]
|
||
ASSUME ES:RESGROUP
|
||
INC [EXTCOM] ; Indicate external command
|
||
MOV [RESTDIR],0 ; Since USERDIR1 is in transient, insure
|
||
; this flag value for re-entry to COMMAND
|
||
MOV DI,FCB
|
||
MOV SI,DI
|
||
MOV CX,052H
|
||
REP MOVSW ; Transfer parameters to resident header
|
||
MOV DX,OFFSET TRANGROUP:EXECPATH
|
||
MOV BX,OFFSET RESGROUP:EXEC_BLOCK
|
||
MOV AX,EXEC SHL 8
|
||
JMP [EXEC_ADDR] ; Jmp to the EXEC in the resident
|
||
|
||
BADCOM:
|
||
PUSH CS
|
||
POP DS
|
||
MOV DX,OFFSET TRANGROUP:BADNAM
|
||
CERROR:
|
||
CALL ERROR_PRINT
|
||
JMP TCOMMAND
|
||
|
||
SINGLETEST:
|
||
ASSUME DS:RESGROUP
|
||
CMP [SINGLECOM],0
|
||
JZ RET5
|
||
CMP [SINGLECOM],0EFFFH
|
||
return
|
||
|
||
|
||
ASSUME DS:TRANGROUP
|
||
SETREST1:
|
||
MOV AL,1
|
||
SETREST:
|
||
PUSH DS
|
||
MOV DS,[RESSEG]
|
||
ASSUME DS:RESGROUP
|
||
MOV [RESTDIR],AL
|
||
POP DS
|
||
ASSUME DS:TRANGROUP
|
||
RET5:
|
||
return
|
||
|
||
CHKCNT:
|
||
TEST [FILECNT],-1
|
||
JNZ ENDDIR
|
||
NOTFNDERR:
|
||
MOV DX,OFFSET TRANGROUP:NOTFND
|
||
JMP CERROR
|
||
|
||
ENDDIR:
|
||
; Make sure last line ends with CR/LF
|
||
MOV AL,[LINLEN]
|
||
CMP AL,[LINCNT] ; Will be equal if just had CR/LF
|
||
JZ MESSAGE
|
||
CALL CRLF2
|
||
MESSAGE:
|
||
MOV DX,OFFSET TRANGROUP:DIRMES_PRE
|
||
CALL PRINT
|
||
MOV SI,[FILECNT]
|
||
XOR DI,DI
|
||
CALL DISP32BITS
|
||
MOV DX,OFFSET TRANGROUP:DIRMES_POST
|
||
CALL PRINT
|
||
MOV AH,GET_DRIVE_FREESPACE
|
||
MOV DL,BYTE PTR DS:[FCB]
|
||
INT int_command
|
||
CMP AX,-1
|
||
retz
|
||
MOV DX,OFFSET TRANGROUP:BYTMES_PRE
|
||
CALL PRINT
|
||
MUL CX ; AX is bytes per cluster
|
||
MUL BX
|
||
MOV DI,DX
|
||
MOV SI,AX
|
||
CALL DISP32BITS
|
||
MOV DX,OFFSET TRANGROUP:BYTMES_POST
|
||
JMP PRINT
|
||
|
||
ASSUME DS:RESGROUP
|
||
|
||
PIPEDEL:
|
||
PUSH DX
|
||
MOV DX,OFFSET RESGROUP:PIPE1 ; Clean up in case ^C
|
||
MOV AH,UNLINK
|
||
INT int_command
|
||
MOV DX,OFFSET RESGROUP:PIPE2
|
||
MOV AH,UNLINK
|
||
INT int_command
|
||
XOR AX,AX
|
||
MOV WORD PTR [PIPEFLAG],AX ; Pipe files and pipe gone
|
||
MOV [ECHOFLAG],1 ; Make sure ^C to pipe doesn't leave ECHO OFF
|
||
POP DX
|
||
return
|
||
|
||
PIPEERRSYN:
|
||
MOV DX,OFFSET TRANGROUP:SYNTMES
|
||
JMP SHORT PIPPERR
|
||
PIPEERR:
|
||
MOV DX,OFFSET TRANGROUP:PIPEEMES
|
||
PIPPERR:
|
||
CALL PIPEDEL
|
||
PUSH CS
|
||
POP DS
|
||
JMP CERROR
|
||
|
||
PIPEPROCSTRT:
|
||
ASSUME DS:TRANGROUP,ES:TRANGROUP
|
||
MOV DS,[RESSEG]
|
||
ASSUME DS:RESGROUP
|
||
INC [PIPEFILES] ; Flag that the pipe files exist
|
||
MOV AH,19H ; Get current drive
|
||
INT int_command
|
||
ADD AL,'A'
|
||
MOV [PIPE2],AL ; Make pipe files in root of def drv
|
||
MOV BX,OFFSET RESGROUP:PIPE1
|
||
MOV [BX],AL
|
||
MOV DX,BX
|
||
XOR CX,CX
|
||
MOV AH,CREAT
|
||
INT int_command
|
||
JC PIPEERR ; Couldn't create
|
||
MOV BX,AX
|
||
MOV AH,CLOSE ; Don't proliferate handles
|
||
INT int_command
|
||
MOV DX,OFFSET RESGROUP:PIPE2
|
||
MOV AH,CREAT
|
||
INT int_command
|
||
JC PIPEERR
|
||
MOV BX,AX
|
||
MOV AH,CLOSE
|
||
INT int_command
|
||
CALL TESTDOREIN ; Set up a redirection if specified
|
||
MOV [ECHOFLAG],0 ; No echo on pipes
|
||
MOV SI,[PIPEPTR]
|
||
CMP [SINGLECOM],-1
|
||
JNZ NOSINGP
|
||
MOV [SINGLECOM],0F000H ; Flag single command pipe
|
||
NOSINGP:
|
||
JMP SHORT FIRSTPIPE
|
||
|
||
PIPEPROC:
|
||
ASSUME DS:RESGROUP
|
||
MOV [ECHOFLAG],0 ; No echo on pipes
|
||
MOV SI,[PIPEPTR]
|
||
LODSB
|
||
CMP AL,'|'
|
||
JNZ PIPEEND ; Pipe done
|
||
MOV DX,[INPIPEPTR] ; Get the input file name
|
||
MOV AX,(OPEN SHL 8)
|
||
INT int_command
|
||
PIPEERRJ:
|
||
JC PIPEERR ; Lost the pipe file
|
||
MOV BX,AX
|
||
MOV AL,0FFH
|
||
XCHG AL,[BX.PDB_JFN_Table]
|
||
MOV DS:[PDB_JFN_Table],AL ; Redirect
|
||
FIRSTPIPE:
|
||
MOV DI,OFFSET TRANGROUP:COMBUF + 2
|
||
XOR CX,CX
|
||
CMP BYTE PTR [SI],0DH ; '|<CR>'
|
||
JNZ PIPEOK1
|
||
PIPEERRSYNJ:
|
||
JMP PIPEERRSYN
|
||
PIPEOK1:
|
||
CMP BYTE PTR [SI],'|' ; '||'
|
||
JZ PIPEERRSYNJ
|
||
PIPECOMLP:
|
||
LODSB
|
||
STOSB
|
||
|
||
IF KANJI
|
||
CALL TESTKANJ
|
||
JZ NOTKANJ5
|
||
MOVSB
|
||
JMP PIPECOMLP
|
||
|
||
NOTKANJ5:
|
||
ENDIF
|
||
|
||
CMP AL,0DH
|
||
JZ LASTPIPE
|
||
INC CX
|
||
CMP AL,'|'
|
||
JNZ PIPECOMLP
|
||
MOV BYTE PTR ES:[DI-1],0DH
|
||
DEC CX
|
||
MOV [COMBUF+1],CL
|
||
DEC SI
|
||
MOV [PIPEPTR],SI ; On to next pipe element
|
||
MOV DX,[OUTPIPEPTR]
|
||
PUSH CX
|
||
XOR CX,CX
|
||
MOV AX,(CREAT SHL 8)
|
||
INT int_command
|
||
POP CX
|
||
JC PIPEERRJ ; Lost the file
|
||
MOV BX,AX
|
||
MOV AL,0FFH
|
||
XCHG AL,[BX.PDB_JFN_Table]
|
||
MOV DS:[PDB_JFN_Table+1],AL
|
||
XCHG DX,[INPIPEPTR] ; Swap for next element of pipe
|
||
MOV [OUTPIPEPTR],DX
|
||
JMP SHORT PIPECOM
|
||
|
||
LASTPIPE:
|
||
MOV [COMBUF+1],CL
|
||
DEC SI
|
||
MOV [PIPEPTR],SI ; Point at the CR (anything not '|' will do)
|
||
CALL TESTDOREOUT ; Set up the redirection if specified
|
||
PIPECOM:
|
||
PUSH CS
|
||
POP DS
|
||
JMP NOPIPEPROC ; Process the pipe element
|
||
|
||
PIPEEND:
|
||
CALL PIPEDEL
|
||
CMP [SINGLECOM],0F000H
|
||
JNZ NOSINGP2
|
||
MOV [SINGLECOM],-1 ; Make it return
|
||
NOSINGP2:
|
||
JMP TCOMMAND
|
||
|
||
TRANCODE ENDS
|
||
END
|
||
|