path: root/v2.0/source/TCODE3.ASM

TITLE   PART3 - 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
        EXTRN   RETCODE:WORD,ECHOFLAG:BYTE
        EXTRN   SINGLECOM:WORD,FORFLAG:BYTE,UFORDRV:BYTE
        EXTRN   FORSET:BYTE,FORCOM:BYTE,FORVAR:BYTE,FORPTR:WORD
        EXTRN   FORUFCB:BYTE,FORFCB:BYTE,RE_INSTR:BYTE,RE_OUT_APP:BYTE
        EXTRN   RE_OUTSTR:BYTE,PIPEFLAG:BYTE

DATARES ENDS

TRANDATA        SEGMENT PUBLIC

        EXTRN   BADLAB:BYTE,SYNTMES:BYTE,FORNESTMES:BYTE
        EXTRN   NOTFND:BYTE,FULDIR:BYTE,IFTAB:BYTE
TRANDATA        ENDS

TRANSPACE       SEGMENT PUBLIC

        EXTRN   BATHAND:WORD,RESSEG:WORD,DIRBUF:BYTE,COMBUF:BYTE
        EXTRN   GOTOLEN:WORD,IFNOTFLAG:BYTE

TRANSPACE       ENDS


TRANCODE        SEGMENT PUBLIC BYTE
ASSUME  CS:TRANGROUP,DS:NOTHING,ES:NOTHING,SS:NOTHING

        EXTRN   SCANOFF:NEAR,DOCOM:NEAR,DOCOM1:NEAR,CERROR:NEAR
        EXTRN   PRINT:NEAR,TCOMMAND:NEAR,DELIM:NEAR,GETBATBYT:NEAR
        EXTRN   FCB_TO_ASCZ:NEAR

        PUBLIC  GOTO,$IF,IFERLEV,SHIFT,IFEXISTS
        PUBLIC  STRCOMP,MesTran,$FOR,IFNOT
        PUBLIC  FORPROC,BATOPEN,BATCLOSE
        PUBLIC  IOSET,TESTDOREIN,TESTDOREOUT

        ASSUME  DS:RESGROUP
FORTERM:
        MOV     [FORFLAG],0
        CMP     [SINGLECOM],0FF00H
        JNZ     NOFORP2
        MOV     [SINGLECOM],-1          ; Cause a terminate
NOFORP2:
        JMP     TCOMMAND

FORPROC:
ASSUME  DS:RESGROUP
        CMP     [FORUFCB],-1
        JZ      NORMFOR
        MOV     DX,OFFSET TRANGROUP:DIRBUF
        PUSH    DS
        PUSH    CS
        POP     DS
ASSUME  DS:TRANGROUP
        MOV     AH,SET_DMA
        INT     int_command
        POP     DS
ASSUME  DS:RESGROUP
        MOV     DX,OFFSET RESGROUP:FORFCB
        MOV     AH,DIR_SEARCH_NEXT
        CMP     [FORUFCB],0
        JZ      DOFORSRCH
        MOV     AH,DIR_SEARCH_FIRST
        MOV     [FORUFCB],0
DOFORSRCH:
        INT     int_command
        OR      AL,AL
        JNZ     FORTERM
        PUSH    DS
        POP     ES
ASSUME  ES:RESGROUP
        PUSH    CS
        POP     DS
ASSUME  DS:TRANGROUP
        MOV     SI,OFFSET TRANGROUP:DIRBUF
        MOV     DI,OFFSET RESGROUP:FORSET
        MOV     [FORPTR],DI
        LODSB                   ;Get drive spec
        ADD     AL,'@'
        CMP     AL,'@'
        JZ      NDRV8
        CMP     [UFORDRV],0
        JZ      NDRV8
        MOV     AH,':'
        STOSW
NDRV8:
        CALL    FCB_TO_ASCZ
        MOV     BYTE PTR ES:[DI-1],0DH
        PUSH    ES
        POP     DS
ASSUME  DS:RESGROUP
NORMFOR:
        PUSH    CS
        POP     ES
ASSUME  ES:TRANGROUP
        MOV     BX,[FORPTR]
        CMP     BYTE PTR [BX],0
        JZ      FORTERM
        MOV     SI,BX
