; COMMAND version 1.17
;
; This version of COMMAND is divided into three distinct parts. First
; is the resident portion, which includes handlers for interrupts
; 22H (terminate), 23H (Cntrl-C), 24H (fatal error), and 27H (stay
; resident); it also has code to test and, if necessary, reload the
; transient portion. Following the resident is the init code, which is
; overwritten after use. Then comes the transient portion, which
; includes all command processing (whether internal or external).
; The transient portion loads at the end of physical memory, and it may
; be overlayed by programs that need as much memory as possible. When
; the resident portion of command regains control from a user program,
; a checksum is performed on the transient portion to see if it must be
; reloaded. Thus programs which do not need maximum memory will save
; the time required to reload COMMAND when they terminate.

;Use the following booleans to set assembly flags
FALSE   EQU     0
TRUE    EQU     NOT FALSE

IBMVER  EQU     FALSE   ;Switch to build IBM version of Command
MSVER   EQU     TRUE    ;Switch to build MS-DOS version of Command

HIGHMEM EQU     TRUE    ;Run resident part above transient (high memory)

LINPERPAG       EQU     23
NORMPERLIN      EQU     1
WIDEPERLIN      EQU     5

        IF      IBMVER
SYM     EQU     ">"
COMDRV  EQU     1
        ENDIF

        IF      MSVER
SYM     EQU     ":"
COMDRV  EQU     0
        ENDIF

FCB     EQU     5CH
DSKRESET EQU    13
SETBASE EQU     38
SRCHFRST EQU    17
SRCHNXT EQU     18
RENAM   EQU     23
INCHAR  EQU     1
GETFAT  EQU     27
OPEN    EQU     15
CLOSE   EQU     16
MAKE    EQU     22
DELETE  EQU     19
RDBLK   EQU     39
WRBLK   EQU     40
SETDMA  EQU     26
SELDRV  EQU     14
GETDRV  EQU     25
PRINTBUF EQU    9
OUTCH   EQU     2
INBUF   EQU     10
GETDATE EQU     2AH
SETDATE EQU     2BH
GETTIME EQU     2CH
SETTIME EQU     2DH
RR      EQU     33
RECLEN  EQU     14
FILLEN  EQU     16
OFFDATE EQU     20


;The following are all of the segments used in the load order

CODERES SEGMENT
CODERES ENDS

DATARES SEGMENT BYTE
DATARES ENDS

INIT    SEGMENT BYTE
INIT    ENDS

TAIL    SEGMENT PARA
TAIL    ENDS

TRANCODE        SEGMENT PARA
TRANCODE        ENDS

TRANDATA        SEGMENT BYTE
TRANDATA        ENDS

TRANSPACE       SEGMENT BYTE
TRANSPACE       ENDS

RESGROUP        GROUP   CODERES,DATARES,INIT,TAIL
TRANGROUP       GROUP   TRANCODE,TRANDATA,TRANSPACE

;Data for resident portion

DATARES SEGMENT BYTE
        ORG     0
ZERO    =       $
MESBAS  DW      OFFSET RESGROUP:ERR0
        DW      OFFSET RESGROUP:ERR2
        DW      OFFSET RESGROUP:ERR4
        DW      OFFSET RESGROUP:ERR6
        DW      OFFSET RESGROUP:ERR8
        DW      OFFSET RESGROUP:ERR10
        DW      OFFSET RESGROUP:ERR12
ERR0    DB      "Write protect$"
ERR2    DB      "Not ready$"
ERR4    DB      "Data$"
ERR6    DB      "Seek$"
ERR8    DB      "Sector not found$"
ERR10   DB      "Write fault$"
ERR12   DB      "Disk$"
READ    DB      "read$"
WRITE   DB      "writ$"
ERRMES  DB      " error "
IOTYP   DB      "writing"
DRVNUM  DB      " drive "
DRVLET  DB      "A"
NEWLIN  DB      13,10,"$"
REQUEST DB      "Abort, Retry, Ignore? $"
BADFAT  DB      13,10,"File allocation table bad,$"
COMBAD  DB      13,10,"Invalid COMMAND.COM"
NEEDCOM DB      13,10,"Insert DOS disk in "
        IF      IBMVER
        DB      "drive A"
        ELSE
        DB      "default drive"
        ENDIF
PROMPT  DB      13,10,"and strike any key when ready",13,10,"$"
NEEDBAT DB      13,10,"Insert disk with batch file$"
ENDBATMES DB    13,10,"Terminate batch job (Y/N)? $"
LOADING DB      0
BATFCB  DB      1,"AUTOEXECBAT"
        DB      21 DUP(?)
        DW      0
        DW      0               ;Initialize RR field to zero
PARMTAB DW      10 DUP(-1)      ;No parameters initially
BATCH   DB      1               ;Assume batch mode initially
COMFCB  DB      COMDRV,"COMMAND COM"
        DB      25 DUP(?)
TRANS   DW      OFFSET TRANGROUP:COMMAND
TRNSEG  DW      ?
BATBYT  DB      ?
MEMSIZ  DW      ?
SUM     DW      ?
INITADD DB      4 DUP(?)
RESDATASIZE     EQU     $-ZERO
DATARES ENDS

;Data for transient portion

TRANDATA        SEGMENT BYTE
        ORG     0
ZERO    =       $
BADNAM  DB      "Bad command or file name",13,10,"$"
MISNAM  DB      "Missing file name$"
RENERR  DB      "Duplicate file name or "
NOTFND  DB      "File not found$"
EXEBAD  DB      "Error in EXE file$"
NOSPACE DB      "Insufficient disk space",13,10,"$"
FULDIR  DB      "File creation error",13,10,"$"
OVERWR  DB      "File cannot be copied onto itself",13,10,"$"
LOSTERR DB      "Content of destination lost before copy",13,10,"$"
COPIED  DB      " File(s) copied$"
DIRMES  DB      " File(s)$"
TOOBIG  DB      "Program too big to fit in memory$"
BADDRV  DB      "Invalid drive specification$"
PAUSMES DB      "Strike a key when ready . . . $"
BADSWT  DB      "Illegal switch",13,10,"$"
WEEKTAB DB      "SunMonTueWedThuFriSat"
BADDAT  DB      13,10,"Invalid date$"
CURDAT  DB      "Current date is $"
NEWDAT  DB      13,10,"Enter new date: $"
BADTIM  DB      13,10,"Invalid time$"
CURTIM  DB      "Current time is $"
NEWTIM  DB      13,10,"Enter new time: $"
SUREMES DB      "Are you sure (Y/N)? $"

COMTAB  DB      4,"DIR",1
        DW      OFFSET TRANGROUP:CATALOG
        DB      7,"RENAME",1
        DW      OFFSET TRANGROUP:RENAME
        DB      4,"REN",1
        DW      OFFSET TRANGROUP:RENAME
        DB      6,"ERASE",1
        DW      OFFSET TRANGROUP:ERASE
        DB      4,"DEL",1
        DW      OFFSET TRANGROUP:ERASE
        DB      5,"TYPE",1
        DW      OFFSET TRANGROUP:TYPEFIL
        DB      4,"REM",1
        DW      OFFSET TRANGROUP:COMMAND
        DB      5,"COPY",1
        DW      OFFSET TRANGROUP:COPY
        DB      6,"PAUSE",1
        DW      OFFSET TRANGROUP:PAUSE
        DB      5,"DATE",0
        DW      OFFSET TRANGROUP:DATE
        DB      5,"TIME",0
        DW      OFFSET TRANGROUP:TIME
        DB      0               ;Terminate command table

COMBUF  DB      128,1,13

TRANDATASIZE    EQU     $-ZERO
TRANDATA        ENDS

;Uninitialized transient data
TRANSPACE       SEGMENT BYTE
        ORG     0
ZERO    =       $
        DB      128 DUP(?)
TPA     DW      1 DUP(?)
RESSEG  DW      1 DUP(?)
CHKDRV  DB      1 DUP(?)
FILTYP  DB      1 DUP(?)
CURDRV  DB      1 DUP(?)
PARM1   DB      1 DUP(?)
PARM2   DB      1 DUP(?)
COMSW   DW      1 DUP(?)
ARG1S   DW      1 DUP(?)
ARG2S   DW      1 DUP(?)
FLAGER  DB      1 DUP(?)
CFLAG   DB      1 DUP(?)
SPECDRV DB      1 DUP(?)
BYTCNT  DW      1 DUP(?)
NXTADD  DW      1 DUP(?)
LINCNT  DB      1 DUP(?)
LINLEN  DB      1 DUP(?)
FILECNT DW      1 DUP(?)
EXEFCB  LABEL WORD
IDLEN   DB      1 DUP(?)
ID      DB      8 DUP(?)
COM     DB      3 DUP(?)
DEST    DB      37 DUP(?)
DESTNAME DB     11 DUP(?)
DIRBUF  DB      37 DUP(?)
BITS    DW      1 DUP(?)
FULLSCR DW      1 DUP(?)
EXEEND  DW      1 DUP(?)
;Header variables for EXE file load
;These are overlapped with COPY variables, below
RUNVAR  LABEL WORD
RELPT   DW      1 DUP(?)
RELSEG  DW      1 DUP(?)
PSIZE   LABEL   WORD
PAGES   DW      1 DUP(?)
RELCNT  DW      1 DUP(?)
HEADSIZ DW      1 DUP(?)
        DW      1 DUP(?)
