.TITLE	BATCH  SUBMIT EXECUTOR
	.IDENT	/V01.16/
; COPYRIGHT (C) 1978
; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A
; SINGLE COMPUTER SYSTEM AND MAY  BE  COPIED   ONLY  WITH  THE
; INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE,  OR
; ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED  OR  OTHERWISE
; MADE AVAILABLE TO ANY OTHER PERSON   EXCEPT FOR  USE ON SUCH
; SYSTEM AND TO ONE WHO AGREES TO THESE LICENSE  TERMS.  TITLE
; TO AND OWNERSHIP OF THE SOFTWARE SHALL AT ALL  TIMES  REMAIN
; IN DEC.
;
; THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT
; NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL
; EQUIPMENT CORPORATION.
;
; DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF
 
;
; VERSION V01.00
;
;		ERIC ROSDOL	SWS/VIENA
;
;				11-FEB-78
;
; MODULE CONTENTS:
;
; THIS MODULE CONTAINS ALL ROUTINES NECESSARY TO CONTROL THE 
; THE PSEUDO BATCH FUNCTIONALITY OF THE SUBMIT COMMAND WITH 
; THE VIRTUAL TERMINAL DRIVER VT1:
;
; MODULE MODIFICATION HISTORY:
;
;	JGD01	23-MAY-78	MODIFIED TO CLEAN UP A BIT, EXTEND BUFFER SIZE
;				FOR LOG FILE, TRUNCATE LOG FILE ON EXIT, ETC
;				CORRECT(OR TRY TO) SEVERE SYNCRONIZATION PROBLEMS
;				WITH LOGING ON. ALSO (TOGETHER WITH BYE MODIFICATIONS) FIX 
;				LOGOFF SYNCRONIZATION PROBLEM.
;				ALSO AS INITIALLY WRITTEN, BATCH(NE' SEX...)
;				DID NOT CORRECTLY USE THE UIC OF THE 
;				SENDER TASK WHEN INSTALLED AS SLAVE. 
;
;		JGD02		SPEED BATCH UP A BIT. HAVE BYE SEND A '>' IF
;				A VT: LOGS OFF.  BATCH NEED NOT WAIT 10 SEC FOR BYE
;				COMMAND TO TIME OUT(THIS IS REALLY A BYE FIX).  CHECK FOR
;				...AT. TO BECOME ACTIVE BEFORE STARTING TIMEOUT ON READS
;				TO ...AT.  THIS SOLVES A WIERD  PROBLEM IN WHICH IF ...AT.
;				WAS NOT ACTIVATED BY THE @COMMAND AT VT: WITHIN 2 SECONDS
;				BATCH WOULD SEND A BYE TO MCR FROM VT:.  BYE WOULD THEN 
;				PROCEED TO ABORT ...AT. BEFORE IT HAD EVEN STARTED EXECUTING
;				THE COMMAND FILE.  THIS PROBLEM ONLY OCCURED WHEN THE SYSTEM
;				WAS LOADED DOWN.
;
;		JGD03		A MAJOR REWRITE.  AS INITIALLY WRITTEN, BATCH WOULD MALFUNCTION
;				WITH ANY NON MCR COMMANDS.  THIS WAS BECAUSE BATCH TIMES OUT
;				IF IT DID NOT NOTICE THAT MCR WAS PROCESSING AN INDIRECT COMMAND
;				(IE U2.AT ON).  THIS MENT NICE FEATURES LIKE CREATING COMMAND 
;				FILES ON THE FLY WERE IMPOSSIBLE.
;					TO FIX THIS PROBLEM, AST'S ARE NOT USED TO TIME OUT
;				READS TO VT:(THE OUTPUT FROM THE BATCH ...AT.).  THIS SPEEDS
;				THINGS UP AT TIMES.  SINCE THERE ARE NO LONGER ANY(OR ALMOST)
;				TIMEOUTS, THE END OF THE INDIRECT COMMAND FILE IS DETECTED BY
;				SCANNING THE BUFFER FOR  @ <EOF>, AT WHICH POINT THE COMMAND
;				IS SENT TO VT: TO LOG OFF.  WITH THESE CHANGES, THE PREVIOUS 
;				BYE CHANGES COULD BE REMOVED, AND MAYBE SOMEDAY THEY WILL.
;
;		JGD04		BATCH AND ALL THE TASKS IT SPAWNED ON VT: CAN HANG UP IF
;				BATCH GETS SHUFFLED. DOING QIO IO.KILL AND MARKTIMES DO
;				NOT SEEM TO SOLVE THE PROBLEM, NEITHER DOES PUTTING A
;				TIMEOUT COUNT IN VTDRV.  IT LOOKS AS IF THE SYSTEM PLACES
;				A CHECKPOINT REQUEST TO BAT...(IT GETS MARKED WITH  CKR)
;				AND ALL ITS REGISTERS AND PC GETS SAVED, BUT IT CAN'T
;				CHECKPOINT BECAUSE ITS IO COUNT IS ALMOST NEVER ZERO.
;				AVOID PROBLEM BY MAKING BATCH NON-CHECKPOINTABLE JUST
;				DURING THE TIMES IT IS READING FROM VT:
;
;		JGD13		MODIFY TO WORK WITH V3.2, START TO TRY TO MAKE IT MORE
;				LOGICAL.  NOW HELLO AND BYE SIGNAL THEIR EXIT
;				WITH A $SOJ AND A $EOJ RESPECTIVELY
;
;		JGD14		NO LONGER SUBMIT COMMAND FILES TO ...AT.  RATHER LET
;				THE FILES BE EXECUTED ON VT0: BY ...PIN.  NOW ...PIN
;				WILL ONLY EXECUTE SIMPLE MCR COMMANDS, BUT(!!) IT IS 
;				ALMOST 4 TIMES SMALLER THAN ...AT.
;
;		JGD15		CONVERT TO USE A DEVICE SET WITH A GLOBAL PATCH AT 
;				TASK BUILD TIME.
;
; THIS CODE EXPLICITLY EXCLUDES THE ORIGINAL NETWORK CODE			; JGD01
; MACRO CALL DEFINITIONS							; JGD01
;
	
	.MCALL	ALUN$C,QIOW$,MRKT$C,RCVX$C,EXIT$S,FDAT$A,OPEN$W,GET$
	.MCALL	CMKT$S,GLUN$C,DIR$,QIOW$C,ASTX$S,QIO$,CLOSE$,OPEN$R,PUT$
	.MCALL	FDBDF$,FDRC$A,FDOP$A,FSRSZ$,FINIT$,PRINT$,DELET$,OPEN$U
	.MCALL	GTSK$C,UCBDF$,WTSE$,ENCP$S,DSCP$S			; JGD01; JGD04
	.MCALL	QIOW$
	UCBDF$									; JGD01
 
 

;DEBUG=0

;
; LOCAL MACRO DEFINITIONS
;
 
 
 
; SAVE A REGISTER ON THE STACK
	.MACRO	PUSH	X
	MOV	X,-(SP)
	.ENDM
 
 
; RECALL A REGISTER FROM OFF OF THE STACK
	.MACRO	POP	X
	MOV	(SP)+,X
	.ENDM
 
 
; PRINT AN ASCIZ STRING
	.MACRO	PRINT	STRING
	PUSH	R0
	PUSH	R1
	MOV	#STRING,R0
	CALL	PNTLIN
	POP	R1
	POP	R0
	.ENDM	PRINT
 
	.NLIST	BEX

;
; EQUATED SYMBOLS
;
 
 
;
; FILE DEFINITION BLOCKS
;
 
LOG:	FDBDF$
	FDAT$A	R.VAR,FD.CR	;						; JGD01
	FDRC$A	,LOGBUF,132.	; EXPAND LOGBUF TO 132. TO HANDLE LONG LINES	; JGD01
	FDOP$A	1,LOGDS,,FO.WRT
;
; FILE STORAGE REGION
;
 
	FSRSZ$	1		; ONLY ONE FILE AT A TIME
 
;
; DATA SET DESCRIPTOR BLOCK FOR THE LOG-FILE
;
 
LOGDS:	.WORD	DEVL,DEV
	.WORD	0,0		; UFD DESCRIPTOR BLOCK =0 => USE DEFAULT	; JGD01
				; UIC DESCRIPTOR IN $$FSR2			; JGD01
	.WORD	0,FILNM		; WILL BE DEFINED AT RUN TIME
 
; DEVICE FOR LOG FILES.
;	IT IS A PECULIARITY OF TASKS INSTALLED AS SLAVE THAT THEY DO NOT KNOW	; JGD01
;	THE SY: OF THE TASK STARTING THEM OFF.   WHEN AN ALUN$			; JGD01
;	IS DONE, ONLY THE GLOBAL ASSIGNMENTS ARE SEARCHED, NOT THOSE LOCAL	; JGD01
;	TO THE INITIATING TERMINAL(WHICH BATCH KNOWS ABOUT).  THIS CAUSES A	; JGD01
;	PROBLEM SINCE THE LOG FILE MUST BE WRITTEN OUT TO THE DISK DRIVE  	; JGD01
;	CORRESPONDING TO THE SY: OF THE USER SUBMITTING THE FILE.  EVEN 	; JGD01
; 	SWITCHING TO THE SYSTEM STATE AND SCANNING THE LOGICAL ASSINGMENTS    	; JGD01
;	TABLE FOR THE TERMINAL WILL NOT HANDLE ALL PATHALOGICAL CASES.		; JGD01
; 	(WHAT IF USER LOGS OFF, BATCH KNOWS TI:, BUT WHERE'S SY:?).  ONE WAY	; JGD01
;	AROUND THE PROBLEM IS TO CODE THE COMMAND TO BATCH(FROM SUBMIT) IN 	; JGD01
;	RAD50 FORMAT WHICH WOULD LEAVE ROOM FOR SENDING THE BATCH SY0:(WHICH	; JGD01
;	BY THE WAY SUBMIT WOULD HAVE TO FIND) ON TO WHICH TO RIGHT THE LOG	; JGD01
;	FILES.									; JGD01
;	AS A TEMPORARY EXPEDIENT, ALL USERS WHO WILL BE USING BATCH, ARE NOW	; JGD01
;	AND WILL REMAIN ON LB1:( GLOBALLY ASSIGNED, IN OUR CASE TO DM:)		; JGD01
 
DEV::	.ASCII	/DM0:/		; THIS MUST BE HARDWIRED IN		; JGD01; JGD15
UIC:	.ASCIZ	/[000,000]/	; WILL BE USED IN CREATING THE DEFAULT UIC 	; JGD01
				; DISCRIPTOR IN $$FSR2				; JGD01
DEVL=4
UICL=9.
	.EVEN
LOGXT:	.ASCII	/.LOG;1/	; ONLY EVER KEEP ONE VERSION OF A LOG FILE	; JGD01
BYEBUF:	.ASCII	/BYE/<15>
	BYECT=.-BYEBUF
 
;
; DIRECTIVE PARAMETER BLOCKS
;
 
VT1WRT:	QIO$	IO.WLB,5,5,,,,<0,0,0>
VT1RD:	QIOW$	IO.RLB,5,5,,VTSTAT,,<LOGBUF,132.>; ASK FOR UP TO 132 CHARACTERS BACK; JGD01
 
QIODPB:	QIOW$	IO.WVB,6,6,,,,<0,0,40> ; WRITE TO TERMINAL
;
; LOCAL DATA
;
 
VTSTAT:	.BLKW	2		;
LUNINF:	.BLKW	6		; LUN INFORMATION
GLNBUF:	.BLKW	6		; BUFFER FOR GETLUN				; JGD01
CMDBUF:	.BLKW	2		; SENDERS TASK NAME RAD50
SPEC:	.BLKW	15.		; SPECIFIER BUFFER AND OVERHEAD
TIMOUT:	.WORD	0		; TIMEOUT INDICATOR
LOGBUF:	.BLKW	140.		; BUFFER FOR LOGFILE RECORD
FILNM:	.BLKW	30.		; LOGFILE FILENAME
SNDNAM:	.BLKW	2		; SENDER'S TASK NAME
PRMTSW:	.WORD	0		; PROMPT BYPASS SWITCH
TEMP:	.WORD	0		; TEMP STORAGE					; JGD01
COUNT:	.WORD	0		; CHARACTER COUNT				; JGD01
TSKBUF:	.BLKW	16.		; BUFFER FOR GTSK$ DIRECTIVE			; JGD01
LOGCNT:	.WORD	0		; NUMBER OF TIMES TRIED LOGGING ON		; JGD01
EOFFLG:	.WORD	0		; FLAG TO INDICATE END OF INDIRECT 		; JGD01
HELERR:	.WORD	0		; FLAG TO INDICATE LOGIN ERROR			; JGD13
				; COMMAND FILE REACHED				; JGD01
 
;
; LOCAL MESSAGES
;
 
MSG1:	.ASCIZ	<15>/BAT -- YOUR COMMAND FILE IS FINISHED/<15><12><7><7>/>/
MSG2:	.ASCIZ	<15>"BAT -- I/O ERROR ON LOG FILE        "<7><7><15><12>/>/	; JGD01
MSG3:	.ASCIZ	<15>/BAT -- ATTACH FAILURE ON VIRTUAL TERMINAL/<7><7><15><12>/>/
MSG4:	.ASCIZ	<15>/BAT -- USER NOT ABLE TO LOG ONTO VT, TRY AGAIN/<7><15><12>/>/; JGD01
MSG5:	.ASCIZ	<15>/BAT -- COMMAND FILE EXTENSIONS NOT ALLOWED/<7><15><12>/>/	; JGD04
	.EVEN
EM1:	.ASCIZ	<15>/ AT FIRST READ TIMEOUT/
EM2:	.ASCIZ	<15>/AT SECOND READ TIMEOUT/
.EVEN
 
.EVEN
HDRTXT:	.ASCII	/** START OF COMMAND FILE SUBMITTED BY :/
TSKNAM:	.BLKB	6.
 
	.ASCII	/ **/
HDRLN=.-HDRTXT
	.EVEN

;+
; **-$SBCFL
;
; THIS ROUTINE TRIES TO GET A DATA PACKET OUT OF ITS RECEIVE QUEUE.
; IF THIS QUEUE IS EMPTY, IT SIMPLY EXITS.  IF NOT, 
; COMMAND LOGON INFORMATION IS PARSED AND THE
; HELLO MCR FUNCTION EXECUTED ON VT1:.  AFTER LOGGING IN, THE
; INDIRECT COMMAND FILE IS SUBMITTED TO VT1: FOR EXECUTION.
; NOTE THAT THE VIRTUAL TERMINAL IS NOT USED TO SUBMIT MCR TYPE
; COMMANDS FROM A UNPRIVLEGED TASK.  IT IS USED TO GET
; INDIRECT COMMAND FILE INFORMATON LOGGED UNDER A FILE RATHER THAN ON THE
; NORMAL TI TERMINAL (WHICH IN ADDITION IT TIES UP).  
;	BATCH MUST BE INSTALLED AS A SLAVE TASK. IF IT IS SLAVE IT ASSUMES THE 	; JGD01
; 	UIC OF THE SENDER TASK(...SUB) AND THE TI: OF THE SENDER TASK.		; JGD01
;	BOTH FEATURES ARE NECESSARY IF BATCH IS TO OPEN A FILE ON THE USER'S 	; JGD01
;	UFD AND NOTIFY THE USER (ON HIS VERY OWN TI:) WHEN ALL IS DONE.		; JGD01
;	THIS REQUIRES THAT BATCH BE PRIVLEGED BECAUSE IT MUST BE ABLE TO WRITE 	; JGD01
; 	INTO ANY UIC REQUESTED BY SUB.  ALSO IT MUST BE PRIVLEGED TO CONTINUE	; JGD01
;	EXECUTION IF USER LOGS OFF HIS TERMINAL.(BATCH MUST NEVER BE ABORTED).	; JGD01
;
;	NOTE, IT IS NECESSARY TO INSERT THE TASK'S UIC INTO $FSR2.  SINCE BAT...; JGD01
;	IS A SLAVE TASK,'S UIC BECOMES THAT OF THE INITIATING TERMINAL.  WHEN IT; JGD01
;	INITIATED, THE ACT OF FIRST STARTING BATCH UP, CORRECTLY INITIALIZES THE; JGD01
;	DEFAULT DIRECTORY STRING IN $$FSR2.  HOWEVER, IF BATCH RECEIVES ANOTHER ; JGD01
;	REQUEST BEFORE EXITING, THE DEFAULT UIC IN $$FSR2 MUST BE CHANGED TO 	; JGD01
;	THAT OF THE NEW TERMINAL'S UIC. THERE MUST BE A BETTER WAY OF DOING THIS ; JGD01
;	THAN THE FOLLOWING, BUT I HAVEN'T BEEN ABLE TO GET ANY TO WORK CORRECTLY.; JGD01
 
	.ENABLE	LSB
 
$SBCFL::			; REFERENCE LABEL
	ENCP$S			; ENABLE CHECKPOINTING, IF DISABLED		; JGD04
	CLR	HELERR		; RESET FLAG					; JGD13
	RCVX$C	,CMDBUF		; GET FIRST PACKET (COMMAND)
				; AT THIS POINT THE TASK HAS ASSUMED THE TI:  	; JGD01
				; AND UIC OF ...SUB.  HOWEVER IT IS NECESSARY TO; JGD01
				; PUT THE INFORMATION ON UIC INTO $$FSR2 TO  	; JGD01
				; GOVERN WHAT UIC BATCH TRIES TO OPEN A LOG FILE; JGD01
	CLR	EOFFLG		; ON TO SHOW THAT NOT AT END OF FILE YET	; JGD03
	GTSK$C	TSKBUF		; GET PARAMETERS OF THIS TASK(LIKE UIC OF TI:)	; JGD01
	MOV	#TSKBUF+30.,R0	; ADDRESS OF UIC WORD				; JGD01
	MOV	(R0),R3		; BINARY REPRESENTATION OF UIC			; JGD01
	MOV	#UIC,R2		; WHERE UIC STRING WILL GO			; JGD01
	MOV	#1,R4		; DO NOT SUPPRESS LEADING ZEROS,PLACE, IN STRING; JGD01
	CALL	.PPASC		; CONVERT BINARY UIC TO ASCII			; JGD01
	MOV	#UIC,R2		; CREATE NEW DEFAULT DIRECTORY STRING IN $$FSR2	; JGD01
	MOV	#9.,R1		; 9 BYTES LONG					; JGD01
	CALL	.WDFDR		; WRITE IT INTO  $$FSR2				; JGD01
 
 
	ALUN$C	6,TI,0		; ASSIGN TI OF SENDER TASK
	ALUN$C	4,VT,0		; ASSIGN TO VT AND CHECK IF LOADED
	BCC	10$		; IF CC DEVICE OK
	JMP 	ATTERR		; PRINT ERROR MESSAGE
10$:	ALUN$C	5,VT,1		; ASSIGN TO COMMAND INPUT
	QIOW$C	IO.ATT,5,5	; ATTACH VT1 TERMINAL
	BCC	20$		; IF CC ATTACH OK
	JMP	ATTERR		; OTHERWISE PRINT ERROR
20$:	MOV	#CMDBUF,R1	; GET ADDRESS OF SPEC'S
	MOV	(R1),SNDNAM	; SAVE TASK NAME

	MOV	2(R1),SNDNAM+2	; OF SENDER TASK
	MOV	(PC)+,(R1)+	; STORE THE LOGGON
	.ASCII	/HE/
	MOV	(PC)+,(R1)+	; COMMAND FOR VT1
	.ASCII	/L /
30$:	CMPB	#' ,(R1)+	; IS IT A BLANK?
	BNE	30$		; IF NE NO REZAP...
	MOVB	#15,-1(R1)	; STUFF IN A <CR>
	MOV	R1,R2		; COPY FOR LATER USE
	SUB	#CMDBUF,R1	; GET LENGTH OF STRING
	MOV	R1,VT1WRT+Q.IOPL+2 ; SETUP DPB COUNT FILED
	MOV	#CMDBUF,VT1WRT+Q.IOPL ; AND DPB ADDRESS FILED
	MOV	#FILNM,R3	; SET ADDRESS OF FILENAME BUFFER
40$:	MOVB	(R2)+,(R3)	; COPY THE IND-FILENAME
	CMPB	#'.,(R3)	; IS THE USER TRYING TO INCLUDE AN EXTENSION	; JGD04
	BNE	45$		; NOT THIS TIME ANYWAY				; JGD04
	PRINT	MSG5		; WARN USER OF PROBLEM				; JGD04
	JMP	$SBCFL		; AND LOOK TO SEE IF ANOTHER FILE TO PROCESS	; JGD04
45$:	TSTB	(R3)+		; HAVE WE GOTTEN TO THE END(NULL BYTE)		; JGD04
	BNE	40$		; IF NE, NOT FINISHED
	MOV	#LOGXT,R4	; SET ADDRESS OF EXTENSION
	DEC	R3		; OVERWRITE THE NULL BYTE
	.REPT	6		; DO IT OVER 6 TIMES, IT'S EASIER		; JGD01
	MOVB	(R4)+,(R3)+	; APPEND EXTENSION AND VERSION			; JGD01
	.ENDR									; JGD01
	MOVB	#15,-1(R2)	; TERMINATE LINE WITH <CR>
	SUB	#FILNM,R3	; FILE NAME LENGTH
	MOV	R3,LOGDS+10	; SETUP INDSDB
	OPEN$W	#LOG		; OPEN OUTPUT FILE
	BCC	50$		; IF CC NO FILE ERROR
	JMP	FILERR		; OPEN ERROR
50$:	PUSH	R0		; SAVE IT, BECAUSE NEXT
	PUSH	R1		; ROUTINE NEEDS IF
	MOV	#TSKNAM,R0	; GET ADDRESS TO STORE
	MOV	SNDNAM,R1	; GET FIRST RAD50 HALF OF TASK NAME
	CALL	$C5TA		; CONVERT TO ASCII STRING
	MOV	SNDNAM+2,R1	; GET SECOND RAD50 HALF OF TASK NAME
	CALL	$C5TA		; CONVERT TO ASCII STRING
	POP	R1		; GET OLD REGISTERS
	POP	R0		; BACK FROM STACK
	PUT$	R0,#HDRTXT,#HDRLN ; WRITE LOG HEADER
	BCC	60$		; IF CC PUT OK
	JMP	FILERR		; OTHERWISE FILE ERROR
60$:	;PUT$	R0,#CMDBUF,R1	; LOG THE HELLO INPUT					; JGD01
	BCC	70$		; IF CC OK
	JMP	FILERR		; OTHERWISE FILE ERROR
70$:	CALL	SBMCMD		; ISSUE HELLO COMMAND
	QIOW$C	IO.KILL,5,5	; TIDY UP ANY LEFT OVER I/O				; JGD13
	TST	HELERR		; WAS LOGIN OK						; JGD13
	BNE	72$		; IF NE, NO						; JGD13
	CALL	CKLOG		; SEE IF TERMINAL LOGGED ON ALRIGHT			; JGD01
	BCC	75$		; LOGGED ON OK, PROCEED					; JGD01
72$:	TST	HELERR		; WAS LOGIN OK						; JGD13
				; THE REASON FOR THE DOUBLE TEST, IT THAT HELLO WILL	; JGD13
				; ALWAYS TRY TO LOG ON VT: EVEN IN CASES THAT IT WOULD	; JGD13
				; NORMALLY REJECT(MULTIPLE LOGONS)			; JGD13
	BEQ	75$		; IF EQ, YES						; JGD13
	CLOSE$	R0		; CLOSE THE LOG FILE					; JGD01
	PRINT	MSG4		; WARN USER THAT HE COULDN'T LOG ONTO VT:		; JGD01
	CLR	TIMOUT		; RESET TIMEOUT SWITCH					; JGD01
	QIOW$C	IO.KIL,5,5	; TIDY UP ANY LEFT OVER I/O				; JGD03
	JMP	$SBCFL		; GET A NEW COMMAND LINE				; JGD01
75$:				;
	SUB	#2,R3		; NOW FILENAME WITHOUT EXT., WITH <CR> AND PIN		; JGD14
	ADD	#3,R3		; ADD 3 CHARACTERS MORE THAN '@'			; JGD14
	MOV	R3,VT1WRT+Q.IOPL+2 ; SETUP NEW COMMAND LENGTH
;	DEC	R1		; POINT TO START OF COMMAND
	SUB	#4,R1		;  MOVE BACK SO CAN INSERT PIN				; JGD14
	ADD	R1,VT1WRT+Q.IOPL ; POINT  DPB TO START OF COMMAND FIELD
;	MOVB	#'@,@VT1WRT+Q.IOPL ; STUFF IN AN AT SIGN
	MOV	VT1WRT+Q.IOPL,R1;  BUFFER ADDRESS 4 CHARACTERS IN FRONT OF FILE NAME	; JGD14
	MOVB	#'P,(R1)+	; INSERT A 'P'						; JGD14
	MOVB	#'I,(R1)+	; INSERT A 'I'						; JGD14
	MOVB	#'N,(R1)+	; INSERT A 'N'						; JGD14
	MOVB	#' ,(R1)	; INSERT A <SPACE>					; JGD14
	DIR$	#VT1WRT		; EXECUTE COMMAND
 
 
	DIR$	#VT1RD		; ISSUE FIRST READ FOR OUTPUT FROM PIN, 		; JGD14
				; DON'T ISSUE ANY MARK TIMES.  		 		; JGD02
	BR	90$		; GO LOG THE OUTPUT					; JGD02
 
; THIS SECTION SHOULD BE REWRITTEN TO MAKE IT FLOW LINEARLY				; JGD03
;
80$:				; REFERENCE LABLE					; JGD03
	TST	EOFFLG		; HAVE WE RECIEVED AN  #<EOF>  FROM ...PIN?		; JGD03
	BEQ	85$		; IF EQ, NO, CONTINUE TO ISSUE READS TO VT:		; JGD03
	BR	100$		; IF NE GO ISSUE  BYE  COMMAND				; JGD03
85$:				; REF LABLE						; JGD04
	DSCP$S			; DISABLE CHECKPOINTING WHILE TALKING TO VT:		; JGD04
				; I THOUGHT WE COULD LIVE WITHOUT THIS, BUT BATCH AND	; JGD04
				; ALL VT: TASKS GET LOCKED UP IF BATCH GETS CHECKPOINTED; JGD04
	.IF DF DEBUG		;
	CLR	TIMOUT		; RESET TIMEOUT JUST IN CASE
	MRKT$C	5,1,2,MRKAST	; SET 1 SEC MARKTIME
	.ENDC			;
	DIR$	#VT1RD		; READ MCR MESSAGES
	.IF DF	DEBUG		;
	CMKT$S			; CANCEL MARKTIMES
	TST	TIMOUT		;
	BEQ	86$		; IF EQ, WE DID NOT TIMEOUT
	QIOW$C	IO.KIL,5,5	;  WE TIMED OUT , KILL I/O
	PRINT	EM2		; SHOW WE ARE HERE
86$:				; REF LABLE
	.ENDC
	ENCP$S			; MAKE TASK CHECKPOINTABLE AGAIN			; JGD04
	TST	TIMOUT		; FLAG SET BY TIMOUT ?
	BEQ	90$		; IF EQ NO
	QIOW$C	IO.KIL,5,5	; KILL PENDING I/O ANYWAY
;	GLUN$C	4,LUNINF	; READ LUN INFO FROM VT0
	CLR	TIMOUT		; RESET TIMOUT FLAG
	BR	100$		; OTHERWISE LOG OFF
 
90$:				; REF LABLE  CLEAN OUT GARBAGE IN LOG FILE		; JGD01
	CMP	VTSTAT+2,#4	; IF COUNT OF 4 ->A '>' ONLY				; JGD01
	BEQ	80$		; IF SO DON'T OUTPUT RECORD				; JGD01
	MOV	#LOGBUF,TEMP	; GET START OF BUFFER					; JGD01
	PUSH	R5		; SAVE R5						; JGD01
	MOV	VTSTAT+2,R5	; GET CHARACTER COUNT					; JGD01
	ADD	TEMP,R5		; POINT TO END OF BUFFER				; JGD01
	CMPB	(R5),#'>	; IS IT A '>'						; JGD01
	BNE	92$		; NO ,SKIP AROUND					; JGD01
	CLRB	(R5)		; YES, MAKE IT A NUL					; JGD01
92$:	CMPB	(R5),#12	; IS IT A LF						; JGD01
	BNE	94$		; NO, SKIP						; JGD01
	CLRB	-2(R5)		; YES MAKE IT A NUL					; JGD01
94$:	POP	R5		; RESTORE R5						; JGD01
	CMPB	#'+,@TEMP	; MAYBE WE HAVE A '+'					; JGD01
	BNE	96$		; IF NE, NO						; JGD01
	INC	TEMP		; YES, SKIP OVER					; JGD01
	DEC	VTSTAT+2	; AND DECREASE CHARACTER COUNT				; JGD01
96$:				; REF LABLE						; JGD01
	PUSH	R5		; SAVE R5						; JGD01
	CMPB	#'>,(R5)	; MAYBE SECOND CHARACTER IS A '>'			; JGD01
	BNE	98$		; IF NE, NO SKIP AROUND					; JGD01
	CLRB	(R5)		; YES SO MAKE IT A NUL					; JGD01
98$:				; REF LABLE						; JGD01
	CALL	CHKEOF		; CHECK TO SEE IF END OF PROCEDURE COMMAND FILE		; JGD02
	POP	R5		; RESTORE R5						; JGD01
	PUT$	R0,TEMP,VTSTAT+2; LOG THE MCR OUTPUT					; JGD01
	BCC	80$		; IF CC NO FILE ERROR					; JGD01
	JMP	FILERR		; OTHERWISE PRINT ERROR					; JGD01
100$:				; REF LABLE
	MRKT$C	5,1,2,MRKAST	; SET TIMEOUT TRAP FOR 1 SEC				; JGD13
	CLR	TIMOUT		; RESET TIMEOUT						; JGD13
	DIR$	#VT1RD		; READ PROMPT FROM AT. EXIT				; JGD13
	CMKT$S			; CANCEL MARKTIME					; JGD13
	TST	TIMOUT		; DID WE TIMEOUT					; JGD13
	BEQ	100$		; NO, READ AGAIN					; JGD13
	QIOW$C	IO.KIL,5,5	; KILL ANY LEFT OVER IO					; JGD13
	MOV	#BYEBUF,VT1WRT+Q.IOPL ; SETUP ADDRESS OF BYE BUFFER
	MOV	#BYECT,VT1WRT+Q.IOPL+2 ; AND BYTE COUNT
	MRKT$C	,10,2,MKAST1	; TIMEOUT ON BYE FOR SOME STRANGE REASONS
	CALL	SBMCMD		; ISSUE BYE COMMAND ALTERNATE ENTRY
RESUM:	CMKT$S			; CANCEL THE MARK TIME
	CLR	PRMTSW		; CLEAR PROMPT REVERSE SWITCH
;	PRINT$	R0		; SPOOL THE LOG FILE
	CLOSE$	R0		; CLOSE THE FILE, THE USER CAN PIP IT TO TI:
	BCS	FLERR		; IF CS, CLOSE ERROR
; IF IT IS DESIRED TO SPEED UP THE CREATION OF LISTING FILESONE MAY SET THE		; JGD01
; EXTENSION BLOCK COUNT>1 IN FDAT$A. THE LOG FILE IS TRUNCATED AT THIS POINT TO 	; JGD01
; SAVE DISK SPACE.  COMMENTING OUT THE CODE WILL SPEED UP PROCESSING SOMEWHAT FOR	; JGD01
; SYSTEMS WITH LOTS OF DISK SPACE.							; JGD01
	OPEN$U	R0		; OPEN FILE FOR UPDATE(NEED EXTEND ACCESS FOR TRUNCATE)	; JGD01
	BCS	FLERR		; IF CS, OPEN ERROR					; JGD01
	CALL	.TRNCL		; CLOSE THE FILE AND TRUNCATE IT			; JGD01
	BCS	FLERR		; IF CS, TRUNCATE ERROR					; JGD01


	PRINT	MSG1		; PRINT READY MESSAGE
	CLR	TIMOUT		; RESET POSSIBLE TIMEOUT SWITCH
	QIOW$C	IO.KIL,5,5	; KILL ANY PENDING IO					; JGD03
	JMP	$SBCFL		; DEQUE NEXT REQUEST OR EXIT
FLERR:	JMP	FILERR		; GO REPORT FILE ERROR					; JGD03
 
	.DSABLE LSB
 
 
;+ 
; **-CHKEOF
;
;     CHECK TO SEE IF ...PIN HAS OUTPUT AN  #<EOF>
;	IF SO SET EOFFLG
;-
CHKEOF:				; REFERENCE LABLE
	PUSH	R0		; SAVE R0 FOR LATER					; JGD03
	PUSH	R1		; SAVE R1						; JGD03
	MOV	#LOGBUF,R0	; ADDRESS OF BUFFER TO CHECK				; JGD03
	MOV	#7,R1		; ONLY CHECK FIRST 7 CHARACTERS				; JGD03
10$:				; REF LABLE
	CMPB	#'#,(R0)+	; HAVE WE GOT AN '#'	?				; JGD16
	BEQ	20$		; YES, CHECK SOME MORE					; JGD03
	SOB	R1,10$		; LOOP UNTIL R1=0					; JGD03
	BR	100$		; IF NEVER FIND AN '#' GIVE UP				; JGD03
20$:				; REF LABLE						; JGD16
	CMPB	(R0)+,#'<	; IS IT A '<'?						; JGD03
	BNE	100$		; NO, NO GOOD						; JGD03
	CMPB	(R0)+,#'E	; IS IT AN 'E'?						; JGD03
	BNE	100$		; NO NO GOOD						; JGD03
	CMPB	#'O,(R0)+	; IS IT AN 'O'						; JGD03
	BNE	100$		; NO, NO GOOD						; JGD03
	CMPB	#'F,(R0)+	; IS IT AN 'F'						; JGD03
	BNE	100$		; NO, NO GOOD						; JGD03
	CMPB	#'>,(R0)	; IS IT AN '>'						; JGD03
	BNE	100$		; NO , NO GOOD, BUT CLOSE				; JGD03
	INC	EOFFLG		; SET EOFFLG						; JGD03
100$:	POP	R1		;RESTORE R1						; JGD03
	POP	R0		;RESTORE R0						; JGD03
	RETURN			; 							; JGD03
;+
; **-SBMCMD
;
; THIS ROUTINE FIRST ISSUES THE PREPARED COMMANDLINE
; TO VT1: (EITHER HELLO OR BYE) AND READS THE 
; MCR OUTPUTS AND PUTS IT IN THE LOG FILE.
;
; EXIT IS DETECTED WHEN HELLO ISSUES A $SOJ OR WHEN BYE
; ISSUES A $EOJ.
;
;
; INPUTS:
;
;	R0=ADDRESS OF LOG FDB
;	DPB'S=PREPARED TO ISSUE COMMAND
;	LOGFILE ALREADY OPEN
;
; OUTPUTS:
;
;	R0=UNCHANGED
;	REQUESTED PROCEDURE DONE (HEL, BYE)
;	DIRECT JUMP TO FILERR IF FILE ERROR
;
;-
	.ENABLE	LSB
SBMCMD:	DIR$	#VT1WRT		; ISSUE COMMAND SET UP
10$:	DIR$	#VT1RD		; READ MCR OUTPUT
	.IF DF	DEBUG
	PUT$	R0,#LOGBUF,VTSTAT+2 ; LOG THE MCR OUTPUT
	.ENDC
	BCS	40$		; IF CS FILE ERROR
	CALL	CKEOJ		; IS IT END OF JOB				; JGD13
	BCS	10$		; IF CS,NO,  TRY AGAIN				; JGD13
35$:	RETURN			; SO GO RETURN TO CALLER
40$:	TST	(SP)+		; FILE I/O ERROR, REMOVE ARG FROM STACK
	JMP	FILERR		; AND LEAVE ROUTINE DIRECTLY
 
	.ENABLE LSB

;+
; CKEOJ -- LOOK FOR END OF JOB MARKER FROM BYE ($EOJ)
; 	   LOOK FOR START OF JOB MARKER FROM HELLO ($SOJ)
;
;-
CKEOJ:				; REF LABLE
	PUSH	R1		; SAVE R1 FOR LATER
	PUSH	R0		; SAVE R0 FOR LATER
	MOV	#LOGBUF,R5	; GET ADDRESS OF BUFFER
	MOV	#7,R1		; ONLY SCAN FIRST 7 CHAR
10$:				; REF LABLE
	CMPB	#'H,(R5)	; IS IT A LOGON ERROR MESSAGE
	BEQ	20$		; IF EQ, YES
	CMPB	#'$,(R5)+	; IS IT A "$"
	BNE	15$		; IF NE, NO
	CMPB	(R5),#'E	; IS IT $E?
	BEQ	30$		; IF EQ, YES
	CMPB	(R5),#'S	; MAYBE $SOJ
	BEQ	30$		; IF EQ,SHOW SUCCESS
15$:	SOB	R1,10$		; LOOP UNTIL ITS FOUND
	SEC			; NOT FOUND, SET CARRY
	BR	EOJXIT		; BACK TO CALLER
20$:	INC	HELERR		; SHOW WE HAVE A LOGON ERROR
	SEC			; SHOW '$' NOT FOUND
	BR	EOJXIT		; AND RETURN
30$:	CLC			; CLEAR CARRY
EOJXIT:	POP	R0		; RESTORE R0
	POP	R1		; RESTORE R1
	RETURN			; ALL DONE
 
	.DSABL	LSB
;+
; **-MKAST1
;
; THIS AST SERVICE ROUTINE IS NECESSARY TO COVER THE PROBLEMS, WHEN 
; ISSUING A BYE COMMAND.  IF THE SUBMIT REQUEST SPECIFIED AN
; ACCOUNT WHICH DOESN'T EXIST, THE CODE FOR THE BYE COMMAND
; (SBMCM1) CANNOT DETECT THE "MCR -- NOT LOGGED IN" ERROR
; MESSAGE.  THIS ( AND SOME OTHER PROBLEMS) ARE MAINLY CAUSED
; BY THE FACT, THAT MCR ISSUES THE PROMT (>) IN VERY DIFFERENT WAYS.
; THIS IS A BIT INCOSISTENT AND SHOULD BE ADDRESSED TO FUTURE
; RELEASES.
;
;-
 
MKAST1:	TST	(SP)+		; REMOVE EVENTFLAG FROM STACK
	MOV	#RESUM,2(SP)	; MODIFY RETURN ADDDRESS
	QIOW$C	IO.KIL,5,5	; KILL THE READ PENDING ON VT1
	ASTX$S			; AND LEAVE AST ROUTINE
 
 
 
 
 
;+
; **-MRKAST
;
; AST SERVICE ROUTINE FOR MARK TIME ASTS
; SIMPLY SETS THE TIMEOUT INDICATOR
; EVENTFLAG IMPLICITLY SET AS WELL.
;
;-
;>>>>
 
MRKAST:
	TST	(SP)+		; REMOVE EVENT FLAG FROM STACK
	INC	TIMOUT		; SET TIMEOUT INDICATOR
	ASTX$S			; EXIT AST ROUTINE
;+
; **-FILERR
; **-ATTERR
;
; SOME SORT OF INTELLIGENT ERROR HANDLING SHOULD
; BE DONE THERE, HOWEVER:
; ENTRY AT FILERR >> PRINT ERROR AND START OVER
; ENTRY AT ATTERR >> PRINT ERROR AND EXIT ( NO VT AVAILABLE)
;
;-
 
FILERR:	MOV	F.ERR(R0),LOGBUF ; PRESERV FILE SYSTEM ERROR
	CLOSE$	R0		; CLOSE THE LOG FILE
	MOV	#MSG2+31.,R0	; ADDR OF WHERE ERROR CODE GOES			; JGD01
	MOV	LOGBUF,R1	; ERROR CODE					; JGD01
	BIS	#177400,R1	; TURN ON HIGH ORDER BITS(TO CONVERT CORRECTLY)	; JGD01
	CLR	R2		; SUPRESS LEADING ZEROS				; JGD01
	CALL	$CBDSG		; CONVERT BINARY ERROR CODE TO SIGNED DECIMAL	; JGD01
	PRINT	MSG2		; PRINT THE ERROR MESSAGE			; JGD01
	PRINT	DEV		; PRINT OUT DEVICE				; JGD01
;	PRINT	UIC		; AND UIC					; JGD01
	JMP	$SBCFL		; START OVER AGAIN
 
ATTERR:				; REFERENCE LABEL
	PRINT	MSG3		; PRINT ERROR MESSAGE
	EXIT$S			; AND LEAVE PROGRAM
 
;+										; JGD01
; CHECK LOG BIT TO SEE IF VT LOGGED ON ALRIGHT					; JGD01
; CC - SET IF FAILED								; JGD01
; CC - CLEAR IF SUCCESS								; JGD01
;-										; JGD01
	.DSABLE	LSB
	.ENABLE LSB
CKLOG:				; REF LABLE					; JGD03
	CLR	LOGCNT		; RESET THE LOGON TRIES				; JGD03
10$:	MRKT$C	5,1,2		; MARK TIME FOR 1 SECOND			; JGD01
	GLUN$C	4,LUNINF	; READ LUN INFO FOR VT0:			; JGD01
	BIT	#U2.LOG,LUNINF+6 ; IS VT: LOGGED ON YET				; JGD01
	BEQ	100$		; IF EQ, YES, SO EXIT WITH CARRY CLEAR		; JGD01
	INC	LOGCNT		; INCREMENT THE NUMBER OF TIMES TRIED TO LOGON	; JGD01
	CMP	#4,LOGCNT	; ARE WE AT 3 YET				; JGD01
	BEQ	75$		; YES, GO SET CARRY AND EXIT			; JGD01
	BR	10$		; AND TRY AGAIN					; JGD01
75$:	SEC			; SET CARRY					; JGD01
100$:	RETURN			; ALL DONE					; JGD01
 
 
;+
; PNTLIN
;
; THIS ROUTINE WILL PRINT AN ASCIZ LINE
;-
PNTLIN:	MOV	#-1,R1		; GET COUNT INITIALIZED
	MOV	R0,QIODPB+Q.IOPL ; STORE BUFFER ADDRESS
170$:	INC	R1		; INCREMENT COUNTER
	TSTB	(R0)+		; IS THIS THE LAST BYTE?
	BNE	170$		; NO. KEEP GOING
	MOV	R1,QIODPB+Q.IOPL+2 ; STORE BYTE COUNT
	DIR$	#QIODPB
	RETURN
 
 
 
	.END	$SBCFL