.TITLE	PSZPRS - PARSING SUBROUTINE FOR PARSIZ TASK.
	.SBTTL	PSZPRS - TITLE PAGE
	.IDENT	/V001A/
;+
;
;	PSZPRS - PARSING SUBROUTINE FOR PARSIZ TASK.
;
;	AUTHOR - RODGER S. MILES	DATE:	14-APR-80
;
;	THIS ROUTINE WILL PARSE THE COMMAND LINE POINTED
;	TO BY R0.  IT ASSUMES THAT THE LINE IS TERMINATED
;	BY A NULL CHARACTER (ZERO).  IF ANY ERROR IS
;	ENCOUNTERED, THE ROUTINE WILL RETURN THE C-BIT
;	SET. OTHERWISE IT WILL RETURN HAVING UPDATED THE
;	PARAMETERS PARNM, IF "/PAR=" IS USED, AND $PSIZE,
;	IF "/SIZE=" IS USED.
;	THIS ROUTINE WAS ADAPTED FROM THE LDCTL MODULE
;	OF THE RSX11M TASK "...LOA".
;
; INPUTS:
;	R0 = ADDRESS OF A COMMAND LINE.
;
; OUTPUTS:
;	C-BIT  - SET ON ERROR/CLEAR ON SUCCESS
;	$PARNM - UPDATED IF '/PAR' SWITCH IS USED.
;	$PSIZE - UPDATED IF '/SIZE' SWITCH IS USED.
;	R0-R5  - DESTROYED.
;
; THE GENERAL FORM OF THE COMMAND LINE IS:
;
; XXX[...] [/PAR=PNAME][/SIZE=PSIZE]
;
; WHERE	XXX[...] - THE TASK NAME.
;	PNAME    - THE NAME OF THE PARTITION TO BE REDUCED IN SIZE.
;	PSIZE    - THE NEW UPPER LIMIT OF THE PARTITION IN UNITS
;		   OF 64 BYTES BLOCKS.  THE VALUE MUST BE OCTAL.
;
;-
 
	.MCALL	DIR$,FINIT$
 
	.SBTTL	...... - LOCAL DATA - TEXT STRINGS
	.PSECT	DATA,D
	.NLIST	BEX
 
PARSTR:	.ASCII	/PAR/		;'/PAR' KEYWORD STRING
PARLEN=.-PARSTR			;STRING LENGTH
SIZSTR:	.ASCII	/SIZE/		;'/SIZE' KEYWORD STRING
SIZLEN=.-SIZSTR			;STRING LENGTH
 
	.EVEN


	.SBTTL	PSZPRS - SUBROUTINE ENTRY
	.PSECT	CODE,I
PSZPRS::			;ENTRY POINT
 
10$:	CALL	GETCHR		;FETCH NEXT CHARACTER
	BCS	PDONE		;IF 'EOL', ASSUME NO COMMAND LINE GIVEN.
	CMPB	#40,R5		;HAVE WE REACHED SEPARATING BLANK?
	BNE	10$		;IF NE NO
 
	CALL	GETNB		;GET NEXT NON-BLANK CHARACTER
	BCC	29$		;IF CC DID NOT FIND END-OF-LINE
	JMP	PDONE		;
29$:	CMPB	#'/,R5		;NEXT LEGAL CHARACTER IS A SLASH
	BNE	STXERR		;IF NE SYNTAX ERROR
	CALL	GETCHR		;GET NEXT CHARACTER
	BCS	STXERR		;IF CS SYNTAX ERROR
	MOV	#SIZSTR,R4	;ASSUME /SIZE KEYWORD
	CMPB	(R4)+,R5	;FOUND AN S?
	BNE	70$		;IF NE NO
 
;
; /SIZE=PSIZE
;
 
	TST	$PSIZE		;ALREADY DID /SIZE?
	BNE	STXERR		;IF NE YES
	MOV	#<SIZLEN-1>,R3	;GET REMAINING LENGTH OF KEYWORD
52$:	CALL	GETCHR		;GET NEXT CHARACTER
	BCS	STXERR		;IF CS SYNTAX ERROR
	CMPB	(R4)+,R5	;IS IT NEXT LEGAL CHARACTER?
	BNE	STXERR		;IF NE NO
	DEC	R3		;FOUND ALL OF /SIZE?
	BGT	52$		;IF GT NO
	CALL	GETNB		;GET NEXT NONBLANK CHARACTER
	BCS	STXERR		;IF CS SYNTAX ERROR
	CMPB	#'=,R5		;IS IT LEGAL?
	BNE	STXERR		;IF NE NO
	CALL	$COTB		;CONVERT OCTAL TO BINARY
	MOV	R1,$PSIZE	;SAVE THE RESULT
	BR	120$		;