LOADLOW DW      1 DUP(?)
INITSS  DW      1 DUP(?)
INITSP  DW      1 DUP(?)
        DW      1 DUP(?)
INITIP  DW      1 DUP(?)
INITCS  DW      1 DUP(?)
RELTAB  DW      1 DUP(?)
RUNVARSIZ       EQU     $-RUNVAR

        DB      80H DUP(?)
STACK   LABEL   WORD

PRETRLEN        EQU     $-ZERO          ;Used later to compute TRNLEN

        ORG     RUNVAR-ZERO                     ;Overlaps EXE variables

SRCPT   DW      1 DUP(?)
INEXACT DB      1 DUP(?)
APPEND  DB      1 DUP(?)
NOWRITE DB      1 DUP(?)
ASCII   DB      1 DUP(?)
PLUS    DB      1 DUP(?)
SOURCE  DB      11 DUP(?)
TRANSPACESIZE   EQU     $-ZERO
TRANSPACE       ENDS


;START OF RESIDENT PORTION

CODERES SEGMENT
ASSUME  CS:RESGROUP,DS:RESGROUP,ES:RESGROUP,SS:RESGROUP
        ORG     0
ZERO    =       $
PARMBUF LABEL   WORD

        ORG     100H

RSTACK  LABEL   WORD

PROGSTART:
        JMP     CONPROC

LTPA    DW      0               ;WILL STORE TPA SEGMENT HERE
MYSEG   DW      0               ;Put our own segment here

CONTC:
        MOV     AX,CS
        MOV     DS,AX
        MOV     SS,AX
        MOV     SP,OFFSET RESGROUP:RSTACK
        STI
        CALL    SETVECT
        MOV     AH,DSKRESET
        INT     33              ;Reset disks in case files were open
        TEST    [BATCH],-1
        JZ      LODCOM
ASKEND:
        MOV     DX,OFFSET RESGROUP:ENDBATMES
        MOV     AH,PRINTBUF
        INT     33
        MOV     AX,0C00H+INCHAR
        INT     33
        AND     AL,5FH
        CMP     AL,"N"
        JZ      LODCOM
        CMP     AL,"Y"
        JNZ     ASKEND
        MOV     [BATCH],0
LODCOM:
        MOV     AX,CS
        MOV     SS,AX
        MOV     SP,OFFSET RESGROUP:RSTACK
        MOV     DS,AX
        CALL    SETVECT
        CALL    CHKSUM
        CMP     DX,[SUM]
        JZ      HAVCOM
        MOV     [LOADING],1
        CALL    LOADCOM
CHKSAME:
        CALL    CHKSUM
        CMP     DX,[SUM]
        JZ      HAVCOM
        CALL    WRONGCOM
        JMP     SHORT CHKSAME
HAVCOM:
        MOV     [LOADING],0
        MOV     SI,OFFSET RESGROUP:LTPA
        MOV     DI,OFFSET TRANGROUP:TPA
        MOV     ES,[TRNSEG]
        CLD
        MOVSW           ;Move TPA segment to transient storage
        MOVSW           ;Move resident segment too
        MOV     AX,[MEMSIZ]
        MOV     WORD PTR ES:[2],AX
        JMP     DWORD PTR [TRANS]

RESIDENT:
        ADD     DX,15
        MOV     CL,4
        SHR     DX,CL           ;Number of paragraphs of new addition
        ADD     CS:[LTPA],DX
        XOR     AX,AX
        MOV     DS,AX
        JMP     DWORD PTR DS:[80H]              ;Pretend user executed INT 20H

DSKERR:
        ;******************************************************
        ;       THIS IS THE DEFAULT DISK ERROR HANDLING CODE 
        ;       AVAILABLE TO ALL USERS IF THEY DO NOT TRY TO 
        ;       INTERCEPT INTERRUPT 24H.
        ;******************************************************
        STI
        PUSH    DS
        PUSH    CS
        POP     DS              ;Set up local data segment
        PUSH    DX
        CALL    CRLF
        POP     DX
        ADD     AL,"A"          ;Compute drive letter
        MOV     [DRVLET],AL
        TEST    AH,80H          ;Check if hard disk error
        JNZ     FATERR
        MOV     SI,OFFSET RESGROUP:READ
        TEST    AH,1
        JZ      SAVMES
        MOV     SI,OFFSET RESGROUP:WRITE
SAVMES:
        LODSW
        MOV     WORD PTR [IOTYP],AX
        LODSW
        MOV     WORD PTR [IOTYP+2],AX
        AND     DI,0FFH
        CMP     DI,12
        JBE     HAVCOD
        MOV     DI,12
HAVCOD:
        MOV     DI,WORD PTR [DI+MESBAS] ;Get pointer to error message
        XCHG    DI,DX           ;May need DX later
        MOV     AH,PRINTBUF
        INT     33              ;Print error type
        MOV     DX,OFFSET RESGROUP:ERRMES
        INT     33
        CMP     [LOADING],0
        JNZ     GETCOMDSK
ASK:
        MOV     DX,OFFSET RESGROUP:REQUEST
        MOV     AH,PRINTBUF
        INT     33
        MOV     AX,0C00H+INCHAR
        INT     33              ;Get response
        CALL    CRLF
        OR      AL,20H          ;Convert to lower case
        MOV     AH,0            ;Return code for ignore
        CMP     AL,"i"          ;Ignore?
        JZ      EXIT
        INC     AH
        CMP     AL,"r"          ;Retry?
        JZ      EXIT
        INC     AH
        CMP     AL,"a"          ;Abort?
        JNZ     ASK
EXIT:
        MOV     AL,AH
        MOV     DX,DI
        POP     DS
        IRET

FATERR:
        MOV     DX,OFFSET RESGROUP:BADFAT
        MOV     AH,PRINTBUF
        INT     33
        MOV     DX,OFFSET RESGROUP:DRVNUM
        INT     33
        MOV     AL,2            ;Abort
        POP     DS
        IRET

GETCOMDSK:
        MOV     DX,OFFSET RESGROUP:NEEDCOM
        MOV     AH,PRINTBUF
        INT     33
        MOV     AX,0C07H        ;Get char without testing or echo
        INT     33
        JMP     LODCOM

CRLF:
        MOV     DX,OFFSET RESGROUP:NEWLIN
        PUSH    AX
        MOV     AH,PRINTBUF
        INT     33
        POP     AX
RET10:  RET

LOADCOM:
        PUSH    DS
        MOV     DS,[TRNSEG]
        MOV     DX,100H
        MOV     AH,SETDMA
        INT     33
        POP     DS
        MOV     DX,OFFSET RESGROUP:COMFCB
        MOV     AH,OPEN
        INT     33              ;Open COMMAND.COM
        OR      AL,AL
        JZ      READCOM
        MOV     DX,OFFSET RESGROUP:NEEDCOM
PROMPTCOM:
        MOV     AH,PRINTBUF
        INT     33
        MOV     AX,0C07H        ;Get char without testing or echo
        INT     33
        JMP     SHORT LOADCOM
READCOM:
        MOV     WORD PTR[COMFCB+RR],OFFSET RESGROUP:TRANSTART
        XOR     AX,AX
        MOV     WORD PTR[COMFCB+RR+2],AX
        MOV     [COMFCB],AL             ;Use default drive
        INC     AX
        MOV     WORD PTR[COMFCB+RECLEN],AX
        MOV     CX,COMLEN
        MOV     DX,OFFSET RESGROUP:COMFCB
        MOV     AH,RDBLK
        INT     33
        OR      AL,AL
        JZ      RET10
WRONGCOM:
        MOV     DX,OFFSET RESGROUP:COMBAD
        JMP     SHORT PROMPTCOM

CHKSUM:
        CLD
        PUSH    DS
        MOV     DS,[TRNSEG]
        MOV     SI,100H
        MOV     CX,COMLEN
        SHR     CX,1
        XOR     DX,DX
CHK:
        LODSW
        ADD     DX,AX
        LOOP    CHK
        POP     DS
        RET

SETVECT:
        MOV     DX,OFFSET RESGROUP:LODCOM
        MOV     AX,2522H        ;Set Terminate address
        INT     21H
        MOV     DX,OFFSET RESGROUP:CONTC
        MOV     AX,2523H        ;Set Ctrl-C address
        INT     21H
        MOV     DX,OFFSET RESGROUP:DSKERR
        MOV     AX,2524H        ;Set Hard Disk Error address
        INT     33
        MOV     DX,OFFSET RESGROUP:RESIDENT
        MOV     AX,2527H        ;Set Terminate and Stay Resident address
        INT     33
        RET
RESCODESIZE     EQU     $-ZERO
CODERES ENDS

;*******************************************************************
;START OF INIT PORTION
;This code is overlayed the first time the TPA is used.

INIT    SEGMENT BYTE

        ORG     0
