.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,,,,<TXT,TXTL,40>
;
GETMCR:	GMCR$				; GET MCR INPUT
	BUF=	GETMCR+G.MCRB+4		; INPUT BUFFER
	BUFL=	.-BUF			; MAX LENGHT
;
RPRM:	QIOW$	IO.RPR,1,1,,IOSB,,<BUF,BUFL,,PRM,PRML,44>
;
	.SBTTL	DIRECT EQUATED SYMBOLS
	SPACE=	40
	CR=	15
;
	.SBTTL	TEXTEN
	.NLIST	BEX
PRM:	.ASCII	/EFN>/
	PRML=	.-PRM
;
CTXT:	.ASCII	<CR>/EFN -- /
	CTXTL=	.-CTXT
CSE:	.ASCII	<CSEL>/ - Syntax error/
	CSEL=	.-CSE-1
FNR:	.ASCII	<FNRL>/Illegal flag number/
	FNRL=	.-FNR-1
NGL:	.ASCII	<NGLL>/System does not support group-global flags/	;JHA04
	NGLL=	.-NGL-1							;JHA04
NGR:	.ASCII	<NGRL>/Group /
GRTXT:	.ASCII	/xxx/
	.ASCII	/ has no group global event flags/
	NGRL=	.-NGR-1
NOT:	.ASCII	<NOTL>/No task name specified/
	NOTL=	.-NOT-1
TNS:	.ASCII	<TNSL>/Task not active/
	TNSL=	.-TNS-1
ACL:	.ASCII	<ACLL>/All flags clear/
	ACLL=	.-ACL-1
TNR:	.ASCII	<TNRL>/Task name error/
	TNRL=	.-TNR-1
GER:	.ASCII	<GERL>/Illegal group number/
	GERL=	.-GER-1
IGR:	.ASCII	<IGRL>/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