.TITLE	MGCML RSX-11M INDIRECT FILE PROCESSOR GCML
	.IDENT	/M10.7/                                                         ;HJL027
;                                                                               ;**-1
;
; VERSION	M10.7                                                           ;HJL027
;                                                                               ;**-1
; WRITTEN BY:
;	R. GROVE
;	P. KNEUVEN
;
; MODIFIED BY:
;	C.A. D'ELIA	26-NOV-73	001
;	C.A. D'ELIA	12-JAN-74	002
;	C.A. D'ELIA	12-MAR-74	003
;	C.A. D'ELIA	19-MAR-74	004
;	C.A. D'ELIA	31-MAR-74	005
;	C.A. D'ELIA	05-APR-74	006
;	C.A. D'ELIA	04-JUN-74	007
;	C.A. D'ELIA	01-JUL-74	008
;	C.A. D'ELIA	01-AUG-74	009
;	H. LEV		11-NOV-74
;	H. LEV		14-MAY-75
;	G. EVERHART	29-OCT-78
;                                                                               ;HJL027
;	HJL027	5/18/76	FIX TEST FOR FINIT                                      ;HJL027
;                                                                               ;HJL027
	.PSECT	DATA,RW
;
;
; LOCAL OFFSET AND SYMBOL DEFINITIONS
	.MCALL	CSI$		;++009
	CSI$	DEF$L
	.MCALL	GCMLD$		;++009
	GCMLD$	DEF$L
	.MCALL	NBOFF$		;++009
	NBOFF$	DEF$L		;++009 DEFINE NAME BLOCK OFFSETS


	.MCALL	CALL,RETURN,DIR$,CSI$1,CSI$2,CLOSE$  ;++003
	.MCALL	ENCP$S,DSCP$S	;++008
	.MCALL	DELET$


	.IF NDF	R$$11M		;++003

	.MCALL	OPEN$R,GET$	;++003

	.IFF			;++003

	.MCALL	OFNB$R,GET$S,FINIT$  ;++003

	.ENDC			;++003


; INTERNAL GCML$ BLOCK OFFSET DEFINITIONS
G.CDEP	==G.ERR+10.;	CURRENT PUSH DOWN DEPTH
G.MDEP	=G.CDEP+1;	MAXIMUM PUSH DOWN DEPTH
G.PPTR	=G.MDEP+1;	PUSH DOWN STORAGE POINTER
G.RBUF	==G.PPTR+2;	RECORD BUFFER POINTER
G.DPRM	=G.RBUF+2;	DEFAULT PROMPT STRING TEXT
G.DFNB	=G.DPRM+6;	DEFAULT FILE NAME BLOCK
G.PDSL = <3*2>+<13.*2>		;++001 PUSH DOWN FRAME SIZE (16 WORDS)

; G.MODE BIT DEFINITIONS
GE.MCR	=200;		G.MODE BIT, SET IF TOP LEVEL IS MCR LINE
GE.IEF	==	20	; SET IF INTERMEDIATE END OF FILE REACHED
GE.RWD	==	40	; SET MEANS REWIND ON HITTING  EOF
GE.FOP	==	100	; SET MEANS EXIT AFTER OPENING FILE

; ASCII CHARACTER DEFINITIONS
CR	=15
TAB	=11
BLANK	=40
ALTMOD	=33
ESC=33
SPACE=40
	.MACRO	.SAVR1
	JSR	R5,.SAVR1
	.ENDM	.SAVR1

; GCML$ - ENTRY TO GET NEXT COMMAND LINE
	.PSECT	CODE,RO