ZERO    =       $
CONPROC:
        MOV     SP,OFFSET RESGROUP:RSTACK

        IF      HIGHMEM
        MOV     AX,WORD PTR DS:[2]
        SUB     AX,((RESCODESIZE+RESDATASIZE)+15)/16            ;Subtract size of resident
        MOV     WORD PTR DS:[2],AX
        MOV     ES,AX
        MOV     SI,100H
        MOV     DI,SI
        MOV     CX,((RESCODESIZE+RESDATASIZE)-100H+1)/2 ;Length of resident in words
        REP     MOVSW                   ;Move to end of memory
        MOV     DS,AX
        MOV     [LTPA],CS
        ENDIF

        IF      NOT HIGHMEM
        MOV     AX,CS
        ADD     AX,((RESCODESIZE+RESDATASIZE)+15)/16            ;Compute segment of TPA
        MOV     [LTPA],AX
        MOV     AX,WORD PTR DS:[2]
        ENDIF

        MOV     [MYSEG],DS
        MOV     [MEMSIZ],AX
        SUB     AX,TRNLEN               ;Subtract size of transient
        MOV     [TRNSEG],AX
        CALL    SETVECT
        CALL    LOADCOM
        CALL    CHKSUM
        MOV     [SUM],DX

        IF MSVER
        IF      HIGHMEM
        PUSH    DS
        PUSH    CS
        POP     DS
        ENDIF
        MOV     DX,OFFSET RESGROUP:HEADER
        MOV     AH,PRINTBUF
        INT     33
        IF      HIGHMEM
        POP     DS
        ENDIF
        ENDIF

        MOV     DX,OFFSET RESGROUP:BATFCB
        MOV     AH,OPEN
        INT     33                      ;See if AUTOEXEC.BAT exists
        MOV     WORD PTR[BATFCB+RECLEN],1       ;Set record length to 1
        OR      AL,AL                   ;Zero means file found
        JZ      DRV0
        MOV     [BATCH],0               ;Not found--turn off batch job
        MOV     AX,OFFSET TRANGROUP:DATINIT
        MOV     WORD PTR[INITADD],AX
        MOV     AX,[TRNSEG]
        MOV     WORD PTR[INITADD+2],AX
        CALL    DWORD PTR DS:[INITADD]

        IF IBMVER
        MOV     DX,OFFSET RESGROUP:HEADER
        MOV     AH,PRINTBUF
        INT     33
        ENDIF

DRV0:
        JMP     HAVCOM


        IF MSVER
HEADER  DB      13,10,"Command v. 1.17"
        IF      HIGHMEM
        DB      "H"
        ENDIF
        DB      13,10,"$"
        ENDIF

        IF IBMVER
HEADER  DB      13,10,13,10,"The IBM Personal Computer DOS",13,10
        DB      "Version 1.10 (C)Copyright IBM Corp 1981, 1982",13,10,"$"
        DB      "Licensed Material - Program Property of IBM"
        ENDIF

INITSIZE        EQU     $-ZERO
INIT    ENDS

;This TAIL segment is used to produce a PARA aligned label in the resident
; group which is the location where the transient segments will be loaded
; initialy.

TAIL    SEGMENT PARA
        ORG     0
TRANSTART       LABEL   WORD
TAIL    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 PARA
ASSUME  CS:TRANGROUP,DS:TRANGROUP,ES:TRANGROUP,SS:TRANGROUP

WSWITCH EQU     1               ;Wide display during DIR
PSWITCH EQU     2               ;Pause (or Page) mode during DIR
VSWITCH EQU     4               ;Verify during COPY
ASWITCH EQU     8               ;ASCII mode during COPY
BSWITCH EQU     10H             ;Binary mode during COPY

        ORG     0
ZERO    =       $

        ORG     100H            ;Allow for 100H parameter area

SETDRV:
        MOV     AH,SELDRV
        INT     21H
COMMAND:
        CLD
        MOV     AX,CS
        MOV     SS,AX
        MOV     SP,OFFSET TRANGROUP:STACK
        MOV     ES,AX
        MOV     DS,AX
        STI
        MOV     AX,46*100H
        MOV     DL,0
        INT     33              ;Turn off verify after write
        MOV     AX,CS           ;Get segment we're in
        SUB     AX,[TPA]        ;AX=size ot 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
        CALL    CRLF2
GETCOM:
        MOV     AH,GETDRV
        INT     21H
        MOV     [CURDRV],AL
        ADD     AL,"A"
        CALL    OUT             ;Print letter for default drive
        MOV     AL,SYM
        CALL    OUT
        MOV     DS,[RESSEG]     ;All batch work must use resident seg.
ASSUME  DS:RESGROUP
        TEST    [BATCH],-1
        JNZ     READBAT
        PUSH    CS
        POP     DS              ;Need local segment to point to buffer
ASSUME  DS:TRANGROUP
        MOV     DX,OFFSET TRANGROUP:COMBUF
        MOV     AH,INBUF
        INT     21H             ;Get a command
        JMP     DOCOM

;All batch proccessing has DS set to segment of resident portion
ASSUME  DS:RESGROUP
NEEDPARM:
        CALL    GETBATBYT
        CMP     AL,"%"          ;Check for two consecutive %
        JZ      SAVBATBYT
        CMP     AL,13           ;Check for end-of-line
        JZ      SAVBATBYT
        SUB     AL,"0"
        JB      RDBAT           ;Ignore parameter reference if invalid
        CMP     AL,9
        JA      RDBAT
        CBW
        MOV     SI,AX
        SHL     SI,1            ;Two bytes per entry
        MOV     SI,[SI+OFFSET RESGROUP:PARMTAB] ;Get pointer to corresponding parameter
        CMP     SI,-1           ;Check if parameter exists
        JZ      RDBAT           ;Ignore if it doesn't
        MOV     AH,OUTCH
RDPARM:
        LODSB           ;From resident segment
        CMP     AL,0DH          ;Check for end of parameter
        JZ      RDBAT
        STOSB           ;To transient segment
        MOV     DL,AL
        INT     33              ;Display paramters too
        JMP     SHORT RDPARM

PROMPTBAT:
        MOV     AH,PRINTBUF
        MOV     DX,OFFSET RESGROUP:NEEDBAT
        INT     33              ;Prompt for batch file
        MOV     AH,PRINTBUF
        MOV     DX,OFFSET RESGROUP:PROMPT
        INT     33
        MOV     AX,0C00H+INCHAR
        INT     33
        JMP     COMMAND

BADCOMJ1:JMP    BADCOM

READBAT:
        MOV     DX,OFFSET RESGROUP:BATFCB
        MOV     AH,OPEN
        INT     33              ;Make sure batch file still exists
        OR      AL,AL
        JNZ     PROMPTBAT       ;If OPEN fails, prompt for disk
        MOV     WORD PTR [BATFCB+RECLEN],1
        MOV     DX,OFFSET RESGROUP:BATBYT
        MOV     AH,SETDMA
        INT     33
        MOV     DI,OFFSET TRANGROUP:COMBUF+2
RDBAT:
        CALL    GETBATBYT
        CMP     AL,"%"          ;Check for parameter
        JZ      NEEDPARM
SAVBATBYT:
        STOSB
        CALL    OUT             ;Display batched command line
        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
        PUSH    CS
        POP     DS              ;Go back to local segment
ASSUME DS:TRANGROUP
DOCOM:
;All segments are local for command line processing
        MOV     AL,10
        CALL    OUT
        MOV     SI,OFFSET TRANGROUP:COMBUF+2
        MOV     DI,OFFSET TRANGROUP:IDLEN
        MOV     AX,2901H        ;Make FCB with blank scan-off
        INT     21H
        CMP     AL,1            ;Check for ambiguous command name
        JZ      BADCOMJ1        ;Ambiguous commands not allowed
        CMP     AL,-1
        JNZ     DRVGD
        JMP     DRVBAD
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
        MOV     CX,0
        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.
        MOV     [FLAGER],0      ;Set error flag before any calls to switch 
        CALL    SWITCH          ;Is the next character a "/"
        MOV     [COMSW],AX
        MOV     DI,FCB
        MOV     AX,2901H
        INT     21H
        MOV     [PARM1],AL      ;Save result of parse
        CALL    SWITCH
        MOV     [ARG1S],AX
        MOV     DI,FCB+10H
        MOV     AX,2901H
        INT     21H             ;Parse file name
        MOV     [PARM2],AL      ;Save result
        CALL    SWITCH
        MOV     [ARG2S],AX
        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
        JMP     GETCOM

RETSW:
        XCHG    AX,BX           ;Put switches in AX
        RET

SWITCH:
        XOR     BX,BX           ;Initialize - no switches set
SWLOOP:
        CALL    SCANOFF         ;Skip any delimiters
        CMP     AL,"/"          ;Is it a switch specifier?
        JNZ     RETSW           ;No -- we're finished
        INC     SI              ;Skip over "/"
        CALL    SCANOFF
        INC     SI
;Convert lower case input to upper case
        CMP     AL,"a"
        JB      SAVCHR
        CMP     AL,"z"
        JA      SAVCHR
        SUB     AL,20H          ;Lower-case changed to upper-case
SAVCHR:
        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:
        MOV     [FLAGER],1      ;Record error in switch
        JMP     SHORT SWLOOP

SWLIST  DB      "BAVPW"
SWCOUNT EQU     $-SWLIST

