.TITLE EFN -- Eventflag routine .IDENT /JHA2.3/ .ENABL LC ;+ ; THIS PROGRAM WILL ALLOW FULL MANIPULATION OF VARIOUS TYPES OF ; RSX EVENT FLAGS ; ; PROGRAMMED BY: ; I.F.E.M. HOLTZ ; UNILEVER ENG.DIV. I.C.A. ; SCHIEDAMSEDIJK 18 ; 3134 KK VLAARDINGEN ; HOLLAND ; TEL 010-352044 ; ; EDITTED FOR LOWER CASE : 19-MAY-82 BY HANS HAMAKERS BBN ROTTERDAM ; EDITTED FOR SET/CLR Local flags ; : 16-MAY-83 BY HANS HAMAKERS BBN ROTTERDAM ; Changed taskname fron EVF to EFN ; EVF is a digital DECNET task ; : 8-Jul-87 By Hans Hamakers BBC Rotterdam ; Determine if Group-global flags are supported by the system ; : 6-Jul-88 By Hans Hamakers ABB Rotterdam ; ; ASSEMBLE: ; MAC EFN,EFN/-SP=LB:[1,1]EXEMC/ML,[11,10]RSXMC/PA:1,SY:[uic]EFN ; ; TASK BUILD: ; EFN/CP/PR,EFN/MA/-SP=EFN ; LB:[1,1]EXELIB/LB ; LB:[1,54]RSX11M.STB/SS ; / ; UNITS=1 ; ASG=TI:1 ; TASK=...EFN ; PRI=200 ; // ;- ; SYNTAX MUST BE: ; >EFN g ; READS ALL GLOBAL FLAGS ; >EFN gr ; READS ALL OWN GROUP GLOBAL FLAGS ; >EFN gr/gr=num ; READS ALL GROUP GLOBAL FLAGS FOR OTHER GROUP ; >EFN l/t=name ; READ ALL LOCAL FLAGS FOR TASK ; >EFN xx ; READS GLOBAL OR OWN GROUP-GLOBAL FLAGS ; >EFN xx/gr=num ; READS GROUPGLOBAL FLAG FOR OTHER GROUP ; >EFN xx/t=name ; READS LOCAL FLAG FOR TASK ; >EFN xxs ; SETS GLOBAL OR OWN GROUP-GLOBAL FLAGS ; >EFN xxs/gr=num ; SETS GROUP GLOBAL FLAG FOR GROUP ; >EFN xxs/t=name ; SETS LOCAL FLAGS ; >EFN xxc ; CLEARS GLOBAL OR OWN GROUP-GLOBAL FLAGS ; >EFN xxc/gr=num ; CLEARS GROUP GLOBAL FLAG FOR GROUP ; >EFN xxc/t=name ; CLEARS LOCAL FLAGS .SBTTL INSTRUCTIONS FOR USING EFN ; ; ; FOLLOWS THE CONTENCE OF USE INSTRUCTIONS FROM LB:[1,2]EFN.HLP ; ; EFN -- THE EVENTFLAG UTILITY ; ============================ ; EFN can inspect and SET/CLR global or group global event flags ; EFN can inspect local event flags for a specified task ; Using EFN: (FLG is decimal flag number) ; Global flags ( 32 < FLG < 65 ) ; EFN>g Inspect all global flags ; EFN>flg Inspect flag number FLG ; EFN>flg(s/c) Set/Clear flag number FLG ; ; Group global flags ( 64 < FLG < 97 ) (GRP is octal group number) ; EFN>gr Inspect all group global flags ; EFN>gr/gr=grp Inspect all group global flags for group GRP ; EFN>flg Inspect flag number FLG ; EFN>flg/gr=grp Inspect flag number FLG for group GRP ; EFN>flg(s/c) Set/Clear flag number FLG ; EFN>flg(s/c)/gr=grp Set/Clear flag number FLG for group GRP ; > Note after specifying GRP once it remains default ; ; Local flags ( 0 < FLG < 33 ) ; EFN>l/t=tsk Inspect all local flag for task TSK ; EFN>flg/t=tsk Inspect local flag number FLG for task TSK ; EFN>flg(s/c)/t=tsk Set/Clear local flag number FLG ; .SBTTL TPARSE SYNTAX ANALYSE TABLE ; .MCALL ISTAT$, STATE$ ,TRAN$ .MCALL DIR$, EXIT$S, SETF$, CLEF$, RDXF$ ,RDAF$ ;JHA04 .MCALL QIOW$, QIOW$S, GMCR$ ; ; START OF SYNTAX ANALYSE TABLE ; ISTAT$ STAT,KEY ; INITIALISE TABLE ; STATE$ TRAN$ "EFN" ; MANDATORY SYNTAX STATE$ TRAN$ 'G,L10,TYPRTN TRAN$ 'L,L40,TYPRTN TRAN$ $DNUMB,L20,SAVNUM TRAN$ $EOS,L50 ; ; AFTER G ; STATE$ L10 TRAN$ 'R,L30,TYPRTN ; SET TYPE ROUTINE AT 'R TRAN$ $EOS,$EXIT ; EXIT ; ; AFTER NUMBER ; STATE$ L20 TRAN$ 'S,L30,ACTRTN ; PROCES SET ACTION TRAN$ 'C,L30,ACTRTN ; PROCES CLR ACTION TRAN$ !TSK,L50 ; MAY BE TASK TRAN$ !GRP,L50 ; OR GROUP TRAN$ $EOS,$EXIT ; EXIT ; ; AFTER S,C ; STATE$ L30 TRAN$ !TSK,L50 ; MAY BE TASK TRAN$ !GRP,L50 ; MAY BE GROUP GLOBAL TRAN$ $EOS,$EXIT ; MAY EXIT ; ; PROCES AFTER L ; STATE$ L40 TRAN$ !TSK,L50 ; MUST HAVE TASK ; ; END OF STRING CHECK ; STATE$ L50 ; END OF STRING CHECK TRAN$ $EOS,$EXIT ; EXIT ; ------------------------------------------------------------ ; GROUP SUBEXPRESSION ; STATE$ GRP TRAN$ '/ STATE$ TRAN$ "GR" STATE$ TRAN$ '= STATE$ TRAN$ $NUMBR,$EXIT,GNRTN ; ------------------------------------------------------------ ; TASK NAME SUBEXPRESSION ; STATE$ TSK TRAN$ '/ STATE$ TRAN$ "TASK",NXT3 TRAN$ "T",NXT3 STATE$ NXT3 TRAN$ '= STATE$ TRAN$ $RAD50,$EXIT,TSKRTN ; ------------------------------------------------------------ STATE$ ; END OF TPARS TABLE ; .SBTTL TPARS ACTION ROUTINES ; SAVNUM: TST .PNUMH ; HIGH ORDER MUST BE ZERO BEQ 10$ ADD #2,(SP) ; REJECT TRANSITION 10$: MOV .PNUMB,EFNNUM ; SAVE EVENT FLAG NUMBER RETURN ; MAY STOP IF OFF RANGE ! ; TYPRTN: MOV .PCHAR,TYPE ; SET TYPE RETURN ; ACTRTN: MOV .PCHAR,ACTION ; GET ACTION TYPE RETURN ; GNRTN: TST .PNUMH ; MUST BE ZERO BEQ 10$ ADD #2,(SP) ; REJECT TRANSITION 10$: MOV .PNUMB,GRNUM ; GET GROUP NUMBER RETURN ; TSKRTN: MOV .PSTPT,TSKBUF MOV .PSTCN,TSKL RETURN .SBTTL LOCAL MACROS .MACRO ERROR LAB CALL ERRTXT .WORD LAB .ENDM ERROR ERRTXT: JSR R5,$SAVRG ; SAVE R3-R5 MOV #TXT,R3 MOV #CTXT,R4 MOV #CTXTL,R5 10$: MOVB (R4)+,(R3)+ SOB R5,10$ MOV @10(SP),R4 ; GET ADRES ADD #2,10(SP) ; ADJUST RETURN MOVB (R4)+,R5 ; GET CHAR COUNT 20$: MOVB (R4)+,(R3)+ SOB R5,20$ SUB #TXT,R3 MOV R3,OUT+Q.IOPL+2 DIR$ #OUT RETURN ; BACK TO COROUTINE TO EXIT ; .SBTTL DATA AREA STATUS: 0 ; Status of localflag before operation EFNNUM: 0 ; SAVE EVENTFLAG NUMBER (0-96.) TYPE: 0 ; SAVE FLAG TYPE ('G,'R,'L,0) ACTION: 0 ; ACTION TYPE WANTED ('S,'C,0) GRNUM: 0 ; GROUP NUMBER (0-377) TSKL: 0 ; TASK NAME LENGTH TSKBUF: 0 ; START OF TASK NAME NOGRGL: 0 ; No groupglobalflags in system ;JHA04 EXF: 0 ; EXIT FLAG IOSB: 0,0 ; IOSB FOR READ AFTER PROMPT TNAM: 0,0 ; TASK NAME TXT: .BLKW 40. ; IMPURE TXT BUFFER TXTL= .-TXT FLGBUF: 0,0 ; FLAG BUFFER FLGINC: 0 ; OFFSET FOR FLGBUF SETOF: 40 ; STARTOFF FLAGS: .BLKW 6 ; BUFFER FOR EXTENDED FLAGS ERR: 0 .SBTTL VARIOUS DIRECTIVE PARAMETER BLOCKS ; GETFLG: RDXF$ FLAGS ; GET EXTENDED ALL EVENT FLAGS ;JHA04 GETFLA: RDAF$ ; GET ALL EVENT FLAGS ;JHA04 ; SETF: SETF$ 1 ; SET EVENT FLAG ; CLEF: CLEF$ 1 ; CLEAR EVENT FLAG ; OUT: QIOW$ IO.WVB,1,1,,,, ; GETMCR: GMCR$ ; GET MCR INPUT BUF= GETMCR+G.MCRB+4 ; INPUT BUFFER BUFL= .-BUF ; MAX LENGHT ; RPRM: QIOW$ IO.RPR,1,1,,IOSB,, ; .SBTTL DIRECT EQUATED SYMBOLS SPACE= 40 CR= 15 ; .SBTTL TEXTEN .NLIST BEX PRM: .ASCII /EFN>/ PRML= .-PRM ; CTXT: .ASCII /EFN -- / CTXTL= .-CTXT CSE: .ASCII / - Syntax error/ CSEL= .-CSE-1 FNR: .ASCII /Illegal flag number/ FNRL= .-FNR-1 NGL: .ASCII /System does not support group-global flags/ ;JHA04 NGLL= .-NGL-1 ;JHA04 NGR: .ASCII /Group / GRTXT: .ASCII /xxx/ .ASCII / has no group global event flags/ NGRL= .-NGR-1 NOT: .ASCII /No task name specified/ NOTL= .-NOT-1 TNS: .ASCII /Task not active/ TNSL= .-TNS-1 ACL: .ASCII /All flags clear/ ACLL= .-ACL-1 TNR: .ASCII /Task name error/ TNRL= .-TNR-1 GER: .ASCII /Illegal group number/ GERL= .-GER-1 IGR: .ASCII /Flag is not group global/ IGRL= .-IGR-1 TXT1: .ASCII /Flag / TXT1L= .-TXT1 CLTXT: .ASCII / was clear/ CLTXTL= .-CLTXT SETXT: .ASCII / was set / .EVEN .LIST BEX .SBTTL MAIN PROGRAM START: DIR$ #GETFLG ; Get flags BCC 1$ ; OK => 1$ MOV GETFLA,GETFLG ; Change to RDAF$ INC NOGRGL ; No group globals 1$: DIR$ #GETMCR ; GET MCR INPUT STRING MOV $DSW,R3 ; GET INPUT COUNT CLR EXF ; SET FOR IMMEDIATE EXIT CMP R3,#3 ; JUST THE PROMPT ? BGT 30$ ; BR IF MORE MOVB #SPACE,BUF-1 ; SET SPACE 10$: DIR$ #RPRM ; GET COMMAND LINE MOV IOSB+2,R3 ; GET INPUT CHAR COUNT BNE 20$ ; BR IF INPUT BR 100$ ; OR EXIT 20$: MOV #CR,SETOF ; MAKE OFFSET OK CALL LOWUP ; DO LOWER TO UPPER CONVERSION MOV R3,EXF ; SET EXIT FLAG ADD #4,R3 ; SET COUNT OK 30$: CLR R1 ; BLANKS SHOULD BE IGNORED MOV #KEY,R2 ; SETUP KEY TABLE MOV #GETMCR+G.MCRB,R4 ; SETUP POINTER TO INPUT STRING MOV #STAT,R5 ; SETUP POINTER TO FIRST STATE CLR EFNNUM ; MUST BE INITIALISED CLR TYPE MOV #-1,GRNUM ; INIT GROUP CLR ACTION ; INIT CLR TSKL ; NO TASK CALL .TPARSE ; PARSE THE STRING BCC 80$ ; NO ERROR CONTINUE MOV #GETMCR+G.MCRB,R0 ; LET R0 POINT BUFFER MOV #TXT,R1 ; POINT TEXT MOVB #CR,(R1)+ ; SET CR IN BUFFER MOVB SETOF,(R1)+ ; SET OFFSET 40$: CMP R0,R4 ; ERROR FOUND ? BEQ 50$ ; CONTINUE IF NOT MOVB #SPACE,(R1)+ ; SPACE FILL INC R0 ; COUNT POINTER BR 40$ 50$: MOVB #'^,(R1)+ MOV #CSE,R0 ; POINT SYNTAX ERROR TEXT MOVB (R0)+,R2 ; GET COUNT 60$: MOVB (R0)+,(R1)+ ; MOV ERROR TEXT CMP R1,#TXT+80. ; FULL ? BGT 70$ ; SCRAMM SOB R2,60$ ; AND DO WHOLE TEXT SUB #TXT,R1 ; MAKE COUNT OK MOV R1,OUT+Q.IOPL+2 DIR$ #OUT BR 90$ ; AND EXIT 70$: ERROR CSE ; COMMAND ERROR BR 90$ ; AND EXIT 80$: CALL DISPLA ; DO THE DISPLAY 90$: TST EXF ; SHOULD EXIT BNE 10$ ; BR IF NOT 100$: EXIT$S LOWUP: MOV #BUF,R0 ; GET BUFFER ADRES MOV R0,R1 ; KEEP CHARS IN SAME BUFFER MOV R3,R2 ; GET COUNT CALL $CVTUC ; CONVERT RETURN ; DISPLA: TST TSKL ; DOING SOMETHING LOCAL ? BEQ 10$ ; BR IF NOT CALL LOCAL ; DO THE LOCAL FLAGS BR 100$ ; AND EXIT 10$: TST GRNUM ; DOING SOMETHING GROUP GLOBAL BLT 20$ ; BR IF NOT TST NOGRGL ; Any groupglobals ? ;JHA04 BEQ 11$ ; Yes : => 11$ ;JHA04 ERROR NGL ; Error ;JHA04 BR 100$ ; Exit ;JHA04 11$: ;JHA04 CALL GGLOBL ; GO DO IT BR 100$ ; AND EXIT 20$: MOV TYPE,R0 ; GET TYPE BEQ 50$ ; NO TYPE GIVEN MUST HAVE NUMBER CMP R0,#'G ; GLOBAL ? BNE 40$ ; NO MUST BE GROUP GLOBAL DIR$ #GETFLG ; GET FLAGS MOV #33.,FLGINC ; SET INCREMENT MOV #FLGBUF,R1 ; USE R1 TO POINT 2 FLAGWORDS MOV FLAGS+4,(R1)+ ; GET FLAGS MOV FLAGS+6,(R1) ; GET FLAGS TO BUFFER CALL SHOW ; AND DISPLAY BR 100$ ; AND EXIT 40$: TST NOGRGL ; Any groupglobals ? ;JHA04 BEQ 41$ ; Yes : => 41$ ;JHA04 ERROR NGL ; Error ;JHA04 BR 100$ ; Exit ;JHA04 41$: ;JHA04 CALL SHOWGR ; SHOW GROUP GLOBAL FLAGS BR 100$ ; AND EXIT 50$: MOV EFNNUM,R0 ; GET FLAG NUMBER BGT 60$ ; MUST BE MORE THAN ZERO ERROR FNR ; ERROR FLAG NUMBER BR 100$ ; EXIT 60$: SUB #32.,R0 ; R0 NOW 1-64. BGT 70$ ; BR IF NOT ERROR NOT ; MUST HAVE TASK NAME BR 100$ ; AND EXIT 70$: CMP R0,#64. ; IN RANGE ? BLE 80$ ; BR IF OK ERROR FNR ; ERROR FLAG NUMBER OUTOF RANGE BR 100$ ; AND EXIT 80$: TST ACTION ; ACTION WANTED ? BNE 90$ ; BR IF SO CALL ONEFLG ; SHOW ONE FLAG BR 100$ ; AND EXIT 90$: CALL FLGACT ; DO ACTION ON FLAG 100$: RETURN FLGACT: MOV EFNNUM,R0 ; GET FLAG NUMBER CMP ACTION,#'S ; SET THE FLAG BNE 10$ ; NO CLEAR MOV R0,SETF+S.ETEF ; SET NUMBER DIR$ #SETF ; DO IT BR 20$ ; AND CONTINUE 10$: MOV R0,CLEF+C.LEEF ; SET FLAG DIR$ #CLEF 20$: CMP $DSW,#IS.CLR ; WAS CLEAR ? BNE 30$ ; NO CALL WASCLR ; SHOW IT BR 50$ ; EXIT 30$: CMP $DSW,#IS.SET ; FLAG SET ? BEQ 40$ CALL NGRERR ; MUST BE GROUP ERROR BR 50$ ; AND EXIT 40$: CALL WASSET ; SHOW IT 50$: RETURN ; ONEFLG: MOV EFNNUM,R0 ; GET FLAG NUMBER IN R0 CMP R0,#33. ; LOCAL FLAG ? BGE 10$ ; NO READ ALL FLAGS MOV #FLGBUF,R2 ; SET R2 TO POINT FLAGS BR 30$ ; AND DISPLAY 10$: DIR$ #GETFLG ; GET YOUR EVENT FLAGS CMP R0,#65. ; GLOBAL FLAG ? BLT 20$ ; YES CMP $DSW,#IS.CLR ; DO WE HAVE GROUP FLAGS BNE 20$ ; WE HAV CALL NGRERR ; DISPAY NO GROUP GLOBAL FLAGS BR 70$ ; AND EXIT 20$: MOV #FLAGS,R2 ; USE R2 TO POINT FLAG 30$: CMP R0,#16. ; TO BIG FOR THIS WORD BLE 40$ ; BR IF NOT SUB #16.,R0 ; DEC WORD TST (R2)+ ; INC BUFFER BR 30$ ; TRY AGAIN 40$: MOV (R2),R2 ; GET FLAG WORD 50$: ROR R2 ; ROTATE TO CARRY SOB R0,50$ ; TILL FINISHED MOV EFNNUM,R0 ; GET ORIGINAL FLAG NUMBER BCC 60$ ; NO CARRY WAS CLEAR CALL WASSET ; FLAG IN R0 WAS SET BR 70$ 60$: CALL WASCLR ; FLAG WAS CLEAR 70$: RETURN ; AND EXIT SHOW: MOV FLGINC,R0 ; GET INTIAL FLAG NUMBER CLR R5 ; USE AS ALL CLEAR FLG MOV FLGBUF,R1 ; GET FIRST WORD CALL 20$ ; DO THAT MOV FLGBUF+2,R1 ; NEXT WORD CALL 20$ TST R5 ; ALL CLEAR BNE 10$ ; BR IF NOT ERROR ACL ; ALL CLEAR 10$: RETURN ; AND EXIT 20$: MOV #16.,R2 ; GET COUNT 30$: ROR R1 ; SHIFT BCC 40$ ; BR IF CLEAR CALL WASSET ; FLAG R0 WAS SET INC R5 ; SET FLAG 40$: INC R0 ; NEXT NUMBER SOB R2,30$ ; DO ALL RETURN ; WASCLR: CALL $SAVAL ; SAVE REGISTERS MOV #CLTXT,R2 ; GET TEXT BR WASCOM WASSET: CALL $SAVAL MOV #SETXT,R2 WASCOM: MOV R0,R1 ; GET FLAG NUMBER MOV R2,R5 ; SAVE TRAILER TEXT MOV #TXT,R0 ; GET TEXT POINTER MOV #TXT1,R3 ; GET LEADER MOV #TXT1L,R4 ; AND LENGHT 10$: MOVB (R3)+,(R0)+ ; MOVE OVER SOB R4,10$ ; DO ALL MOV #13012,R2 ; CONVERSION MODE CALL $CBTA ; CONVERT MOV #CLTXTL,R4 ; GET TEXT 20$: MOVB (R5)+,(R0)+ ; MOVE OVER SOB R4,20$ SUB #TXT,R0 ; R0 IS COUNT MOV R0,OUT+Q.IOPL+2 DIR$ #OUT ; AND TYPE OUT RETURN ; SHOWGR: DIR$ #GETFLG ; GET ALL FLAGS CMP $DSW,#IS.CLR BNE 10$ ; BR IF FLAGS CALL NGRERR ; DISPAY NO GROUP GLOBAL FLAGS BR 20$ ; EXIT 10$: MOV #FLGBUF,R1 ; USE R1 TO POINT TWO FLAG WORDS MOV #65.,FLGINC ; SET CORRECT INCREMENT MOV FLAGS+10,(R1)+ ; SET IN BUFFER MOV FLAGS+12,(R1) ; TWO WORDS CALL SHOW ; SHOW IT ALL 20$: RETURN ; BACK TO CALLER NGRERR: MOV $HEADR,R0 ; GET MY CURRENT TASK HEADER MOVB H.CUIC+1(R0),R1 ; GET THE CURRENT GROUP BIC #177400,R1 ; NO SIGN EXTENSION PLEASE MOV #GRTXT,R0 ; GET ADRES TO SHOW MOV #17010,R2 ; SET CONVERSION TYPE CALL $CBTA ; CONVERT ERROR NGR ; SET TEXT RETURN ; AND EXIT ; LOCAL: CALL CONTSK ; CONVERT TASKNAME TO R50 BCS 60$ ; EXIT IF ERROR CALL FIND ; GO FIND THE TASK AND PICKUP FLAGS TST ERR ; TASK MAY NOT BE THERE BEQ 20$ ; BR IF YES BMI 10$ ; TASK NOT IN SYSTEM ERROR FNR ; ERROR FLAG NOT LOCAL BR 60$ ; AND EXIT 10$: ERROR TNS ; ERROR TASK NOT IN SYSTEM BR 60$ ; AND EXIT 20$: TST ACTION ; SET/CLR ? BEQ 40$ ; NO: => 40$ MOV EFNNUM,R0 ; TST STATUS ; SET/CLR BEQ 30$ ; CLR => 30$ CALL WASSET ; BR 60$ ; 30$: CALL WASCLR ; BR 60$ ; 40$: TST EFNNUM ; SEE IF FLAG NUMBER GIVEN BEQ 50$ ; NONE GIVEN DO ALL CALL ONEFLG ; DISPLAY BR 60$ ; AND EXIT 50$: MOV #1,FLGINC ; SET CORRECT INCREMENT CALL SHOW ; DISPLAY THEM ALL 60$: RETURN ; CONTSK: CLR TNAM+2 ; CLEAR TASK NAME+2 MOV TSKBUF,R0 ; POINT R0 TO TASK NAME MOV R0,R1 ; GET A COPY ADD TSKL,R1 ; POINT OVER BUFFER CLRB (R1) ; SET ZERO AS TERMINATOR MOV #1,R1 ; ASK FOR . TO BE INCLUDED CALL $CAT5 ; CONVERT MOV R1,TNAM ; GET FIRST TASK NAME PART BCS 10$ ; IF FINISH BR MOV #1,R1 ; ASK FOR . TO BE INCLUDED CALL $CAT5 ; TASK ANOTHER WORD MOV R1,TNAM+2 ; SET SECOND WORD BCS 10$ ; PREMATURE END ? MOVB (R0),R2 ; SET TERMINATOR 10$: TSTB R2 ; MUST BE ZERO BEQ 20$ ; THEN OK ERROR TNR ; TASK NAME ERROR SEC ; FLAG ERROR 20$: RETURN FIND: CLR ERR ; RESET ERROR CALL $SWSTK,110$ ;; TO SYSTEM STATE 10$: MOV $ACTHD,R5 ;; POINT THE ATL 20$: CMP TNAM,T.NAM(R5) ;; IS THAT MY TASK ? BNE 90$ CMP TNAM+2,T.NAM+2(R5) ;; SURE MY TASK ? BNE 90$ MOV T.EFLG(R5),FLGBUF ;; GET HIS LOCAL FLAGS MOV T.EFLG+2(R5),FLGBUF+2 ;;+ TST ACTION ;; SET/CLR ? BEQ 110$ ;; No: => 110$ MOV EFNNUM,R0 ;; R0 = EFN nr MOV #FLGBUF,R1 ;; R1 => Flagbuffer CMP R0,#33. ;; >= 33 ? BGE 80$ ;; Yes : => ERROR CMP R0,#16. ;; <= 16 ? BLE 30$ ;; Yes : => 30$ SUB #16.,R0 ;; Update TST (R1)+ ;; somethings 30$: CLR R2 ;; Our help SEC ;; 40$: ROL R2 ;; Position the SOB R0,40$ ;; bit. ;; CLR STATUS ;; BIT R2,(R1) ;; SET/CLR ? BEQ 50$ ;; INC STATUS ;; 50$: CMP ACTION,#'S ;; SET ? BNE 60$ ;; BIS R2,(R1) ;; SET BR 70$ ;; 60$: BIC R2,(R1) ;; CLEAR 70$: MOV FLGBUF,T.EFLG(R5) ;; MOV FLGBUF+2,T.EFLG+2(R5) ;; ;; BR 110$ 80$: INC ERR ;; BR 110$ ;; 90$: MOV T.ACTL(R5),R5 ;; GET NEXT TASK TST T.ACTL(R5) ;; END OF ATL ? BNE 20$ TST TNAM+2 ;; IF 3 LETTERS TASK BNE 100$ ;; THAN TRY ...TSK MOV TNAM,TNAM+2 MOV #^R...,TNAM BR 10$ ;; AND TRY TO FIND THAT 100$: DEC ERR 110$: RETURN ; LEAVE SYSTEM STATE AND RTS FROM FIND ; GGLOBL: MOV GRNUM,R0 ; GET GROUP NUMBER BEQ 10$ ; ZERO IS ILLEGAL CMP R0,#400 ; GROUP MUST BE BYTE BLT 20$ ; CONTINUE IF OK 10$: ERROR GER ; GIVE GROUP ERROR BR 80$ ; AND EXIT 20$: MOV EFNNUM,R0 ; GET NUMBER BEQ 40$ ; BR IF NO NUMBER GIVEN CMP R0,#64. ; MUST BE MORE THAN 64. BLE 30$ ; IF LESS FORGET CMP R0,#96. ; BUT NO OVER 96. BLE 40$ ; THEN OK 30$: ERROR IGR ; ILLEGAL AS GROUP FLAG BR 80$ ; AND EXIT 40$: CALL $SWSTK,50$ ;; GO TO SYSTEM STATE MOV $HEADR,R0 ;; POINT TASK HEADER MOVB GRNUM,H.CUIC+1(R0) ;; SET UIC TO INPUT RETURN ;; EXIT FROM SYSTEM STATE 50$: TST ACTION ; ACTION REQUIRED ? BEQ 60$ ; BR IF NOT CALL FLGACT ; DO FLAG ACTION BR 80$ ; AND RETURN 60$: TST EFNNUM ; ALL FLAGS WANTED ? BEQ 70$ ; BR IF SO CALL ONEFLG ; SHOW ONE FLAG BR 80$ 70$: CALL SHOWGR ; SHOW ALL FLAGS 80$: RETURN ; RETURN ; .END START