$MGCL1::.SAVR1
	MOV	R0,R5;		BLOCK POINTER ALWAYS IN R5
	BICB	#GE.IEF,G.MODE(R5) ; CLEAR INTERMEDIATE EOF FLAG
	TSTB	G.CDEP(R5)	;++001 TEST CURRENT DEPTH
	BEQ	LVL0		;++001 SPECIAL TEST IF AT LEVEL ZERO
	BGT	PROMPT		;++001 IF .GT. ZERO, THEN PROMPT FOR CMD
	CALL	GETMCR;		TRY TO GET AN MCR LINE
	BCC	CMLSCN;		GOT ONE - DON'T DO TOP-LEVEL OPEN


	.IF NDF	R$$11M		;++002


	OPEN$R	R5;		TOP-LEVEL OPEN

	.IFF			;++002

	MOV	F.DSPT(R5),R2	;++002 GET DESCRIPTOR IN R2
	CALL	GOPEN		;++002 OPEN THE FILE


	.ENDC			;++002


	BCC	LVL0		;++008 SKIP ON SUCCESS
	JMP	IOERR		;++008 ELSE, INITIAL OPEN FAILED
LVL0:	BITB	#GE.MCR,G.MODE(R5) ;++001 DID WE HAVE MCR INPUT?
	BEQ	PROMPT		; NO
	JMP	TOPEOF		; YES, LEVEL 0 IS END

PROMPT:	TST	F.BDB(R5)	;++001 IS FILE ALREADY OPEN?
	BNE	1$		;++001 YES, SKIP THE OPEN
	CALL	POPOP1		;++001 NO, POP IT UP AND OPEN IT
1$:	BITB	#FD.TTY,F.RCTL(R5) ;++001 IS IT A TTY?
	BEQ	4$;		NO - DON'T PROMPT
	DSCP$S			;++008 DISABLE CHECKPOINTING
	MOV	@#$DSW,-(SP)	;++008 SAVE DIRECTIVE STATUS FOR LATER
	MOV	#IO.ATT,R1	;++001 SPECIFY ATTACH
	CLR	R2		;++001 NO EXTRA QIO PARMS NEEDED
	CALL	.XQIO		;++001 USE FCS TO ATTACH THE TTY
	MOV	G.PSDS+2(R5),R1;USER PROMPT STRING ADDRESS
	MOV	G.PSDS(R5),R2;	USER PROMPT STRING LENGTH
	BNE	2$;		USE USER'S STRING
	MOV	R5,R1;		USE DEFAULT PROMPT FROM BLOCK
	ADD	#G.DPRM,R1;
	MOV	#6,R2;		EXACTLY 6 BYTE'S WORTH
2$:				;++001
	MOV	G.RBUF(R5),R3	;++002 PUT ADDR OF BUFFER IN R3
	MOV	R1,(R3)+	;++002 SPECIFY PROMPT STRING ADDR
	MOV	R2,(R3)+	;++002 SPECIFY BYTE COUNT
	CLR	(R3)		;++002 CLEAR CARRIAGE CONTROL
	CMP	-(R3),-(R3)	;++002 POINT R3 TO PARM LIST
	MOV	#3,R2		;++002 SET PARAMETER COUNT
	MOV	#IO.WVB,R1	;++002 SPECIFY WRITE VIRTUAL BLOCK
	CALL	.XQIO		;++002 SEND PROMPT STRING
	BCS	6$;		DETACH AND I/O ERROR HANDLING
4$:				;++002


	.IF NDF	R$$11M		;++002


	GET$	R5,G.RBUF(R5),#80.  ;++002 READ A COMMAND LINE

	.IFF			;++002

	GET$S	R5,G.RBUF(R5),#80.  ;++002 READ A COMMAND LINE


	.ENDC			;++002


6$:	ROR	R4		;++001 SAVE THE C-BIT
	MOVB	F.ERR(R5),R3	;++001 SAVE FCS RETURN STATUS
	BITB	#FD.TTY,F.RCTL(R5);	DETACH ONLY IF TTY
	BEQ	8$;
	MOV	#IO.DET,R1	;++001 SPECIFY DETACH
	CLR	R2		;++001 NO EXTRA QIO PARMS NEEDED
	CALL	.XQIO		;++001 USE FCS TO DETACH THE TTY
	TST	(SP)+		;++008 EXAMINE 'DSCP$S' STATUS
	BLT	8$		;++008 SKIP IF IT FAILED EARLIER
	ENCP$S			;++008 ELSE, ENABLE CHECKPOINTING AGAIN