DRVBAD:
        MOV     DX,OFFSET TRANGROUP:BADDRV
        JMP     ERROR

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    DX
COMJMP: JMP     COMMAND

BADCOMJ:JMP     BADCOM

SETDRV1:
        JMP     SETDRV

DRVCHK:
        DEC     DL              ;Adjust for correct drive number
        DEC     AL              ;Check if anything else is on line
        JZ      SETDRV1
EXTERNAL:
        MOV     AL,[SPECDRV]
        MOV     [IDLEN],AL
        MOV     WORD PTR[COM],4F00H+"C" ;"CO"
        MOV     BYTE PTR[COM+2],"M"
        MOV     DX,OFFSET TRANGROUP:IDLEN
        MOV     AH,OPEN
        INT     33              ;Check if command to be executed
        MOV     [FILTYP],AL     ;0 for COM files, -1 for EXE files
        OR      AL,AL
        JZ      EXECUTE
        MOV     WORD PTR[COM],5800H+"E" ;"EX"
        MOV     BYTE PTR[COM+2],"E"
        INT     33              ;Check for EXE file
        OR      AL,AL
        JZ      EXECUTE
        MOV     WORD PTR[COM],4100H+"B" ;"BA"
        MOV     BYTE PTR[COM+2],"T"
        INT     33              ;Check if batch file to be executed
        OR      AL,AL
        JNZ     BADCOMJ
BATCOM:
;Batch parameters are read with ES set to segment of resident part
        MOV     ES,[RESSEG]
ASSUME  ES:RESGROUP
        MOV     DI,OFFSET RESGROUP:PARMTAB
        MOV     AX,-1
        MOV     CX,10
        REP     STOSW           ;Zero parameter pointer table
        MOV     SI,OFFSET TRANGROUP:COMBUF+2
        MOV     DI,OFFSET RESGROUP:PARMBUF
        MOV     BX,OFFSET RESGROUP:PARMTAB
EACHPARM:
        CALL    SCANOFF
        CMP     AL,0DH
        JZ      HAVPARM
        MOV     ES:[BX],DI              ;Set pointer table to point to actual parameter
        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
        CMP     BX,OFFSET RESGROUP:PARMTAB+20   ;Maximum number of parameters?
        JB      EACHPARM
HAVPARM:
        MOV     SI,OFFSET TRANGROUP:IDLEN
        MOV     DI,OFFSET RESGROUP:BATFCB
        MOV     CX,16
        REP     MOVSW           ;Move into private batch FCB
        XOR     AX,AX
        PUSH    ES
        POP     DS                      ;Simply batch FCB setup
ASSUME  DS:RESGROUP
        MOV     WORD PTR[BATFCB+RR],AX
        MOV     WORD PTR[BATFCB+RR+2],AX        ;Zero RR field
        INC     AX
        MOV     WORD PTR[BATFCB+RECLEN],AX      ;Set record length to 1 byte
        MOV     [BATCH],AL              ;Flag batch job in progress
        JMP     COMMAND
ASSUME  DS:TRANGROUP,ES:TRANGROUP

EXECUTE:
        MOV     AX,WORD PTR[IDLEN+16]
        OR      AX,WORD PTR[IDLEN+18]           ;See if zero length
        JZ      BADCOM                  ;If so, error
        XOR     AX,AX
        MOV     WORD PTR[IDLEN+RR],AX
        MOV     WORD PTR[IDLEN+RR+2],AX         ;Set RR field to zero
        INC     AX
        MOV     WORD PTR[IDLEN+RECLEN],AX       ;Set record length field to 1
        MOV     DX,[TPA]
        MOV     BX,DX
        MOV     AH,SETBASE
        INT     21H
        TEST    [FILTYP],-1             ;Check if file is COM or EXE
        JZ      COMLOAD
        JMP     EXELOAD
COMLOAD:PUSH    DS
        MOV     DS,DX
        MOV     DX,100H
        MOV     AH,SETDMA
        INT     21H
        POP     DS
        MOV     CX,[BYTCNT]
        SUB     CX,100H
        MOV     DX,OFFSET TRANGROUP:IDLEN
        MOV     AH,RDBLK
        INT     21H
        DEC     AL
        MOV     DX,OFFSET TRANGROUP:TOOBIG
        JNZ     ERROR
;Set up exit conditions
        MOV     CX,[BYTCNT]
        MOV     DS,BX
        MOV     ES,BX
        CLI
        MOV     SS,BX
        MOV     SP,CX
        STI
        SUB     CX,100H         ;Allow some stack space
        XOR     AX,AX
        PUSH    AX
        MOV     AX,100H
        PUSH    BX
        PUSH    AX
        CALL    SETUP
XXX     PROC    FAR
        RET
XXX     ENDP
BADCOM:
        MOV     DX,OFFSET TRANGROUP:BADNAM
ERROR:
        MOV     AH,PRINTBUF
        INT     21H
        JMP     COMMAND

CHKCNT:
        TEST    [FILECNT],-1
        JNZ     ENDDIR
        MOV     DX,OFFSET TRANGROUP:NOTFND
        JMP     ERROR

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     SI,[FILECNT]
        XOR     DI,DI
        CALL    DISP32BITS
        MOV     DX,OFFSET TRANGROUP:DIRMES
        MOV     AH,PRINTBUF
        INT     21H
        RET

CATALOG:
        MOV     AL,"?"                  ;*.* is default file spec.
        MOV     DI,5DH
        MOV     CX,11
        REP     STOSB
        MOV     SI,81H
        CALL    SWITCH
        MOV     DI,5CH
        MOV     AX,41*100H+0DH          ;Parse with default name and extension
        INT     33

;Begin by processing any switches that may have been specified.
;BITS will contain any information about switches that was
;found when the command line was parsed.

SETSWT:
        MOV     AX,[COMSW]              ;Get switches from command
        OR      AX,[ARG1S]              ;OR in switches from first parameter
        MOV     [BITS],AX
        MOV     BYTE PTR[FULLSCR],LINPERPAG
        TEST    AL,1                    ;Look for /W
        MOV     AL,NORMPERLIN
        JZ      DIR
        MOV     AL,WIDEPERLIN
DIR:
        MOV     [LINLEN],AL             ;Set number of entries per line
        MOV     [LINCNT],AL
        MOV     [FILECNT],0     ;Keep track of how many files found
        MOV     DX,OFFSET TRANGROUP:DIRBUF      ;Set Disk transfer address
        MOV     AH,SETDMA
        INT     21H             
        MOV     AH,SRCHFRST
SHOWDIR:
        MOV     DX,5CH          ;DX -> Unopened FCB
        INT     21H             ;Search for a file to match FCB
        INC     AL              ;FF = file not found
        JNZ     AGAIN           ;Either an error or we are finished
        JMP     CHKCNT
AGAIN:
        INC     [FILECNT]       ;Keep track of how many we find
        MOV     SI,OFFSET TRANGROUP:DIRBUF+1    ;SI -> information returned by sys call
        CALL    SHONAME
        TEST    BYTE PTR[BITS],1        ;/W set?
        JNZ     NEXENT          ;If so, no size, date, or time
        CALL    DISPSIZE        ;Print size of file
        CALL    TWOSPC
        MOV     AX,WORD PTR[DIRBUF+25]  ;Get date
        OR      AX,AX
        JZ      NEXENT          ;Skip if no date
        MOV     DX,AX
        MOV     CL,5
        SHR     AX,CL           ;Align month
        AND     AL,0FH
        MOV     BH,"0"-" "      ;Enable zero suppression
        CALL    OUT2
        MOV     AL,"-"
        CALL    OUT
        MOV     AL,DL
        AND     AL,1FH          ;Mask to day
        CALL    OUT2
        MOV     AL,"-"
        CALL    OUT
        MOV     AL,DH
        SHR     AL,1            ;Align year
        ADD     AX,80           ;Relative 1980
        CMP     AL,100
        JB      MILLENIUM
        SUB     AL,100
MILLENIUM:
        CALL    OUT2
        MOV     BX,WORD PTR[DIRBUF+23]  ;Get time
        OR      BX,BX           ;Time field present?
        JZ      NEXENT
        CALL    TWOSPC  
        SHR     BX,1
        SHR     BX,1
        SHR     BX,1
        SHR     BL,1
        SHR     BL,1            ;Hours in BH, minutes in BL
        MOV     AL,BH
        MOV     DH,"a"          ;Assume A.M.
        CMP     AL,12           ;In the afternoon?
        JB      MORN
        MOV     DH,"p"
        JE      MORN
        SUB     AL,12           ;Keep it to 12 hours or less
MORN:
        OR      AL,AL           ;Before 1 am?
        JNZ     SHOHOURS
        MOV     AL,12
SHOHOURS:
        MOV     BH,"0"-" "      ;Enable zero suppression
        CALL    OUT2
        MOV     AL,":"
        CALL    OUT
        MOV     AL,BL           ;Output minutes
        CALL    OUT2
        MOV     AL,DH           ;Get "a" or "p"
        CALL    OUT
NEXENT:
        DEC     [LINCNT]
        JNZ     SAMLIN
