.TITLE PARAM .IDENT /RICE01/ ; ; SETS UP PARAMETERS FOR COLOR DISPLAY. TABLE 2 HOLDS ;INFORMATION FOR DISPLAY ; ; ; CALL PSET(IER,IPAGE,ISKIP,IDIFF,ITYPE,DATA,NWORDS, ; LABELS,IHILO,HILO) ; IER = 0 NO ERROR ; IER = NON ZER INADEQUATE SPACE FOR SETUP ; IPAGE = PAGE NO FOR PARAM DISPLAY (0 TO 15) ; ISKIP = NON ZERO TO SKIP 1 LINE AFTER PREVIOUS ENTRY ; IDIFF = 0 DON'T DISPLAY DIFFERENCE ; ITYPE = NO OF WORDS OF PRECISION INTEGER VARIABLE ; 1,2 ARE NO. OF WORDS OF PRECISION ; 0 IS SINGLE PRECISION FLOAT PT ; DATA = ARRAY OF DATA TO DISPLAY ; NWORDS = NUMBER OF WORDS OF DATA ; LABEL = ARRAY OF LABELS 4 CHAR PER LABEL ; IHILO = ARRAY SPECIFYING LIMITS TO BE PLACED (ARRAY ; IS 1 OR 2 WORDS LONG) ; COMBINE THE BELOW VALUES FOR THE LIMITS SPECIFIED ; 1 = LO LIM ; 2 = HI LIM ; 4 = PURPLE LIMITS ; 8 = VALUE IS CHANGEABLE ; HILO = ARRAY OF HILO VALUES ; ; TABLE FORMAT ; ; LONG 0 Address of next entry (0 if this is last entry) ; BYTE 4 #OF VARIABLES + (100 STORE DIFF) ; BYTE 5 #200+ PAGE#+ (100 DOUBLE WD.)+ (40 FLOATING)+ (20 CHANGEABLE) ; BYTE 6,7 Line skip count ; LONG 8 ADDRESS OF ARRAY ; WORD 12..... N 2WORD LABELS ; n word limits ; n word last value ; ........... ; P.DIF =^O100 P.VAR=^O10000 P.FLT=^O20000 P.DBL=^O40000 IN.ERR = 0 IN.SW = 4 IN.SKP = 8 IN.DIF = 12 IN.TYP = 16 IN.DAT = 20 IN.SIZ = 24 IN.LAB = 28 IN.MOD = 32 IN.LIM = 36 PARAM:: EXIT: RET .ENTRY PSET,^M MOVL AP,R5 ; GET PARAMS MOVL (R5)+,R4 ; AND NUMBER OF PARAMS CMPB R4,#10 ; Test number of params BLSS EXIT ; Bad ? CLRL @(R5) ; NO ERROR YET CLRL R6 ; Will be header word MOVZWL #^O100000,R6 ; Will be header word MOVZBL @IN.SIZ(R5),R7 ; NUMBER OF VARIABLES BICB #^O300,R7 ; CLEAR EXTRA BITS BEQL EXIT ADDW R7,R6 ; ADD IN COUNT MOVB @IN.SW(R5),R0 ; DISPLAY SWITCH # BICW #^O177760,R0 ; STRIP OFF SW (0 TO 16) ASHL #8,R0,R0 ; Shift up to next byte ADDW R0,R6 ; Save as part of header BITB #^O10,@IN.MOD(R5) ; TEST IF VALUE FOR INPUT BEQL 10$ ; NOT AN INPUT PARAM BISW #P.VAR,R6 ; YES CHANGEABLE 10$: MOVL R7,R4 ; Number of words CMPB @IN.TYP(R5),#1 ; TYPE OF DATA? BGEQ 20$ ; INTEGER TYPE BISW #P.FLT,R6 ; Floating point indicator BRW 30$ ; DO NOT SET DOUBLEQ WD 20$: BEQL 40$ ; SINGLE PRECISION BISW #P.DBL,R6 ; Double precision 30$: ADDL R7,R4 ; Words/array 40$: MOVL R7,R0 ; Words/array ADDL R7,R0 ; Number of words for label TSTB @IN.DIF(R5) ; DIFFERENCE REQUESTED? BEQL 50$ ; NO ADDL R4,R0 ; Extra entries BISW #P.DIF,R6 ; YES, MARK IT 50$: BITB #1,@IN.MOD(R5) ; LOWER LIMIT? BEQL 60$ ; NO ADDL R4,R0 ; Extra entries 60$: BITB #2,@IN.MOD(R5) ; UPPER LIMIT? BEQL 70$ ; NO ADDL R4,R0 ; Extra entries 70$: ADDL #6,R0 ; Add number of words needed for header ASHL #1,R0,R0 ; Number of bytes needed JSB BREQB ; Request buffer BEQL EXIT1 ; None ? MOVL #SVT2,R2 ; ADDRESS OF LIST 80$: TSTL (R2) ; END OF LIST? BEQL 90$ ; YES MOVL (R2),R2 ; NO BRW 80$ 90$: MOVL R0,(R2) ; Link in new list CLRL (R0)+ ; Room for next list address MOVW R6,(R0)+ ; LIST HEADER MOVZBW @IN.SKP(R5),(R0) ; Skip count? BICW #^O177740,(R0)+ ; Limit skip to 32 max MOVL IN.DAT(R5),(R0)+ ; ADDRESS OF ARRAY TO DISP MOVL R0,R2 ; NOW HAVE A BUFFER ; ;CALCULATE LAST LOC USED ON SCOPE TO BE SURE ALL WDS FIT ;SAVE HIGHEST LOC IN TAG FOR THIS SWITCH # ;GET ADDR OF LABELS AND HILO SWITCHES ;HI BIT OF LABEL CHARS ARE USED AS HI-LO SWITCHES ; MOVL IN.LAB(R5),R3 ; Address of label descriptor MOVL 4(R3),R3 ; Get character string address MOVB @IN.MOD(R5),R4 ; SPEC FOR HI,LO LABL: MOVL IN.LIM(R5),R1 ; ARRAY FOR HI,LO SPEC MOVL R2,R0 ; NEXT ENTRY TSTL (R2)+ ; Skip label BSBW CHARGT BSBW CHARGT BITB #1,R4 ; LO LIM? BEQL 10$ ; NO BSBW LIMIT ; SET LIMIT 10$: BSBW CHARGT BSBW CHARGT BITB #2,R4 ; HI LIM? BEQL 20$ ; NO BSBW LIMIT ; YES, SET LIMIT 20$: TSTB @IN.DIF(R5) ; DIFFERENCE? BEQL 30$ ; NONE CMPB @IN.TYP(R5),#1 ; 1 word type ? BEQL 25$ ; Yes TSTW (R2)+ ; Skip 1 word 25$: TSTW (R2)+ ; Skip 1 word 30$: DECB R7 ; DECREMENT DATA COUNT BNEQ LABL ; 1 LABEL AND HILO/DATA WD EXIT1: RET ; ; MOVE 1 CHARACTER FROM (R3)+ TO (R2)+ ; CHARGT: MOVB (R3)+,(R0) BICB #^O200,(R0) CMPB (R0),#32 ; IS IT GREATER THAN BLANK BGEQ 1$ ; YES MOVB #32,(R0) ; NO, SUBSTITUTE BLANK 1$: INCL R0 ; NEXT CHAR TO MOVE RSB ; ; SET LIMIT ; LIMIT: BISW #^O100000,-2(R0) ; LIMIT FLAG LIMIT2: CMPB @IN.TYP(R5),#^O1 ; TYPE OF DATA? BEQL 10$ ; SINGLE MOVW (R1)+,(R2)+ ; first word 10$: MOVW (R1)+,(R2)+ ; Second or only word RSB ; ; 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 = 4 IN.TYP = 8 IN.LO = 12 IN.HI = 16 ; ;R0,R1 = Temporary data ;R2 = SOB counter ;R3 = Table pointer ;R4 = Misc pointer ;R5 = Next table pointer ;R6 = Current data count (# of elements) ;R7 = Current data address ;R8 = Current list status ; PLEND: RET .ENTRY PLIM,^M CMPB (AP),#4 ; 4 Params ? BNEQ PLEND ; No ? CMPB @IN.TYP(AP),#8 ; Change variable ? BNEQ 10$ ; No ? MOVW #1,@IN.HI(AP) ; Set error param 10$: MOVL SVT2,R5 ; STARTING POINT BEG: MOVL R5,R3 BEQL PLEND MOVL (R3)+,R5 ; Next table of params MOVZWL (R3)+,R0 ; STATUS OF DATA IN TABLE TSTW (R3)+ ; Skip skip count MOVW R0,R8 ; Save the type BEQL PLEND ; END OF TABLE MOVL (R3)+,R7 MOVB R0,R6 ; SAVE WORD COUNT BICB #^O300,R6 ; CLEAR EXTRA BITS BICW #^O117777,R0 ; STRIP OFF EXTRANEOUS BITS AGAIN: MOVL @IN.CHR(AP),R1 ; Get 4 byte label MOVL R3,R4 ; Save the char address MOVL (R3)+,R0 ; Get label from list BICL #^X80808080,R0 ; Get rid of extra bits BICL #^X80808080,R1 ; Get rid of extra bits 30$: CMPB @IN.TYP(AP),#^O10 ; IS VALUE CHANGE REQUESTED? BEQL 50$ ; YES, NO WILD CARD ALLOWED CMPB R1,#^A/*/ ; TEST IF WILD CARD CHAR BEQL 60$ ; YES!! 50$: CMPB R0,R1 ; Same? BNEQ 140$ ; No match ? 60$: ASHL #-8,R1,R1 ASHL #-8,R0,R0 BGTR 30$ ; Still data to compare ? ; ; HERE WE HAVE A PERFECT MATCH BETWEEN CHAR ; CMPB @IN.TYP(AP),#^O10 ; IS VALUE CHANGE REQUESTED BEQL STVAL ; Yes ? BGTR 65$ ; Unconditional limit change BITW #P.VAR,R8 ; Is this input param? BNEQ 140$ ; Yes, do not change limits 65$: MOVL #1,R0 ; FIRST CHECK IF LO LIMIT REQ. MOVF IN.LO(AP),R1 ; GET LO LIMIT BSBW LOAD ; CHECK IT AND LOAD IT IF NECESSARY MOVL #2,R0 ; CHECK IF HI LIMIT MOVF IN.HI(AP),R1 ; GET HI LIM BSBW LOAD ; CHECK IT AND LOAD IT IF NECESSARY 70$: BITW #P.DIF,R8 ; STORAGE FOR DIFF? BEQL 100$ ; NO BSBW UNLVAR ; Pop difference 100$: BITW #P.FLT!P.DBL,R8 ; Is it floating or 2 word data ? BEQL 110$ ; SINGLE WORD ADDL #2,R7 110$: ADDL #2,R7 ; Points to next variable DECB R6 ; CHECK IF CONTINUE IN LIST BGTR AGAIN ; YES, CONTINUE SEQUENCE OF N WORDS BRW BEG ; NO, NEW TYPE OF ENTRY IN TABLE ; ; Skip over an entry ; 140$: BSBW UNLOAD ; UNLOAD NAME BSBW UNLOAD ; UNLOAD NAME BRW 70$ ; Continue get next entry ; ; HERE WE STORE VALUE REQUESTED ; STVAL: INCB @IN.HI(AP) ; 2 = Not variable BITW #P.VAR,R8 ; IS CHANGE PERMISSIBLEQ BEQL 40$ ; NO CHANGE ALLOWED ON VALUE INCB @IN.HI(AP) ; 3 = Below lower limit BSBW LIMTST ; Test the limit BLSS 40$ ; Smaller than lower limit is bad 10$: INCB @IN.HI(AP) ; 4 = Above upper limit BSBW LIMTST ; Test the limit BGTR 40$ ; Greater than upper limit is bad 20$: MOVL IN.LO(AP),R1 ; Address of input data MOVL R7,R3 ; Address of number INCB @IN.HI(AP) ; 5 = Value too big for conversion BSBW STORE ; Store the number requested BVS 40$ ; Overflow ? CLRL @IN.HI(AP) ; OK status 40$: RET ; ; SUBROUTINE TO LOAD LIMIT ; LIMTST: TSTW (R4)+ ; Limit available? BGTR 50$ ; No BITW #P.FLT,R8 ; Floating data ? BNEQ 20$ ; Floating? BITW #P.DBL,R8 ; Double word data ? BNEQ 10$ ; Yes ? CVTWF (R3)+,R0 ; Get word to compare BRB 30$ 10$: CVTLF (R3)+,R0 ; Get single word BRB 30$ 20$: MOVF (R3)+,R0 ; Get floating limits 30$: CMPF @IN.LO(AP),R0 ; Compare with limit RSB 50$: MOVL #0,R0 ; Result of comparison RSB UNLOAD: TSTW (R4)+ ; Limit avail? BGEQ LRET ; No UNLVAR: TSTW (R3)+ ; Pop 1 word of limit BITW #P.FLT!P.DBL,R8 ; Type ? BEQL 10$ ; 1 word? TSTW (R3)+ ; Pop 1 word of limit 10$: RSB ; ; ROUTINE TO LOAD LIMITS ; LOAD: BITB R0,@IN.TYP(AP) ; Limit desired? BEQL UNLOAD ; NO TSTW (R4)+ ; CHECK IF LIMIT IS AVAILABLE BGEQ LRET ; NO LIMIT AVAILABLE STORE: BITW #P.FLT,R8 ; CHECK TYPE OF LIMIT BNEQ 10$ ; IT IS FLOATING BITW #P.DBL,R8 ; Check if double BEQL 20$ ; 1 word ? CVTFL (R1),(R3)+ ; Longword limit RSB 10$: MOVF (R1),(R3)+ ; Floating limit RSB 20$: CVTFW (R1),(R3)+ ; 1 word limit LRET: RSB ; ; CALL PSCAN(ITEST,LABEL,DATA,ISKIP,ILIM,LOLIM,HILIM) ; ; REGISTERS ; ; ; ; ; ; ; ECTR: .LONG 0 ; Array counter SVT2: .LONG 0 ; List header SVTB2: .LONG 0 ; Save start of current entry in table SVTB: .LONG 0 ; Save label address SVDATA: .LONG 0 ; Save current data address STATUS: .LONG 0 ; Saved status END: CLRL STATUS ; SET FIRST TIME INDICATOR CLRL (R3) ; Tell user no more params PSEND: RET .ENTRY PSCAN,^M MOVL AP,R5 MOVL (R5)+,R4 ; Number of params BISL #^X80000000,R4 ; Return when no params CMPB R4,#3 ; Too few? BLSS PSEND ; Insufficient params ? BSBW TESTP ; Get first param into R3 BEQL PSEND CLRL R6 ; Will be skip count TSTW STATUS ; FIRST TIME THRU BEQL 10$ ; YES TSTW (R3) ; FIRST TIME THRU? BNEQ 20$ ; THIS IS NOT FIRST TIME THRU 10$: MOVL SVT2,SVTB2 ; ADDRESS OF ARRAY BRW UPDATE 20$: MOVL SVTB,R2 ; LABELS DECB ECTR ; OUTPUT OLD DATA? BGTR OUTNXT ; NEXT IN LINE UPDATE: MOVL SVTB2,R2 ; NEXT ENTRY IN TABLE BEQL END ; NO MORE TO DO MOVL (R2)+,SVTB2 ; Save next table address MOVW (R2)+,R0 ; TYPE SWITCH MOVW R0,STATUS ; SAVE STATUS BICB #^O300,R0 ; CLEAR EXTRA BITS MOVB R0,ECTR ; COUNT OF DATA WDS MOVW (R2)+,R6 ; Skip count MOVL (R2)+,SVDATA ; SOURCE ADDRESS MOVL R2,SVTB ; SAVE LABELS NEXT OUTNXT: MOVW STATUS,(R3) ; TYPE OF DATA BSBW TESTP MOVL (R2),(R3) ; Move label BICL #^X80808080,(R3) ; Strip off extra bits MOVL SVDATA,R1 ; Address of data BSBW GETDAT ; Get a datum MOVL R1,SVDATA ; Save data address BSBW TESTP ; Address into R3 MOVF R0,(R3) ; Data to caller MOVL R2,R1 ; WILL BE FOR COMPARISON TSTL (R1)+ ; Points to possible limits BSBW TESTP BEQL 30$ ; No MOVW R6,(R3) ; Skip count to caller 30$: BSBW TESTP BEQL 40$ CLRB (R3) ; Clear limit indicator BITL #^X80000000,(R2) ; Lo limit exists ? BEQL 35$ ; No ? BISB #1,(R3) ; Tell user it exists 35$: BITL #^X8000,(R2) ; Hi limit exists ? BEQL 40$ ; No ? BISB #2,(R3) ; Tell user it exists 40$: BSBW LIMIT1 ; Move limit to user BSBW LIMIT1 ; Move limit to user BITW #P.DIF,STATUS ; DIFFERENCE REQUESTED? BEQL 70$ ; NO BSBW GETDAT ; get difference 70$: MOVL R1,SVTB ; SAVE CURRENT TITLE RET ; ; Subroutine to get a variable into %0 ; GETDAT: BITW #P.FLT,STATUS ; Floating data ? BNEQ 20$ ; Yes ? BITW #P.DBL,STATUS ; Double word data ? BEQL 10$ ; SINGLE WD INTEGER CVTLF (R1)+,R0 ; Double word integer data RSB 20$: MOVF (R1)+,R0 ; Get floating point data RSB 10$: CVTWF (R1)+,R0 ; Low order bits RSB ; ; Subroutine to get limit and move title to caller ; LIMIT1: TSTW (R2)+ ; Limit requested? BGTR 10$ ; No limit BSBW GETDAT ; Get limit BSBW TESTP BEQL 5$ ; No param MOVF R0,(R3) ; Save hi 5$: RSB 10$: BSBW TESTP RSB ; ; Routine to get input param address ; .END