PARMSUB0:
        LODSB
        CMP     AL,0DH
        JNZ     PARMSUB0
        MOV     DX,SI           ; DX points to next parm
        MOV     SI,OFFSET RESGROUP:FORCOM
        MOV     DI,OFFSET TRANGROUP:COMBUF+2
        XOR     CX,CX
TFORCOM:
        LODSB
        CMP     AL,'%'
        JNZ     NOFORPARM
        MOV     AH,[FORVAR]
        CMP     AH,[SI]
        JNZ     NOFORPARM
        INC     SI
        PUSH    SI
        MOV     SI,BX
PARMSUB:
        LODSB
        CMP     AL,0DH
        JZ      PARMSUBDONE
        INC     CX
        STOSB
        JMP     SHORT PARMSUB
PARMSUBDONE:
        POP     SI              ; Get back command line pointer
        JMP     TFORCOM
NOFORPARM:
        STOSB
        INC     CX
        CMP     AL,0DH
        JNZ     TFORCOM
        DEC     CX
        MOV     [COMBUF+1],CL
        MOV     [FORPTR],DX     ; Point to next set element
        TEST    [ECHOFLAG],-1
        PUSH    CS
        POP     DS
ASSUME  DS:TRANGROUP
        JZ      NOECHO3
        MOV     BYTE PTR ES:[DI-1],'$'
        MOV     DX,OFFSET TRANGROUP:COMBUF+2
        CALL    PRINT
        MOV     BYTE PTR ES:[DI-1],0DH
        JMP     DOCOM
NOECHO3:
        JMP     DOCOM1

ASSUME  DS:TRANGROUP,ES:TRANGROUP

FORNESTERR:
        PUSH    DS
        MOV     DS,[RESSEG]
ASSUME  DS:RESGROUP
        MOV     DX,OFFSET TRANGROUP:FORNESTMES
        CMP     [SINGLECOM],0FF00H
        JNZ     NOFORP3
        MOV     [SINGLECOM],-1          ; Cause termination
NOFORP3:
        POP     DS
ASSUME  DS:TRANGROUP
        JMP     CERROR

$FOR:
        MOV     SI,81H
        XOR     CX,CX
        MOV     ES,[RESSEG]
ASSUME  ES:RESGROUP
        MOV     DI,OFFSET RESGROUP:FORSET
        XOR     AL,AL
        MOV     [UFORDRV],AL
        XCHG    AL,[FORFLAG]
        OR      AL,AL
        JNZ     FORNESTERR
        MOV     [FORPTR],DI
        MOV     [FORUFCB],-1
        CALL    SCANOFF
        LODSW
        CMP     AL,'%'
        JNZ     FORERRORJ
        MOV     [FORVAR],AH
        CALL    SCANOFF
        CMP     AL,0DH
        JZ      FORERRORJ2
        LODSW
        CMP     AX,('N' SHL 8) OR 'I'
        JZ      FOROK1
        CMP     AX,('n' SHL 8) OR 'i'
        JNZ     FORERRORJ
FOROK1:
        CALL    SCANOFF
        LODSB
        CMP     AL,'('
        JNZ     FORERRORJ
        CALL    SCANOFF
        CMP     AL,')'          ; Special check for null set
        JNZ     FORSETLP
        MOV     DS,[RESSEG]
        JMP     FORTERM
FORSETLP:
        LODSB
        CMP     AL,0DH
FORERRORJ2:
        JZ  FORERRORJ3
        CMP     AL,')'
        JZ      FORSETEND
        STOSB
        CMP     AL,'*'
        JZ      SETFORSCAN
        CMP     AL,'?'
        JNZ     NOFORSCAN
SETFORSCAN:
        MOV     [FORUFCB],1
NOFORSCAN:
        CALL    DELIM
        JNZ     FORSETLP
        MOV     BYTE PTR ES:[DI-1],0DH
        CALL    SCANOFF
        JMP     FORSETLP

FORSETEND:
        MOV     AX,000DH
        CMP     BYTE PTR ES:[DI-1],0DH
        JNZ     FORSETTERM
        XOR     AX,AX
FORSETTERM:
        STOSW
        CALL    SCANOFF
        LODSW
        CMP     AX,('O' SHL 8) OR 'D'
        JZ      FOROK2
        CMP     AX,('o' SHL 8) OR 'd'
FORERRORJ:
        JNZ  FORERROR
FOROK2:
        CALL    SCANOFF
        CMP     AL,0DH