NEXLIN:
        MOV     AL,[LINLEN]
        MOV     [LINCNT],AL
        CALL    CRLF2
        TEST    BYTE PTR[BITS],2        ;/P switch present?
        JZ      SCROLL          ;If not, just continue
        DEC     BYTE PTR[FULLSCR]
        JNZ     SCROLL
        MOV     BYTE PTR[FULLSCR],LINPERPAG
        MOV     AH,PRINTBUF
        MOV     DX,OFFSET TRANGROUP:PAUSMES
        INT     33
        MOV     AX,0C08H        ;Wait for any character to be typed
        INT     21H
        CALL    CRLF2
SCROLL:
        MOV     AH,SRCHNXT
        JMP     SHOWDIR

SAMLIN:
        MOV     AL,9            ;Output a tab
        CALL    OUT
        JMP     SHORT SCROLL

SHONAME:
        MOV     CX,8
        CALL    OUTCNT
        CALL    ONESPC
        MOV     CX,3
OUTCNT:
        LODSB
        CALL    OUT
        LOOP    OUTCNT
        RET

TWOSPC:
        CALL    ONESPC
ONESPC:
        MOV     AL," "
        JMP     OUT

CRLF2:
        MOV     AL,13
        CALL    OUT
        MOV     AL,10
        JMP     OUT

DISPSIZE:
        MOV     SI,WORD PTR[DIRBUF+29]
        MOV     DI,WORD PTR[DIRBUF+31]
DISP32BITS:
;Prints the 32-bit number DI:SI on the console in decimal. Uses a total
;of 9 digit positions with leading blanks.
        XOR     AX,AX
        MOV     BX,AX
        MOV     BP,AX
        MOV     CX,32
CONVLP:
        SHL     SI,1
        RCL     DI,1
        XCHG    AX,BP
        CALL    CONVWRD
        XCHG    AX,BP
        XCHG    AX,BX
        CALL    CONVWRD
        XCHG    AX,BX
        ADC     AL,0
        LOOP    CONVLP
; Conversion complete. Print 9-digit number.
        MOV     CX,1810H        ;Allow leading zero blanking for 8 digits
        XCHG    DX,AX
        CALL    DIGIT
        XCHG    AX,BX
        CALL    OUTWORD
        XCHG    AX,BP
OUTWORD:
        PUSH    AX
        MOV     DL,AH
        CALL    OUTBYTE
        POP     DX
OUTBYTE:
        MOV     DH,DL
        SHR     DL,1
        SHR     DL,1
        SHR     DL,1
        SHR     DL,1
        CALL    DIGIT
        MOV     DL,DH
DIGIT:
        AND     DL,0FH
        JZ      BLANKZER
        MOV     CL,0
BLANKZER:
        DEC     CH
        AND     CL,CH
        OR      DL,30H
        SUB     DL,CL
        MOV     AH,OUTCH
        INT     21H
        RET

CONVWRD:
        ADC     AL,AL
        DAA
        XCHG    AL,AH
        ADC     AL,AL
        DAA
        XCHG    AL,AH
RET20:  RET

ERASE:
        MOV     CX,11
        MOV     SI,FCB+1
AMBSPEC:        
        LODSB
        CMP     AL,"?"
        JNZ     ALLFIL
        LOOP    AMBSPEC
ALLFIL: 
        CMP     CX,0
        JNZ     NOPRMPT
ASKAGN:         
        MOV     DX,OFFSET TRANGROUP:SUREMES     ;"Are you sure (Y/N)?"
        MOV     AH,PRINTBUF
        INT     21H
        MOV     AX,0C00H+INCHAR
        INT     21H
        AND     AL,5FH
        CMP     AL,"N"
        JZ      RET20
        CMP     AL,"Y"
        CALL    CRLF2
        JZ      NOPRMPT
        JMP     SHORT ASKAGN
NOPRMPT:
        MOV     AH,DELETE
        MOV     BX,OFFSET TRANGROUP:NOTFND
        CMP     BYTE PTR DS:[FCB+1]," " ;Check if parameter exists
        JMP     SHORT OPFILE
RENAME:
        MOV     AH,RENAM
        MOV     BX,OFFSET TRANGROUP:RENERR
        CMP     BYTE PTR DS:[FCB+16+1]," "  ;Check if parameter exists
OPFILE:
        MOV     DX,OFFSET TRANGROUP:MISNAM
        JZ      ERRJ            ;Error if missing parameter
        MOV     DX,FCB
        INT     21H
        INC     AL
        JNZ     RET20
        MOV     DX,BX
ERRJ:   JMP     ERROR

TYPEFIL:
        MOV     DS,[TPA]
        XOR     DX,DX
        MOV     AH,SETDMA
        INT     21H
        PUSH    CS
        POP     DS
        MOV     DX,FCB
        MOV     AH,OPEN
        INT     21H
        OR      AL,AL
        MOV     DX,OFFSET TRANGROUP:NOTFND
        JNZ     ERRJ
        XOR     AX,AX
        MOV     WORD PTR DS:[FCB+RR],AX ;Set RR field
        MOV     WORD PTR DS:[FCB+RR+2],AX
        INC     AX
        MOV     WORD PTR DS:[FCB+RECLEN],AX     ;Set record length
        MOV     ES,[TPA]
TYPELP:
        MOV     DX,FCB
        MOV     CX,[BYTCNT]
        MOV     AH,RDBLK
        INT     21H
        JCXZ    RET30
        XOR     SI,SI           ;Start at 0 in TPA
OUTLP:
        LODS    BYTE PTR ES:[SI]                ;In TPA segment
        CMP     AL,1AH
        JZ      RET30
        MOV     AH,OUTCH
        MOV     DL,AL
        INT     21H
        LOOP    OUTLP
        JMP     SHORT TYPELP

RET30:  RET                             ;Need a nearby RET

COPY:
        XOR     AX,AX
        MOV     [PLUS],AL               ;Will keep track of "+"s
        MOV     [FILECNT],AX
        MOV     SI,81H                  ;Point to input line
        CALL    SWITCH                  ;Skip over switches on command
        MOV     BP,AX
        MOV     DI,FCB
        CALL    PARSNAM                 ;Scan first source
        MOV     [PARM1],DL              ;Save ambiguous flag
        MOV     [SRCPT],SI              ;Save pointer to command line
;Parse each name to find destination and check for /V switch
SCANNAM:
        CALL    PARSE
        JNZ     SCANNAM
GETDEST:
        MOV     DI,OFFSET TRANGROUP:DEST
        MOV     BX,BP                   ;Remeber switches so far
        XOR     BP,BP                   ;Must have dest. swtiches alone
        CALL    PARSNAM
        MOV     [ARG2S],BP              ;Remember switches on destination
        JNZ     HAVDESTNAM              ;File name present?
        INC     DI                      ;Point to file name spot
        MOV     AL,"?"                  ;Substitute *.*
        MOV     CX,11
        REP     STOSB
HAVDESTNAM:
        OR      BX,BP                   ;BX = all switches combined
        AND     BL,VSWITCH              ;Verify requested?
        JZ      NOVER
        MOV     AX,46*100H+1            ;Set verify
        MOV     DL,0
        INT     33
NOVER:
        MOV     DI,OFFSET TRANGROUP:DESTNAME
        MOV     SI,OFFSET TRANGROUP:DEST+1
        MOV     BX,FCB+1
        CALL    BUILDNAME               ;See if we can make it unambiguous
        MOV     DI,OFFSET TRANGROUP:DESTNAME
        MOV     AL,"?"
        MOV     CX,11
        REPNE   SCASB                   ;Scan for "?" to see if ambiguous
        MOV     AL,1                    ;Flag if ambig.
        JZ      AMBIG
        DEC     AX                      ;AL=0 if unambig.
AMBIG:
        MOV     DL,AL
        MOV     AH,[PLUS]               ;1=found "+"
        XOR     AL,1                    ;0=ambig, 1=unambig destination
        AND     AL,[PARM1]              ;Source ambig. AND dest unambig.
        OR      AL,AH                   ;OR found "+" means concatenation
        MOV     [ASCII],AL              ;Concatenation implies ASCII mode
        MOV     [INEXACT],AL            ;ASCII implies inexact copy
        SHL     AL,1
        OR      AL,DL                   ;Combine multiple and concat flags
        MOV     [PARM2],AL
        MOV     AL,BYTE PTR[COMSW]
        CALL    SETASC                  ;Check /A,/B on command
        MOV     AL,BYTE PTR[ARG1S]
        CALL    SETASC                  ;Check for ASCII on first filename
        MOV     BYTE PTR[COMSW],AL              ;Save starting switch values
        MOV     AH,SRCHFRST
        CALL    SEARCH                  ;Search for first source name
MULTDEST:
        JZ      FIRSTSRC                ;Find a first source name?
        TEST    [PARM2],1               ;If multiple, we're done
        JNZ     ENDCOPY
        XOR     AX,AX
        MOV     [NXTADD],AX
        MOV     [CFLAG],AL              ;Flag nothing read yet
NEXTSNG:
        MOV     DI,FCB
        MOV     SI,[SRCPT]
        CALL    PARSESRC                ;Parse next file name into FCB
        MOV     [PARM1],DL              ;Remember if it's ambiguous
        MOV     [SRCPT],SI
        JZ      SNGCLOS
        MOV     AH,SRCHFRST
        CALL    SEARCH                  ;Search for new file name
        JNZ     NEXTSNG                 ;If none, skip it and move to next name