8$:	ROL	R4		;++001 RESTORE THE C-BIT (FROM GET$)
	BCS	IOERR0;
	MOV	F.NRBD+2(R5),R1;GET COMMAND LINE ADDRESS
	MOV	F.NRBD(R5),R2;	GET COMMAND LINE LENGTH

; PROCESS COMMAND LINE OBTAINED
;    R1 IS COMMAND LINE ADDRESS
;    R2 IS COMMAND LINE LENGTH
CMLSCN:	MOV	R1,G.CMLD+2(R5);SET COMMAND LINE ADDRESS
	MOV	R2,G.CMLD(R5);	AND LENGTH
	BEQ	OKOUT;		RETURN NULL LINE TO USER
	BITB	#GE.LC,G.MODE(R5) ; PASS LOWER CASE?
	BNE	30$		; YES
	MOV	R2,-(SP)	; NO, SAVE BUFFER SIZE
	ADD	R2,R1		; POINT TO LAST CHARACTER PLUS 1
10$:	CMPB	-(R1),#141	; IS THIS A LOWER CASE CHARACTER
	BLT	20$		; NO
	CMPB	(R1),#172	; MAYBE
	BGT	20$		;NO
	BICB	#40,(R1)	; YES, CONVERT TO UPPER CASE
20$:	DEC	R2		; DONE?
	BGT	10$		; NO, LOOP
	MOV	(SP)+,R2	; YES, RESTORE COUNT
30$:	CMPB	#';,(R1);	CHECK FOR ; IN COLUMN 1
	BNE	OKOUT		; NONE - RETURN TO USER
	BITB	#GE.COM,G.MODE(R5); COMMENTS PERMITTED ?
	BNE	PROMPT;		YES - GET ANOTHER LINE
	BR	OKOUT;		NO  - RETURN IT TO USER

; I/O ERROR AND END-OF-FILE PROCESSING
IOERR0:	CMPB	#IE.EOF,R3	;++001 END OF FILE ERROR?
	BNE	IOERR;		NO - I/O ERROR
	MOVB	G.CDEP(R5),R0;	ARE WE AT TOP LEVEL ALREADY ?
	BEQ	TOPEOF;		YES - RETURN EOF TO CALLER
	BISB	#GE.IEF,G.MODE(R5) ; SET INTERMEDIATE EOF SEEN
	BITB	#GE.RWD,G.MODE(R5) ; REWIND AFTER EOF?
	BEQ	10$		; NO
	MOV	R5,R0		; COPY FCB ADDRESS
	BITB	#FD.REC,F.RCTL(R5) ; YES, IS THIS RECORD DEVICE?
	BNE	10$		; YES, CAN'T REWIND THEN
	CLR	R1		; NO, SET TO READ VBN1
	MOV	#1,R2		;
	CLR	R3		; BYTE ZERO
	CALL	.POINT		; SET TO START OF FILE
	BCS	IOERR		; I/O ERROR
	BR	3$		; GET NEXT COMMAND
10$:	DEC	R0;		IF NOT AT LEVEL 1
	BNE	2$;		POP UP AND CARRY ON
	BITB	#GE.MCR,G.MODE(R5);IF RETURNING TO LEVEL 0
	BNE	TOPEOF		;++001 AND TOP WAS MCR, RETURN EOF TO CALLER
2$:	CALL	POPOPN;		POP UP A LEVEL
3$:	JMP	PROMPT;		TRY FOR ANOTHER COMMAND

; EXITS FROM $MGCL1 AND $MGCL2

OKOUT:	CLR	-(SP)		;++005 INDICATE GCML SUCCESS

OUT:	BITB	#GE.CLO,G.MODE(R5) ;++005 CLOSE FILE AFTER THIS GET?
	BEQ	1$		;++001 NO, SET RETURN INFORMATION
	CALL	CLOCRT		;++001 YES, CLOSE CURRENT LEVEL
1$:	MOVB	(SP),G.ERR(R5)	;++005 PUT RETURN CODE IN G.ERR
	ROL	(SP)+		;++005 SET C-BIT RETURN STATUS
	MOV	R5,R0;		RESTORE R0
	RETURN