FORERRORJ3:
        JZ      FORERROR
        MOV     DI,OFFSET RESGROUP:FORCOM
FORCOMLP:
        LODSB
        STOSB
        CMP     AL,0DH
        JNZ     FORCOMLP
        INC     [FORFLAG]
        CMP     [SINGLECOM],-1
        JNZ     NOFORP
        MOV     [SINGLECOM],0FF00H      ; Flag single command for
NOFORP:
        CMP     [FORUFCB],1
        retnz
        PUSH    ES
        POP     DS
ASSUME  DS:RESGROUP
        MOV     DI,OFFSET RESGROUP:FORFCB
        MOV     SI,OFFSET RESGROUP:FORSET
        CMP     BYTE PTR [SI+1],':'
        JNZ     NOSETUDRV
        INC     [UFORDRV]
NOSETUDRV:
        MOV     AX,PARSE_FILE_DESCRIPTOR SHL 8
        INT     int_command
        return


ASSUME  DS:TRANGROUP,ES:TRANGROUP

IFERRORP:
        POP     AX
IFERROR:
FORERROR:
        MOV     DX,OFFSET TRANGROUP:SYNTMES
        JMP     CERROR

$IF:
        MOV     [IFNOTFLAG],0
        MOV     SI,81H
IFREENT:
        CALL    SCANOFF
        CMP     AL,0DH
        JZ      IFERROR
        MOV     BP,SI
        MOV     DI,OFFSET TRANGROUP:IFTAB     ; Prepare to search if table
        MOV     CH,0
IFINDCOM:
        MOV     SI,BP
        MOV     CL,[DI]
        INC     DI
        JCXZ    IFSTRING
        JMP     SHORT FIRSTCOMP
IFCOMP:
        JNZ     IFDIF
FIRSTCOMP:
        LODSB
        MOV     AH,ES:[DI]
        INC     DI
        CMP     AL,AH
        JZ      IFLP
        OR      AH,20H          ; Try lower case
        CMP     AL,AH
IFLP:
        LOOP    IFCOMP
IFDIF:
        LAHF
        ADD     DI,CX           ; Bump to next position without affecting flags
        MOV     BX,[DI]         ; Get handler address
        INC     DI
        INC     DI
        SAHF
        JNZ     IFINDCOM
        LODSB
        CMP     AL,0DH
IFERRORJ:
        JZ    IFERROR
        CALL    DELIM
        JNZ     IFINDCOM
        CALL    SCANOFF
        JMP     BX

IFNOT:
        NOT     [IFNOTFLAG]
        JMP     IFREENT


IFSTRING:
        PUSH    SI
        XOR     CX,CX
FIRST_STRING:
        LODSB
        CMP     AL,0DH
        JZ      IFERRORP
        CALL    DELIM
        JZ      EQUAL_CHECK
        INC     CX
        JMP     SHORT FIRST_STRING
EQUAL_CHECK:
        CMP     AL,'='
        JZ      EQUAL_CHECK2
        CMP     AL,0DH
        JZ      IFERRORP
        LODSB
        JMP     SHORT EQUAL_CHECK
EQUAL_CHECK2:
        LODSB
        CMP     AL,'='
        JNZ     IFERRORP
        CALL    SCANOFF
        CMP     AL,0DH
        JZ      IFERRORP
        POP     DI
        REPE    CMPSB
        JZ      MATCH
        CMP     BYTE PTR [SI-1],0DH
        JZ      IFERRORJ
SKIPSTRINGEND:
        LODSB
NOTMATCH:
        CMP     AL,0DH
IFERRORJ2:
        JZ   IFERRORJ
        CALL    DELIM
        JNZ     SKIPSTRINGEND
        MOV     AL,-1
        JMP     SHORT IFRET
MATCH:
        LODSB
        CALL    DELIM
        JNZ     NOTMATCH
        XOR     AL,AL
        JMP     SHORT IFRET

IFEXISTS:
        MOV     DI,OFFSET TRANGROUP:DIRBUF
        MOV     AX,(PARSE_FILE_DESCRIPTOR SHL 8) OR 01H
        INT     int_command
        MOV     AH,FCB_OPEN
        MOV     DX,DI
        INT     int_command
IFRET:
        TEST    [IFNOTFLAG],-1
        JZ      REALTEST
        NOT     AL
REALTEST:
        OR      AL,AL
        JZ      IFTRUE
        JMP     TCOMMAND