READSNG:
        CALL    CHECKREAD
SNGLOOP:
        CALL    SEARCHNEXT              ;See if any more of this name
        JZ      READSNG
        JMP     SHORT NEXTSNG

SNGCLOS:
        CALL    CLOSEFIL
ENDCOPY:
        MOV     SI,[FILECNT]
        XOR     DI,DI
        CALL    DISP32BITS
        MOV     DX,OFFSET TRANGROUP:COPIED
        MOV     AH,PRINTBUF
        INT     21H
        JMP     COMMAND                 ;Stack could be messed up

FIRSTSRC:
        MOV     SI,OFFSET TRANGROUP:DIRBUF+1
        MOV     DI,OFFSET TRANGROUP:SOURCE
        MOV     CX,11
        REP     MOVSB                   ;Copy first source name to SOURCE
        MOV     SI,OFFSET TRANGROUP:DESTNAME
        MOV     DI,OFFSET TRANGROUP:DEST+1
        MOV     BX,OFFSET TRANGROUP:SOURCE
        CALL    BUILDNAME               ;Build destination name
        XOR     AX,AX
        MOV     [NXTADD],AX
        MOV     [CFLAG],AL
        MOV     [APPEND],AL
        MOV     [NOWRITE],AL
        TEST    [PARM2],1               ;Multiple destinations?
        JZ      NOPRT
        MOV     SI,OFFSET TRANGROUP:DIRBUF+1
        CALL    SHONAME                 ;If so, show first source
        CALL    CRLF2
NOPRT:
        CALL    COMPNAME                ;Source and dest. the same?
        JNZ     DOREAD                  ;If not, read source in
        TEST    [PARM2],2               ;Concatenation?
        MOV     DX,OFFSET TRANGROUP:OVERWR
        JZ      COPERRJ                 ;If not, overwrite error
        MOV     [APPEND],1              ;Set physical append
        MOV     AH,OPEN
        MOV     DX,OFFSET TRANGROUP:DEST
        INT     33                      ;Open (existing) destination
        CMP     [ASCII],0               ;ASCII flag set?
        JZ      BINARYAPP
;ASCII append. Must find logical EOF, then seek there with dest. FCB
        MOV     [NOWRITE],1
        CALL    READIN                  ;Find EOF
        CALL    FLSHFIL                 ;Seek there
        MOV     [NOWRITE],0
        CALL    FLSHFIL                 ;Truncate file
        JMP     SHORT SNGLCHK

SNGLOOPJ:JMP    SNGLOOP

COPERRJ:JMP     COPERR

BINARYAPP:
        MOV     WORD PTR[DEST+RECLEN],1         ;Set record length to 1
        MOV     SI,OFFSET TRANGROUP:DEST+16             ;Point to file size
        MOV     DI,OFFSET TRANGROUP:DEST+RR
        MOVSW
        MOVSW                           ;Seek to end of file
        MOV     [CFLAG],1
        JMP     SHORT SNGLCHK
DOREAD:
        CALL    READIN
SNGLCHK:
        TEST    [PARM2],1               ;Single or multiple destinations?
        JZ      SNGLOOPJ
        MOV     SI,[SRCPT]
MULTAPP:
        CALL    PARSE
        JZ      MULTCLOS
        PUSH    SI
        MOV     SI,OFFSET TRANGROUP:DIRBUF+1
        MOV     DI,SI
        MOV     BX,OFFSET TRANGROUP:SOURCE
        CALL    BUILDNAME
        CALL    CHECKREAD
        POP     SI
        JMP     SHORT MULTAPP
MULTCLOS:
        CALL    CLOSEFIL
        MOV     AL,BYTE PTR[COMSW]
        MOV     [ASCII],AL              ;Restore ASCII flag
        CALL    SEARCHNEXT
        JMP     MULTDEST

PARSE:
        MOV     DI,OFFSET TRANGROUP:DIRBUF
PARSESRC:
        CALL    SCANOFF
        CMP     AL,"+"
        JNZ     RETZF
        MOV     [PLUS],1                ;Keep track of "+" signs
        INC     SI                      ;Skip over it
PARSNAM:
        MOV     AX,2901H
        INT     33                      ;Parse file name
        CMP     AL,-1                   ;Illegal?
        MOV     DX,OFFSET TRANGROUP:BADDRV
        JZ      COPERRJ
        XCHG    AX,DX                   ;Save parse flag in DL
        MOV     AL,BYTE PTR[DI]         ;Get drive number
        OR      AL,AL                   ;Is it default?
        JNZ     PARSW
        MOV     AL,[CURDRV]             ;Substitute actual drive
        INC     AX
        MOV     BYTE PTR[DI],AL
PARSW:
        PUSH    BX
        PUSH    DI
        CALL    SWITCH                  ;Process switches
        OR      BP,AX                   ;Combine all switches
        CALL    SETASC                  ;Check for /A or /B
        POP     DI
        POP     BX
        CMP     BYTE PTR[DI+1]," "              ;Did we even get a file name?
        RET

RETZF:
        XOR     AX,AX
RET35:  RET

SEARCHNEXT:
        MOV     AL,[PARM1]              ;Is name ambiguous?
        DEC     AL
        JNZ     RET35                   ;Don't perform search if not
        MOV     AH,SRCHNXT
SEARCH:
        PUSH    AX
        MOV     AH,SETDMA
        MOV     DX,OFFSET TRANGROUP:DIRBUF
        INT     33                      ;Put result of search in DIRBUF
        POP     AX                      ;Restore search first/next command
        MOV     DX,FCB
        INT     33                      ;Do the search
        OR      AL,AL
        RET

SETASC:
;Given switch vector in AX, 
;       Set ASCII switch if /A is set
;       Clear ASCII switch if /B is set
;       Leave ASCII unchanged if neither or both are set
; Also sets INEXACT if ASCII is ever set. AL = ASCII on exit, flags set
        AND     AL,ASWITCH+BSWITCH
        JPE     LOADSW                  ;PE means both or neither are set
        AND     AL,ASWITCH
        MOV     [ASCII],AL
        OR      [INEXACT],AL
LOADSW:
        MOV     AL,[ASCII]
        OR      AL,AL
        RET

BUILDNAME:
; [SI] = Ambiguous input file name
; [BX] = Source of replacement characters
; [DI] = Destination
; File name is copied from [SI] to [DI]. If "?"s are encountered,
; they are replaced with the character in the same position at [BX].
        MOV     CX,11
BUILDNAM:
        LODSB
        CMP     AL,"?"
        JNZ     NOTAMBIG
        MOV     AL,BYTE PTR[BX]
NOTAMBIG:
        STOSB
        INC     BX
        LOOP    BUILDNAM
        RET

COMPNAME:
        MOV     SI,OFFSET TRANGROUP:DEST
        MOV     DI,OFFSET TRANGROUP:DIRBUF
        MOV     CX,6
        REPE    CMPSW
        RET

CHECKREAD:
;Read file in (with READIN) if not identical to destination
        CALL    COMPNAME                ;See if source and destination the same
        JNZ     READIN
        CMP     [APPEND],0              ;If physical append, it's OK
        JNZ     RET40
        MOV     DX,OFFSET TRANGROUP:LOSTERR             ;Tell him he's not going to get it
        MOV     AH,PRINTBUF
        INT     33
RET40:  RET

READIN:
;Open source file and read it in. If memory fills up, flush it out to
;destination and keep reading. If /A switch set, chop file at first ^Z.
; Inputs/Outputs:
;       [NXTADD] has current pointer in buffer
;       [CFLAG] <>0 if destination has been created

        MOV     DX,OFFSET TRANGROUP:DIRBUF
        MOV     AH,OPEN
        INT     21H
        OR      AL,AL                   ;Successful open?
        JNZ     RET40                   ;If not, just ignore it
        XOR     AX,AX
        MOV     WORD PTR[DIRBUF+RR],AX
        MOV     WORD PTR[DIRBUF+RR+2],AX
        INC     AX
        MOV     WORD PTR[DIRBUF+RECLEN],AX
COPYLP:
        MOV     DX,[NXTADD]
        MOV     AH,SETDMA
        PUSH    DS
        MOV     DS,[TPA]
        INT     33
        POP     DS
        MOV     CX,[BYTCNT]
        SUB     CX,DX                   ;Compute available space
        MOV     DX,OFFSET TRANGROUP:DIRBUF
        MOV     AH,RDBLK                ;Read in source file
        INT     21H
        JCXZ    RET40
        CMP     [ASCII],0
        JZ      BINREAD
        MOV     DX,CX
        MOV     DI,[NXTADD]
        MOV     AL,1AH
        PUSH    ES
        MOV     ES,[TPA]
        REPNE   SCASB                   ;Scan for EOF
        POP     ES
        JNZ     USEALL
        INC     CX
USEALL:
        SUB     DX,CX
        MOV     CX,DX
BINREAD:
        ADD     CX,[NXTADD]
        MOV     [NXTADD],CX
        CMP     CX,[BYTCNT]             ;Is buffer full?
        JB      RET40                   ;If not, we must have found EOF
        CALL    FLSHFIL
        JMP     SHORT COPYLP