;
; /PAR=PNAME
;
 
70$:	DEC	R0		;BACK UP SCAN
	TST	$PARNM		;ALREADY DID /PAR KEYWORD?
	BNE	STXERR		;IF NE YES
	MOV	#PARSTR,R4	;POINT R4 TO 'PAR' STRING
	MOV	#PARLEN,R3	;PUT CHARACTER COUNT IN R3
100$:	CALL	GETCHR		;GET NEXT CHARACTER
	BCS	STXERR		;IF CS SYNTAX ERROR
	CMPB	(R4)+,R5	;IS IT NEXT LEGAL CHARACTER?
	BNE	STXERR		;IF NE NO -- SYNTAX ERROR
	DEC	R3		;DECREMENT CHARACTER COUNT
	BGT	100$		;IF GT KEEP SCANNING
	CALL	GETNB		;GET NEXT NON-BLANK CHARACTER
	BCS	STXERR		;IF CS SYNTAX ERROR
	CMPB	#'=,R5		;NEXT LEGAL CHARACTER IS EQUAL SIGN
	BNE	STXERR		;IF NE SYNTAX ERROR
	CALL	GETNB		;GET NEXT NON-BLANK CHARACTER
	BCS	STXERR		;IF CS END-OF-LINE
	DEC	R0		;BACKUP CHARACTER POINTER
	MOV	SP,R1		;PREPARE TO CONVERT TO RAD50
	CALL	$CAT5		;CONVERT NEXT 3 CHARACTERS
	MOV	R1,$PARNM	;STORE RESULT
	BCS	120$		;IF CS FEWER THAN 3 CHARS CONVERTED
	CALL	$CAT5		;CONVERT 3 MORE CHARACTERS
	MOV	R1,$PARNM+2	;STORE SECOND HALF OF NAME
	BCS	120$		;IF CS FEWER THAN 3 CHARS CONVERTED
115$:	MOVB	(R0)+,R2	;GET NEXT CHARACTER
120$:	TST	R2		;IS THIS THE END-OF-LINE?
	BEQ	PDONE		;IF EQ YES
	MOV	R2,R5		;PUT CHARACTER WHERE IT IS EXPECTED
	JMP	29$		;
 
 
PDONE:	CLC			;RETURN SUCCESS.
	RETURN			;
STXERR:	SEC			;RETURN ERROR.
	RETURN
 


	.SBTTL	GETNB  - SUBROUTINE TO GET NEXT NON-BLANK CHARACTER
;+
;
; GETNB - GET NEXT NON-BLANK CHARACTER FROM BUFFER
; GETCHR - GET NEXT CHARACTER FROM BUFFER
;
; INPUTS:
;	R0=ADDRESS OF NEXT CHARACTER IN BUFFER
;
; OUTPUTS:
;	R0=UPDATED ADDRESS OF NEXT CHARACTER IN BUFFER
;	R5=CHARACTER FROM BUFFER
;	C-BIT CLEAR IF NOT AT END-OF-LINE
;	C-BIT SET IF END-OF-LINE REACHED (R5=0)
;
;-
 
GETNB:	CALL	GETCHR		;GET NEXT CHARACTER
	BCS	10$		;IF CS END-OF-LINE
	CMPB	#40,R5		;IS THIS A BLANK?
	BEQ	GETNB		;IF EQ GET NEXT CHARACTER
	CLC			;INDICATE SUCCESS
10$:	RETURN			;
 
	.SBTTL	GETCHR - SUBROUTINE TO GET NEXT CHARACTER
 
GETCHR:	SEC			;ASSUME AT END-OF-LINE
	MOVB	(R0),R5		;GET CHARACTER FROM BUFFER
	BEQ	20$		;IF EQ AT END-OF-LINE
	TSTB	(R0)+		;CLEAR C-BIT AND POINT TO NEXT CHARACTER
20$:	RETURN			;


	.SBTTL	$DIV64 - DIVIDE BY 64 BYTES.
 
;+
; **-$DIV64-DIVIDE BY 64
;
; INPUTS:
;
;	R1=NUMBER TO BE DIVIDED
;
; OUTPUTS:
;
;	R1=QUOTIENT
;-
 
$DIV64::CLC			;
	ROR	R1		;
	ASR	R1		;
	ASR	R1		;
	ASR	R1		;
	ASR	R1		;
	ASR	R1		;
	RETURN			;
 
	.END