.TITLE	EDTMG
	.IDENT	/18/

;
; COPYRIGHT   1985,  DIGITAL  EQUIPMENT  CORP.  MAYNARD,   MASS.
; COPYRIGHT   1984,  DIGITAL  EQUIPMENT  CORP.  MAYNARD,   MASS.
; COPYRIGHT   1981,  DIGITAL  EQUIPMENT  CORP.  MAYNARD,   MASS.
; COPYRIGHT   1980,  DIGITAL  EQUIPMENT  CORP.  MAYNARD,   MASS.
; COPYRIGHT   1976,  DIGITAL  EQUIPMENT  CORP.  MAYNARD,   MASS.
; COPYRIGHT   1975,  DIGITAL  EQUIPMENT  CORP.  MAYNARD,   MASS.
; THIS SOFTWARE IS FURNISHED TO PURCHASER UNDER A LICENSE FOR USE
; ON A  SINGLE COMPUTER SYSTEM AND CAN BE COPIED (WITH INCLUSION
; OF DEC'S COPYRIGHT NOTICE) ONLY FOR USE IN SUCH SYSTEM, EXCEPT
; AS MAY OTHERWISE BE PROVIDED IN WRITING BY 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 ITS  SOFTWARE ON  EQUIPMENT WHICH  IS NOT SUPPLIED BY DEC.
;
; VERSION 16
;
; D. N. CUTLER/C. MONIA 10-MAY-74
;
; MODIFICATIONS:
;
; NO.		DATE		PROGRAMMER
; ---		----		----------
;
; 030		02-JAN-75	C. MONIA
; 043		28-OCT-75	C. MONIA
; 055		13-APR-76	J.A.KASSON
; 060		15-DEC-78	E.H. MARISON
; EP001		26-DEC-78	J.E.POLLACK -- %I
; SR069		07-APR-80	S. RUZICH - MAKE POSITION INDEPENDENT
;				ASSEMBLY OPTION FOR SUPER MODE LIB VERSION
; SR081		19-MAY-80	S. RUZICH - %P BUG FIX
;
; CBP096	08-JAN-81	C. PUTNAM - ADD %Q (ZERO SUPPRESSED %P)
;
; JMK003	28-OCT-81	J. KINNEAR - I/D SPACE PSECT CHANGES
;
; 	07-Nov-84	L. B. McCulley 			17
;		LBM001		reduce size for combined user/super mode FCSRES
;
;	10-Apr-85	Eric Postpischil		18
;		edp002		Correct erroneous output of space in %B fields.
;
; GENERALIZED FORMATTING ROUTINE
;
;
	.PSECT	.RSXD.,D,RO	; PURE DATA PSECT


; EQUATED SYMBOLS
;
;

NP=1				; NO-PARAMETER FLAG


;
; LOCAL DATA
;

OPRAND:	.BYTE	'A		;%A-ASCII
	.BYTE	'B		;++030 %B-BINARY BYTE TO OCTAL
	.BYTE	'D		;%D-SIGNED BINARY TO DECIMAL CONVERSION
	.BYTE	'E		;++030 %E-EXTENDED ASCII CONVERSION
	.BYTE	'F		;%F-FORM FEED
	.BYTE	'I		;%I-INCLUDE ASCIZ STRING
	.BYTE	'M		; %M-MAGNITUDE DECIMAL CONVERSION, SURPRESSED
	.BYTE	'N		;%N-NEW LINE (CR-LF)
	.BYTE	'O		;%O-SIGNED BINARY TO OCTAL CONVERSION
	.BYTE	'P		;%P-MAGNITUDE BINARY TO OCTAL CONVERSION
	.BYTE	'Q		; %Q-MAGNITUDE BINARY TO OCTAL, ZERO SUPPRESS
	.BYTE	'R		;%R-BINARY TO RAD50 CONVERSION
	.BYTE	'S		;++030 %S-SPACE GENERATOR
	.BYTE	'T		; %T-DOUBLE PRECISION DECIMAL
	.BYTE	'U		; %U-MAGNITUDE DECIMAL CONVERSION, NO SURPRESS
	.BYTE	'X		;%X-FILE NAME CONVERSION
	.BYTE	'Y		;%Y-DATE CONVERSION
	.BYTE	'Z		;%Z-TIME CONVERSION
	.BYTE	'<		; %<-DEFINE FIELD
	.BYTE	'>		; %>-SEARCH FOR FIELD DELIMITER
OPRNDX=.-OPRAND			;NUMBER OF DIRECTIVES

	.EVEN

;
; DIRECTIVE DISPATCH TABLE:
;
; THE LOW ORDER BIT IS SET FOR THOSE DIRECTIVES NOT REQUIRING
; AN ARGUMENT BLOCK ENTRY
;


VECTOR:	.WORD	ILLDIR-.!NP	; ILLEGAL DIRECTIVE
	.WORD	ASCII-.		; %A->ASCII STRING
	.WORD	BYTE-.		; ++030 %B->BINARY BYTE TO OCTAL
	.WORD	BINDEC-.	; %D->SIGNED DECIMAL
	.WORD	EASCI-.		; ++030 %E->EXTENDED ASCII
	.WORD	FORM-.!NP	; %F->FORM CONTROL
	.WORD	INCLUD-.	; %I-INCLUDE ASCIZ STRING
	.WORD	DECSUP-.	; %M->ZERO SUPRESSED DECIMAL MAGNITUDE
	.WORD	NEWLIN-.!NP	; %N->NEWLINE
	.WORD	OCTAL-.		; %0->SIGNED OCTAL
	.WORD	POINT-.		; %P->ABSOLUTE OCTAL
	.WORD	PNTZER-.	; %Q->ZERO SUPPRESSED ABSOLUTE OCTAL
	.WORD	RAD50-.		; %R->RAD50 STRING
	.WORD	SPACE-.!NP	; ++030 %S->SPACE GENERATOR
	.WORD	DOUBLE-.	; %T->DOUBLE PRECISION DECIMAL
	.WORD	DECUNS-.	; %U->DECIMAL MAGNITUDE, NO SURPRESS
	.WORD	XFNAM-.		; %X->FILE NAME STRING
	.WORD	EDATE-.		; %Y->DATE CONVERSION
	.WORD	ETIME-.		; %Z->TIME CONVERSION
	.WORD	DFLD-.!NP	; %<->DEFINE FIXED LENGTH FIELD
	.WORD	LCTFLD-.!NP	; %>->LOCATE FIELD MARK

	.PSECT	.RSXC.,I,RO	; PURE CODE PSECT

;+
; **-$EDMSG-EDIT MESSAGE
;
; THIS ROUTINE IS CALLED TO PROCESS AN ASCIZ FORMAT STRING TO PRODUCE
; AN EDITED OUTPUT STRING. THE INPUTS TO THE ROUTINE ARE A FORMAT STRING
; AND THE ADDRESS OF AN ARGUMENT BLOCK. THE FORMAT STRING IS SCANNED
; LOOKING FOR FORMAT DIRECTIVES. AS EACH NON-FORMAT CHARACTER IS EN-
; COUNTERED, IT IS SIMPLY COPIED INTO THE OUTPUT STRING. A"%" SIGN IS
; USED TO DELIMIT A FORMAT DIRECTIVE. IF A "%" SIGN IS FOLLOWED BY A "V"
; (VALUE), THEN THE REPEAT COUNT IS TAKEN FROM THE NEXT WORD IN THE ARG-
; UMENT BLOCK. ELSE THE NEXT "N" CHARACTERS (BY CONTEXT) ARE CONVERTED
; TO BINARY AND THIS VALUE IS TAKEN AS THE REPEAT COUNT. A REPEAT COUNT
; OF ZERO IS DEFAULTED TO A REPEAT COUNT OF ONE IN EITHER CASE. THE NEXT
; CHARACTER IN THE FORMAT STRING MUST BE A FORMAT DIRECTIVE. THE FOLLOW-
; ING FORMAT DIRECTIVES ARE IMPLEMENTED.
;
;	%A-ASCII STRING
;++030	%B-BINARY BYTE TO OCTAL
;	%D=SIGNED BINARY TO DECIMAL CONVERSION
;++030	%E-EXTENDED ASCII
;	%F-FORM CONTROL
;	%M-DECIMAL MAGNITUDE,  ZERO SURPRESS
;	%N-NEW LINE (CR-LF)
;	%O-SIGNED BINARY TO OCTAL CONVERSION
;	%P-MAGNITUDE BINARY TO OCTAL CONVERSION
;	%Q-MAGNITUDE BINARY TO OCTAL, ZERO SUPPRESSED
;	%R-BINARY TO RAD50 CONVERSION
;++030	%S-SPACE GENERATOR
;	%T-DOUBLE PRECISION BINARY TO DECIMAL CONVERSION
;	%U-DECIMAL MAGNITUDE, NO ZERO SURPRESS
;	%X-FILE NAME CONVERSION
;	%Y-DATE CONVERSION
;	%Z-TIME CONVERSION
;	%<-DEFINE N BYTE, BLANK FILLED FIELD
;	%>-LOCATE FIELD MARK
;
; INPUTS:
;
;	R0=ADDRESS OF OUTPUT STRING.
;	R1=ADDRESS OF INPUT STRING
;	R2=ADDRESS OF ARGUMENT BLOCK.
;
; OUTPUTS:
;
;	R0=ADDRESS OF LAST BYTE IN OUTPUT STRING.
;	R1=LENGTH OF OUTPUT STRING IN BYTES.
;	R2=ADDRESS OF NEXT PARAMETER IN ARGUMENT BLOCK
;-

$EDMSG::JSR	R5,$SAVRG	;SAVE NONVOLITILE REGISTERS
	MOV	R0,-(SP)	;SAVE STARTING ADDRESS OF OUTPUT BUFFER
	CLR	-(SP)		; INSERT INCLUDE STRING STOPPER
	MOV	R0,R3		;MOVE PARAMETERS TO NONVOLITILE REGISTER
	MOV	R1,R4		;
	MOV	R2,R5		;
10$:	MOVB	(R4)+,R2	;GET NEXT CHARACTER IN INPUT STRING
	BEQ	20$		;IF EQ ALL DONE
	CMPB	#'%,R2		;FORMATTING CHARACTER?
	BEQ	30$		;IF EQ YES
	MOVB	R2,(R3)+	;STORE CHARACTER IN OUTPUT STRING
	BR	10$		;GO AGAIN
20$:
	MOV	(SP)+,R4	; GET PREVIOUS FORMAT STRING ADDRESS
	BNE	10$		; BR IF THERE WAS A STRING('%I' ENCOUNTERED)
	CLRB	(R3)		; CLEAR LAST BYTE FOR ASCIZ
	MOV	R3,R0		;SET LAST BYTE ADDRESS
	MOV	R0,R1		;COPY ADDRESS OF NEXT BYTE IN OUTPUT BUF
	SUB	(SP)+,R1	;CALCULATE LENGTH OF LINE IN BYTES
	MOV	R5,R2		; SET ADDRESS OF NEXT PARAMETER
	RETURN			;
30$:	MOV	R4,-(SP)	;SAVE R4 IN CASE OF ILLEGAL DIRECTIVE
	MOV	R4,R0		;SET ADDRESS OF NEXT BYTE
	CMPB	#'V,(R0)+	;NEXT CHARACTER "V"?
	BNE	35$		; IF NE NO
	MOV	(R5)+,R1	; GET ARGUMENT
	BR	40$		; PROCESS DIRECTIVE
35$:				;
	MOV	R4,R0		;SET ADDRESS OF NEXT BYTE
	CALL	$CDTB		;CONVERT LEADING NUMBER
	DEC	R0		;BACKUP TO TERMINAL BYTE
40$:	MOV	R0,R4		;RESTORE ADDRESS OF NEXT CHARACTER
	MOV	R3,R0		;SET ADDRESS OF NEXT IN OUTPUT STRING
	MOV	R1,R3		;SET REPEAT COUNT
	BNE	45$		;IF NE OKAY
	INC	R3		;MAKE COUNT 1

45$:	MOV	PC,R1		;GET PC RELATIVE ADDRESS OF THE BYTE...
	ADD	#<OPRAND+OPRNDX-.>,R1 ; ... AFTER THE OPRAND CODE TABLE
	MOV	#OPRNDX,R2	;COUNT FOR LOOPING THROUGH OPRAND TABLE
50$:	CMPB	(R4),-(R1)	;MATCH?
	BEQ	60$		;IF EQ YES
	DEC	R2		;REPEAT - R2 WILL BE DIR # 0..OPRNDX
	BNE	50$
60$:	INC	R4		;INCREMENT PAST DIRECTIVE
	ASL	R2		;DOUBLE R2 FOR USE AS WORD OFFSET
	ADD	PC,R2		;PIC CODE IS PC RELATIVE
	ADD	#<VECTOR-.>,R2	;R2 = ADDRESS OF PROPER TABLE ENTRY
	ADD	(R2),R2		;R2 = ADDRESS OF ROUTINE
;	ASR	R2		; ISOLATE NO-PARAMETERS FLAG
;	BCS	70$		; IF C/S NO PARAMETERS REQUIRED 
;	MOV	(R5)+,R1	; ELSE FETCH FIRST PARAMETER
;70$:				; 
;	ASL	R2		; CONVERT TO ADDRESS
	BIC	#1, R2		; clear params flag (now in routines)
	CALL	(R2)		; CALL PROCESSING ROUTINE

	MOV	R0,R3		;RESTORE ADDRESS OF NEXT IN OUTPUT STRING
	TST	(SP)+		;CLEAN STACK
	BR	10$		;GO AGAIN



;
; ILLEGAL DIRECTIVE (%"UNKNOWN)
;

ILLDIR:	MOVB	#'%,(R0)+	;STORE PERCENT SIGN IN OUTPUT STRING
	MOV	2(SP),R4	;RESTORE INPUT STRING ADDRESS
	CMPB	#'V,(R4)	;"V" DIRECTIVE?
	BNE	10$		;IF NE NO
	TST	-(R5)		;BACKUP ARGUMENT POINTER
10$:	RETURN			;


;
; INCLUDE FORMAT STRING SEGMENT
;
; PARAMETER IS THE ADDRESS OF ANOTHER ASCIZ STRING TO BE LOGCALLY
; INCLUDED AT THIS POINT IN THE FORMATTING PROCESS
;

INCLUD:
	MOV	(R5)+,R1	;YES- GET THE 1ST PARAMETER 
	BEQ	10$		; AND SKIP IF IT IS NULL
	MOV	(SP),-(SP)	; SHUFFLE STACK (RETURN ADDRESS TO DISPATCH)
	MOV	4(SP),2(SP)	; SAVED FORMAT STRING PTR IN CASE OF ERROR
	MOV	R4,4(SP)	; SAVE CURRENT FORMAT STRING POINTER
	MOV	R1,R4		; AND SUBSTITUTE NEW FORMAT POINTER
10$:	RETURN			; CONTINUE PROCESSING WITH NEW FORMAT STRING

;
; DEFINE N BYTE FIXED LENGTH FIELD (%N<)
;
; N SPACES ARE INSERTED IN THE OUTPUT STREAM FOLLOWED BY A NULL.
; UPON COMPLETION, THE BYTE POINTER (R0) IS RESET TO ITS INITIAL VALUE.
;

DFLD:				;
	MOV	R0,R2		; MARK CURRENT POSITION
	CALL	SPACE		; INSERT N SPACES
	CLRB	(R0)		; MARK END OF FIELD
	MOV	R2,R0		; RESET BYTE POINTER
	RETURN			;

;
; LOCATE FIELD MARK (%N>)
;
; THE OUTPUT STREAM POINTER (R0) IS ADVANCED UNTIL A FIELD DELIMI-
; TER IS LOCATED OR THE REPEAT COUNT IS EXCEEDED (WHICHEVER OCCURS
;  FIRST). THE FIELD MARK IS A NULL.
;

LCTFLD:				;
	TSTB	(R0)+		; FIND NULL?
	BEQ	10$		; IF EQ YES
	DEC	R3		; REPEAT
	BNE	LCTFLD
10$:				;
	DEC	R0		; BACKUP BYTE POINTER
	RETURN			;

;
; ASCII DIRECTIVE (%NA)
;
; MOVE "N" CHARACTERS FROM STRING POINTER TO BY R1 TO OUTPUT STRING.
;

ASCII:	MOV	(R5)+,R1	;YES- GET THE PARAMETER 
10$:	MOVB	(R1)+,(R0)+	;MOVE A BYTE
	DEC	R3		;REPEAT
	BNE	10$
	RETURN			;
                                                                                ;**NEW**
;++030                                                                          ;**NEW**
;++030 BINARY BYTE TO OCTAL CONVERSION (%NB)                                    ;**NEW**
;++030                                                                          ;**NEW**
;++030 CONVERT N CONSECUTIVE BYTES POINTED TO BY R1                             ;**NEW**
;++030                                                                          ;**NEW**
                                                                                ;**NEW**
BYTE:				;++030                                          ;**NEW**
	MOV	(R5)+,R1	;YES- GET THE PARAMETER 
	BR	BLOOP		; Do not output space for first field.
BYTE1:				;++030                                          ;**NEW**
	MOVB	#<' >,(R0)+	;++030 INSERT A SPACE                           ;**NEW**
BLOOP:
	MOVB	(R1)+,R2	;++030 GET NEXT BYTE                            ;**NEW**
	MOV	R1,-(SP)	;++030 SAVE R1                                  ;**NEW**
	MOV	R2,R1		;++030 SET VALUE TO CONVERT                     ;**NEW**
	MOV	SP,R2		;++030 DO NOT SUPPRESS ZEROS                    ;**NEW**
	CALL	$CBTMG		;++030 CONVERT BYTE TO MAGNITUDE OCTAL          ;**NEW**
	MOV	(SP)+,R1	;++030 RESTORE R1                               ;**NEW**
	DEC	R3		;++030 GO AGAIN                                 ;**NEW**
	BNE	BYTE1
	RETURN			;++030                                          ;**NEW**

;
; SIGNED BINARY TO DECIMAL CONVERSION (%ND)
;
; CONVERT "N" CONSECUTIVE ARGUMENT WORDS. IF MORE THAN ONE WORD IS
; CONVERTED, THEN INSERT A TAB BETWEEN WORDS.
;

BINDEC:				;
	CLR	-(SP)		; ZERO SUPRESSION
	MOV	PC,-(SP)	; 
	ADD	#<$CBDSG-.>,(SP); PUSH ADDRESS OF CONVERSION ROUTINE 
	BR	CVNUM		; CONVERT SINGLE PRECISION NUMBER

;
; BINARY TO DECIMAL MAGNITUDE CONVERSION - ZERO SUPRESS (%NM)
;
	.ENABL	LSB
DECSUP:				;
	CLR	-(SP)		; ZERO SUPRESSION
	BR	10$		; JOIN COMMON CODE

;
; BINARY TO DECIMAL MAGNITUDE CONVERSION - NO SURPRESS (%NU)
;

DECUNS:				;
	MOV	R2,-(SP)	; NO SURPRESS
10$:	MOV	PC,-(SP)	; 
	ADD	#<$CBDMG-.>,(SP); PUSH ADDRESS OF CONVERSION ROUTINE 
	BR	CVNUM		;
	.DSABL	LSB


;
; DOUBLE PRECISION BINARY TO DECIMAL CONVERSION (%NT)
;
; CONVERT N CONSECUTIVE DOUBLE-PRECISION VALUES POINTED TO BY R1
;

DOUBLE:				;
	CLR	-(SP)		; ZERO SUPRESSION
	MOV	PC,-(SP)	; 
	ADD	#<$CDDMG-.>,(SP); PUSH ADDRESS OF CONVERSION ROUTINE 
	BR	CVNUM		; CONVERT DOUBLE PRECISION NUMBER
                                                                                ;**NEW**
;++030                                                                          ;**NEW**
;++030 EXTENDED ASCII CONVERSION (%NE)                                          ;**NEW**
;++030                                                                          ;**NEW**
;++030 CONVERT N BYTES POINTED TO BY R1 TO EXTENDED ASCII REPRESENTATION        ;**NEW**
;++030                                                                          ;**NEW**
                                                                                ;**NEW**
EASCI:				;++030                                          ;**NEW**
	MOV	(R5)+,R1	;YES- GET THE PARAMETER 
EASCI1:	MOVB	(R1)+,(R0)	;++030 MOVE NEXT BYTE                           ;**NEW**
	BICB	#200,(R0)	;++030 CLEAR PARITY BIT                         ;**NEW**
	CMPB	(R0),#<' >	;++030 PRINTING CHARACTER?                      ;**NEW**
	BLT	10$		;++030 IF LT NO                                 ;**NEW**
	CMPB	(R0),#177	;++030 RUBOUT?                                  ;**NEW**
	BNE	20$		;++030 IF NE NO                                 ;**NEW**
10$:				;++030                                          ;**NEW**
	MOVB	#<' >,(R0)	;++030 REPLACE NON-PRINTING CHAR. WITH SPACE    ;**NEW**
20$:				;++030                                          ;**NEW**
	INC	R0		;++030 STEP TO NEXT OUTPUT BYTE                 ;**NEW**
	DEC	R3		;++030 GO AGAIN                                 ;**NEW**
	BNE	EASCI1
	RETURN			;++030                                          ;**NEW**
;
; FORM CONTROL DIRECTIVE (%NF)
;
; INSERT "N" FORM FEEDS INTO OUTPUT STRING.
;

FORM:	MOVB	#'L-100,(R0)+	;INSERT A FORM FEED
	DEC	R3		;REPEAT
	BNE	FORM
	RETURN			;
 
;
; NEW LINE DIRECTIVE (%NN)
;
; INSERT "N" CR-LF PAIRS INTO OUTPUT STRING.
;

NEWLIN:	MOVB	#'M-100,(R0)+	;INSERT A CR
	MOVB	#'J-100,(R0)+	;INSERT A LF
	DEC	R3		;REPEAT
	BNE	NEWLIN
	RETURN			;

;
; SIGNED BINARY TO OCTAL CONVERSION DIRECTIVE (%NO)
;
; CONVERT "N" CONSECUTIVE ARGUMENT WORDS. IF MORE THAN ONE WORD IS
; CONVERTED, THEN INSERT A TAB BETWEEN WORDS.
;

OCTAL:				;
	CLR	-(SP)		; ZERO SUPRESSION
	MOV	PC,-(SP)	; 
	ADD	#<$CBOSG-.>,(SP); PUSH ADDRESS OF CONVERSION ROUTINE 
	BR	CVNUM		; CONVERT SINGLE PRECISION NUMBER

;
; MAGNITUDE BINARY TO OCTAL CONVERSION, ZERO SUPPRESS (%Q)
;
	.ENABL	LSB
PNTZER:
	CLR	-(SP)		; ZERO SUPPRESSION
	BR	10$		; JOIN COMMON CODE
;
; MAGNITUDE BINARY TO OCTAL CONVERSION DIRECTIVE (%NP)
;
; CONVERT "N" CONSECUTIVE ARGUMENT WORDS. IF MORE THAN ONE WORD IS
; CONVERTED, THEN INSERT A TAB BETWEEN WORDS.
;

POINT:				;
	MOV	R2,-(SP)	; NO ZERO SUPRESSION
10$:	MOV	PC,-(SP)	; 
	ADD	#<$CBOMG-.>,(SP); PUSH ADDRESS OF CONVERSION ROUTINE 
	BR	CVNUM		; CONVERT NUMBER
	.DSABL	LSB

;
; **-CVNUM-CONVERT NUMBER TO ASCII
;
; "N" CONSECUTIVE ARGUMENT WORDS ARE CONVERTED TO ASCII. IF MORE
; THAN ONE WORD IS CONVERTED A TAB IS INSERTED BETWEEN FIELDS. WHEN
; A DOUBLE PRECISION VALUE IS PROCESSED THE ARGUMENT LIST CONTAINS
; THE ADDRESS OF THE QUANTITY TO BE CONVERTED
;
; INPUTS:
;
;	R0=STRING POINTER
;	R1=FIRST ARGUMENT
;	R3=REPEAT COUNT
;	R5=PARAMETER LIST POINTER
;
;	(SP)=CONVERSION ROUTINE ADDRESS
;	2(SP)=ZERO SURPRESS FLAG
;	4(SP)=RETURN ADDRESS
;
; OUTPUTS:
;
;	R0=UPDATED STRING POINTER
;	R5=UPDATED ARGUMENT LIST POINTER
;	SP NORMALIZED 
;

CVNUM1:				;
	MOVB	#'I-100,(R0)+	; INSERT A TAB
CVNUM:	MOV	(R5)+,R1	; GET NEXT ARGUMENT WORD
				;
	MOV	2(SP),R2	; GET ZERO-SUPRESS FLAG
	MOV	(SP),-(SP)	; DUPLICATE SUBROUTINE ADDRESS
	CALL	@(SP)+		; CALL CONVERSION ROUTINE
	DEC	R3		; REPEAT
	BNE	CVNUM1
	CMP	(SP)+,(SP)+	; CLEAN STACK
	RETURN			;

;
; MAGNITUDE BINARY TO DECIMAL CONVERSION
;

DECMAG:				;
	CLR	-(SP)		; ZERO SUPRESSION
	MOV	PC,-(SP)	; 
	ADD	#<$CBDMG-.>,(SP); PUSH ADDRESS OF CONVERSION ROUTINE 
	BR	CVNUM		; CONVERT BINARY TO ASCII


;
; BINARY TO RAD50 CONVERSION DIRECTIVE
;
; CONVERT "N" CONSECUTIVE RAD50 WORDS.
;

RAD50:	MOV	(R5)+,R1	;GET NEXT ARGUMENT WORD
	CALL	$C5TA		;CONVERT TO RAD50
	DEC	R3		;REPEAT
	BNE	RAD50
	RETURN			;
                                                                                ;**NEW**
;++030                                                                          ;**NEW**
;++030 SPACE GENERATOR (%NS)                                                    ;**NEW**
;++030                                                                          ;**NEW**
;++030 GENERATE N SPACES IN BUFFER                                              ;**NEW**
;++030                                                                          ;**NEW**
                                                                                ;**NEW**
SPACE:				;++030                                          ;**NEW**
	MOVB	#<' >,(R0)+	;++030 PUT IN A SPACE                           ;**NEW**
	DEC	R3		;++030 LOOP UNTIL DONE                          ;**NEW**
	BGT	SPACE
	RETURN			;++030                                          ;**NEW**


;
; DATE CONVERSION
;
; NOTE: REPEAT COUNT IS IGNORED.
;

EDATE:	MOV	R5,R1		;COPY ADDRESS OF NEXT PARAMETER
	CALL	$DAT		;CONVERT DATE
	MOV	R1,R5		;SET ADDRESS OF NEXT ARGUMENT
	RETURN			;

;
; TIME CONVERSION
;
; REPEAT COUNT IS USED TO SPECIFY THE TIME FORMAT.
;

ETIME:	MOV	R5,R1		;COPY ADDRESS OF NEXT ARGUMENT
	MOV	R3,R2		;SET CONVERSION TYPE
	CALL	$TIM		;CONVERT TIME
	MOV	R1,R5		;SET ADDRESS OF NEXT ARGUMENT
	RETURN			;


;
; FILE NAME STRING CONVERSION
;
; CONVERT "N" FILE NAME STRINGS. IF MORE THAN ONE FILE NAME STRING IS
; CONVERTED, THEN INSERT A TAB BETWEEN STRINGS.
;

XFNAM1:	MOVB	#'I-100,(R0)+	;INSERT A TAB
XFNAM:	MOV	(R5)+,R1	;GET NEXT INPUT PARAMETER
	BEQ	10$		;IF EQ NO DEVICE SPEC
	CALL	$C5TA		;CONVERT TO RAD50
	MOV	#3,R2		;SET SUPPRESS COUNT
	CALL	30$		;SUPPRESS TRAILING SPACES
	MOVB	#':,(R0)+	;INSERT COLON SEPARATOR
10$:	MOV	(R5)+,R1	;GET NEXT INPUT PARAMETER
	CALL	$C5TA		;CONVERT TO RAD50
	MOV	(R5)+,R1	;GET NEXT INPUT PARAMETER
	CALL	$C5TA		;CONVERT TO RAD50
	MOV	#6.,R2		;SET SUPRESS COUNT
	CALL	30$		;SUPRESS TRAILING BLANKS
	MOVB	#'.,(R0)+	;INSERT PERIOD SEPARATOR
	MOV	(R5)+,R1	;GET NEXT INPUT PARAMETER
	CALL	$C5TA		;CONVERT FILE TYPE TO RAD50
	MOV	#3,R2		;SET SUPRESS COUNT
	CALL	30$		;SUPRESS TRAILING BLANKS
	TST	(R5)+		;SKIP UNUSED WORD
	DEC	R3		;REPEAT
	BNE	XFNAM1
20$:	RETURN			;
30$:	DEC	R2		;SUPRESS ANY MORE?
	BLT	20$		;IF LT NO
	CMPB	#' ,-1(R0)	;TRAILING BLANK?
	BNE	20$		;IF NE NO
	DEC	R0		;BACK UP A BYTE
	BR	30$		;

	.END