TOPEOF:	BIT	#DELETE,.LIFLG	; DELETE FILE ON CLOSING?
	BEQ	10$		; NO
	DELET$	R5		; YES, DELETE IT
	BR	20$		;
10$:	CLOSE$	R5;		CLOSE TOP LEVEL CMI
20$:	BICB	#GE.MCR,G.MODE(R5) ;++001 ALL DONE, CLEAR MCR BIT, AND ...
	DEC	G.CDEP(R5)	;++001 ... SET DEPTH TO -1 FOR LATER RESTART
	MOV	#GE.EOF,-(SP)	;++005 INDICATE END-OF-FILE
	BR	OUT		;++005
IOERR:	MOV	#GE.IOR,-(SP)	;++005 INDICATE I/O ERROR
	BR	OUT		;++005
OPRERR:	MOV	#GE.OPR,-(SP)	;++005 INDICATE INDIRECT OPEN ERROR
	BR	OUT		;++005
BIFERR:	MOV	#GE.BIF,-(SP)	;++005 INDICATE BAD INDIRECT FILE NAME
	BR	OUT		;++005
MDEERR:	MOV	#GE.MDE,-(SP)	;++005 INDICATE MAX INDIRECT DEPTH EXCEEDED
	BR	OUT

$MGCL2::.SAVR1
	MOV	R0,R5;		SET UP BLOCK POINTER
	TSTB	G.CDEP(R5);	AT TOP ALREADY ?
	BLE	OKOUT		;++007 YES -- EXIT
10$:	DECB	G.CDEP(R5)	;++004 DECREMENT CURRENT DEPTH COUNT
	BEQ	20$		;++004 SKIP BEFORE TOP LEVEL (0) PROCESSED
	SUB	#G.PDSL,G.PPTR(R5)  ;++004 BACK UP THE PUSH-DOWN LIST PTR
	BR	10$		;++004 ITERATE
20$:	INCB	G.CDEP(R5)	;++004 INDICATE LEVEL ONE
	CALL	POPOPN;		POP THINGS UP TO LEVEL 0
	BR	OKOUT;		RETURN BLISSFULLY

; SET UP TO PROCESS AN INDIRECT FILE
; LOOK FOR @ IN COLUMN 1
;    R1 IS COMMAND LINE ADDRESS
;    R2 IS COMMAND LINE LENGTH
;    R5 IS GCML CONTROL BLOCK ADDRESS
;
$MGCL4:: .SAVR1
INDIR:	CMPB	#'@,(R1);	CHECK FOR @
	BNE	OKOUT;		NO  - RETURN LINE TO USER
	BITB	#GE.IND,G.MODE(R5); INDIRECT PERMITTED ?
	BEQ	OKOUT;		NO  - RETURN IT TO USER
; PROCESS INDIRECT FILE
	CMPB	G.CDEP(R5),G.MDEP(R5);	CHECK DEPTH
	BGE	MDEERR;		TOO DEEP
	INC	R1;		SKIP OVER @
	DEC	R2;		1 LESS CHARACTER IN LINE
; CALL CSI1 AND CSI2
	CSI$1	#$CSIBK,R1,R2;	CHECK SYNTAX ON FILE SPEC
	MOV	C.CMLD(R0),G.CMLD(R5);	SET COMPRESSED LENGTH
	INC	G.CMLD(R5);	ADJUST LENGTH FOR @ IN COLUMN 1
	BCS	BIFERR;		BAD SYNTAX
	BITB	#CS.EQU,C.STAT(R0)  ;++009 WAS EQUAL SIGN (=) FOUND?
	BNE	BIFERR		;++009 ANY INDICATION OF INPUT SPEC IS ERROR
	CSI$2	R0,OUTPUT,#$SWTAB	;GET THE OUTPUT FILE
	BCS	BIFERR;
	BITB	#CS.WLD!CS.MOR,C.STAT(R0); NO * WILD CARDS, AND ONLY ONE FILE
	BNE	BIFERR;
	BITB	#CS.DVF!CS.NMF,C.STAT(R0);
	BEQ	BIFERR;		ERROR - NO DEVICE OR FILE NAME