IFTRUE:
        CALL    SCANOFF
        MOV     CX,SI
        SUB     CX,81H
        SUB     DS:[80H],CL
        MOV     CL,DS:[80H]
        MOV     [COMBUF+1],CL
        MOV     DI,OFFSET TRANGROUP:COMBUF+2
        REP     MOVSB
        MOV     AL,0DH
        STOSB
        JMP     DOCOM1

IFERLEV:
        MOV     BH,10
        XOR     BL,BL
GETNUMLP:
        LODSB
        CMP     AL,0DH
        JZ      IFERRORJ2
        CALL    DELIM
        JZ      GOTNUM
        SUB     AL,'0'
        XCHG    AL,BL
        MUL     BH
        ADD     AL,BL
        XCHG    AL,BL
        JMP     SHORT GETNUMLP
GOTNUM:
        PUSH    DS
        MOV     DS,[RESSEG]
ASSUME  DS:RESGROUP
        MOV     AH,BYTE PTR [RETCODE]
        POP     DS
ASSUME  DS:TRANGROUP
        XOR     AL,AL
        CMP     AH,BL
        JAE     IFRET
        DEC     AL
        JMP     SHORT IFRET

ASSUME  DS:TRANGROUP

SHIFT:
        MOV     DS,[RESSEG]
ASSUME  DS:RESGROUP
        MOV     AX,[BATCH]
        TEST    AX,-1
        retz
        MOV     ES,AX
        MOV     DS,AX
ASSUME  DS:NOTHING,ES:NOTHING
        XOR     CX,CX
        MOV     AX,CX
        MOV     DI,CX
        DEC     CX
        REPNZ   SCASB
        MOV     SI,DI
        INC     SI
        INC     SI
        MOV     CX,9
        REP     MOVSW                   ; Perform shift of existing parms
        CMP     WORD PTR [DI],-1
        retz                            ; No new parm
        MOV     SI,[DI]
        MOV     WORD PTR [DI],-1        ; Assume no parm
        MOV     DS,[RESSEG]
ASSUME  DS:RESGROUP
SKIPCRLP:
        LODSB
        CMP     AL,0DH
        JNZ     SKIPCRLP
        CMP     BYTE PTR [SI],0
        retz                            ; End of parms
        MOV     ES:[DI],SI              ; Pointer to next parm as %9
        return


ASSUME  DS:TRANGROUP,ES:TRANGROUP
GOTO:
        MOV     DS,[RESSEG]
ASSUME  DS:RESGROUP
        TEST    [BATCH],-1
        retz                    ; If not in batch mode, a nop
        XOR     DX,DX
        MOV     WORD PTR [BATLOC],DX    ; Back to start
        MOV     WORD PTR [BATLOC+2],DX
        CALL    BATOPEN                 ; Find the batch file
        MOV     DI,FCB+1        ; Get the label
        MOV     CX,11
        MOV     AL,' '
        REPNE   SCASB
        JNZ     NOINC
        INC     CX
NOINC:
        SUB     CX,11
        NEG     CX
        MOV     [GOTOLEN],CX
        CALL    GETBATBYT
        CMP     AL,':'
        JZ      CHKLABEL
LABLKLP:                        ; Look for the label
        CALL    GETBATBYT
        CMP     AL,0AH
        JNZ     LABLKTST
        CALL    GETBATBYT
        CMP     AL,':'
        JZ      CHKLABEL
LABLKTST:
        TEST    [BATCH],-1
        JNZ     LABLKLP
        CALL    BATCLOSE
        PUSH    CS
        POP     DS
        MOV     DX,OFFSET TRANGROUP:BADLAB
        JMP     CERROR

CHKLABEL:
        MOV     DI,FCB+1
        MOV     CX,[GOTOLEN]
NEXTCHRLP:
        PUSH    CX
        CALL    GETBATBYT
        POP     CX
        OR      AL,20H
        CMP     AL,ES:[DI]
        JNZ     TRYUPPER
        JMP     SHORT NEXTLABCHR
TRYUPPER:
        SUB     AL,20H
        CMP     AL,ES:[DI]
        JNZ     LABLKTST
NEXTLABCHR:
        INC     DI
        LOOP    NEXTCHRLP
        CALL    GETBATBYT
        CMP     AL,' '
        JA      LABLKTST
        CMP     AL,0DH
        JZ      SKIPLFEED