CLOSEFIL:
        MOV     AX,[NXTADD]
        MOV     BX,AX
        OR      AL,AH                   ;See if any data is loaded
        OR      AL,[CFLAG]              ;   or file was created
        JZ      RET50                   ;Don't close or count if not created
        MOV     AL,BYTE PTR[ARG2S]
        CALL    SETASC                  ;Check for /B or /A on destination
        JZ      BINCLOS
        CMP     BX,[BYTCNT]             ;Is memory full?
        JNZ     PUTZ
        CALL    FLSHFIL                 ;Empty it to make room for 1 lousy byte
        XOR     BX,BX
PUTZ:
        PUSH    DS
        MOV     DS,[TPA]
        MOV     WORD PTR[BX],1AH                ;Add End-of-file mark (Ctrl-Z)
        POP     DS
        INC     [NXTADD]
BINCLOS:
        CALL    FLSHFIL
        CMP     [INEXACT],0             ;Copy not exact?
        JNZ     NODATE                  ;If so, don't copy date & time
        MOV     SI,OFFSET TRANGROUP:DIRBUF+OFFDATE
        MOV     DI,OFFSET TRANGROUP:DEST+OFFDATE        ;Make date & time same as original
        MOVSW                           ;Copy date
        MOVSW                           ;Copy time
NODATE:
        MOV     DX,OFFSET TRANGROUP:DEST
        MOV     AH,CLOSE
        INT     21H
        INC     [FILECNT]
RET50:  RET

FLSHFIL:
;Write out any data remaining in memory.
; Inputs:
;       [NXTADD] = No. of bytes to write
;       [CFLAG] <>0 if file has been created
; Outputs:
;       [NXTADD] = 0

        MOV     AL,1
        XCHG    [CFLAG],AL
        OR      AL,AL
        JNZ     EXISTS
        CMP     [NOWRITE],0
        JNZ     SKPMAK                  ;Don't actually create if NOWRITE set
        MOV     DX,OFFSET TRANGROUP:DEST
        MOV     AH,MAKE
        INT     21H
        MOV     DX,OFFSET TRANGROUP:FULDIR
        OR      AL,AL
        JNZ     COPERR
SKPMAK:
        XOR     AX,AX
        MOV     WORD PTR[DEST+RR],AX
        MOV     WORD PTR[DEST+RR+2],AX
        INC     AX
        MOV     WORD PTR[DEST+RECLEN],AX
EXISTS:
        XOR     CX,CX
        XCHG    CX,[NXTADD]
        CMP     [NOWRITE],0             ;If NOWRITE set, just seek CX bytes
        JNZ     SEEKEND
        XOR     DX,DX
        PUSH    DS
        MOV     DS,[TPA]
        MOV     AH,SETDMA
        INT     33
        POP     DS
        MOV     DX,OFFSET TRANGROUP:DEST
        MOV     AH,WRBLK
        INT     21H
        OR      AL,AL
        JZ      RET60
        MOV     DX,OFFSET TRANGROUP:DEST
        MOV     AH,CLOSE
        INT     21H
        MOV     AH,DELETE
        INT     33
        MOV     DX,OFFSET TRANGROUP:NOSPACE
COPERR:
        MOV     AH,9
        INT     21H
        JMP     ENDCOPY

SEEKEND:
        ADD     WORD PTR[DEST+RR],CX
        ADC     WORD PTR[DEST+RR+2],0           ;Propagate carry
RET60:  RET

GETBATBYT:
;Get one byte from the batch file and return it in AL. End-of-file
;returns <CR> and ends batch mode. DS must be set to resident segment.
;AH, CX, DX destroyed.
ASSUME  DS:RESGROUP
        MOV     DX,OFFSET RESGROUP:BATFCB
        MOV     AH,RDBLK
        MOV     CX,1
        INT     33              ;Get one more byte from batch file
        JCXZ    BATEOF
        MOV     AL,[BATBYT]
        CMP     AL,1AH
        JNZ     RET70
BATEOF:
        MOV     AL,0DH          ;If end-of-file, then end of line
        MOV     [BATCH],0       ;And turn off batch mode
RET70:  RET
ASSUME  DS:TRANGROUP

SCANOFF:
        LODSB
        CALL    DELIM
        JZ      SCANOFF
        DEC     SI              ;Point to first non-delimiter
        RET

DELIM:
        CMP     AL," "
        JZ      RET80
        CMP     AL,"="
        JZ      RET80
        CMP     AL,","
        JZ      RET80
        CMP     AL,9            ;Check for TAB character
RET80:  RET

PAUSE:
        MOV     DX,OFFSET TRANGROUP:PAUSMES
        MOV     AH,PRINTBUF
        INT     33
        MOV     AX,0C00H+INCHAR ;Get character with KB buffer flush
        INT     33
RET90:  RET

;Date and time are set during initialization and use
;this routines since they need to do a long return

DATINIT:
        PUSH    ES
        PUSH    DS              ;Going to use the previous stack
        MOV     AX,CS           ;Set up the appropriate segment registers
        MOV     ES,AX
        MOV     DS,AX
        MOV     WORD PTR DS:[81H],13    ;Want to prompt for date during initialization
        CALL    DATE
        CALL    TIME
        POP     DS
        POP     ES
YYY     PROC    FAR
        RET
YYY     ENDP

; DATE - Gets and sets the time

DATE:
        MOV     SI,81H          ;Accepting argument for date inline
        CALL    SCANOFF
        CMP     AL,13
        JZ      PRMTDAT
        MOV     BX,2F00H+"-"    ;"/-"
        CALL    INLINE
        JMP     COMDAT

PRMTDAT:
        MOV     DX,OFFSET TRANGROUP:CURDAT
        MOV     AH,PRINTBUF
        INT     33              ;Print "Current date is "
        MOV     AH,GETDATE
        INT     33              ;Get date in CX:DX
        CBW
        MOV     SI,AX
        SHL     SI,1
        ADD     SI,AX           ;SI=AX*3
        ADD     SI,OFFSET TRANGROUP:WEEKTAB
        MOV     BX,CX
        MOV     CX,3
        CALL    OUTCNT
        MOV     AL," "
        CALL    OUT
        MOV     AX,BX
        MOV     CX,DX
        MOV     DL,100
        DIV     DL
        XCHG    AL,AH
        XCHG    AX,DX
        MOV     BL,"-"
        CALL    SHOW
GETDAT:
        MOV     DX,OFFSET TRANGROUP:NEWDAT
        MOV     BX,2F00H+"-"    ;"/-" in BX
        CALL    GETBUF
COMDAT: JZ      RET90
        JC      DATERR
        LODSB   
        CMP     AL,BL
        JZ      SEPGD
        CMP     AL,BH
        JNZ     DATERR
SEPGD:  CALL    GETNUM
        JC      DATERR
        MOV     CX,1900
        CMP     BYTE PTR[SI],13
        JZ      BIAS
        MOV     AL,100
        MUL     AH
        MOV     CX,AX
        CALL    GETNUM
        JC      DATERR
BIAS:
        MOV     AL,AH
        MOV     AH,0
        ADD     CX,AX
        LODSB
        CMP     AL,13
        JNZ     DATERR
        MOV     AH,SETDATE
        INT     33
        OR      AL,AL
        JNZ     DATERR
        JMP     RET90
DATERR:
        MOV     DX,OFFSET TRANGROUP:BADDAT
        MOV     AH,PRINTBUF
        INT     33
        JMP     GETDAT

; TIME gets and sets the time

TIME:
        MOV     SI,81H                  ;Accepting argument for time inline
        CALL    SCANOFF
        CMP     AL,13
        JZ      PRMTTIM
        MOV     BX,3A00H+":"
        CALL    INLINE
        JMP     COMTIM

PRMTTIM:
        MOV     DX,OFFSET TRANGROUP:CURTIM
        MOV     AH,PRINTBUF
        INT     33              ;Print "Current time is "
        MOV     AH,GETTIME
        INT     33              ;Get time in CX:DX
        MOV     BL,":"
        CALL    SHOW
GETTIM:
        XOR     CX,CX           ;Initialize hours and minutes to zero
        MOV     DX,OFFSET TRANGROUP:NEWTIM
        MOV     BX,3A00H+":"
        CALL    GETBUF
COMTIM: JZ      RET100          ;If no time present, don't change it
        JC      TIMERR
        MOV     CX,DX
        XOR     DX,DX
        LODSB
        CMP     AL,13
        JZ      SAVTIM
        CMP     AL,BL
        JNZ     TIMERR
        MOV     BL,"."
        CALL    GETNUM
        JC      TIMERR
        MOV     DH,AH           ;Position seconds
        LODSB
        CMP     AL,13
        JZ      SAVTIM
        CMP     AL,BL
        JNZ     TIMERR  
        CALL    GETNUM
        JC      TIMERR
        MOV     DL,AH
        LODSB
        CMP     AL,13
        JNZ     TIMERR
SAVTIM:
        MOV     AH,SETTIME
        INT     33
        OR      AL,AL
        JZ      RET100          ;Error in time?