; SAVE FILE ID AND POINTERS
	CALL	PSHCLS;		PUSH AND CLOSE FILE
	MOV	#$CSIBK,R2	;++002 POINT R2 TO THE CSI DATA ...
	ADD	#C.DSDS,R2	;++002 ... SET DESCRIPTOR
	MOV	#"SY,N.DVNM+G.DFNB(R5);DEFAULT DEVICE IS SY FOR LOWER OPEN'S


	.IF NDF	R$$11M		;++002


	OPEN$R	R5,,R2		;++002 OPEN THE FILE

	.IFF			;++002

	CALL	GOPEN		;++002 OPEN THE FILE


	.ENDC			;++002


	BCS	4$;		ERROR - CLEANUP AND REPORT ERROR
	BITB	#GE.FOP,G.MODE(R5) ; EXIT AFTER OPENING FILE?
	BNE	2$		; YES
	JMP	PROMPT;		ALL OK - GET A COMMAND LINE
2$:	RETURN			;
4$:	CALL	POPOPN;		RE-OPEN THE LEVEL ABOVE
	BR	OPRERR;		REPORT ERROR ON @ FILE OPEN

;
; POPOPN - SUBROUTINE TO CLOSE, POP UP, AND RE-OPEN
;
POPOPN:	BIT	#DELETE,.LIFLG	; DELETE FILE ON CLOSING?
	BEQ	10$		; NO
	DELET$	R5		; YES, DELETE IT
	BR	POPOP1		;
10$:	CLOSE$	R5		; NO, CLOSE FILE
POPOP1:				;++001
	MOV	G.PPTR(R5),R4;	UPDATE PUSHDOWN POINTER
	SUB	#G.PDSL,G.PPTR(R5) ;++001 RESET PUSHDOWN PTR IN GCML BLK
	DECB	G.CDEP(R5);	DECREASE PUSHDOWN LEVEL
	BNE	1$;		IF POPPING TO LEVEL 0
	BITB	#GE.MCR,G.MODE(R5) ;++001 AND TOP WAS AN MCR LINE,
	BNE	3$;		DON'T RE-OPEN LEVEL 0
1$:	MOV	R5,R3		;++001 POINT R3
	ADD	#F.FNB+N.UNIT+2,R3 ;  TO END OF NAME BLOCK
	MOV	#<N.UNIT-N.DID+2>/2,R2 ; SET NUMBER OF WORDS TO RESTORE
10$:	MOV	-(R4),-(R3)	; RESTORE NAME BLOCK
	DEC	R2		; DONE?
	BGT	10$		; NO, LOOP
	SUB	#N.DID-N.STAT,R3 ; POINT TO VERSION NUMBER
	MOV	#<N.FVER-N.FID+2>/2,R2 ; GET LENGTH
20$:	MOV	-(R4),-(R3)	; RESTORE REST OF NAME BLOCK
	DEC	R2		; DONE?
	BGT	20$		; NO, LOOP


	.IF NDF	R$$11M		;++002


	OPEN$R	R5;		RE-OPEN THE LEVEL ABOVE

	.IFF			;++002

	OFNB$R	R5		;++003 OPEN FILE BY FILENAME BLOCK


	.ENDC			;++002


	BCS	4$;		ERRROR ON RE-OPEN, VERY BAD
; RESTORE POINTERS INTO THE FILE
	MOV	-(R4),R3;	BYTE-IN-BLOCK
	MOV	-(R4),R2;
	MOV	-(R4),R1;	VIRTUAL BLOCK NUMBER
	CALL	.POINT;		FDB IS IN R0, NOW .POINT
	BCC	3$;		NO ERRORS
	CMPB	#IE.EOF,F.ERR(R5);
	BNE	4$;		ANYTHING EXCEPT EOF IS AN I/O ERROR
3$:	RETURN	;		ALL IS NOW READY FOR NEXT GET$
4$:	TST	(SP)+;		THROW AWAY CALLER'S RETURN ADDRESS
	JMP	IOERR;		CALL IT AN I/O ERROR

;++001
;
; CLOSE CURRENT COMMAND LEVEL
;
;--001
$MGCL3::.SAVR1			;++001 SAVE REGISTERS
	MOV	R0,R5		;++001 SET FDB POINTER