TONEXTBATLIN:
        CALL    GETBATBYT
        CMP     AL,0DH
        JNZ     TONEXTBATLIN
SKIPLFEED:
        CALL    GETBATBYT
BATCLOSE:
        MOV     BX,CS:[BATHAND]
        MOV     AH,CLOSE
        INT     int_command
        return

BATOPEN:
;Open the BATCH file, If open fails, AL is drive of batch file (A=1)
ASSUME  DS:RESGROUP,ES:TRANGROUP
        PUSH    DS
        MOV     DS,[BATCH]
ASSUME  DS:NOTHING
        XOR     DX,DX
        MOV     AX,OPEN SHL 8
        INT     int_command             ; Open the batch file
        JC      SETERRDL
        POP     DS
ASSUME  DS:RESGROUP
        MOV     [BATHAND],AX
        MOV     BX,AX
        MOV     DX,WORD PTR [BATLOC]
        MOV     CX,WORD PTR [BATLOC+2]
        MOV     AX,LSEEK SHL 8          ; Go to the right spot
        INT     int_command
        return

SETERRDL:
        MOV     BX,DX
        MOV     AL,[BX]                 ; Get drive spec
        SUB     AL,'@'                  ; A = 1
        POP     DS
        STC                             ; SUB mucked over carry
        return

MESTRAN:
ASSUME  DS:NOTHING,ES:NOTHING
        LODSB
        CMP     AL,"$"
        retz
        STOSB
        JMP     MESTRAN
IOSET:
; ALL REGISTERS PRESERVED
ASSUME  DS:NOTHING,ES:NOTHING,SS:NOTHING
        PUSH    DS
        PUSH    DX
        PUSH    AX
        PUSH    BX
        PUSH    CX
        MOV     DS,[RESSEG]
ASSUME  DS:RESGROUP
        CMP     [PIPEFLAG],0
        JNZ     NOREDIR                 ; Don't muck up the pipe
        CALL    TESTDOREIN
        CALL    TESTDOREOUT
NOREDIR:
        POP     CX
        POP     BX
        POP     AX
        POP     DX
        POP     DS
ASSUME  DS:NOTHING
        return

TESTDOREIN:
ASSUME  DS:RESGROUP
        CMP     [RE_INSTR],0
        retz
        MOV     DX,OFFSET RESGROUP:RE_INSTR
        MOV     AX,(OPEN SHL 8)
        INT     int_command
        MOV     DX,OFFSET TRANGROUP:NOTFND
        JC      REDIRERR
        MOV     BX,AX
        MOV     AL,0FFH
        XCHG    AL,[BX.PDB_JFN_Table]
        MOV     DS:[PDB_JFN_Table],AL
        return

REDIRERR:
        PUSH    CS
        POP     DS
        JMP     CERROR

TESTDOREOUT:
ASSUME  DS:RESGROUP
        CMP     [RE_OUTSTR],0
        JZ      NOREOUT
        CMP     [RE_OUT_APP],0
        JZ      REOUTCRT
        MOV     DX,OFFSET RESGROUP:RE_OUTSTR
        MOV     AX,(OPEN SHL 8) OR 1
        INT     int_command
        JC      REOUTCRT
        XOR     DX,DX
        XOR     CX,CX
        MOV     BX,AX
        MOV     AX,(LSEEK SHL 8) OR 2
        INT     int_command
        JMP     SHORT SET_REOUT
REOUTCRT:
        MOV     DX,OFFSET RESGROUP:RE_OUTSTR
        XOR     CX,CX
        MOV     AH,CREAT
        INT     int_command
        MOV     DX,OFFSET TRANGROUP:FULDIR
        JC      REDIRERR
        MOV     BX,AX
SET_REOUT:
        MOV     AL,0FFH
        XCHG    AL,[BX.PDB_JFN_Table]
        MOV     DS:[PDB_JFN_Table+1],AL
NOREOUT:
        return

STRCOMP:
; Compare ASCIZ DS:SI with ES:DI.
; SI,DI destroyed.
        CMPSB
        retnz                           ; Strings not equal
        cmp     byte ptr [SI-1],0       ; Hit NUL terminator?
        retz                            ; Yes, strings equal
        jmp     short STRCOMP           ; Equal so far, keep going



TRANCODE        ENDS
        END