.NLIST	TTM	
	.TITLE	PLIM	
	.IDENT	/RICE01/	
;	
;	THIS SUBROUTINE IS DESIGNED TO CHANGE ALARM AND LIMIT 
;	STATUS FOR PARAMETER DISPLAY ON COLOR SCOPE	
;	CALL PLIM(CHAR,ITYPE,FLOLIM,FHILIM)   
;	CHAR	= 4 CHAR NAME FOR DISPLAY PARAM WHOSE LIMIT IS TO BE CHANGED	
;	IF ANY OF THE CHARACTERS IS * IT IS DCONSIDERED TO BE WILD	
;	AND CAN REPRESENT ANY OTHER CHAR.  IE. CHAR	= A*** WILL	
;	CHANGE THE LIMITS FOR ALL SCOPE PARAM BEGINNING WITH A	
;	ITYPE	= TYPE OF CHANGE TO IMPLEMENT   
;	0	= TURN ON ALARMS (NO LIM CHANGE)  
;	4	= TURN OFF ALARMS(NO LIM CHANGE)  
;	1,5	= LO LIM CHANGE 
;	2,6	= HI LIM CHANGE 
;	3,7	= BOTH LIM CHANGED	
;	1,2,3	= AUDIBLE ALARM ON	
;	5,6,7	= AUDIBLE ALARM OFF	
;	10   MEANDS SUBSTITUTE FLOLIM FOR VALUE, IGNORE FHILIM
;	>10 IS ILLEGAL, IGNORED	
;	FLOLIM	= LOWER LIM IN FLOATING POINT  
;	FHILIM	= HI LIM IN FLOATING POINT	
;	
IN.CHR	= 0
IN.TYP	= 2
IN.LO	= 4
IN.HI	= 6
;
;R0,R1	= Temporary data
;R2	= Data address, SOB counter
;R3	= Table pointer
;R4	= Misc pointer
;R5	= Param pointer
;
$FPP=1			; To use floating processor
;$FIS=1			; To use Floating instruction set

	.psect	$CODE,RO,I,LCL,CON
END:	RETURN				; RETURN
PLIM::	MOV	#^RM ,-(SP)		; SET UP NAME
	MOV	#^RPLI,R4		; FIRST 3 CHAR NEXT
	JSR	R4,NAM$			; FOR TRACEBACK
	MOV	#4,R0			; ONLY 4 PARAM	
	CALL	R5CHEK			; CHECK THEM	
	CMP	@IN.TYP(R5),#10 
	BNE	10$
	MOV	#-1,@IN.HI(R5)		; SET ERROR PARAM	
10$:	MOV	SVT2,SVTB2		; STARTING POINT
BEG:	MOV	SVTB2,R3
	BEQ	END
	MOV	(R3)+,SVTB2		; Next table of params
	MOV	(R3)+,R0		; TYPE OF DATA IN TABLE	
	MOV	R0,TSAVE  		; Save the type
	BEQ	END			; END OF TABLE   
	BPL	BEG			; Not value entry
	MOV	(R3)+,ADDR 
	MOVB	R0,ECTR			; SAVE WORD COUNT 
	BIC	#177700,ECTR		; CLEAR EXTRA BITS
	BIC	#117777,R0		; STRIP OFF EXTRANEOUS BITS	
	SUB	#20000,R0		; GENERATE DATA TYPE	
;	- = 1 WORD INTEGER, 0 = FLOATING POINT, + = 2 WORD INTEGER	
	MOV	R0,TYPE			; SAVE TYPE	
AGAIN:	MOV	IN.CHR(R5),R4		; Get address of 4 byte label
	MOV	#4,R2			; NUMBER OF BYTES TO COMPARE	
30$:	MOVB	(R4)+,R1		; GET BYTE TO COMPARE	
	MOVB	(R3)+,R0		; Get byte from list
	CMP	@IN.TYP(R5),#10		; IS VALUE CHANGE REQUESTED?	
	BEQ	50$			; YES, NO WILD CARD ALLOWED	
	CMPB	R1,#'*			; TEST IF WILD CARD CHAR	
	BEQ	60$			; YES!!	
50$:	
	BIC	#177600,R0		; Strip byte
	CMPB	R0,R1			; Same?
	BNE	130$			; NO MATCH	
60$:	SOB	R2,30$			; CONTINUE COMPARE ANOTHER	

;
;	HERE WE HAVE A PERFECT MATCH BETWEEN CHAR	
;
	MOV	R3,R4			; WILL BE ADDRESS OF LABEL	
	CMP	-(R4),-(R4)	
	CMP	@IN.TYP(R5),#10		; IS VALUE CHANGE REQUESTED	
	BEQ	STVAL			; YES	
	BGT	65$			; Unconditional limit change
	BIT	#10000,TSAVE		; Is this input param?
	BNE	140$			; Yes, do not change limits
65$:	MOV	#1,R0			; FIRST CHECK IF LO LIMIT REQ.	
	MOV	IN.LO(R5),R1		; GET LO LIMIT
	CALL	LOAD			; CHECK IT AND LOAD IT IF NECESSARY
	MOV	#2,R0			; CHECK IF HI LIMIT	
	MOV	IN.HI(R5),R1		; GET HI LIM
	CALL	LOAD			; CHECK IT AND LOAD IT IF NECESSARY 
70$:	BIT	#100,TSAVE		; STORAGE FOR DIFF?
	BEQ	100$			; NO	
	CALL	UNLVAR			; Pop difference