CLOCRT:	TST	F.BDB(R5)	;++001 IS FILE OPEN?
	BEQ	PSHRTN		;++001 NO, JUST RETURN

;
; PSHCLS - SUBROUTINE TO PUSH DOWN AND CLOSE
;
PSHCLS:	INCB	G.CDEP(R5);	INCREASE PUSHDOWN LEVEL
	MOV	G.PPTR(R5),R4;	NEXT PUSHDOWN FRAME
	MOV	R5,R0;		GET FDB FOR .MARK
	CALL	.MARK;		MARK CURRENT PLACE IN FILE FOR .POINT
	MOV	R1,(R4)+;	VIRTUAL BLOCK NUMBER
	MOV	R2,(R4)+;
	MOV	R3,(R4)+;	BYTE-IN-BLOCK
	ADD	#F.FNB+N.FID,R0  ;++001 POINT R0 TO FILE ID IN FDB
	MOV	#<N.FVER-N.FID+2>/2,R2 ; SET LENGTH OF WORDS TO SAVE
10$:	MOV	(R0)+,(R4)+	; SAVE THE NAME BLOCK
	DEC	R2		; DONE?
	BGT	10$		; NO, LOOP
	MOV	#<N.UNIT-N.DID+2>/2,R2 ; SET NUMBER OF WORDS TO SAVE
	ADD	#N.DID-N.STAT,R0 ; POINT TO REST OF NAME BLOCK
20$:	MOV	(R0)+,(R4)+	; SAVE REST OF FNB
	DEC	R2		; DONE?
	BGT	20$		; NO, LOOP
	MOV	R4,G.PPTR(R5);	RESET PUSHDOWN FRAME
	CLOSE$	R5;		CLOSE CURRENT LEVEL
PSHRTN:				;++001
	RETURN


	.IF DF	R$$11M		;++002

;++002
;
; *-GOPEN-* OPEN FILE BY PERFORMING A PARSE, FIND AND AN OPEN BY
; 	    FILE ID.
;
; INPUTS:
;	R2=DATA SET DESCRIPTOR ADDRESS
;	R5=FDB/GCMLB ADDRESS
;
; OUTPUTS:
;	R0,R1, AND R3 ARE LOST
;	C-BIT CLEAR INDICATES SUCCESS OF ALL THREE STEPS
;	C-BIT SET INDICATES FAILURE
;
;--002
GOPEN:	MOV	R5,R0		;++002 PUT FDB ADDR IN R0
	MOV	@#.FSRPT,R1	;++002 MUST DETERMINE IF A '.FINIT' ...
	TST	A.DFUI(R1)	; HAS BEEN PERFORMED                            ;HJL027
	BNE	1$		;++002 IF SO, THEN SKIP                         ;**-1
	FINIT$			;++002 INITIALIZE
1$:	MOV	R0,R1		;++002 POINT R1 TO THE ...
	ADD	#F.FNB,R1	;++002 ... FILE NAME BLOCK
	MOV	F.DFNB(R0),R3	;++002 PNT R3 TO DEFAULT FILE NAME BLOCK
	CALL	.PARSE		;++002 PARSE THE FILE NAME
	BCS	10$		;++002 SKIP ON ERROR
	OFNB$R			;++003 OPEN FILE FOR READ (VIA FNB)
10$:	RETURN			;++002


	.ENDC			;++002

; GETMCR - SUBROUTINE CONDITIONALLY GETS AN MCR LINE
;    RETURNS
;    C=1 IF NO MCR LINE, C=0 OTHERWISE
;    R1=STRING ADDRESS
;    R2=STRING LENGTH
;    REGISTERS CHANGED R0-R4
GETMCR:	MOV	G.RBUF(R5),R1;	GET RECORD BUFFER ADDRESS
	CLRB	G.CDEP(R5)	;++001 SET CMD LEVEL TO ZERO
	MOV	(PC)+,(R1);	SET UP "GET MCR LINE" DPB
	.BYTE	127.,41.;
	DIR$	R1;		TRY TO GET AN MCR LINE
	BCS	10$;		TASK NOT INVOKED AS MCR FUNCTION
	TST	(R1)+;		POINT TO MCR LINE IN BUFFER
	MOV	@#$DSW,R2	;++006 GET MCR LINE BYTE COUNT