TIMERR:
        MOV     DX,OFFSET TRANGROUP:BADTIM
        MOV     AH,PRINTBUF
        INT     33              ;Print error message
        JMP     GETTIM          ;Try again

GETBUF:
        MOV     AH,PRINTBUF
        INT     33              ;Print "Enter new date: "
        MOV     AH,INBUF
        MOV     DX,OFFSET TRANGROUP:COMBUF
        INT     33              ;Get input line
        CALL    CRLF2
        MOV     SI,OFFSET TRANGROUP:COMBUF+2
        CMP     BYTE PTR[SI],13 ;Check if new date entered
        JZ      RET100
INLINE:
        CALL    GETNUM          ;Get one or two digit number
        JC      RET100
        MOV     DH,AH           ;Put in position
        LODSB
        CMP     AL,BL
        JZ      NEXT
        CMP     BL,":"          ;Is it a date seperator?
        JNZ     DATESEP
        DEC     SI
        MOV     DL,0
RET100: RET                     ;Time may have only an hour specified
DATESEP:
        CMP     AL,BH
        STC
        JNZ     RET100
NEXT:   CALL    GETNUM
        MOV     DL,AH           ;Put in position
        RET

GETNUM:
        CALL    INDIG
        JC      RET100
        MOV     AH,AL           ;Save first digit
        CALL    INDIG           ;Another digit?
        JC      OKRET
        AAD                     ;Convert unpacked BCD to decimal
        MOV     AH,AL
OKRET:
        OR      AL,1
RET110: RET

INDIG:
        MOV     AL,BYTE PTR[SI]
        SUB     AL,"0"
        JC      RET110
        CMP     AL,10
        CMC
        JC      RET110
        INC     SI
        RET

SHOW:
        MOV     AL,CH
        MOV     BH,"0"-" "      ;Enable leading zero suppression
        CALL    OUT2
        MOV     AL,BL
        CALL    OUT
        MOV     AL,CL
        CALL    OUT2
        MOV     AL,BL
        CALL    OUT
        MOV     AL,DH
        CALL    OUT2
        CMP     BL,":"          ;Are we outputting time?
        JNZ     SKIPIT
        MOV     AL,"."
        CALL    OUT
SKIPIT: MOV     AL,DL
OUT2:   ;Output binary number as two ASCII digits
        AAM                     ;Convert binary to unpacked BCD
        XCHG    AL,AH
        OR      AX,3030H        ;Add "0" bias to both digits
        CMP     AL,"0"          ;Is MSD zero?
        JNZ     NOSUP
        SUB     AL,BH           ;Suppress leading zero if enabled
NOSUP:
        MOV     BH,0            ;Disable zero suppression
        CALL    OUT
        MOV     AL,AH
OUT:
;Print char in AL without affecting registers
        XCHG    AX,DX
        PUSH    AX
        MOV     AH,OUTCH
        INT     33
        POP     AX
        XCHG    AX,DX
        RET

EXELOAD:
        MOV     AX,CS
        ADD     AX,LOADSEG
        MOV     [EXEEND],AX     ;Store in EXEEND
        MOV     DX,OFFSET TRANGROUP:RUNVAR      ;Read header in here
        MOV     AH,SETDMA
        INT     33
        MOV     CX,RUNVARSIZ    ;Amount of header info we need
        MOV     DX,OFFSET TRANGROUP:EXEFCB
        MOV     AH,RDBLK
        INT     33              ;Read in header
        OR      AL,AL
        JNZ     BADEXE          ;Must not reach EOF
        MOV     AX,[HEADSIZ]    ;Size of header in paragraphs
;Convert header size to 512-byte pages by multiplying by 32 & rounding up
        ADD     AX,31           ;Round up first
        MOV     CL,5
        SHR     AX,CL           ;Multiply by 32
        MOV     [EXEFCB+RR],AX  ;Position in file of program
        MOV     WORD PTR[EXEFCB+RECLEN],512 ;Set record size
        ADD     BX,10H          ;First paragraph above parameter area
        MOV     DX,[PAGES]      ;Total size of file in 512-byte pages
        SUB     DX,AX           ;Size of program in pages
        MOV     [PSIZE],DX
        SHL     DX,CL           ;Convert pages back to paragraphs
        MOV     AX,DX
        ADD     DX,BX           ;Size + start = minimum memory (paragr.)
        MOV     CX,[EXEEND]     ;Get memory size in paragraphs
        CMP     DX,CX           ;Enough memory?
        JA      SHRTERR
        MOV     DX,[INITSP]
        ADD     DX,15
        SHR     DX,1
        SHR     DX,1
        SHR     DX,1
        SHR     DX,1
        ADD     DX,[INITSS]
        ADD     DX,BX           ;Adjusted value of SP
        CMP     DX,CX           ;Is it valid?
        JA      SHRTERR
        CMP     [LOADLOW],-1    ;Load low or high?
        JZ      LOAD            ;If low, load at segment BX
        SUB     CX,AX           ;Memory size - program size = load addr.
        MOV     BX,CX
LOAD:
        MOV     BP,BX           ;Save load segment
LOAD1:
LOADSEG EQU     (LOAD1-ZERO)/16
        PUSH    DS
        MOV     DS,BX
        XOR     DX,DX           ;Address 0 in segment
        MOV     AH,SETDMA
        INT     33              ;Set load address
        POP     DS
        MOV     CX,[PSIZE]      ;Number of records to read
        MOV     DX,OFFSET TRANGROUP:EXEFCB
        MOV     AH,RDBLK
        INT     33              ;Read in up to 64K
        SUB     [PSIZE],CX      ;Decrement count by amount read
        JZ      HAVEXE          ;Did we get it all?
        TEST    AL,1            ;Check return code if not
        JNZ     BADEXE          ;Must be zero if more to come
        ADD     BX,1000H-20H    ;Bump data segment 64K minus one record
        JMP     SHORT LOAD1             ;Get next 64K block

BADEXE:
        MOV     DX,OFFSET TRANGROUP:EXEBAD
        JMP     ERROR

SHRTERR:
        MOV     DX,OFFSET TRANGROUP:TOOBIG
        JMP     ERROR

HAVEXE:
        MOV     AX,[RELTAB]     ;Get position of table
        MOV     [EXEFCB+RR],AX  ;Set in random record field
        MOV     WORD PTR[EXEFCB+RECLEN],1  ;Set one-byte record
        MOV     DX,OFFSET TRANGROUP:RELPT       ;4-byte buffer for relocation address
        MOV     AH,SETDMA
        INT     33
        CMP     [RELCNT],0
        JZ      NOREL
RELOC:
        MOV     AH,RDBLK
        MOV     DX,OFFSET TRANGROUP:EXEFCB
        MOV     CX,4
        INT     33              ;Read in one relocation pointer
        OR      AL,AL           ;Check return code
        JNZ     BADEXE
        MOV     DI,[RELPT]      ;Get offset of relocation pointer
        MOV     AX,[RELSEG]     ;Get segment
        ADD     AX,BP           ;Bias segment with actual load segment
        MOV     ES,AX
        ADD     WORD PTR ES:[DI],BP             ;Relocate
        DEC     [RELCNT]        ;Count off
        JNZ     RELOC
;Set up exit conditions
NOREL:
        MOV     AX,[INITSS]
        ADD     AX,BP
        CLI
        MOV     SS,AX           ;Initialize SS
        MOV     SP,[INITSP]
        STI
        ADD     [INITCS],BP
        MOV     AX,[TPA]        ;Get pointer to parameter area
        MOV     CX,[BYTCNT]     ;Size of TPA segment
        MOV     ES,AX
        MOV     DS,AX           ;Set segment registers to point to it
        CALL    SETUP
        JMP     DWORD PTR CS:[INITIP]   ;Long jump to program

SETUP:
        AND     CL,0F0H         ;Adjust to even paragraph boundary
        MOV     AX,WORD PTR DS:[6]              ;Get current memory size
        SUB     AX,CX           ;Find out how much we're changing it
        MOV     WORD PTR DS:[6],CX
        MOV     CL,4
        SAR     AX,CL           ;Convert to a segment address
        ADD     WORD PTR DS:[8],AX              ;Adjust long jump to go to same place
        MOV     DX,80H
        MOV     AH,SETDMA
        INT     33              ;Set default disk transfer address
        MOV     AX,WORD PTR CS:[PARM1]  ;Pass on info about FCBs
        XOR     CX,CX
        MOV     DX,CX           ;Assume no batch file
ASSUME  CS:RESGROUP
        TEST    CS:[BATCH],-1   ;Batch file in progress?
ASSUME  CS:TRANGROUP
        JZ      RET120          ;If not, all set up
        MOV     CX,CS:[RESSEG]
        MOV     DX,OFFSET RESGROUP:BATFCB       ;CX:DX points to batch FCB
RET120: RET
TRANCODESIZE    EQU     $-ZERO
TRANCODE        ENDS
COMLEN  EQU     TRANDATASIZE+TRANCODESIZE-102H          ;End of COMMAND load. ZERO Needed to make COMLEN absolute
TRNLEN  EQU     (PRETRLEN+TRANCODESIZE+TRANDATASIZE+15)/16              ;Length of transient in paragraphs
        END     PROGSTART