100$:	TST	TYPE			; NEXT ADDRESS	
	BMI	110$			; SINGLE WORD	
	ADD	#2,ADDR	
110$:	ADD	#2,ADDR			; NOW POINTS TO NEXT ADDRESS	
	DEC	ECTR			; CHECK IF CONTINUE IN LIST	
	BGT	AGAIN			; YES, CONTINUE SEQUENCE OF N WORDS 
	BR	BEG			; NO, NEW TYPE OF ENTRY IN TABLE	
;
;	Skip over an entry
;
130$:	ADD	R2,R3	
	DEC	R3			; NOW POINTS TO LIMITS IF ANY	
	MOV	R3,R4			; WILL BE ADDRESS OF LABEL	
	CMP	-(R4),-(R4)	
140$:	CALL	UNLOAD			; UNLOAD NAME	
	CALL	UNLOAD			; UNLOAD NAME	
	BR	70$			; Continue get next entry

;	
;	HERE WE STORE VALUE REQUESTED
;
STVAL:	DEC	@IN.HI(R5)		; Nother type of error
	BIT	#10000,TSAVE		; IS CHANGE PERMISSIBLE	
	BEQ	40$			; NO CHANGE ALLOWED ON VALUE	
	DEC	@IN.HI(R5)		; Nother type of error
	CALL	LIMTST			; Test the limit
	BR	10$			; No limits
	BLT	40$			; Smaller than lower limit is bad
10$:	DEC	@IN.HI(R5)		; Nother type of error
	CALL	LIMTST			; Test the limit
	BR	20$
	BGT	40$			; Greater than upper limit is bad
20$:	MOV	IN.LO(R5),R1		; Address of input data
	MOV	ADDR,R3			; ADDRESS OF NUMBER
	CALL	STORE			; Store the number requested
	CLR	@IN.HI(R5)		; CLEAR ERROR PARAM	
40$:	RETURN

;
;	SUBROUTINE TO LOAD LIMIT
;
LIMTST:	TST	(R4)+			; Limit available?
	BPL	50$			; No
	.IFDF	$FPP
	SETF
	SETI
	TST	TYPE			; Type of data?
	BEQ	20$			; Floating?
	BMI	10$			; 1 Word?
	SETL
	MOV	(R3)+,-(SP)		; Lo bits
10$:	MOV	(R3)+,-(SP)		; Hi bits or only bits
	LDCIF	(SP)+,%0		; Get input
	BR	30$			; and compare
20$:	LDF	(R3)+,%0		; Get floating limit
30$:	CMPF	@IN.LO(R5),%0		; Compare with limit
	ADD	#2,(SP)			; Limit avialable
	CFCC				; Get results of comparison
	.endc
	.ifdf	$FIS
	ADD	#2,(SP)			; Limit avialable
	CLR	R0			; In case if double word
	TST	TYPE			; Type of data?
	BEQ	20$			; Floating?
	MOV	(R3)+,R1		; Lo bits
	TST	TYPE			; Type?
	BLT	10$			; 1 word?
	MOV	(R3)+,R0		; Hi bits
10$:	CALL	$FLOT2			; Get floating number
	BR	30$			; Now compare
20$:	MOV	(R3)+,R0		; Hi bits
	MOV	(R3)+,R1		; Lo bits
30$:	MOV	IN.LO(R5),R2		; Address of number
	MOV	2(R2),-(SP)		; Get number to compare
	MOV	(R2),-(SP)		; Hi bits
	MOV	R1,-(SP)		; Limit onto stack
	MOV	R0,-(SP)
	MOV	SP,R0			; Save stack pointer
	ADD	#10,R0			; Old stack address
	FSUB	SP			; Get the difference
	MOV	R0,SP			; Restore stack
	.endc
50$:	RETURN
UNLOAD:	TST	(R4)+			; Limit avail?
	BGE	LRET			; No
UNLVAR:	TST	(R3)+			; Pop 1 word of limit
	TST	TYPE			; Type?
	BLT	10$			; 1 word?
	TST	(R3)+			; Pop 1 word of limit
10$:	RETURN
;
;	ROUTINE TO LOAD LIMITS
;
LOAD:	BIT	R0,@IN.TYP(R5)		; Limit desired?
	BEQ	UNLOAD			; NO
	TST	(R4)+			; CHECK IF LIMIT IS AVAILABLE
	BGE	LRET			; NO LIMIT AVAILABLE	
STORE:	MOV	(R1)+,R0		; Get number
	MOV	(R1)+,R1
	TST	TYPE			; CHECK TYPE OF LIMIT	
	BEQ	10$			; IT IS FLOATING	
	CALL	$FIX2			; Get integer
	MOV	R1,(R3)+		; Store lo bits
	TST	TYPE			; Type ?
	BLT	LRET			; 1 word
	MOV	R0,(R3)+		; Hi bits
	RETURN
10$:	MOV	R0,(R3)+		; Store number
	MOV	R1,(R3)+		; Store
LRET:	RETURN
;
;	IMPURE DATA TABLE
;
	.psect	$VARS,RW,D,LCL,CON
ECTR:	.WORD	0			; WORD COUNT FOR # ENTRIES IN TABELE  
SVTB2:	.WORD	0			; POINTS TO NEXT LIST
TYPE:	.WORD	0			; TYPE FLOATING, 1 WORD, 2 WORD INTEGER
ADDR:	.WORD	0			; ADDRESS OF DATA
TSAVE:	.WORD	0			; STATUS WORD
	.END