;	******
;	CODE ADDED HERE TO SAVE CURRENT COMMAND LINE TEXT IN CMDLIN
;	SPECIAL VARIABLE AND ADJUST MCR BUFFER TO FORGET EVERYTHING
;	AFTER THE FIRST SPACE. UP TO 15. BYTES MAY BE PASSED THIS WAY.
;
	MOV	R0,-(SP)
	MOV	R1,-(SP)
;R1=ADDRESS OF COMMAND LINE
;R2=BYTES IN MCR LINE
	MOV	R3,-(SP)
	MOV	R4,-(SP)
;R3,R4=SCRATCH
	MOV	R2,R3	;COPY LINE LENGTH
	BLE	102$	;(BE SURE POSITIVE)
;SCAN FOR BLANK
	MOV	R1,R4	;COPY BUFF ADDR
STRLEN=16.
ESC=33		;COPY DEF'S FROM OTHER MODULES
SPACE=40
100$:	CMPB	(R4)+,#SPACE	;GET SPACE?
	BEQ	101$
	SOB	R3,100$		;DO TILL ALL DONE
	BR	102$
101$:				;IF WE GET HERE, HAVE SPACE
	MOV	#<STRLEN-1>,R0	;SAVE MAX STRING SIZE
	SUB	R3,R2		;R3 IS LOC OF SPACE
	MOVB	#ESC,-1(R4)	;TERMINATE BUFFER IN ESCAPE
				;WHICH OVER-WRITES SPACE
	INC	R2		;COUNT THE ESCAPE THOUGH
	MOV	#CMDTXT,R1	;NOW POINT TO OUTPUT TEXT AREA
	CMP	R0,R3		;IS STRING AREA BIGGER THAN LINE?
	BHIS	104$		;IF BIGGER USE R3 AS LOOP COUNT (=SMALLEST)
	MOV	R0,R3		;IF SMALLER USE R0. ONLY COPY 15 BYTES MAX
104$:
	MOVB	(R4)+,(R1)+	;COPY A BYTE AT A TIME
	CMPB	@R4,#ESC	; DON'T COPY ESC OR CR TO STRING
	BEQ	103$
	CMPB	@R4,#CR
	BEQ	103$
	SOB	R3,104$		;UNTIL DONE ALL
103$:	CLRB	@R1		;AND NULL THE FINAL BYTE AS END TAG
102$:
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R1
	MOV	(SP)+,R0
;	END OF ADDED CODE
;
2$:	CALL	NXTBYT;		SCAN TO A TAB OR BLANK
	BCS	10$;		NO COMMAND LINE FOLLOWING MCR FUNCTION
	CMPB	R0,#TAB;
	BEQ	4$;
	CMPB	R0,#BLANK;
	BEQ	4$		;
	CMPB	R0,#'@		; INDIRECT FILE SPECIFIER?
	BEQ	6$		; YES
	BNE	2$;
4$:	CALL	NXTBYT;		SKIP TABS AND BLANKS
	BCS	10$;
	CMPB	R0,#TAB
	BEQ	4$
	CMPB	R0,#BLANK
	BEQ	4$

6$:	CMPB	-(R1),(R2)+	;++001 DECR POINTER AND INCR COUNT
	BISB	#GE.MCR,G.MODE(R5);SET TOP-LEVEL MCR FLAG
	CLC	;		AND INDICATE MCR LINE GOTTEN
10$:	RETURN

; NXTBYT - GET NEXT BYTE FROM MCR LINE
;    INPUT - R1 IS STRING POINTER, R2 IS REMAINING BYTE COUNT
;    OUTPUT- R1,R2 UPDATED, R0 IS THE BYTE
;    SETS C=1 ON END OF LINE
NXTBYT:	SUB	#1,R2		;++001 DECR R2 AND SET CC-C WHEN REACH -1
	MOVB	(R1)+,R0;	GET NEXT BYTE
	RETURN
;


	.END