.MCALL	.MODULE
.MODULE SYSMAC,VERSION=182,COMMENT=<System macro library>,LIB=YES

.SBTTL  ...CM.  Copyright statement
.MACRO  ...CM.
.REM %
 Copyright (c) 1998 by Mentec, Inc., Nashua, NH.
 All rights reserved

 This software is furnished under a license for use only on a
 single computer system and  may  be  copied  only  with  the
 inclusion of the above copyright notice.  This software,  or
 any other copies thereof, may not be provided  or  otherwise
 made available to any other person except for  use  on  such
 system and to one who agrees to these license  terms.  Title
 to  and  ownership of the software shall at all times remain
 in Mentec, Inc.

 The information in this document is subject to change without
 notice and should not be construed as a commitment by Digital
 Equipment Corporation, or Mentec, Inc.

 Digital and Mentec  assume  no  responsibility for the use or
 reliability of its software on equipment which is not supplied
 by Digital  or Mentec,  and listed  in the  Software  Product
 Description.
%
.ENDM
;+
;COND
;	MAC$ER	(0)	test error message generation
;		 0	do not (expect clean assembly)
;		 1	do (expect error messages from assembly)
;-
;+TEST
;++
; SYSMAC.MAC can be assembled to test macro definitions and to do some
; crosschecking of interdependencies of some macro definitions.  If the
; symbol MAC$ER is not defined or is defined as 0 no error message
; generation testing will be done, that is, any error message produced
; from the assembly of SYSMAC would be a real error.  If MAC$ER is 1,
; then many error messages may be produced (to test the correct detection
; of error conditions).  Note that some (many) aspects of macro definitions
; will not be checked.
;
;	NOTE: For proper testing SYSMAC.SML should correspond to the
;	same version as SYSMAC.MAC.
;--
.NLIST	BEX
.PSect	Active	;contains executable testing of SYSMAC
.Enabl	LSB

	.MCall	.Print	.TrpSet
	.MCall	.Assume

	.Library "SRC:SYSTEM"
	.MCall	.EMTDf
	.EMTDf

Debug::				;Entry point to test tests
	BPT
Active::			;Entry point for tests
	.TrpSet	#Area,#Err410	;Return error message


.PSect	Servic
Err410:
	Mov	SP,Error	;Indicate error
	Mov	R0,-(SP)
	.Print	#Msg410		;Trap to 4/10 error message
	.TrpSet	#Err410		;Return error message
	Mov	(SP)+,R0
	RTI

BegTst:
	.Print	R0		;ident subtest
	Br	20$		;clear error flag

SkpTst:
	.Print	#SkipT		;test not (yet) written
	BisB	#Warn$,@#UsErrB	; Indicate warning in exit code
	Inc	WarCnt		;count warnings
	Return

TemTst:
	.Print	#SytemT		;tested in SYSTEM
	Return

EndTst:
	Tst	Error
	Bne	10$		;AOK
	.Print	#TestOK		;no failures
	Br	20$		;return
10$:
	.Print	#TestEr		;Not OK
	BisB	#Error$,@#UsErrB ; Indicate error in exit code
20$:
	Clr	Error		;no errors
	Return

AreaSz	=:	10.		;EMT block area size

AreaM1:				;Set AREA to -1
	Mov	R5,-(SP)	;save
	Mov	#Area,R5	;Point to area
	.Rept	AreaSz		;Clear whole area
	Mov	#-1,(R5)+	;set to -1
	.EndR
	Mov	(SP)+,R5	;restore
	Return

.IRpC	x,<123456789>
Err'x:
	Mov	#Test'x'F,R0
	Br	FlgErr
.EndR
.IRp	x,<1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr1
.EndR
.IRp	x,<2.1,2.2,2.3,2.4,2.5,2.6,2.7,2.8,2.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr2
.EndR
.IRp	x,<3.1,3.2,3.3,3.4,3.5,3.6,3.7,3.8,3.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr3
.EndR
FlgErr:
FlgEr1:	
FlgEr2:	
FlgEr3:	
	Br	FlgEr4
.IRp	x,<4.1,4.2,4.3,4.4,4.5,4.6,4.7,4.8,4.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr4
.EndR
.IRp	x,<5.1,5.2,5.3,5.4,5.5,5.6,5.7,5.8,5.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr5
.EndR
.IRp	x,<6.1,6.2,6.3,6.4,6.5,6.6,6.7,6.8,6.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr6
.EndR
.IRp	x,<7.1,7.2,7.3,7.4,7.5,7.6,7.7,7.8,7.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr7
.EndR
FlgEr4:	
FlgEr5:	
FlgEr6:	
FlgEr7:	
	Br	FlgEr8
.IRp	x,<8.1,8.2,8.3,8.4,8.5,8.6,8.7,8.8,8.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr8
.EndR
.IRp	x,<9.1,9.2,9.3,9.4,9.5,9.6,9.7,9.8,9.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgEr9
.EndR
.IRp	x,<A.1,A.2,A.3,A.4,A.5,A.6,A.7,A.8,A.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErA
.EndR
.IRp	x,<B.1,B.2,B.3,B.4,B.5,B.6,B.7,B.8,B.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErB
.EndR
FlgEr8:	
FlgEr9:	
FlgErA:	
FlgErB:	
	Br	FlgErC
.IRp	x,<C.1,C.2,C.3,C.4,C.5,C.6,C.7,C.8,C.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErD
.EndR
.IRp	x,<D.1,D.2,D.3,D.4,D.5,D.6,D.7,D.8,D.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErE
.EndR
.IRp	x,<E.1,E.2,E.3,E.4,E.5,E.6,E.7,E.8,E.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErF
.EndR
.IRp	x,<F.1,F.2,F.3,F.4,F.5,F.6,F.7,F.8,F.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErG
.EndR
FlgErC:	
FlgErD:	
FlgErE:	
FlgErF:	
	Br	FlgErG
.IRp	x,<G.1,G.2,G.3,G.4,G.5,G.6,G.7,G.8,G.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErH
.EndR
.IRp	x,<H.1,H.2,H.3,H.4,H.5,H.6,H.7,H.8,H.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErI
.EndR
.IRp	x,<I.1,I.2,I.3,I.4,I.5,I.6,I.7,I.8,I.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErJ
.EndR
FlgErG:	
FlgErH:	
FlgErI:	
FlgErJ:	
	Br	FlgErK
.IRp	x,<J.1,J.2,J.3,J.4,J.5,J.6,J.7,J.8,J.9>
Err'x:
	Mov	#Tst'x,R0
	Br	FlgErK
.EndR
FlgErK:
	.Print
	Mov	SP,Error
	Inc	ErrCnt
	Return

.Dsabl	LSB
.PSect	Data	;contains word data for executable testing of SYSMAC

	Zero	=:000000	;symbolic zero
	Patter	=:153535	;odd pattern for initing before testing
	UsErrB	=:53
		Warn$ =:2	; warn bit
		Error$=:4	; error bit

Error:	.BlkW	1		;error flag
WarCnt:	.BlkW	1		;number of warnings
ErrCnt:	.BlkW	1		;number of errors
Area:	.BlkW	AreaSz		;EMT block area

.PSect	Text	;contains text data for executable testing of SYSMAC

MSG410:	.Asciz	"?SYSMAC-E-Trap to 4/10"

TestOK:	.Asciz	"%SYSMAC-I-Successful test(s) for this request"
TestER:	.Asciz	"?SYSMAC-W-Unsuccessful test(s) for this request"

SkipT:	.Asciz	"?SYSMAC-W-No test written"

SytemT:	.Asciz	"%SYSMAC-I-Tested in SYSTEM.MAC"

.IRpC	X,<123456789>
Test'x'F:	.ASCIZ	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<2.1,2.2,2.3,2.4,2.5,2.6,2.7,2.8,2.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<3.1,3.2,3.3,3.4,3.5,3.6,3.7,3.8,3.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<4.1,4.2,4.3,4.4,4.5,4.6,4.7,4.8,4.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<5.1,5.2,5.3,5.4,5.5,5.6,5.7,5.8,5.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<6.1,6.2,6.3,6.4,6.5,6.6,6.7,6.8,6.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<7.1,7.2,7.3,7.4,7.5,7.6,7.7,7.8,7.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<8.1,8.2,8.3,8.4,8.5,8.6,8.7,8.8,8.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<9.1,9.2,9.3,9.4,9.5,9.6,9.7,9.8,9.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<A.1,A.2,A.3,A.4,A.5,A.6,A.7,A.8,A.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<B.1,B.2,B.3,B.4,B.5,B.6,B.7,B.8,B.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<C.1,C.2,C.3,C.4,C.5,C.6,C.7,C.8,C.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<D.1,D.2,D.3,D.4,D.5,D.6,D.7,D.8,D.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<E.1,E.2,E.3,E.4,E.5,E.6,E.7,E.8,E.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<F.1,F.2,F.3,F.4,F.5,F.6,F.7,F.8,F.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<G.1,G.2,G.3,G.4,G.5,G.6,G.7,G.8,G.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<H.1,H.2,H.3,H.4,H.5,H.6,H.7,H.8,H.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<I.1,I.2,I.3,I.4,I.5,I.6,I.7,I.8,I.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR
.IRp	X,<J.1,J.2,J.3,J.4,J.5,J.6,J.7,J.8,J.9>
Tst'x':	.Asciz	"?SYSMAC-E-Test 'x' failed"
.EndR

.Even

.PSect	Static	;contains static testing (.assumes) of SYSMAC

.IIf	NDF	MAC$ER	MAC$ER=0
.IIf	NE	MAC$ER	MAC$ER=1
;-TEST
.Page
;++
;	RESERVED SYMBOL NAMES
;	---------------------
;
;	...V1	GLOBAL -- controls .MCALLing of ...CM* & support of V1, V2 and
;			V3 versions of the expansions.
;			NDF means ...CM* not .MCalled
;			= 1 means use version 1 EMTs
;			= 2 means use version 2 EMTs
;			= 3 means use version 3(+) EMTs
;	...V1%	GLOBAL -- counts entries in .DRFMS by letter (%)
;	...V2	LOCAL -- reusable in macro def'ns as local symbols
;	...V3	LOCAL -- reusable in macro def'ns as local symbols
;	...V4	LOCAL -- reusable in macro def'ns as local symbols
;	...V5	GLOBAL -- controls generation of .AUDIT information.
;			NDF means first call to .AUDIT
;			= Location counter for .AUDIT information words
;	...V6	GLOBAL -- used to prevent phase errors between pass1 and pass2
;			in the .AUDIT macro.
;			accumulates RAD50 of MODULE argument of .MODULE call
;			to compare against ...V27 and ...V28 to detect
;			the start of pass 2
;	...V7	GLOBAL -- used to pass OFFSET= setting from .DRBOT to .DREND
;			NDF means .DRBOT OFFSET=YES not specified
;			= -1 same as NDF
;			= 0 means .DRBOT OFFSET=YES was specified
;	...V8	GLOBAL -- used to pass info from ...CMZ to ...CMY
;			= checksum value for ...CMZ
;	...V9	GLOBAL -- used to pass info between .DRPTR & DRBEG
;			NDF means first invocation of any of .DR(PTR,BEG)
;			bits 4--0 are from .DRPTR & or'ed into NOP in .DRBEG
;			bit 4 is set by .DRBEG if UNIT64 specified in .DRDEF
;				or (ADDRCK or SPFUN or NSPFUN) specified in .DRBEG
;				It means the NOP is followed by BR and H1.FG2
;				and possibly more pointers
;			bit 3 is .DRPTR UNLOAD=x; 1 means present
;			bit 2 is .DRPTR LOAD=x; 1 means present
;			bit 1 is .DRPTR RELEASE=x; 1 means present
;			bit 0 is .DRPTR FETCH=x; 1 means present
;	...V10	LOCAL -- reusable in macro def'ns as local symbols
;	...V11	LOCAL -- reusable in macro def'ns as local symbols
;	...V12	GLOBAL -- used to pass info among .DRSPFs
;	...V13	GLOBAL -- used to pass info among .DRSPFs
;	...V14	GLOBAL -- used to pass info among .DRSPFs
;	...V15	GLOBAL -- used to pass info among .DRSPFs
;	...V16	GLOBAL -- used to pass info among .DRSPFs
;	...V17	GLOBAL -- used to pass info among .DRSPFs
;			...V12, ...V13, & ...V14 are the NN portion
;			of NNX spfun codes.  If = 0 means this pair
;			(...V12/...V15, ...V13/...V16, & ...V14/...V17)
;			are not in use (yet).
;			...V15, ...V16, & ...V16 are a bit mask corresponding
;			to the X code(s) found for a specific NN value.
;			If ...V15 is NDF, this is the first call to .DRSPF
;			& ...V12--...V17 are set to zero
;	...V18	GLOBAL -- used to pass MOD byte information between .DRPTR &
;			.DREST
;			bits 7--0 are MOD value from .DREST and .DRPTR
;			bits 15-8 are reserved
;	...V19	GLOBAL -- used to pass CQE information among .DRDEF, .DREST,
;			 .DRPTR, & .DRBEG of bits to be set in ddCQE word.
;			bit 15 is .DRPTR FETCH=*NO* flag; 1 means present
;			bit 15 is or'ed into CQE in .DRBEG
;			bit 14 is .DREST MOD2=DV2.V2 flag; 1 means a second
;			 display only vector table follows the first vector
;			 table in the handler.
;			bit 13 is .DRPTR LOAD=*NO* flag; 1 means present
;			bit 12 is .DRDEF DMA=YES or PERMUMR=x (DV2.DM) flag;
;			 1 means present
;			bits 11-0 are reserved
;	...V20	GLOBAL -- used to pass information to .DRUSE from .DRDEF.
;			Set to 0 by .DRDEF, if zero when .DRUSE is invoked,
;			H.USER in block zero is pointed to the .DRUSE entry.
;			.DRUSE then sets ...V20 non-zero
;
;	...V21	GLOBAL -- used to pass information to .DRTAB from .DRDEF.
;			Set to 0 by .DRDEF, if zero when .DRTAB is invoked,
;			H.DATA in block zero is pointed to the .DRTAB entry.
;			.DRTAB then sets ...V21 non-zero
;
;	...V22	GLOBAL -- used to pass information to .DRBEG and .DREND 
;			from .DRDEF.
;			Set to 0 by .DRDEF if UNIT64, DMA, OR PERMUMR not 
;			specified.  40000 bit set by .DRDEF if UNIT64 is 
;			specified.  10000 bit set by .DRDEF if DMA = YES
;			or PERMUMRs are specified.
;			4000 bit set by .DRDEF if SERIAL = YES is specified.
;			If non-zero when .DRBEG is invoked, H1.FG2 et al
;			are generated and ...V22 value is "or'ed" in.
;			If non-zero when .DREND is invoked, a 64-unit
;			extended owner table is generated following the
;			handler's table of vectors into the monitor.
;
;	...V23	GLOBAL -- used to pass information from .DEBUG to .DPRINT.
;			This variable contains the bit(s) that select debug
;			class(es) of messages to print.  0 indicates no
;			output, each bit set on indicates a class.
;
;	...V24	GLOBAL -- used to pass information from .DEBUG to .DPRINT.
;			If zero, indicates PIC is not required, if non-zero
;			PIC is to be generated.
;
;	...V25  GLOBAL -- used to indicate the first invocation of .DRFMS
;			(set in .DRFMT to 0) If .DRFMS is entered with ...V25
;			set to 0, it generates the default switch list and
;			sets ...V25 to 1.
;	...V26	GLOBAL -- used to distinguish between pass1 and pass2
;			in the .DRFMS macro. (set in .DRFMT)
;			NDF means starting PASS 1 of assembly
;			= 1 means PASS 1 of assembly
;			= 2 means PASS 2 of assembly
;			= 3 means PASS 2 1-time code generated
;	...V27	GLOBAL -- used to prevent phase errors between pass1 and pass2
;			in the .AUDIT macro.
;			accumulates RAD50 of first three characters of MODULE
;			argument on the first call of .MODULE macro
;	...V28	GLOBAL -- used to prevent phase errors between pass1 and pass2
;			in the .AUDIT macro.
;			accumulates RAD50 of second three characters of MODULE
;			argument on the first call of .MODULE macro
;
;	...V*	-- are reserved for more local and global values
;
;	CK.*	-- are used globally when the .CKXX macro is used
;		    to define CK.* macros.  The * strings correspond
;		    to the entries in the .CKXX argument list
;
.Page
;	RESERVED MACRO NAMES
;	--------------------
;
;	..V1..	GLOBAL -- select V1 macro expansions
;	..V2..	GLOBAL -- select V2 macro expansions
;	.MACS	GLOBAL -- default to V3 macro expansions
;	...CM0	GLOBAL -- move a word to the stack, optionally gen EMT
;	...CM1	GLOBAL -- point R0 to AREA, set the CHAN and IC (subcode)
;	...CM2	GLOBAL -- move a word/byte to OFFSET(R0), optionally gen EMT
;	...CM3	GLOBAL -- move a channel and code to R0, gen EMT 374
;	...CM4	GLOBAL -- setup a SDAT/RCVD EMT request
;	...CM5	GLOBAL -- move a word/byte (not R0) to R0, optionally gen EMT
;	...CM6	GLOBAL -- point R0 to area, move chan and code to @R0,
;			  then do ...CM2
;	...CM7	GLOBAL -- setup a READ_/WRIT_ EMT request
;	...CM8	LOCAL  -- macro used within .DRSPF
;	...CM9	LOCAL  -- macro used within .DRFMS
;	...CMB	GLOBAL -- macro used for mapping extension to several EMTs
;	...CMC	GLOBAL -- setup a DSTAT/FETCH EMT request
;	...CMV	GLOBAL -- defines system version number for BSTRAP/RMON*/VIDEO
;	...CMY	GLOBAL -- generate bomb code
;	...CMZ	GLOBAL -- generate bomb code
;	...CM.	?????? -- DEC copyright (so it appears in libraries)
;	...CM*	-- are reserved for more local and global macros
;--
.Page
;+
;ERROR
;
;	Error Messages
;
;?BOOT-U-I/O error
;
;	.DREND message generated for boot blocks
;
;?SYSMAC-MESSAGE;
;
;	.ASSUME	optional user specified message
;
;?SYSMAC-W-A R E A ignored when stack form used;
;
;	.CMAP,.GCMAP, and .MSDS if AREA is specified and
;	CODE=SP|STACK
;
;?SYSMAC-W-"A REL C" is not true;
;
;	.ASSUME	The relationship (REL) between A and C is
;		not true.
;
;?SYSMAC-E-Argument interrelationship too complex;
;
;	...CMC	Arguments overwhelm macro definition
;
;
;?SYSMAC-W-D A T A table specified, but no T Y P E;
;
;	.DREST	The address of a data table is specified,
;		but the type of table is not specified.
;
;?SYSMAC-E-.DEBUG must be used before .DPRINT;
;
;	.DPRINT	.DPRINT wss used, but .DEBUG, which sets up
;		for .DPRINT has not been previously invoked.
;
;?SYSMAC-E-Expecting a single letter, found - UNIT64;
;
;	.DRDEF	The letter to use for the 64 unit version of
;		the handler was incorrectly specified.
;
;?SYSMAC-E-Invalid A D R, expecting #..., found - ADR;
;
;	.ADDR	The address specified was not in the form of
;		an immediate reference.
;
;	.CALLK	The destination specified was not in the
;		form of an immediate reference, and PIC was
;		specified. 
;
;?SYSMAC-E-Invalid argument, #0 in first argument position;
;
;	.CSIGEN
;	.CSISPC	The first argument was specified as #0.
;		This will cause the request to be treated as
;		a .GTLIN request.
;
;?SYSMAC-W-Invalid argument, use #0, not 0;
;
;	generally applicable to macros
;	[...CM0]
;	[...CM1]
;	[...CM2]
;	.DELETE
;	.WAIT	A value was specified as 0, it should have
;		been specified as #0.
;
;?SYSMAC-E-Invalid BMODE, found - 'BM';
;
;	...CMB	expecting UD, SD, CD, UI, SI, or CI
;
;?SYSMAC-E-Invalid C O N T R O L, found - CONTROL;
;
;	.DRBOT	Expecting a (possible combination of) UBUS,
;		QBUS, CBUS, UMSCP, QMSCP, or CMSCP.
;
;?SYSMAC-E-Invalid CMODE, found - 'CM';
;
;	...CMB	expecting U or S
;
;?SYSMAC-E-Invalid date, found - 'MON';
;
;	...CMZ	The expiration month was incorrectly
;	specified. ***DO NOT DOCUMENT***
;
;?SYSMAC-E-Invalid D M A, expecting YES/NO, found - DMA;
;
;	.DRDEF	
;
;?SYSMAC-E-Invalid O P T I O N, expecting NO/NUM/OCT, found - X;
;
;	.DRSET
;
;?SYSMAC-E-Invalid R E G, expecting Rx/@Rx/-(SP), found - REG;
;
;	.ADDR
;
;?SYSMAC-E-Invalid R E T U R N, expecting N,Z,V,C found - 'return';
;
;	.CALLS
;
;?SYSMAC-E-Invalid S I D E S, expecting 1/2, found - SIDES;
;
;	.DRBOT
;
;?SYSMAC-E-Invalid T Y P E, expecting MOV/BIC/BIS, found - TYPE;
;
;	.POKE
;	.PVAL
;
;?SYSMAC-E-Invalid T Y P E, expecting GET/MOV/BIC/BIS/USER, found - TYPE;
;
;	.SFINF
;	.SFSTA
;
;?SYSMAC-E-Invalid T Y P E, expecting OCT/DEC, found - TYPE;
;
;	.DPRINT
;
;?SYSMAC-W-Value specified for U C O D E, but T Y P E=TYPE;
;
;	.SFINF
;	.SFSTA
;
;?SYSMAC-E-Invalid T Y P E, expecting O/R/W/M/T, found - TYPE;
;
;	.DRSPF
;
;?SYSMAC-E-Invalid U N I T 6 4, expecting YES/NO, found - UNIT64;
;
;	.DRDEF

;?SYSMAC-E-Not at location TO;
;
;	.BR

;?SYSMAC-E-Odd or invalid vector specified;
;
;	.DRBEG
;	.DRVTB
;
;?SYSMAC-E-P R M U M R value > 7;
;
;	.DRDEF
;
;?SYSMAC-E-Primary boot too large;
;
;	.DREND
;
;?SYSMAC-E-SPFUN values must be negative;
;
;	[...CM8]
;	.DRSPF
;
;?SYSMAC-E-S W I T C H value unknown, use ON or OFF;
;
;	.DEBUG	The user specified something other than
;		ON or OFF (or any case insensitive version of same)
;
;?SYSMAC-W-This operation may produce random results;
;
;	.ADDR	The user specified adding the PIC address
;		calculated by .ADDR to the word ABOVE the
;		stack.
;
;?SYSMAC-E-TO is not defined;
;
;	.BR	Symbol referenced in .BR is not defined
;
;?SYSMAC-E-Too many different NN_ SPFUN codes;
;
;	.DRSPF	
;
;?SYSMAC-E-U N I T 6 4 = N O and NAME'$N64 = 1
;
;	.DRDEF	SYSGEN conditional for this handler is set for
;		64 unit support, but this handler does not
;		support 64 units.
;-
.SbTtl	..V1..	Select V1 macro generation, .MCall ..CM(0-7)
;++
;	..V1..
;
;	.MCALL the support routines and set the version to 1
;--

.MACRO	..V1..
.MCALL	...CM0,...CM1,...CM2,...CM3,...CM4,...CM5,...CM6,...CM7,...CMB,...CMC
...V1=1
.ENDM

;+TEST
...V1=-1
..V1..
.Assume	...V1 EQ 1 <...V1 ; ..V1.. generated wrong ...V1 value>
;-TEST

.SbTtl	..V2..	Select V2 macro generation, .MCall ..CM(0-7)
;++
;	..V2..
;
;	.MCALL the support routines and set the version to 2
;--

.MACRO	..V2..
.MCALL	...CM0,...CM1,...CM2,...CM3,...CM4,...CM5,...CM6,...CM7,...CMB,...CMC
...V1=2.
.ENDM

;+TEST
...V1=-1
..V2..
.Assume	...V1 EQ 2. <...v1 ; ..V2.. generated wrong ...V1 value>
;-TEST

.SbTtl	.MACS	Select V3+ macro generation, .MCall ..CM(0-7)
;++
;	.MACS
;
;	.MCALL the support routines and set the version to [>=]3
;--

.MACRO	.MACS
.MCALL	...CM0,...CM1,...CM2,...CM3,...CM4,...CM5,...CM6,...CM7,...CMB,...CMC
...V1=3.
.ENDM

;+TEST
...V1=-1
.Macs
.Assume	...V1 EQ 3 <...V1 ;.MACS generated wrong ...V1 value>
;-TEST

.Page
.SbTTl	...CM0	Move a word to the stack, optionally gen EMT
;++
;	...CM0
;
;	Move a word to the stack. If argument blank or #0
;	Put a 0 on the stack.  If second argument present,
;	generate an EMT with that value
;--

.MACRO	...CM0	STARG,INS
.IF B <STARG>
	CLR	-(SP)
.IFF
.IF IDN <STARG>,#0
	CLR	-(SP)
.IFF
.IIF IDN <STARG> <0> .ERROR;?SYSMAC-W-Invalid argument, use #0, not 0;
	MOV	STARG,-(SP)
.ENDC
.ENDC
.IF NB <INS>
	EMT	^o<INS>
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$..CM0:	.Asciz	"%SYSMAC-I-Testing ...CM0"
.PSect	Active
	Mov	#$..CM0,R0	;Ident the test
	Call	BegTst
	Mov	SP,R5		;save old SP pointer value
	Mov	#Patter,-(SP)	;try to insure old strange pattern
	Tst	(SP)+		;restore stack
..CM01:	...CM0
	Tst	@SP		;is the top of the stack 0?
	Beq	10$		;yes
	Call	Err1
10$:
	Mov	#Patter,-(SP)	;try to insure old strange pattern
	Tst	(SP)+		;restore stack
..CM02:	...CM0	#0
	Tst	@SP		;is the top of the stack 0?
	Beq	20$		;yes
	Call	Err2
20$:
	Mov	#Patter,-(SP)	;try to insure old strange pattern
	Tst	(SP)+		;restore stack
..CM03:	...CM0	#100001
	Cmp	@SP,#100001	;is the top of the stack right
	Beq	30$		;yes
	Call	Err3
30$:
..CM04:	...CM0	,377
.=.-2.
35$:
.=.+2.

	Cmp	#EMT+^o377,35$	;correct EMT code?
	Beq	40$		;yes
	Call	Err4
40$:
	Mov	R5,SP		;restore stack
.If	NE	MAC$ER
;Expect P error
...CM0	0
	Mov	R5,SP		;restore stack
.EndC
	Call	EndTst
.DSABL	LSB
;-TEST

.Page
.SbTtl	...CM1	Point R0 to AREA, Set CHAN & IC in 1st word, ARG in 2nd word,
.SbTtl	.		Opt gen EMT 375
;++
;	...CM1
;
;	Setup R0 to point to AREA, set the CHAN and IC (subcode)
;	value in first word.  This macro optimises number of
;	instructions to set up first word.
;	IC is forced to decimal.
;	ARG is set in the second word of AREA
;
;	...V1 used (in ...CM2)
;	...V2 used
;--

.MACRO	...CM1	AREA,IC,CHAN,FLAG,ARG,INS,CSET,BB
...CM5	<AREA>
...V2=0
.IF B <FLAG>
.IIF B <AREA>,...V2=1
.IFF
.IIF DIF <FLAG>,SET,...V2=1
.ENDC
.IF NE ...V2
.IF IDN <CHAN>,<#0>
	CLRB	@R0
.IFF
.IF NB <CHAN>
	MOVB	CHAN,@R0
.ENDC
.ENDC
.IFF
.IF B <CHAN>
	MOVB	#IC'.,1(R0)
.IFF
.NTYPE ...V2,CHAN
.IF EQ ...V2-^o27
	MOV	CHAN+<IC'.*^o400>,@R0
.IFF
	MOV	#IC'.*^o400,@R0
	MOVB	CHAN,@R0
.ENDC
.ENDC
.ENDC
.IIF IDN <CHAN> <0> .ERROR;?SYSMAC-W-Invalid argument, use #0, not 0;
...CM2	<ARG>,2,INS,CSET,BB
.ENDM

;+TEST
;		Area	IC	Chan	Flag	Arg	Ins	CSet	BB
;1		  -	132	  -	  -
;2		  -	132	  -	SET
;3		  -	132	  -	NOSET
;4		  -	132	277	  -
;5		  -	132	277	SET
;6		  -	132	277	NOSET
;7		#Area	132	  -	  -	#123456
;8		#Area	132	  -	SET	-	E	C	B
;9		#Area	132	  -	NOSET	#123	E	C	B
;10		#Area	132	277	  -
;11		#Area	132	277	SET
;12		#Area	132	277	NOSET

.Enabl	LSB
.PSect	Text
$..CM1:	.Asciz	"%SYSMAC-I-Testing ...CM1"
.PSect	Active
	Mov	#$..CM1,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM11:	...CM1	,132
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes	
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM12:	...CM1	,132,FLAG=SET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	60$		;yes	
	Call	Err2.2		;no
60$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM13:	...CM1	,132,FLAG=NOSET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	100$		;yes	
	Call	Err3.2		;no
100$:
	CmpB	#-1.,(R1)+	;is IC unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM14:	...CM1	,132,#277
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	130$		;yes
	Call	Err4.1		;no
130$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	140$		;yes	
	Call	Err4.2		;no
140$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	150$		;yes
	Call	Err4.3		;no
150$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	160$		;yes
	Call	Err4.4		;no
160$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM15:	...CM1	,132,#277,FLAG=SET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	170$		;yes
	Call	Err5.1		;no
170$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	180$		;yes	
	Call	Err5.2		;no
180$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	190$		;yes
	Call	Err5.3		;no
190$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	200$		;yes
	Call	Err5.4		;no
200$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM16:	...CM1	,132,#277,FLAG=NOSET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	210$		;yes
	Call	Err6.1		;no
210$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	220$		;yes	
	Call	Err6.2		;no
220$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	230$		;yes
	Call	Err6.3		;no
230$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	240$		;yes
	Call	Err6.4		;no
240$:
	Call	AreaM1
..CM17:	...CM1	#Area,132
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	250$		;yes
	Call	Err7.1		;no
250$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	260$		;yes	
	Call	Err7.2		;no
260$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	270$		;yes
	Call	Err7.3		;no
270$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	280$		;yes
	Call	Err7.4		;no
280$:
	Call	AreaM1
..CM18:	...CM1	#Area,132,,SET,,E,C,B
	.=.-2			;smash EMT
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	290$		;yes
	Call	Err8.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes	
	Call	Err8.2		;no
300$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	310$		;yes
	Call	Err8.3		;no
310$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	320$		;yes
	Call	Err8.4		;no
320$:
.PSect	Data
	...CM1	#Area,132,,SET,,E,C,B
330$:
.PSect	Active
	Cmp	#EMT+375,330$-2 ;is the EMT generated correctly?
	Beq	340$		;yes
	Call	Err8.5		;no
340$:
	Call	AreaM1
..CM19:	...CM1	#Area,132,,NOSET,#123,E,C,B
	.=.-2			;smash EMT
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	350$		;yes
	Call	Err9.1		;no
350$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	360$		;yes	
	Call	Err9.2		;no
360$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	370$		;yes
	Call	Err9.3		;no
370$:
	CmpB	#123,(R1)+	;is ARG (BYTE) set?
	Beq	380$		;yes
	Call	Err9.4		;no
380$:
	CmpB	#-1,(R1)+	;is ARG high byte unchanged?
	Beq	390$		;yes
	Call	Err9.4		;no
390$:
.PSect	Data
	...CM1	#Area,132,,SET,,E,C,B
400$:
.PSect	Active
	Cmp	#EMT+375,400$-2 ;is the EMT generated correctly?
	Beq	410$		;yes
	Call	Err9.5		;no
410$:
	Call	AreaM1
..CM1A:	...CM1	#Area,132,#277
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	420$		;yes
	Call	ErrA.1		;no
420$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	430$		;yes	
	Call	ErrA.2		;no
430$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	440$		;yes
	Call	ErrA.3		;no
440$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	450$		;yes
	Call	ErrA.4		;no
450$:
	Call	AreaM1
..CM1B:	...CM1	#Area,132,#277,FLAG=SET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	460$		;yes
	Call	ErrB.1		;no
460$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	470$		;yes	
	Call	ErrB.2		;no
470$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	480$		;yes
	Call	ErrB.3		;no
480$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	490$		;yes
	Call	ErrB.4		;no
490$:
	Call	AreaM1
..CM1C:	...CM1	#Area,132,#277,FLAG=NOSET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	500$		;yes
	Call	ErrC.1		;no
500$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	510$		;yes	
	Call	ErrC.2		;no
510$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	520$		;yes
	Call	ErrC.3		;no
520$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	530$		;yes
	Call	ErrC.4		;no
530$:
.If	NE	MAC$ER
;Expect P error
...CM1	,,0
.EndC
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	...CM2	Move an ARG to OFFSET(R0), Opt MOVB, Opt gen EMT 375
;++
;	...CM2
;
;	Move an argument value to OFFSET(R0).
;	Use a CLR_ if the value is #0.
;	Offset is forced to decimal.
;	BB is blank or B for byte operations
;	If INS NB generate an EMT 375
;
;	...V1 used
;--

.MACRO	...CM2	ARG,OFFSE,INS,CSET,BB
.IF B <ARG>
.IF NB <CSET>
.IF NE ...V1-3.
	CLR'BB	OFFSE'.(R0)
.ENDC
.ENDC
.IFF
.IF IDN	<ARG>,#0
	CLR'BB	OFFSE'.(R0)
.IFF
.IIF IDN <ARG> <0> .ERROR;?SYSMAC-W-Invalid argument, use #0, not 0;
	MOV'BB	ARG,OFFSE'.(R0)
.ENDC
.ENDC
.IF NB <INS>
	EMT	^o375
.ENDC
.ENDM

;+TEST
;		Arg	Offse	Ins	CSet	BB	...V1
;		 -	 2	 E	 -	-	3
;		 -	 2	 -	 -	-	3
;		 -	 2	 -	 -	B	3
;		 -	 2	 -	 C	-	3
;		 -	 2	 -	 C	B	3
;		#0	 2	 -	 -	-	3
;		#0	 2	 -	 -	B	3
;		#0	 2	 -	 C	-	3
;		#0	 2	 -	 C	B	3
;		R1	 2	 -	 -	-	3
;		R1	 2	 -	 -	B	3
;		R1	 2	 -	 C	-	3
;		R1	 2	 -	 C	B	3
;
;Version 2 variants NOT tested:
;
;		 -	 2	 -	 -	-	2
;		 -	 2	 -	 -	B	2
;		 -	 2	 -	 C	-	2
;		 -	 2	 -	 C	B	2
;		#0	 2	 -	 -	-	2
;		#0	 2	 -	 -	B	2
;		#0	 2	 -	 C	-	2
;		#0	 2	 -	 C	B	2
;		R1	 2	 -	 -	-	2
;		R1	 2	 -	 -	B	2
;		R1	 2	 -	 C	-	2
;		R1	 2	 -	 C	B	2
;
.Enabl	LSB
.PSect	Text
$..CM2:	.Asciz	"%SYSMAC-I-Testing ...CM2"
.PSect	Active
	Mov	#$..CM2,R0	;Ident the test
	Call	BegTst
.PSect	Data
..CM21:	...CM2	,2,E
.PSect	Active
	Cmp	#EMT+375,..CM21	;correct EMT generated?
	Beq	10$		;yes
	Call	Err1		;no
10$:
..CM22:	...CM2	,2
20$:
	Tst	#..CM22-20$	;expect no code
	Beq	30$		;none
	Call	Err2		;some
30$:
..CM23:	...CM2	,2,,,B
40$:
	Tst	#..CM23-40$	;expect no code
	Beq	50$		;none
	Call	Err2		;some
50$:
..CM24:	...CM2	,2,,C
60$:
	Tst	#..CM24-60$	;expect no code
	Beq	70$		;none
	Call	Err4		;some
70$:
..CM25:	...CM2	,2,,C,B
80$:
	Tst	#..CM25-80$	;expect no code
	Beq	90$		;none
	Call	Err5		;some
90$:
	Mov	#Area,R0	;point to area
	Call	AreaM1		;init it
..CM26:	...CM2	#0,2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;is R0 ok?
	Beq	100$		;yes
	Call	Err6.1		;no
100$:
	Cmp	#-1,(R1)+	;is the word unchanged?
	Beq	110$		;yes
	Call	Err6.2		;no
110$:
	Cmp	#0,(R1)+	;is the word set?
	Beq	120$		;yes
	Call	Err6.3		;no
120$:
	Mov	#Area,R0	;point to area
	Call	AreaM1		;init it
..CM27:	...CM2	#0,2,,,B
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;is R0 ok?
	Beq	130$		;yes
	Call	Err7.1		;no
130$:
	Cmp	#-1,(R1)+	;is the word unchanged?
	Beq	140$		;yes
	Call	Err7.2		;no
140$:
	CmpB	#0,(R1)+	;is the byte set?
	Beq	150$		;yes
	Call	Err7.3		;no
150$:
	CmpB	#-1,(R1)+	;is the byte unchanged?
	Beq	160$		;yes
	Call	Err7.4		;no
160$:
	Mov	#Area,R0	;point to area
	Call	AreaM1		;init it
..CM28:	...CM2	#0,2,,C
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;is R0 ok?
	Beq	170$		;yes
	Call	Err8.1		;no
170$:
	Cmp	#-1,(R1)+	;is the word unchanged?
	Beq	180$		;yes
	Call	Err8.2		;no
180$:
	Cmp	#0,(R1)+	;is the word set?
	Beq	190$		;yes
	Call	Err8.3		;no
190$:
	Mov	#Area,R0	;point to area
	Call	AreaM1		;init it
..CM29:	...CM2	#0,2,,C,B
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;is R0 ok?
	Beq	200$		;yes
	Call	Err9.1		;no
200$:
	Cmp	#-1,(R1)+	;is the word unchanged?
	Beq	210$		;yes
	Call	Err9.2		;no
210$:
	CmpB	#0,(R1)+	;is the byte set?
	Beq	220$		;yes
	Call	Err9.3		;no
220$:
	CmpB	#-1,(R1)+	;is the byte unchanged?
	Beq	230$		;yes
	Call	Err9.4		;no
230$:

	Mov	#Area,R0	;point to area
	Call	AreaM1		;init it
	Mov	#3,R2
..CM2A:	...CM2	R2,2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;is R0 ok?
	Beq	240$		;yes
	Call	ErrA.1		;no
240$:
	Cmp	#-1,(R1)+	;is the word unchanged?
	Beq	250$		;yes
	Call	ErrA.2		;no
250$:
	Cmp	#3,(R1)+	;is the word set?
	Beq	260$		;yes
	Call	ErrA.3		;no
260$:
	Mov	#Area,R0	;point to area
	Call	AreaM1		;init it
	Mov	#3,R2
..CM2B:	...CM2	R2,2,,,B
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;is R0 ok?
	Beq	270$		;yes
	Call	ErrB.1		;no
270$:
	Cmp	#-1,(R1)+	;is the word unchanged?
	Beq	280$		;yes
	Call	ErrB.2		;no
280$:
	CmpB	#3,(R1)+	;is the byte set?
	Beq	290$		;yes
	Call	ErrB.3		;no
290$:
	CmpB	#-1,(R1)+	;is the byte unchanged?
	Beq	300$		;yes
	Call	ErrB.4		;no
300$:
	Mov	#Area,R0	;point to area
	Call	AreaM1		;init it
	Mov	#3,R2
..CM2C:	...CM2	R2,2,,C
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;is R0 ok?
	Beq	310$		;yes
	Call	ErrC.1		;no
310$:
	Cmp	#-1,(R1)+	;is the word unchanged?
	Beq	320$		;yes
	Call	ErrC.2		;no
320$:
	Cmp	#3,(R1)+	;is the word set?
	Beq	330$		;yes
	Call	ErrC.3		;no
330$:
	Mov	#Area,R0	;point to area
	Call	AreaM1		;init it
	Mov	#3,R2
..CM2D:	...CM2	R2,2,,C,B
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;is R0 ok?
	Beq	340$		;yes
	Call	ErrD.1		;no
340$:
	Cmp	#-1,(R1)+	;is the word unchanged?
	Beq	350$		;yes
	Call	ErrD.2		;no
350$:
	CmpB	#3,(R1)+	;is the byte set?
	Beq	360$		;yes
	Call	ErrD.3		;no
360$:
	CmpB	#-1,(R1)+	;is the byte unchanged?
	Beq	370$		;yes
	Call	ErrD.4		;no
370$:
	Call	EndTst
.If	NE	MAC$ER
;Expect P error
...CM2	0
.EndC
.Dsabl	LSB
;-TEST
.Page
.SbTtl	...CM3	Move CHAN & IC to R0, Gen EMT 374
;++
;	...CM3
;
;	Move a channel and code to R0.
;	If CHAN blank, treat as #0
;	Follow this with an EMT 374.
;	This macro optimises the instructions used
;	to load R0.
;
;	If CHAN contains a reference to R0, R0 will no longer be cleared
;	prior to use.
;
;	...V2 used
;--

.MACRO	...CM3	CHAN,IC
.IF B <CHAN>
	MOV	#IC*^o400,R0
.IFF
.NTYPE ...V2,CHAN
.IF EQ ...V2-^o27
	MOV	CHAN+<IC*^o400>,R0
.IFF
.IF EQ ...V2&^o7
.IF NE ...V2
	MOVB	CHAN,-(SP)
	MOV	#IC*^o400,R0
	BISB	(SP)+,R0	
.IFF
	BIC	#^c^o377,R0
	BIS	#IC*^o400,R0
.ENDC
.IFF
	MOV	#IC*^o400,R0
	BISB	CHAN,R0
.ENDC
.ENDC
.ENDC
	EMT	^o374
.ENDM

;+TEST
;		Chan	IC
;		  -	132.
;		#0	132.
;		R2	132.
;		#32	132.
;		#zero	132.
;		R0	132.
;		@R0
;
.Enabl	LSB
.PSect	Text
$..CM3:	.Asciz	"%SYSMAC-I-Testing ...CM3"
.PSect	Active
	Mov	#$..CM3,R0	;Ident the test
	Call	BegTst
	Mov	#Patter,R0	;smash R0
..CM31:	...CM3	,132.
	.=.-2			;smash EMT
	TstB	R0		;channel cleared?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	SwaB	R0
	CmpB	#132.,R0	;IC set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Mov	#Patter,R0	;smash R0
..CM32:	...CM3	#0,132.
	.=.-2			;smash EMT
	TstB	R0		;channel cleared?
	Beq	30$		;yes
	Call	Err2.1		;no
30$:
	SwaB	R0
	CmpB	#132.,R0	;IC set?
	Beq	40$		;yes
	Call	Err2.2		;no
40$:
	Mov	#Patter,R0	;point to area
	Mov	#32,R2		;channel number
..CM33:	...CM3	R2,132.
	.=.-2			;smash EMT
	CmpB	#32,R0		;channel set?
	Beq	50$		;yes
	Call	Err3.1		;no
50$:
	SwaB	R0
	CmpB	#132.,R0	;IC set?
	Beq	60$		;yes
	Call	Err3.2		;no
60$:
	Mov	#Patter,R0	;point to area
..CM34:	...CM3	#32,132.
	.=.-2			;smash EMT
	CmpB	#32,R0		;channel set?
	Beq	70$		;yes
	Call	Err4.1		;no
70$:
	SwaB	R0
	CmpB	#132.,R0	;IC set?
	Beq	80$		;yes
	Call	Err4.2		;no
80$:
	Mov	#Patter,R0	;point to area
..CM35:	...CM3	#Zero,132.
	.=.-2			;smash EMT
	CmpB	#0,R0		;channel set?
	Beq	90$		;yes
	Call	Err5.1		;no
90$:
	SwaB	R0
	CmpB	#132.,R0	;IC set?
	Beq	100$		;yes
	Call	Err5.2		;no
100$:
.PSect	Data
..CM36:	...CM3	,132.
110$:
.PSect	Active
	Cmp	#EMT+374,110$-2	;correct EMT generated?
	Beq	120$		;yes
	Call	Err6		;no
120$:
	Mov	#12,R0		;load channel number
..CM37:	...CM3	R0,132.
	.=.-2			;smash EMT
	CmpB	#12,R0		;channel set?
	Beq	130$		;yes
	Call	Err7.1		;no
130$:
	SwaB	R0
	CmpB	#132.,R0	;IC set?
	Beq	140$		;yes
	Call	Err7.2		;no
140$:
;		@R0
	Mov	#150$,R0	;load address of channel number
.PSect	Data
150$:	.Word 11
.PSect	Active
..CM38:	...CM3	@R0,132.
	.=.-2			;smash EMT
	CmpB	#11,R0		;channel set?
	Beq	160$		;yes
	Call	Err8.1		;no
160$:
	SwaB	R0
	CmpB	#132.,R0	;IC set?
	Beq	170$		;yes
	Call	Err8.2		;no
170$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	...CM4	Setup a SDAT/RCVD EMT block
;++
;	...CM4
;
;	Setup for a SDAT/RCVD EMT block
;--

.MACRO	...CM4	AREA,BUF,WCNT,CRTN,IC,CODE,BM,CM
.IIF IDN <CODE>,NOSET ...CM1 <AREA>,IC,,<CODE>
.IIF DIF <CODE>,NOSET ...CM1 <AREA>,IC,#0,<CODE>
...CM2 <BUF>,4
...CM2 <WCNT>,6
...CMB <BM>,<CM>,<CRTN>,,,<CODE>
.ENDM

;+TEST
;	Area	Buf	WCnt	CRtn	IC	Code	BM	CM
;	-	-	-	-	10	
;	-	-	-	-	10	SET
;	-	-	-	-	10	NOSET
;	#Area	-	-	-	10	
;	#Area	-	-	-	10	SET
;	#Area	-	-	-	10	NOSET
;	-	#020000	#040000	#010000	10	
;	#Area	#020000	#040000	#010000	10	
;	#Area	-	-	-	10		CI	S
;	

.Enabl	LSB
.PSect	Text
$..CM4:	.Asciz	"%SYSMAC-I-Testing ...CM4"
.PSect	Active
	Mov	#$..CM4,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CM41:	...CM4	,,,,10
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is "channel" cleared?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unaltered?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	80$		;yes
	Call	Err1.8		;no
80$:
	Call	AreaM1
	Mov	#Area,R0	;point to area
..CM42:	...CM4	,,,,10,CODE=SET
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	90$		;yes
	Call	Err2.1		;no
90$:
	CmpB	#0,(R1)+	;is "channel" cleared?
	Beq	100$		;yes
	Call	Err2.2		;no
100$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	110$		;yes
	Call	Err2.3		;no
110$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	120$		;yes
	Call	Err2.4		;no
120$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	130$		;yes
	Call	Err2.5		;no
130$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	140$		;yes
	Call	Err2.6		;no
140$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	150$		;yes
	Call	Err2.7		;no
150$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	160$		;yes
	Call	Err2.8		;no
160$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CM43:	...CM4	,,,,10,CODE=NOSET
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	170$		;yes
	Call	Err3.1		;no
170$:
	CmpB	#-1,(R1)+	;is "channel" unaltered?
	Beq	180$		;yes
	Call	Err3.2		;no
180$:
	CmpB	#-1,(R1)+	;is IC unaltered?
	Beq	190$		;yes
	Call	Err3.3		;no
190$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	200$		;yes
	Call	Err3.4		;no
200$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	210$		;yes
	Call	Err3.5		;no
210$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	220$		;yes
	Call	Err3.6		;no
220$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	230$		;yes
	Call	Err3.7		;no
230$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	240$		;yes
	Call	Err3.8		;no
240$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
..CM44:	...CM4	#Area,,,,10
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	250$		;yes
	Call	Err4.1		;no
250$:
	CmpB	#0,(R1)+	;is "channel" cleared?
	Beq	260$		;yes
	Call	Err4.2		;no
260$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	270$		;yes
	Call	Err4.3		;no
270$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	280$		;yes
	Call	Err4.4		;no
280$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	290$		;yes
	Call	Err4.5		;no
290$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	300$		;yes
	Call	Err4.6		;no
300$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	310$		;yes
	Call	Err4.7		;no
310$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	320$		;yes
	Call	Err4.8		;no
320$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;point to area
..CM45:	...CM4	#Area,,,,10,CODE=SET
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	330$		;yes
	Call	Err5.1		;no
330$:
	CmpB	#0,(R1)+	;is "channel" cleared?
	Beq	340$		;yes
	Call	Err5.2		;no
340$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	350$		;yes
	Call	Err5.3		;no
350$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	360$		;yes
	Call	Err5.4		;no
360$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	370$		;yes
	Call	Err5.5		;no
370$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	380$		;yes
	Call	Err5.6		;no
380$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	390$		;yes
	Call	Err5.7		;no
390$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	400$		;yes
	Call	Err5.8		;no
400$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;point to area
..CM46:	...CM4	#Area,,,,10,CODE=NOSET
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	410$		;yes
	Call	Err6.1		;no
410$:
	CmpB	#-1,(R1)+	;is "channel" unaltered?
	Beq	420$		;yes
	Call	Err6.2		;no
420$:
	CmpB	#-1,(R1)+	;is IC unaltered?
	Beq	430$		;yes
	Call	Err6.3		;no
430$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	440$		;yes
	Call	Err6.4		;no
440$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	450$		;yes
	Call	Err6.5		;no
450$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	460$		;yes
	Call	Err6.6		;no
460$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	470$		;yes
	Call	Err6.7		;no
470$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	480$		;yes
	Call	Err6.8		;no
480$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CM47:	...CM4	,#040000,#020000,#010000,10
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	490$		;yes
	Call	Err7.1		;no
490$:
	CmpB	#0,(R1)+	;is "channel" cleared?
	Beq	500$		;yes
	Call	Err7.2		;no
500$:
	CmpB	#-1,(R1)+	;is IC unaltered?
	Beq	510$		;yes
	Call	Err7.3		;no
510$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	520$		;yes
	Call	Err7.4		;no
520$:
	Cmp	#040000,(R1)+	;is BUF set?
	Beq	530$		;yes
	Call	Err7.5		;no
530$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	540$		;yes
	Call	Err7.6		;no
540$:
	Cmp	#010000,(R1)+	;is CRTN set?
	Beq	550$		;yes
	Call	Err7.7		;no
550$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	560$		;yes
	Call	Err7.8		;no
560$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
..CM48:	...CM4	#Area,#040000,#020000,#010000,10
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	570$		;yes
	Call	Err8.1		;no
570$:
	CmpB	#0,(R1)+	;is "channel" cleared?
	Beq	580$		;yes
	Call	Err8.2		;no
580$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	590$		;yes
	Call	Err8.3		;no
590$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	600$		;yes
	Call	Err8.4		;no
600$:
	Cmp	#040000,(R1)+	;is BUF set?
	Beq	610$		;yes
	Call	Err8.5		;no
610$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	620$		;yes
	Call	Err8.6		;no
620$:
	Cmp	#010000,(R1)+	;is CRTN set?
	Beq	630$		;yes
	Call	Err8.7		;no
630$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	640$		;yes
	Call	Err8.8		;no
640$:
.PSect	Data
..CM49:	...CM4
650$:
.PSect	Active
	Cmp	#EMT+375,650$-2	;Correct EMT generated?
	Beq	660$		;yes
	Call	Err9		;no
660$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
..CM4A:	...CM4	#Area,,,,10,BM=CI,CM=S
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	670$		;yes
	Call	ErrA.1		;no
670$:
	CmpB	#0,(R1)+	;is "channel" cleared?
	Beq	680$		;yes
	Call	ErrA.2		;no
680$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	690$		;yes
	Call	ErrA.3		;no
690$:
	Cmp	#-1,(R1)+	;is "reserved" unaltered?
	Beq	700$		;yes
	Call	ErrA.4		;no
700$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	710$		;yes
	Call	ErrA.5		;no
710$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	720$		;yes
	Call	ErrA.6		;no
720$:
	Cmp	#..ISPA!..CURR!^o3,(R1)+ ;is the flag word correct?
	Beq	730$		;yes
	Call	ErrA.7		;no
730$:
	Cmp	#-1,(R1)+	;is SRTN unaltered?
	Beq	740$		;yes
	Call	ErrA.8		;no
740$:
.PSect	Data
..CM4B:	...CM4 CM=S,BM=SI
750$:
.PSect	Active
	Cmp	#EMT+375,750$-2	;Correct EMT generated?
	Beq	760$		;yes
	Call	ErrB.1		;no
760$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	...CM5	Move a value to R0, opt MOVB, opt gen EMT
;++
;	...CM5
;
;	Move a (byte) value to R0 unless the src is
;	blank or R0.  If so, then generate nothing.
;	BB is blank for word operations or B for byte.
;	If second argument present, generate an EMT with 
;	that code value.
;--

.MACRO	...CM5	SRC,INS,BB
.IF NB <SRC>
.IF DIF <SRC>,R0
	MOV'BB	SRC,R0
.ENDC
.ENDC
.IF NB <INS>
	EMT	^o<INS>
.ENDC
.ENDM

;+TEST
;	SRC	INS	BB
;	-	-	-
;	-	-	B
;	-	377	-
;	-	377	B
;	R0	-	-
;	#23	-	B
;	#23	377	-
;	R1	377	B
.Enabl	LSB
.PSect	Text
$..CM5:	.Asciz	"%SYSMAC-I-Testing ...CM5"
.PSect	Active
	Mov	#$..CM5,R0	;Ident the test
	Call	BegTst
10$:
..CM51:	...CM5
20$:
	Tst	#20$-10$	;nothing generated?
	Beq	30$		;yes
	Call	Err1		;no
30$
30$:
..CM52:	...CM5
40$:
	Tst	#40$-30$	;nothing generated?
	Beq	50$		;yes
	Call	Err2		;no
50$:
..CM53:	...CM5	,377
	Cmp	#EMT+377,..CM53	;correct EMT generated
	Beq	60$		;yes
	Call	Err3
60$:
..CM54:	...CM5	,377
70$:
	Cmp	#EMT+377,70$-2	;correct EMT generated
	Beq	80$		;yes
	Call	Err4.1
80$:
	Cmp	#70$-60$,#2	;just EMT generated?
	Beq	90$		;yes
	Call	Err4.2		;no
90$:
100$:
..CM55:	...CM5	R0
110$:
	Tst	#110$-100$	;nothing generated?
	Beq	120$		;yes
	Call	Err5		;no
120$:
	Mov	#Patter,R0	;init R0
..CM56:	...CM5	#23,,B
	Cmp	#23,R0		;channel set in R0?
	Beq	130$		;yes
	Call	Err6		;no
130$:
	Mov	#Patter,R0	;init R0
..CM57:	...CM5	#23,377
140$:
	Cmp	#23,R0		;channel set in R0?
	Beq	150$		;yes
	Call	Err7.1		;no
150$:
	Cmp	#EMT+377,140$-2	;correct EMT generated?
	Beq	160$		;yes
	Call	Err7.2		;no
160$:
	Mov	#Patter,R0	;init R0
	Mov	#377*^o400+23,R1	;load register
..CM58:	...CM5	R1,377,B
170$:
	Cmp	#23,R0		;channel set in R0?
	Beq	180$		;yes
	Call	Err8.1		;no
180$:
	Cmp	#EMT+377,170$-2	;correct EMT generated?
	Beq	190$		;yes
	Call	Err8.2		;no
190$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTTl	...CM6	Move CODE & IC @R0, Move ARG to 2(R0), Opt gen EMT 375
;++
;	...CM6
;
;	Move a code and channel to @R0.  This macro
;	optimises the instructions needed to load R0.
;	Do the first ...CM2 also.
;	IC and CHAN are used in current radix.
;
;	...V1 used (...CM2)
;--

.MACRO	...CM6	AREA,IC,CHAN,FLAG,ARG,INS,CSET,BB
...CM5	<AREA>
.IF B <FLAG>
.IF NB <AREA>
	MOV	#IC*^o400+CHAN,@R0
.ENDC
.IFF
.IF IDN <FLAG>,SET
	MOV	#IC*^o400+CHAN,@R0
.ENDC
.ENDC
...CM2	<ARG>,2,INS,CSET,BB
.ENDM

;+TEST
;		Area	IC	Chan	Flag	Arg	Ins	CSet	BB
;1		  -	132.	  -	  -
;2		  -	132.	  -	SET
;3		  -	132.	  -	NOSET
;4		  -	132.	177.	  -
;5		  -	132.	177.	SET
;6		  -	132.	177.	NOSET
;7		#Area	132.	  -	  -	#123456
;8		#Area	132.	  -	SET	-	E	C	B
;9		#Area	132.	  -	NOSET	#123	E	C	B
;10		#Area	132.	177.	  -
;11		#Area	132.	177.	SET
;12		#Area	132.	177.	NOSET
;	
.Enabl	LSB
.PSect	Text
$..CM6:	.Asciz	"%SYSMAC-I-Testing ...CM6"
.PSect	Active
	Mov	#$..CM6,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM61:	...CM6	,132.
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes	
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM62:	...CM6	,132.,177.,FLAG=SET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#177.,(R1)+	;is CHAN unchanged?
	Beq	60$		;yes	
	Call	Err2.2		;no
60$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM63:	...CM6	,132.,FLAG=NOSET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	100$		;yes	
	Call	Err3.2		;no
100$:
	CmpB	#-1.,(R1)+	;is IC unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM64:	...CM6	,132.,177.
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	130$		;yes
	Call	Err4.1		;no
130$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	140$		;yes	
	Call	Err4.2		;no
140$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	150$		;yes
	Call	Err4.3		;no
150$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	160$		;yes
	Call	Err4.4		;no
160$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM65:	...CM6	,132.,177.,FLAG=SET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	170$		;yes
	Call	Err5.1		;no
170$:
	CmpB	#177.,(R1)+	;is CHAN set?
	Beq	180$		;yes	
	Call	Err5.2		;no
180$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	190$		;yes
	Call	Err5.3		;no
190$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	200$		;yes
	Call	Err5.4		;no
200$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
..CM66:	...CM6	,132.,177.,FLAG=NOSET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	210$		;yes
	Call	Err6.1		;no
210$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	220$		;yes	
	Call	Err6.2		;no
220$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	230$		;yes
	Call	Err6.3		;no
230$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	240$		;yes
	Call	Err6.4		;no
240$:
	Call	AreaM1
..CM67:	...CM6	#Area,132.,177.
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	250$		;yes
	Call	Err7.1		;no
250$:
	CmpB	#177.,(R1)+	;is CHAN unchanged?
	Beq	260$		;yes	
	Call	Err7.2		;no
260$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	270$		;yes
	Call	Err7.3		;no
270$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	280$		;yes
	Call	Err7.4		;no
280$:
	Call	AreaM1
..CM68:	...CM6	#Area,132.,177.,SET,,E,C,B
	.=.-2			;smash EMT
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	290$		;yes
	Call	Err8.1		;no
290$:
	CmpB	#177.,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes	
	Call	Err8.2		;no
300$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	310$		;yes
	Call	Err8.3		;no
310$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	320$		;yes
	Call	Err8.4		;no
320$:
.PSect	Data
	...CM6	#Area,132.,0,SET,,E,C,B
330$:
.PSect	Active
	Cmp	#EMT+375,330$-2 ;is the EMT generated correctly?
	Beq	340$		;yes
	Call	Err8.5		;no
340$:
	Call	AreaM1
..CM69:	...CM6	#Area,132.,,NOSET,#123,E,C,B
	.=.-2			;smash EMT
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	350$		;yes
	Call	Err9.1		;no
350$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	360$		;yes	
	Call	Err9.2		;no
360$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	370$		;yes
	Call	Err9.3		;no
370$:
	CmpB	#123,(R1)+	;is ARG (BYTE) set?
	Beq	380$		;yes
	Call	Err9.4		;no
380$:
	CmpB	#-1,(R1)+	;is ARG high byte unchanged?
	Beq	390$		;yes
	Call	Err9.4		;no
390$:
.PSect	Data
	...CM6	#Area,132.,0,SET,,E,C,B
400$:
.PSect	Active
	Cmp	#EMT+375,400$-2 ;is the EMT generated correctly?
	Beq	410$		;yes
	Call	Err9.5		;no
410$:
	Call	AreaM1
..CM6A:	...CM6	#Area,132.,177.
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	420$		;yes
	Call	ErrA.1		;no
420$:
	CmpB	#177.,(R1)+	;is CHAN set?
	Beq	430$		;yes	
	Call	ErrA.2		;no
430$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	440$		;yes
	Call	ErrA.3		;no
440$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	450$		;yes
	Call	ErrA.4		;no
450$:
	Call	AreaM1
..CM6B:	...CM6	#Area,132.,177.,FLAG=SET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	460$		;yes
	Call	ErrB.1		;no
460$:
	CmpB	#177.,(R1)+	;is CHAN set?
	Beq	470$		;yes	
	Call	ErrB.2		;no
470$:
	CmpB	#132.,(R1)+	;is IC set?
	Beq	480$		;yes
	Call	ErrB.3		;no
480$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	490$		;yes
	Call	ErrB.4		;no
490$:
	Call	AreaM1
..CM6C:	...CM6	#Area,132.,177.,FLAG=NOSET
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	500$		;yes
	Call	ErrC.1		;no
500$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	510$		;yes	
	Call	ErrC.2		;no
510$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	520$		;yes
	Call	ErrC.3		;no
520$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	530$		;yes
	Call	ErrC.4		;no
530$:
.If	NE	MAC$ER
;Expect P error
...CM6	,,0.
.EndC
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	...CM7	Generate a READ_/WRIT_ request
;++
;	...CM7
;
;	Generate READ_/WRIT_ requests
;--

.MACRO	...CM7	AREA,CHAN,BUF,WCNT,BLK,CRTN,IC,CODE,V1,BM,CM
.IF NE ...V1-1
...CM1 <AREA>,IC,<CHAN>,<CODE>,<BLK>
...CM2 <BUF>,4
...CM2 <WCNT>,6
...CMB <BM>,<CM>,<CRTN>,,,<CODE>
.MEXIT
.ENDC
...CM5	<WCNT>
...CM0	<CRTN>
...CM0	<BUF>
...CM0	<CHAN>,<V1+AREA>
.ENDM

;+TEST
;	Area	Chan	Buf	WCnt	Blk	CRtn	IC	Code	BM CM
;	-	-	-	-	-	-	10	
;	-	#0	-	-	-	-	10	SET
;	-	-	-	-	-	-	10	NOSET
;	#Area	-	-	-	-	-	10	
;	#Area	#0	-	-	-	-	10	SET
;	#Area	-	-	-	-	-	10	NOSET
;	-	R2	#020000	#040000	#010000	#000000	10	
;	#Area	#2	#020000	#040000	#010000	#000000	10	
;	#Area	-	-	-	-	-	10		UD S
;
;	Version 1 not tested
;
.Enabl	LSB
.PSect	Text
$..CM7:	.Asciz	"%SYSMAC-I-Testing ...CM7"
.PSect	Active
	Mov	#$..CM7,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CM71:	...CM7	,,,,,,10
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unaltered?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unaltered?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unaltered?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	80$		;yes
	Call	Err1.8		;no
80$:
	Call	AreaM1
	Mov	#Area,R0	;point to area
..CM72:	...CM7	,#0,,,,,10,CODE=SET
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	90$		;yes
	Call	Err2.1		;no
90$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	100$		;yes
	Call	Err2.2		;no
100$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	110$		;yes
	Call	Err2.3		;no
110$:
	Cmp	#-1,(R1)+	;is BLK unaltered?
	Beq	120$		;yes
	Call	Err2.4		;no
120$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	130$		;yes
	Call	Err2.5		;no
130$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	140$		;yes
	Call	Err2.6		;no
140$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	150$		;yes
	Call	Err2.7		;no
150$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	160$		;yes
	Call	Err2.8		;no
160$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CM73:	...CM7	,,,,,,10,CODE=NOSET
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	170$		;yes
	Call	Err3.1		;no
170$:
	CmpB	#-1,(R1)+	;is CHAN unaltered?
	Beq	180$		;yes
	Call	Err3.2		;no
180$:
	CmpB	#-1,(R1)+	;is IC unaltered?
	Beq	190$		;yes
	Call	Err3.3		;no
190$:
	Cmp	#-1,(R1)+	;is BLK unaltered?
	Beq	200$		;yes
	Call	Err3.4		;no
200$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	210$		;yes
	Call	Err3.5		;no
210$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	220$		;yes
	Call	Err3.6		;no
220$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	230$		;yes
	Call	Err3.7		;no
230$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	240$		;yes
	Call	Err3.8		;no
240$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
..CM74:	...CM7	#Area,,,,,,10
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	250$		;yes
	Call	Err4.1		;no
250$:
	CmpB	#-1,(R1)+	;is CHAN unaltered?
	Beq	260$		;yes
	Call	Err4.2		;no
260$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	270$		;yes
	Call	Err4.3		;no
270$:
	Cmp	#-1,(R1)+	;is BLK unaltered?
	Beq	280$		;yes
	Call	Err4.4		;no
280$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	290$		;yes
	Call	Err4.5		;no
290$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	300$		;yes
	Call	Err4.6		;no
300$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	310$		;yes
	Call	Err4.7		;no
310$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	320$		;yes
	Call	Err4.8		;no
320$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;point to area
..CM75:	...CM7	#Area,#0,,,,,10,CODE=SET
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	330$		;yes
	Call	Err5.1		;no
330$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	340$		;yes
	Call	Err5.2		;no
340$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	350$		;yes
	Call	Err5.3		;no
350$:
	Cmp	#-1,(R1)+	;is BLK unaltered?
	Beq	360$		;yes
	Call	Err5.4		;no
360$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	370$		;yes
	Call	Err5.5		;no
370$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	380$		;yes
	Call	Err5.6		;no
380$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	390$		;yes
	Call	Err5.7		;no
390$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	400$		;yes
	Call	Err5.8		;no
400$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;point to area
..CM76:	...CM7	#Area,,,,,,10,CODE=NOSET
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	410$		;yes
	Call	Err6.1		;no
410$:
	CmpB	#-1,(R1)+	;is CHAN unaltered?
	Beq	420$		;yes
	Call	Err6.2		;no
420$:
	CmpB	#-1,(R1)+	;is IC unaltered?
	Beq	430$		;yes
	Call	Err6.3		;no
430$:
	Cmp	#-1,(R1)+	;is BLK unaltered?
	Beq	440$		;yes
	Call	Err6.4		;no
440$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	450$		;yes
	Call	Err6.5		;no
450$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	460$		;yes
	Call	Err6.6		;no
460$:
	Cmp	#-1,(R1)+	;is CRTN unaltered?
	Beq	470$		;yes
	Call	Err6.7		;no
470$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	480$		;yes
	Call	Err6.8		;no
480$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
	Mov	#3,R2		;setup reg
..CM77:	...CM7	,R2,#040000,#020000,#010000,#000000,10
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	490$		;yes
	Call	Err7.1		;no
490$:
	CmpB	#3,(R1)+	;is CHAN set?
	Beq	500$		;yes
	Call	Err7.2		;no
500$:
	CmpB	#-1,(R1)+	;is IC unaltered?
	Beq	510$		;yes
	Call	Err7.3		;no
510$:
	Cmp	#010000,(R1)+	;is BLK set?
	Beq	520$		;yes
	Call	Err7.4		;no
520$:
	Cmp	#040000,(R1)+	;is BUF set?
	Beq	530$		;yes
	Call	Err7.5		;no
530$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	540$		;yes
	Call	Err7.6		;no
540$:
	Cmp	#000000,(R1)+	;is CRTN set?
	Beq	550$		;yes
	Call	Err7.7		;no
550$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	560$		;yes
	Call	Err7.8		;no
560$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
..CM78:	...CM7	#Area,#2,#040000,#020000,#010000,#000000,10
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	570$		;yes
	Call	Err8.1		;no
570$:
	CmpB	#2,(R1)+	;is CHAN set?
	Beq	580$		;yes
	Call	Err8.2		;no
580$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	590$		;yes
	Call	Err8.3		;no
590$:
	Cmp	#010000,(R1)+	;is BLK set?
	Beq	600$		;yes
	Call	Err8.4		;no
600$:
	Cmp	#040000,(R1)+	;is BUF set?
	Beq	610$		;yes
	Call	Err8.5		;no
610$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	620$		;yes
	Call	Err8.6		;no
620$:
	Cmp	#000000,(R1)+	;is CRTN set?
	Beq	630$		;yes
	Call	Err8.7		;no
630$:
	Cmp	#-1,(R1)+	;is flag unaltered?
	Beq	640$		;yes
	Call	Err8.8		;no
640$:
.PSect	Data
..CM79:	...CM7
650$:
.PSect	Active
	Cmp	#EMT+375,650$-2	;Correct EMT generated?
	Beq	660$		;yes
	Call	Err9		;no
660$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
..CM7A:	...CM7	#Area,,,,,,10,BM=UD,CM=S
	.=.-2			;smash EMT
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	670$		;yes
	Call	ErrA.1		;no
670$:
	CmpB	#-1,(R1)+	;is CHAN unaltered?
	Beq	680$		;yes
	Call	ErrA.2		;no
680$:
	CmpB	#10.,(R1)+	;is IC set?
	Beq	690$		;yes
	Call	ErrA.3		;no
690$:
	Cmp	#-1,(R1)+	;is BLK unaltered?
	Beq	700$		;yes
	Call	ErrA.4		;no
700$:
	Cmp	#-1,(R1)+	;is BUF unaltered?
	Beq	710$		;yes
	Call	ErrA.5		;no
710$:
	Cmp	#-1,(R1)+	;is WCNT unaltered?
	Beq	720$		;yes
	Call	ErrA.6		;no
720$:
	Cmp	#..DSPA!..USER!^o3,(R1)+ ;Is flag set correctly?
	Beq	730$		;yes
	Call	ErrA.7		;no
730$:
	Cmp	#-1,(R1)+	;is SRTN unaltered?
	Beq	740$		;yes
	Call	ErrA.8		;no
740$:
.PSect	Data
..CM7B:	...CM7	#Area,,,,,,10,BM=UD,CM=S
750$:
.PSect	Active
	Cmp	#EMT+375,750$-2	;Correct EMT generated?
	Beq	760$		;yes
	Call	ErrB.1		;no
760$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	...CMB	Generate the extended mapping bits
;+
;	...CMB
;
;	The ...CMB macro generates extended mapping bits for buffer
;	and crtn arguments.
;
;	...V2 used
;	...V3 used
;
;	BM	BUF mode and space argument
;	CM	CRTN mode and space argument
;	FUNC	function byte value
;	SPFUN	nb means always generate long form (with SRTN not CRTN)
;	CODE	SET/NOSET
;
;	BM=*BYPASS* means that the CM string is substituted for the
;	source argument. Example:
;
;	...CMB	*BYPASS*,R4
;		MOV	R4,8.(R0)
;
;	*BYPASS* is primarily designed for SYSLIB routines.
;
;-
.MACRO	...CMB	BM,CM,CRTN,FUNC,SPFUN,CODE
.IF B <BM'CM'SPFUN>
...CM2	<CRTN>,8,E
.MEXIT
.ENDC
.IF IDN <BM>,<*BYPASS*>
	MOV	CM,8.(R0)
...CM2	<CRTN>,10,E
.MEXIT
.ENDC
...V2=-1
...V3=-1
.IF NB <BM'CM>
.IIF B   <BM>		...V2=^o377
.IIF IDN <BM>,<UD>	...V2=^o3
.IIF IDN <BM>,<SD>	...V2=^o7
.IIF IDN <BM>,<CD>	...V2=^o13
.IIF IDN <BM>,<UI>	...V2=^o23
.IIF IDN <BM>,<SI>	...V2=^o27
.IIF IDN <BM>,<CI>	...V2=^o33
.IIF B   <CM>		...V3=0
.IIF IDN <CM>,<U>	...V3=0
.IIF IDN <CM>,<S>	...V3=1
.IF EQ <...V2+1>
.ERROR ;?SYSMAC-E-Invalid BMODE, found 'BM';
...V2=^o377
.ENDC
.IF EQ <...V3+1>
.ERROR ;?SYSMAC-E-Invalid CMODE, found 'CM';
...V3=0
.ENDC
.IFF
...V2=^o377
...V3=0
.ENDC
.IF B <SPFUN>
	MOV	#...V2,8.(R0)
.IFF
.IF NB <FUNC>
.NTYPE ...V4,FUNC
.IF NE ...V4-^o27
.IF DIF <CODE>,NOSET
	MOVB	#...V2,8.(R0)
.ENDC
...CM2	<FUNC>,9,,,B
.IFF
	MOV	FUNC'*^o400+...V2,8.(R0)
.ENDC
.ENDC
.ENDC
.IF EQ ...V3
...CM2	<CRTN>,10,E
.IFF
.IF NB <CRTN>
.NTYPE ...V4,CRTN
.IF NE ...V4-^o27
...CM2	<CRTN>,10
	INC	10.(R0)
	EMT	^o375
.IFF
...CM2	<CRTN'+1>,10,E
.ENDC
.IFF
	EMT	^o375
.ENDC
.ENDC
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$..CMB:	.Asciz	"%SYSMAC-I-Testing ...CMB"
.PSect	Active
	Mov	#$..CMB,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CMB1:	...CMB	,,#123456
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	Cmp	#123456,8.(R1)	;is CRTN set?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#-1,10.(R1)	;is SRTN unchanged?
	Beq	20$		;yes
	Call	Err1.2
20$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
	Mov	#135353,R3
..CMB2:	...CMB	*BYPASS*,#123456,R3
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	Cmp	#123456,8.(R1)	;is CRTN set?
	Beq	30$		;yes
	Call	Err2.1		;no
30$:
	Cmp	#135353,10.(R1)	;is SRTN set?
	Beq	40$		;yes
	Call	Err2.2
40$:
	Call	AreaM1		;init area
	Mov	#135353,Area+8.	;expect -1 in a byte
	Mov	#Area,R0	;point to area
..CMB3:	...CMB	,U,#123456
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	CmpB	#377,8.(R1)	;is TYPE set?
	Beq	50$		;yes
	Call	Err3.1		;no
50$:
	CmpB	#0,9.(R1)	;is FUNC set?
	Beq	60$		;yes
	Call	Err3.2
60$:
	Cmp	#123456,10.(R1)	;is SRTN set?
	Beq	70$		;yes
	Call	Err3.3
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CMB4:	...CMB	UD,S
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	CmpB	#..USER!..DSPA!^o3,8.(R1) ;is flag set correctly?
	Beq	80$		;yes
	Call	Err4.1		;no
80$:
	CmpB	#0,9.(R1)	;is FUNC set correctly?
	Beq	90$		;yes
	Call	Err4.2
90$:
	Cmp	#-1,10.(R1)	;is SRTN set unchanged?
	Beq	100$		;yes
	Call	Err4.3
100$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CMB5:	...CMB	SD,S,#123456
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	CmpB	#..SUPY!..DSPA!^o3,8.(R1) ;is flag set correctly?
	Beq	110$		;yes
	Call	Err5.1		;no
110$:
	CmpB	#0,9.(R1)	;is FUNC set correctly?
	Beq	120$		;yes
	Call	Err5.2
120$:
	Cmp	#123456+1,10.(R1) ;is SRTN set correctly?
	Beq	130$		;yes
	Call	Err5.3
130$:

	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CMB6:	...CMB	CD
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	CmpB	#..CURR!..DSPA!^o3,8.(R1) ;is flag set correctly?
	Beq	140$		;yes
	Call	Err6.1		;no
140$:
	CmpB	#0,9.(R1)	;is func set?
	Beq	150$		;yes
	Call	Err6.2
150$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
	Mov	#123456,R3
..CMB7:	...CMB	UI,S,R3
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	Cmp	#..USER!..ISPA+^o3,8.(R1) ;is flag set correctly?
	Beq	160$		;yes
	Call	Err7.1		;no
160$:
	Cmp	#123456+1,10.(R1) ;is SRTN set correctly?
	Beq	170$		;yes
	Call	Err7.2		;no
170$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CMB8:	...CMB	SI
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	Cmp	#..SUPY!..ISPA!^o3,8.(R1) ;is flag set correctly?
	Beq	180$		;yes
	Call	Err8.1		;no
180$:
	Cmp	#-1,10.(R1)	;is SRTN unchanged?
	Beq	190$		;yes
	Call	Err8.1		;no
190$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
..CMB9:	...CMB	CI
	.=.-2			;crush EMT
	Mov	#Area,R1	;point to area
	Cmp	#..CURR!..ISPA!^o3,8.(R1) ;is flag set correctly?
	Beq	200$		;yes
	Call	Err9.1		;no
200$:
	Cmp	#-1,10.(R1)	;is SRTN unchanged?
	Beq	210$		;yes
	Call	Err9.1		;no
210$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
	Mov	#302,R3
	Mov	#101010,8.(R0)	;-1 is expected value
..CMBA:	...CMB	,,#123456,R3,S
	.=.-2			;crush EMT
	Mov	#Area,R1
	CmpB	#377,8.(R1)	;is flag set?
	Beq	220$		;yes
	Call	ErrA.1		;no
220$:
	CmpB	#302,9.(R1)	;is func set?
	Beq	230$		;yes
	Call	ErrA.2		;no
230$:
	Cmp	#123456,10.(R1)	;is SRTN set?
	Beq	240$		;yes
	Call	ErrA.3		;no
240$:

	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
	Mov	#302,R3
	Mov	#101010,8.(R0)	;-1 is expected value
..CMBB:	...CMB	,,#123456,R3,S,CODE=NOSET
	.=.-2			;crush EMT
	Mov	#Area,R1
	CmpB	#010,8.(R1)	;is flag unchanged?
	Beq	250$		;yes
	Call	ErrB.1		;no
250$:
	CmpB	#302,9.(R1)	;is func set?
	Beq	260$		;yes
	Call	ErrB.2		;no
260$:
	Cmp	#123456,10.(R1)	;is SRTN set?
	Beq	270$		;yes
	Call	ErrB.3		;no
270$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
	Mov	#101010,8.(R0)	;-1 is expected value
..CMBC:	...CMB	UD,S,#123456,#302,S
	.=.-2			;crush EMT
	Mov	#Area,R1
	CmpB	#..USER!..DSPA!^o3,8.(R1) ;is flag set?
	Beq	280$		;yes
	Call	ErrC.1		;no
280$:
	CmpB	#302,9.(R1)	;is func set?
	Beq	290$		;yes
	Call	ErrC.2		;no
290$:
	Cmp	#123456+1,10.(R1)	;is SRTN set?
	Beq	300$		;yes
	Call	ErrC.3		;no
300$:
.PSect	Data
..CMBD:	...CMB	,,#123456
.=.-2
310$:
.=.+2
.PSect	Active
	Cmp	#EMT+375,310$
	Beq	320$
	Call	ErrD.1
320$:
.PSect	Data
..CMBE:	...CMB	*BYPASS*,#1
.=.-2
330$:
.=.+2
.PSect	Active
	Cmp	#EMT+375,330$
	Beq	340$
	Call	ErrE.1
340$:
.PSect	Data
..CMBF:	...CMB	SD,,#2
.=.-2
350$:
.=.+2
.PSect	Active
	Cmp	#EMT+375,350$
	Beq	360$
	Call	ErrF.1
360$:
.PSect	Data
..CMBG:	...CMB	UI,S,R3
.=.-2
370$:
.=.+2
.PSect	Active
	Cmp	#EMT+375,370$
	Beq	380$
	Call	ErrG.1
380$:
.PSect	Data
..CMBH:	...CMB	CI
.=.-2
390$:
.=.+2
.PSect	Active
	Cmp	#EMT+375,390$
	Beq	400$
	Call	ErrH.1
400$:
	Call	EndTst
.Dsabl	LSB
.If	NE	MAC$ER
;Expect P errors
...CMB	XX
...CMB	,X
...CMB	X,XX
.EndC
;-TEST
.SbTtl	...CMC	Support .DSTATUS and .FETCH
;+
;
;	...CMC
;
;	This macro places the first argument on the stack and the
;	second in R0. It handles most cases when the arguments
;	interfer with each other (e.g.: when the first argument
;	references R0 and/or the second, SP).
;	The third argument specifies the EMT code number
;
;	Addressing modes of the form:
;
;	STACK	R0    @R0 (R0)+ @(R0)+ -(R0) @-(R0) x(R0) @x(R0)
;		      @SP (SP)+ @(SP)+              x(SP) @x(SP)
;
;	RZERO	R0 SP @SP (SP)+ @(SP)+              x(SP) @x(SP)
;
;	are considered special and have specific code generated for
;	them.
;
;	Some combinations of the special addressing modes are "hard"
;	and are rejected with an error message.
;
;	Addressing modes of the form: PC @PC -(PC) @-(PC)
;					     -(SP) @-(SP)
;	are considered silly and not treated specially in this macro.
;
;	If STACK is omitted it is defaulted to (SP)+, which means
;	the macro assumes the value for the STACK argument is on
;	the stack prior to invocation and it to be popped.
;
;	IF RZERO is omitted it is defaulted to R0, which means
;	the macro assumes the value for the RZERO argument is in
;	R0 prior to invocation (and is destroyed by the EMT).
;
;	In general the arguments are processed left to right.
;	When both arguments include references to SP, they may
;	be processed in the reverse order.
;
;	LOCAL SYMBOLS:
;
;		...V10	addressing type for STACK
;		...V11	addressing type for RZERO
;		...V2	=0 STACK is a special addressing mode
;			<> STACK is a normal addressing mode
;		...V3	=0 RZERO is a special addressing mode
;			<> RZERO is a normal addressing mode
;		...V4	=0 "hard" case if STACK is special
;-

.MACRO	...CMC	STACK,RZERO,INS
						;get type/defaults
.IF NB	<STACK>
.NTYPE	...V10,STACK
.IFF
...V10=^o26					;default to (SP)+
.ENDC
.IF NB	<RZERO>
.NTYPE	...V11,RZERO
.IFF
...V11=0					;default to R0
.ENDC
						;sort out main types
...V2=^o<<...V10&7>*<...V10&7-6>>		;0=STACK is special
...V3=...V11*^o<...V11&7-6>			;0=RZERO is special
...V4=^o<<...V11-26>*<...V11-36>*<...V11-76>>	;0=probable hard case

.IF NE ...V2&...V3				;nothing special
...CM0	<STACK>
...CM5	<RZERO>,INS
.MEXIT
.ENDC

.IF EQ ...V2!...V4				;STACK special, hard case
.ERROR;?SYSMAC-E-Argument interrelationship too complex;
.MEXIT
.ENDC
						;args already in place?
.IF EQ ...V11					;RZERO=R0
.IF EQ ...V10-^o26				;STACK=(SP)+
	EMT	^o<INS>
.IFF						;R0 is, STACK isn't
...CM0	<STACK>,INS
.ENDC
.MEXIT
.ENDC

.IF EQ ...V11-^o66				;RZERO=x(SP)
.IF EQ ...V2					;STACK special
...CM0	<STACK>
...CM5	<2.+RZERO>,INS
.MEXIT
.ENDC
.ENDC

.IF EQ ...V2					;STACK is special
.IF EQ ...V11-^o16				;RZERO= @SP
...CM0	<STACK>
...CM5	2.(SP),INS
.MEXIT
.ENDC
.ENDC

.IF EQ ...V10-^o26				;STACK=(SP)+
...CM5	<RZERO>,INS
.MEXIT
.ENDC

...CM5	<RZERO>
...CM0	<STACK>,INS
.ENDM

;+TEST
;	STACK	RZERO	INS
;	<B>	<B>	200
;	R0	R0	200
;	SP	SP	200
;	@R1	@SP	200
;	@SP	x(R2)	200
;	(R4)+	(SP)+	200
;	(SP)+	R0	200
;	(SP)+	(R3)+	200
;	@(R1)+	@(SP)+	200
;	@(PC)+	x(SP)	200	
;	@x(R4)	@x(SP)	200
;	R0	@SP	200
;	R0	x(SP)	200
;	@R0	@SP	200
;	@R0	x(SP)	200
;	@SP	@SP	200
;	@SP	x(SP)	200
;	(R0)+	@SP	200
;	(R0)+	x(SP)	200
;	(SP)+	@SP	200
;	(SP)+	x(SP)	200
;	@(R0)+	@SP	200
;	@(R0)+	x(SP)	200
;	@(SP)+	@SP	200
;	@(SP)+	x(SP)	200
;	-(R0)	@SP	200
;	-(R0)	x(SP)	200
;	@R0	@SP	200
;	@R0	x(SP)	200
;	@-(R0)	x(SP)	200
;	@-(R0)	@SP	200
;	x(R0)	@SP	200
;	x(R0)	x(SP)	200
;	x(SP)	@SP	200
;	x(SP)	x(SP)	200
;	@x(R0)	@SP	200
;	@x(R0)	x(SP)	200
;	@x(SP)	@SP	200
;	@x(SP)	x(SP)	200
;	R0	(SP)+	200	Expect Error
;	R0	@(SP)+	200	Expect Error
;	R0	@x(SP)	200	Expect error
;	@R0	(SP)+	200	Expect Error
;	@R0	@(SP)+	200	Expect Error
;	@R0	@x(SP)	200	Expect error
;	@SP	(SP)+	200	Expect Error
;	@SP	@(SP)+	200	Expect Error
;	@SP	@x(SP)	200	Expect error
;	(R0)+	(SP)+	200	Expect Error
;	(R0)+	@(SP)+	200	Expect Error
;	(R0)+	@x(SP)	200	Expect error
;	(SP)+	(SP)+	200	Expect Error
;	(SP)+	@(SP)+	200	Expect Error
;	(SP)+	@x(SP)	200	Expect error
;	@(R0)+	(SP)+	200	Expect Error
;	@(R0)+	@(SP)+	200	Expect Error
;	@(R0)+	@x(SP)	200	Expect error
;	@(SP)+	(SP)+	200	Expect Error
;	@(SP)+	@(SP)+	200	Expect Error
;	@(SP)+	@x(SP)	200	Expect error
;	-(R0)	(SP)+	200	Expect Error
;	-(R0)	@(SP)+	200	Expect Error
;	-(R0)	@x(SP)	200	Expect error
;	@R0	(SP)+	200	Expect Error
;	@R0	@(SP)+	200	Expect Error
;	@R0	@x(SP)	200	Expect error
;	@-(R0)	(SP)+	200	Expect Error
;	@-(R0)	@(SP)+	200	Expect Error
;	@-(R0)	@x(SP)	200	Expect error
;	x(R0)	(SP)+	200	Expect Error
;	x(R0)	@(SP)+	200	Expect Error
;	x(R0)	@x(SP)	200	Expect error
;	x(SP)	(SP)+	200	Expect Error
;	x(SP)	@(SP)+	200	Expect Error
;	x(SP)	@x(SP)	200	Expect error
;	@x(R0)	(SP)+	200	Expect Error
;	@x(R0)	@(SP)+	200	Expect Error
;	@x(R0)	@x(SP)	200	Expect error
;	@x(SP)	(SP)+	200	Expect Error
;	@x(SP)	@(SP)+	200	Expect Error
;	@x(SP)	@x(SP)	200	Expect error

.Enabl	LSB
.PSect	Text
$..CMC:	.Asciz	"%SYSMAC-I-Testing ...CMC"
$.CMC0:	.Asciz	"%SYSMAC-I-tests 01-09"
$.CMC1:	.Asciz	"%SYSMAC-I-tests 11-19"
$.CMC2:	.Asciz	"%SYSMAC-I-tests 21-29"
$.CMC3:	.Asciz	"%SYSMAC-I-tests 31-39"
$.CMC4:	.Asciz	"%SYSMAC-I-tests 41-49"
$.CMC5:	.Asciz	"%SYSMAC-I-tests 51-59"
.PSect	Active
	Mov	#$..CMC,R0	;Ident the test
	Call	BegTst
	.Print	#$.CMC0

;	<B>	<B>	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#377,R0		;preload R0
	Mov	#123456,-(SP)	;value to stack
.CMC01:	...CMC	,,200		;blank arguments
	.=.-2			;squash EMT
	Cmp	#377,R0		;is R0 ok?
	Beq	101$		;yes
	Call	Err1.1
101$:
	Cmp	#123456,(SP)+	;value on stack ok?
	Beq	102$		;yes
	Call	Err1.2
102$:
	Cmp	SP,R5		;stack aligned?
	Beq	103$		;yes
	Call	Err1.3
103$:
	Mov	R5,SP

;	R0	R0	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#12,R0		;value for stack and R0
	Mov	#Patter,-(SP)	;put strange pattern on stack
	Tst	(SP)+		;restore stack
.CMC02:	...CMC	R0,R0,200
	.=.-2			;squash EMT
	Cmp	#12,R0		;is R0 ok?
	Beq	201$		;yes
	Call	Err2.1
201$:
	Cmp	#12,(SP)+	;value on stack ok?
	Beq	202$		;yes
	Call	Err2.2
202$:
	Cmp	SP,R5		;stack aligned?
	Beq	203$		;yes
	Call	Err2.3
203$:
	Mov	R5,SP

;	SP	SP	200
;;;.CMC03:	...CMC	SP,SP,200	DELETED - causes Z error

;	@R1	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#404$,R1
.PSect	Data
404$:	.Word	12
.PSect	Active
	Mov	#255,-(SP)
	Mov	#Patter,-(SP)	;put strange pattern on stack
	Tst	(SP)+		;restore stack
.CMC04:	...CMC	@R1,@SP,200
	.=.-2			;squash EMT
	Cmp	#255,R0		;is R0 ok?
	Beq	401$		;yes
	Call	Err4.1
401$:
	Cmp	#12,(SP)+	;value on stack ok?
	Beq	402$		;yes
	Call	Err4.2
402$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	403$		;yes
	Call	Err4.3
403$:
	Mov	R5,SP

;	@SP	x(R2)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#504$-4,R2
.PSect	Data
504$:	.Word	12
.PSect	Active
	Mov	#255,-(SP)
	Mov	#Patter,-(SP)	;put strange pattern on stack
	Tst	(SP)+		;restore stack
.CMC05:	...CMC	@SP,4(R2),200
	.=.-2			;squash EMT
	Cmp	#12,R0		;is R0 ok?
	Beq	501$		;yes
	Call	Err5.1
501$:
	Cmp	#255,(SP)+	;value on stack ok?
	Beq	502$		;yes
	Call	Err5.2
502$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	503$		;yes
	Call	Err5.3
503$:
	Mov	R5,SP

;	(R4)+	(SP)+	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#605$,R4
.PSect	Data
605$:	.Word	12
.PSect	Active
	Mov	#255,-(SP)	;preload stack
.CMC06:	...CMC	(R4)+,(SP)+,200
	.=.-2			;squash EMT
	Cmp	#255,R0		;is R0 ok?
	Beq	601$		;yes
	Call	Err6.1
601$:
	Cmp	#12,(SP)+	;value on stack ok?
	Beq	602$		;yes
	Call	Err6.2
602$:
	Cmp	SP,R5		;stack aligned?
	Beq	603$		;yes
	Call	Err6.3
603$:
	Cmp	R4,#605$+2
	Beq	604$
	Call	Err6.4
604$:
	Mov	R5,SP

;	(SP)+	R0	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#7,R0		;preload R0
	Mov	#255,-(SP)	;preload stack
.CMC07:	...CMC	(SP)+,R0,200
	.=.-2			;squash EMT
	Cmp	#7,R0		;is R0 ok?
	Beq	701$		;yes
	Call	Err7.1
701$:
	Cmp	#255,(SP)+	;value on stack ok?
	Beq	702$		;yes
	Call	Err7.2
702$:
	Cmp	SP,R5		;stack aligned?
	Beq	703$		;yes
	Call	Err6.3
703$:	Mov	R5,SP

;	(SP)+	(R3)+	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#805$,R3
.PSect	Data
805$:	.Word	12
.PSect	Active
	Mov	#255,-(SP)	;preload stack
.CMC08:	...CMC	(SP)+,(R3)+,200
	.=.-2			;squash EMT
	Cmp	#12,R0		;is R0 ok?
	Beq	801$		;yes
	Call	Err8.1
801$:
	Cmp	#255,(SP)+	;value on stack ok?
	Beq	802$		;yes
	Call	Err8.2
802$:
	Cmp	SP,R5		;stack aligned?
	Beq	803$		;yes
	Call	Err8.3
803$:
	Cmp	R3,#805$+2
	Beq	804$
	Call	Err8.4
804$:	Mov	R5,SP

;	@(R1)+	@(SP)+	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#909$,R1
	Mov	#907$,-(SP)
.PSect	Data
909$:	.Word	908$
908$:	.Word	12
907$:	.Word	34
.PSect	Active
.CMC09:	...CMC	@(R1)+,@(SP)+,200
	.=.-2			;squash EMT
	Cmp	#34,R0		;is R0 ok?
	Beq	901$		;yes
	Call	Err9.1
901$:
	Cmp	#12,(SP)+	;value on stack ok?
	Beq	902$		;yes
	Call	Err9.2
902$:
	Cmp	SP,R5		;stack aligned?
	Beq	903$		;yes
	Call	Err9.3
903$:
	Cmp	R1,#909$+2
	Beq	904$
	Call	Err9.4
904$:

	.Print	#$.CMC1
	Mov	R5,SP

;	@(PC)+	x(SP)	200	
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#17,-(SP)	;argument value on stack
	Tst	-(SP)		;junk on stack
.CMC11:	...CMC	#73,2(SP),200
	.=.-2			;squash EMT
	Cmp	#17,R0		;is R0 ok?
	Beq	1101$		;yes
	Call	Err1.1
1101$:
	Cmp	#73,(SP)+	;value on stack ok?
	Beq	1102$		;yes
	Call	Err1.2
1102$:
	Cmp	(SP)+,(SP)+	;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	1103$		;yes
	Call	Err1.3
1103$:	Mov	R5,SP

;	@x(R4)	@x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1208$-2,R4
	Mov	#1209$,-(SP)	;argument value on stack
.PSect	Data
1209$:	.Word	17
1208$:	.Word	1207$
1207$:	.Word	3
.PSect	Active
	Tst	-(SP)		;junk on stack
	Mov	#Patter,R0
.CMC12:	...CMC	@2(R4),@2(SP),200
	.=.-2			;squash EMT
	Cmp	#17,R0		;is R0 ok?
	Beq	1201$		;yes
	Call	Err2.1
1201$:
	Cmp	#3,(SP)+	;value on stack ok?
	Beq	1202$		;yes
	Call	Err2.2
1202$:
	Cmp	(SP)+,(SP)+	;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	1203$		;yes
	Call	Err2.3
1203$:	Mov	R5,SP

;	R0	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#773,R0		;preload R0
	Mov	#221,-(SP)	;preload stack
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC13:	...CMC	R0,@SP,200
	.=.-2			;squash EMT
	Cmp	#221,R0		;is R0 ok?
	Beq	1301$		;yes
	Call	Err3.1
1301$:
	Cmp	#773,(SP)+	;value on stack ok?
	Beq	1302$		;yes
	Call	Err3.2
1302$:
	Tst	(SP)+		;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	1303$		;yes
	Call	Err3.3
1303$:	Mov	R5,SP

;	R0	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#773,R0		;preload R0
	Mov	#321,-(SP)	;preload stack
	Mov	#Patter,-(SP)	;junk on stack
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC14:	...CMC	R0,2(SP),200
	.=.-2			;squash EMT
	Cmp	#321,R0		;is R0 ok?
	Beq	1401$		;yes
	Call	Err4.1
1401$:
	Cmp	#773,(SP)+	;value on stack ok?
	Beq	1402$		;yes
	Call	Err4.2
1402$:
	Cmp	(SP)+,(SP)+	;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	1403$		;yes
	Call	Err4.3
1403$:	Mov	R5,SP

;	@R0	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1509$,R0	;preload R0
.PSect	Data
1509$:	.Word	333
.PSect	Active
	Mov	#123,-(SP)	;preload stack
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC15:	...CMC	@R0,@SP,200
	.=.-2			;squash EMT
	Cmp	#123,R0		;is R0 ok?
	Beq	1501$		;yes
	Call	Err5.1
1501$:
	Cmp	#333,(SP)+	;value on stack ok?
	Beq	1502$		;yes
	Call	Err5.2
1502$:
	Tst	(SP)+		;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	1503$		;yes
	Call	Err5.3
1503$:	Mov	R5,SP

;	@R0	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1609$,R0	;preload R0
	Mov	#332,-(SP)	;preload stack
.PSect	Data
1609$:	.Word	321
.PSect	Active
	Tst	-(SP)		;push down stack
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC16:	...CMC	@R0,2(SP),200
	.=.-2			;squash EMT
	Cmp	#332,R0		;is R0 ok?
	Beq	1601$		;yes
	Call	Err6.1
1601$:
	Cmp	#321,(SP)+	;value on stack ok?
	Beq	1602$		;yes
	Call	Err6.2
1602$:
	Cmp	(SP)+,(SP)+	;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	1603$		;yes
	Call	Err6.3
1603$:	Mov	R5,SP

;	@SP	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#222,-(SP)
.CMC17:	...CMC	@SP,@SP,200
	.=.-2			;squash EMT
	Cmp	#222,R0		;is R0 ok?
	Beq	1701$		;yes
	Call	Err7.1
1701$:
	Cmp	#222,(SP)+	;value on stack ok?
	Beq	1702$		;yes
	Call	Err7.2
1702$:	
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	1703$		;yes
	Call	Err7.3
1703$:	Mov	R5,SP

;	@SP	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#332,-(SP)	;preload stack
	Mov	#223,-(SP)	;preload stack
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC18:	...CMC	@SP,2(SP),200
	.=.-2			;squash EMT
	Cmp	#332,R0		;is R0 ok?
	Beq	1801$		;yes
	Call	Err8.1
1801$:
	Cmp	#223,(SP)+	;value on stack ok?
	Beq	1802$		;yes
	Call	Err8.2
1802$:
	Cmp	(SP)+,(SP)+	;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	1803$		;yes
	Call	Err8.3
1803$:	Mov	R5,SP

;	(R0)+	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1909$,R0	;Point to argument
.PSect	Data
1909$:	.Word	222
.PSect	Active
	Mov	#223,-(SP)	;preload stack
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC19:	...CMC	(R0)+,@SP,200
	.=.-2			;squash EMT
	Cmp	#223,R0		;is R0 ok?
	Beq	1901$		;yes
	Call	Err9.1
1901$:
	Cmp	#222,(SP)+	;value on stack ok?
	Beq	1902$		;yes
	Call	Err9.2
1902$:
	Tst	(SP)+		;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	1903$		;yes
	Call	Err9.3
1903$:
	.Print	#$.CMC2
	Mov	R5,SP

;	(R0)+	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#2109$,R0	;Point to argument
.PSect	Data
2109$:	.Word	777
.PSect	Active
	Mov	#223,-(SP)	;preload stack
	Mov	#Patter,-(SP)	;push it down
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC21:	...CMC	(R0)+,2(SP),200
	.=.-2			;squash EMT
	Cmp	#223,R0		;is R0 ok?
	Beq	2101$		;yes
	Call	Err1.1
2101$:
	Cmp	#777,(SP)+	;value on stack ok?
	Beq	2102$		;yes
	Call	Err1.2
2102$:
	Cmp	(SP)+,(SP)+	;dump temp stuff
	Cmp	SP,R5		;stack aligned?
	Beq	2103$		;yes
	Call	Err1.3
2103$:	Mov	R5,SP

;	(SP)+	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#223,-(SP)	;preload stack
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC22:	...CMC	(SP)+,@SP,200
	.=.-2			;squash EMT
	Cmp	#223,R0		;is R0 ok?
	Beq	2201$		;yes
	Call	Err2.1
2201$:
	Cmp	#1234,(SP)+	;value on stack ok?
	Beq	2202$		;yes
	Call	Err2.2
2202$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	2203$		;yes
	Call	Err2.3
2203$:	Mov	R5,SP

;	(SP)+	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#223,-(SP)	;preload stack
	Mov	#Patter,-(SP)	;and push some more
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC23:	...CMC	(SP)+,2(SP),200
	.=.-2			;squash EMT
	Cmp	#223,R0		;is R0 ok?
	Beq	2301$		;yes
	Call	Err3.1
2301$:
	Cmp	#1234,(SP)+	;value on stack ok?
	Beq	2302$		;yes
	Call	Err3.2
2302$:
	Cmp	(SP)+,(SP)+	;dump junk
	Cmp	SP,R5		;stack aligned?
	Beq	2303$		;yes
	Call	Err3.3
2303$:	Mov	R5,SP

;	@(R0)+	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#2409$,R0	;preload R0
.PSect	Data
2409$:	.Word	2408$
2408$:	.Word	654
.PSect	Active
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC24:	...CMC	@(R0)+,@SP,200
	.=.-2			;squash EMT
	Cmp	#1234,R0		;is R0 ok?
	Beq	2401$		;yes
	Call	Err4.1
2401$:
	Cmp	#654,(SP)+	;value on stack ok?
	Beq	2402$		;yes
	Call	Err4.2
2402$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	2403$		;yes
	Call	Err4.3
2403$:	Mov	R5,SP

;	@(R0)+	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#2509$,R0	;preload stack
.PSect	Data
2509$:	.Word	2508$
2508$:	.Word	324
.PSect	Active
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;and again
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC25:	...CMC	@(R0)+,2(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	2501$		;yes
	Call	Err5.1
2501$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	2502$		;yes
	Call	Err5.2
2502$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	2503$		;yes
	Call	Err5.3
2503$:	Mov	R5,SP

;	@(SP)+	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1233,-(SP)	;push it down
	Mov	#2609$,-(SP)	;preload stack
.PSect	Data
2609$:	.Word	323
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC26:	...CMC	@(SP)+,@SP,200
	.=.-2			;squash EMT
	Cmp	#1233,R0	;is R0 ok?
	Beq	2601$		;yes
	Call	Err6.1
2601$:
	Cmp	#323,(SP)+	;value on stack ok?
	Beq	2602$		;yes
	Call	Err6.2
2602$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	2603$		;yes
	Call	Err6.3
2603$:	Mov	R5,SP

;	@(SP)+	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;bury it
	Mov	#2709$,-(SP)	;push
.PSect	Data
2709$:	.Word	3333
.Psect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC27:	...CMC	@(SP)+,2(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	2701$		;yes
	Call	Err7.1
2701$:
	Cmp	#3333,(SP)+	;value on stack ok?
	Beq	2702$		;yes
	Call	Err7.2
2702$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	2703$		;yes
	Call	Err7.3
2703$:	Mov	R5,SP

;	-(R0)	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#2809$+2,R0	;preload R0
.PSect	Data
2809$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC28:	...CMC	-(R0),@SP,200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	2801$		;yes
	Call	Err8.1
2801$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	2802$		;yes
	Call	Err8.2
2802$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	2803$		;yes
	Call	Err8.3
2803$:	Mov	R5,SP

;	-(R0)	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;and cover it
	Mov	#2909$+2,R0	;preload R0
.PSect	Data
2909$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC29:	...CMC	-(R0),2(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	2901$		;yes
	Call	Err9.1
2901$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	2902$		;yes
	Call	Err9.2
2902$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	2903$		;yes
	Call	Err9.3
2903$:
	.Print	#$.CMC3
	Mov	R5,SP

;	@R0	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#3109$,R0	;preload R0
.PSect	Data
3109$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC31:	...CMC	@R0,@SP,200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	3101$		;yes
	Call	Err1.1
3101$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	3102$		;yes
	Call	Err1.2
3102$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3103$		;yes
	Call	Err1.3
3103$:	Mov	R5,SP

;	@R0	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;and cover it up
	Mov	#3209$,R0	;preload R0
.PSect	Data
3209$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC32:	...CMC	@R0,2(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	3201$		;yes
	Call	Err2.1
3201$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	3202$		;yes
	Call	Err2.2
3202$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3203$		;yes
	Call	Err2.3
3203$:	Mov	R5,SP

;	@-(R0)	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;and cover it up
	Mov	#3309$+2,R0	;preload R0
.PSect	Data
3309$:	.Word	3308$
3308$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC33:	...CMC	@-(R0),2(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	3301$		;yes
	Call	Err3.1
3301$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	3302$		;yes
	Call	Err3.2
3302$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3303$		;yes
	Call	Err3.3
3303$:	Mov	R5,SP

;	@-(R0)	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#3409$+2,R0	;preload R0
.PSect	Data
3409$:	.Word	3408$
3408$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC34:	...CMC	@-(R0),@SP,200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	3401$		;yes
	Call	Err4.1
3401$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	3402$		;yes
	Call	Err4.2
3402$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3403$		;yes
	Call	Err4.3
3403$:	Mov	R5,SP

;	x(R0)	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;and cover it up
	Mov	#3509$-2,R0	;preload R0
.PSect	Data
3509$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC35:	...CMC	2(R0),2(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	3501$		;yes
	Call	Err5.1
3501$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	3502$		;yes
	Call	Err5.2
3502$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3503$		;yes
	Call	Err5.3
3503$:	Mov	R5,SP

;	x(SP)	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#324,-(SP)	;preload R0
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC36:	...CMC	2(SP),@SP,200
	.=.-2			;squash EMT
	Cmp	#324,R0	;is R0 ok?
	Beq	3601$		;yes
	Call	Err6.1
3601$:
	Cmp	#1234,(SP)+	;value on stack ok?
	Beq	3602$		;yes
	Call	Err6.2
3602$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3603$		;yes
	Call	Err6.3
3603$:	Mov	R5,SP

;	x(SP)	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#4321,-(SP)	;and put in another
	Mov	#Patter,-(SP)	;and cover it up
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC37:	...CMC	2(SP),4(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	3701$		;yes
	Call	Err7.1
3701$:
	Cmp	#4321,(SP)+	;value on stack ok?
	Beq	3702$		;yes
	Call	Err7.2
3702$:
	Cmp	(SP)+,(SP)+
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3703$		;yes
	Call	Err7.3
3703$:	Mov	R5,SP

;	@x(R0)	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#3809$-2,R0	;preload R0
.PSect	Data
3809$:	.Word	3808$
3808$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC38:	...CMC	@2(R0),@SP,200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	3801$		;yes
	Call	Err8.1
3801$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	3802$		;yes
	Call	Err8.2
3802$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3803$		;yes
	Call	Err8.3
3803$:	Mov	R5,SP

;	@x(R0)	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;and cover it up
	Mov	#3909$-2,R0	;preload R0
.PSect	Data
3909$:	.Word	3908$
3908$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC39:	...CMC	@2(R0),2(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	3901$		;yes
	Call	Err9.1
3901$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	3902$		;yes
	Call	Err9.2
3902$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	3903$		;yes
	Call	Err9.3
3903$:
	.Print	#$.CMC4
	Mov	R5,SP

;	@x(SP)	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#4109$,-(SP)	;push it down
.PSect	Data
4109$:	.Word	1234
.PSect	Active
	Mov	#350,-(SP)	;preload R0
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC41:	...CMC	@2(SP),@SP,200
	.=.-2			;squash EMT
	Cmp	#350,R0		;is R0 ok?
	Beq	4101$		;yes
	Call	Err1.1
4101$:
	Cmp	#1234,(SP)+	;value on stack ok?
	Beq	4102$		;yes
	Call	Err1.2
4102$:
	Cmp	(SP)+,(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	4103$		;yes
	Call	Err1.3
4103$:	Mov	R5,SP

;	@x(SP)	x(SP)	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#4209$,-(SP)	;preload R0
.PSect	Data
4209$:	.Word	2345
.PSect	Active
	Mov	#1234,-(SP)	;push it down
	Mov	#Patter,-(SP)	;shove it down
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC42:	...CMC	@4(SP),2(SP),200
	.=.-2			;squash EMT
	Cmp	#1234,R0		;is R0 ok?
	Beq	4201$		;yes
	Call	Err2.1
4201$:
	Cmp	#2345,(SP)+	;value on stack ok?
	Beq	4202$		;yes
	Call	Err2.2
4202$:
	Cmp	(SP)+,(SP)+
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	4203$		;yes
	Call	Err2.3
4203$:	Mov	R5,SP

;	x(R0)	@SP	200
	Mov	#Patter,R0	;trash R0
	Mov	SP,R5		;current stack alignment
	Mov	#1234,-(SP)	;push it down
	Mov	#4909$-2,R0	;preload R0
.PSect	Data
4909$:	.Word	324
.PSect	Active
	Mov	#Patter,-(SP)	;junk on stack
	Tst	(SP)+		;pop junk
.CMC49:	...CMC	2(R0),@SP,200
	.=.-2			;squash EMT
	Cmp	#1234,R0	;is R0 ok?
	Beq	4901$		;yes
	Call	Err9.1
4901$:
	Cmp	#324,(SP)+	;value on stack ok?
	Beq	4902$		;yes
	Call	Err9.2
4902$:
	Tst	(SP)+
	Cmp	SP,R5		;stack aligned?
	Beq	4903$		;yes
	Call	Err9.3
4903$:
	Mov	R5,SP
	.Print	#$.CMC5
.PSect	Data
.CMC52:	...CMC	(SP)+,R0,200
.=.-2
5209$:
.=.+2
.PSect	Active
	Cmp	#EMT+200,5209$
	Beq	5201$
	Call	Err2.1
5201$:
.PSect	Data
.CMC53:	...CMC	R4,R0,200
.=.-2
5309$:
.=.+2
.PSect	Active
	Cmp	#EMT+200,5309$
	Beq	5301$
	Call	Err3.1
5301$:
.PSect	Data
.CMC54:	...CMC	(SP)+,2(SP),200
.=.-2
5409$:
.=.+2
.PSect	Active
	Cmp	#EMT+200,5409$
	Beq	5401$
	Call	Err4.1
5401$:
.PSect	Data
.CMC55:	...CMC	(SP)+,R4,200
.=.-2
5509$:
.=.+2
.PSect	Active
	Cmp	#EMT+200,5509$
	Beq	5501$
	Call	Err5.1
5501$:
.PSect	Data
.CMC56:	...CMC	R0,@SP,200
.=.-2
5609$:
.=.+2
.PSect	Active
	Cmp	#EMT+200,5609$
	Beq	5601$
	Call	Err6.1
5601$:
.PSect	Data
.CMC57:	...CMC	R4,2(SP),200
.=.-2
5709$:
.=.+2
.PSect	Active
	Cmp	#EMT+200,5709$
	Beq	5701$
	Call	Err7.1
5701$:
.PSect	Data
.CMC58:	...CMC	@R0,@SP,200
.=.-2
5809$:
.=.+2
.PSect	Active
	Cmp	#EMT+200,5809$
	Beq	5801$
	Call	Err8.1
5801$:
	Mov	R5,SP
.IF NE	MAC$ER
	...CMC	R0	(SP)+	200 ;	Expect Error
	...CMC	R0	@(SP)+	200 ;	Expect Error
	...CMC	R0	@x(SP)	200 ;	Expect error
	...CMC	@R0	(SP)+	200 ;	Expect Error
	...CMC	@R0	@(SP)+	200 ;	Expect Error
	...CMC	@R0	@x(SP)	200 ;	Expect error
	...CMC	@SP	(SP)+	200 ;	Expect Error
	...CMC	@SP	@(SP)+	200 ;	Expect Error
	...CMC	@SP	@x(SP)	200 ;	Expect error
	...CMC	(R0)+	(SP)+	200 ;	Expect Error
	...CMC	(R0)+	@(SP)+	200 ;	Expect Error
	...CMC	(R0)+	@x(SP)	200 ;	Expect error
	...CMC	(SP)+	(SP)+	200 ;	Expect Error
	...CMC	(SP)+	@(SP)+	200 ;	Expect Error
	...CMC	(SP)+	@x(SP)	200 ;	Expect error
	...CMC	@(R0)+	(SP)+	200 ;	Expect Error
	...CMC	@(R0)+	@(SP)+	200 ;	Expect Error
	...CMC	@(R0)+	@x(SP)	200 ;	Expect error
	...CMC	@(SP)+	(SP)+	200 ;	Expect Error
	...CMC	@(SP)+	@(SP)+	200 ;	Expect Error
	...CMC	@(SP)+	@x(SP)	200 ;	Expect error
	...CMC	-(R0)	(SP)+	200 ;	Expect Error
	...CMC	-(R0)	@(SP)+	200 ;	Expect Error
	...CMC	-(R0)	@x(SP)	200 ;	Expect error
	...CMC	@R0	(SP)+	200 ;	Expect Error
	...CMC	@R0	@(SP)+	200 ;	Expect Error
	...CMC	@R0	@x(SP)	200 ;	Expect error
	...CMC	@-(R0)	(SP)+	200 ;	Expect Error
	...CMC	@-(R0)	@(SP)+	200 ;	Expect Error
	...CMC	@-(R0)	@x(SP)	200 ;	Expect error
	...CMC	x(R0)	(SP)+	200 ;	Expect Error
	...CMC	x(R0)	@(SP)+	200 ;	Expect Error
	...CMC	x(R0)	@x(SP)	200 ;	Expect error
	...CMC	x(SP)	(SP)+	200 ;	Expect Error
	...CMC	x(SP)	@(SP)+	200 ;	Expect Error
	...CMC	x(SP)	@x(SP)	200 ;	Expect error
	...CMC	@x(R0)	(SP)+	200 ;	Expect Error
	...CMC	@x(R0)	@(SP)+	200 ;	Expect Error
	...CMC	@x(R0)	@x(SP)	200 ;	Expect error
	...CMC	@x(SP)	(SP)+	200 ;	Expect Error
	...CMC	@x(SP)	@(SP)+	200 ;	Expect Error
	...CMC	@x(SP)	@x(SP)	200 ;	Expect error
.EndC;	NE MAC$ER
	Call	EndTst
	Mov	R5,SP

;-TEST
.Page
.SbTtl	...CMV	Define monitor prefix, release, version, and suffix
;+
;	...CMV
;
;	The ...CMV macro defines the system identification number
;	and letters for various system components.  It is provided
;	in SYSMAC, so that changes to it need to be done only in one
;	place and so that the monitor sources will be (potentially)
;	version independent, in that a change to the system version
;	identification will not require changing monitor sources.
;
;	NOTE: to change the release value defaulted for .MODULE, you
;	must also alter the .MODULE definition.  The value in .MODULE
;	RELEASE=prr should be defined as p being the same as ...CMV
;	XPREFIX=p and rr being the same as ...CMV XRELEASE=rr
;
;	SUFFIX should be defaulted to space.
;	SUFFIX may be 1 or 2 characters long.
;
;	Assuming XPREFIX=X, XRELEASE=05, XVERSION=09,XSUFFIX=ca
;
;	TYPE=Z	generate .ASCIZ	(default)	.ASCIZ "X05.09 ca"
;	TYPE=I	generate .ASCII			.ASCII "X05.09 ca"
;	TYPE=V	generate values			RT$%%% =: ...
;
;	For TYPE=Z or I the following is generated:
;
;	PART=ALL    generate std ID (default)	.ASCIZ "X05.09 ca"
;	PART=PREFIX generate letter prefix	.ASCIZ "X"
;	PART=RELEASEgenerate release infix	.ASCIZ "05"
;	PART=VERSIONgenerate version infix	.ASCIZ "09"
;	PART=SUFFIX generate baselevel suffix	.ASCIZ "ca"
;
;	For TYPE=V the following is generated:
;
;	PART=ALL	all of the following
;	PART=PREFIX	RT$PRE =: 'X
;	PART=RELEASE	RT$RLS =: 05.
;	PART=VERSION	RT$VER =: 09.
;	PART=SUFFIX	RT$SUF =: 'c
;	PART=SUBFIX	RT$SUB =: 'a
;-

.Page
.MACRO	...CMV	TYPE=Z,PART=ALL,XPREFIX=V,XRELEASE=05,XVERSION=07,XSUFFIX=< >
.IF	IDN	<PART> <ALL>
.IF	IDN	<TYPE> <V>
RT$PRE	=:	''XPREFIX
RT$REL	=:	'XRELEASE'.
RT$VER	=:	'XVERSION'.
.IRPC x <XSUFFIX>
RT$SUF	=:	''x
.MEXIT
.ENDR
.IRPC x <XSUFFIX>
...V2	=	''x
.ENDR
RT$SUB	=:	...V2
.IFF
	.ASCI'TYPE'	"'XPREFIX''XRELEASE'.'XVERSION' 'XSUFFIX'"
.ENDC
.ENDC
.IF	IDN	<PART> <PREFIX>
.IF	IDN	<TYPE> <V>
RT$PRE	=:	''XPREFIX
.IFF
	.ASCI'TYPE'	"'XPREFIX'"
.ENDC
.ENDC
.IF	IDN	<PART> <RELEASE>
.IF	IDN	<TYPE> <V>
RT$REL	=:	'XRELEASE'.
.IFF
	.ASCI'TYPE'	"'XRELEASE'"
.ENDC
.ENDC
.IF	IDN	<PART> <VERSION>
.IF	IDN	<TYPE> <V>
RT$VER	=:	'XVERSION'.
.IFF
	.ASCI'TYPE'	"'XVERSION'"
.ENDC
.ENDC
.IF	IDN	<PART> <SUFFIX>
.IF	IDN	<TYPE> <V>
.IRPC x <XSUFFIX>
RT$SUF	=:	''x
.MEXIT
.ENDR
.IFF
	.ASCI'TYPE'	"'XSUFFIX'"
.ENDC
.ENDC
.IF	IDN	<PART> <SUBFIX>
.IF	IDN	<TYPE> <V>
.IRPC x <XSUFFIX>
...V2	=	''x
.ENDR
RT$SUB	=:	...V2
.IFF
	.ASCI'TYPE'	"'XSUFFIX'"
.ENDC
.ENDC
.ENDM

;+TEST
.Page
	.List ME
.PSect	Text
	...CMV	TYPE=I,PART=ALL
	...CMV	TYPE=I,PART=PREFIX
	...CMV	TYPE=I,PART=RELEASE
	...CMV	TYPE=I,PART=VERSION
	...CMV	TYPE=I,PART=SUFFIX

	...CMV	TYPE=Z,PART=ALL
	...CMV	TYPE=Z,PART=PREFIX
	...CMV	TYPE=Z,PART=RELEASE
	...CMV	TYPE=Z,PART=VERSION
	...CMV	TYPE=Z,PART=SUFFIX

	...CMV	TYPE=V,PART=ALL
	...CMV	TYPE=V,PART=PREFIX
	...CMV	TYPE=V,PART=RELEASE
	...CMV	TYPE=V,PART=VERSION
	...CMV	TYPE=V,PART=SUFFIX
	.NList ME
;-TEST
.Page
.SbTtl	...CMY	Verify that ...CMZ has not been altered
;+
;	...CMY
;
;	The ...CMY checks that the user has not patched
;	out the ...CMZ message.  If the ...CMZ code or
;	message has been altered, the ...CMY causes a
;	trap to 10 from location -1.
;
;NOTE: ...CMY and ...CMZ need to be nulled out / reestablished
;	as a pair.
;-

.MACRO	...CMY	L0,L1,L2,L3
.ENDM

;.MACRO	...CMY	L0=...CMA,L1=...CMZ,?L2,?L3
;	MOV	R0,-(SP)
;	MOV	R1,-(SP)
;	MOV	#L0,R0
;	CLR	R1
;L2:	ADD	(R0)+,R1
;	CMP	R0,#L1+2.
;	BNE	L2
;	CMP	#...V8,R1
;	BEQ	L3
;	MOV	#-1,-(SP)
;	MOV	@SP,-(SP)
;	CLC
;	JMP	@10
;L3:
;	MOV	(SP)+,R1
;	MOV	(SP)+,R0
;.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$..CMY:	.Asciz	"%SYSMAC-I-Testing ...CMY"
.PSect	Active
	Mov	#$..CMY,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	...CMZ	Field test / DECUS bomb
;+
;	...CMZ
;
;	This macro is designed to be included in the startup code
;	of each of the CUSPs and monitor images.  It is designed
;	to irritate users who are using field test software after
;	the end of field test.  During generation of field test
;	baselevels, use the long definition of ...CMZ.  When
;	building the actual release software, use the "null"
;	(2 line) definition of ...CMZ to remove the message.
;
;	The macro has one argument which is to be set in each
;	program:
;
;	FUDGE	-- Should be set to the edit level (.SL in SL)
;		of each module.  This will "randomize" the number
;		of days after expiration that each component will
;		start hassling the user.  This will increase the
;		irritation.
;
;	The macro has 3 additional arguments which should be set
;	in SYSMAC.MAC by the project leader at an arbitrary date
;	following the end of field test:
;
;	DAY	-- day of the month 1-31
;	MON	-- three letter month name (in English)
;	YEAR	-- last 2 digits of the year.
;
;	The L0, L1 and L2 arguments should be left to default.
;
;	NOTE: The date comparison used is NOT exact, it is
;	a +-1 day test since the low bit of the day is lost.
;-
.Page
;NOTE: for field test, uncomment first .MACRO, delete second .MACRO
;	Then remove the .IF EQ 1 conditional and leave the Field
;	Test message
;
;NOTE: ...CMY and ...CMZ need to be nulled out / reestablished
;	as a pair.


.MACRO	...CMZ	FUDGE,DAY,MON,YEAR,L0,L1,L2
.ENDM

;.MACRO	...CMZ	FUDGE=0,DAY=15,MON=SEP,YEAR=92,L0=...CMA,?L1,L2=...CMZ
;...V8=0
;...V2=0
;...V3=-1
;.IRP X,<JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC>
;...V2=...V2+1
;.IIF IDN <X>,<MON> ...V3=...V2
;.ENDR
;.IIF LT ...V3 .ERROR ;?SYSMAC-E-Invalid date, found - 'MON';
;L0:	MOV	R0,-(SP)	;Save work reg
;				...V8=...V8+MOV+0000+46
;	MOV	#12*^o400,R0	;.DATE
;				...V8=...V8+MOV+2700+00
;				...V8=...V8+<12*^o400>
;	EMT	374		;...
;				...V8=...V8+EMT+374
;	MOV	R0,-(SP)	;Save date
;				...V8=...V8+MOV+0000+46
;	ASL	R0		;<month||day>/4
;				...V8=...V8+ASL+00
;	ASL	R0		;...
;				...V8=...V8+ASL+00
;	SWAB	R0		;<month||day>/2 to low byte
;				...V8=...V8+SWAB+00
;	SWAB	@SP		;Year to high byte
;				...V8=...V8+SWAB+16
;	MOVB	R0,@SP		;Combine them
;				...V8=...V8+MOVB+0000+16
;	BIC	#^c17777,@SP	;Mask junk
;				...V8=...V8+BIC+2700+16
;				...V8=...V8+^c17777
;	CMP	#<'YEAR'.-72.>*^o400+<...V3*20>+<<DAY+1>/2>+<FUDGE>,(SP)+ ;Past limit?
;				...V8=...V8+CMP+2700+26
;		...V8=...V8+<<'YEAR'.-72.>*^o400+<...V3*20>+<<DAY+1>/2>+<FUDGE>>
;	BGE	L2		;No, skip message
;				...V8=...V8+BGE+<L2-./2>
;	MOV	PC,R0		;PIC
;				...V8=...V8+MOV+0700+00
;	ADD	#L1-.,R0	;Load message addr
;				...V8=...V8+ADD+2700+00
;				...V8=...V8+L1-.+4
;	EMT	351		;.Print
;				...V8=...V8+EMT+351
;	BR	L2		;Skip text
;				...V8=...V8+BR+<L2-./2>
;.IF	EQ	0
;L1:	.ASCIZ	"?RT11-W-Field test over"
;				...V8=...V8+'?+<'R*^o400>
;				...V8=...V8+'T+<'1*^o400>
;				...V8=...V8+'1+<'-*^o400>
;				...V8=...V8+'W+<'-*^o400>
;				...V8=...V8+'F+<'i*^o400>
;				...V8=...V8+'e+<'l*^o400>
;				...V8=...V8+'d+<' *^o400>
;				...V8=...V8+'t+<'e*^o400>
;				...V8=...V8+'s+<'t*^o400>
;				...V8=...V8+' +<'o*^o400>
;				...V8=...V8+'v+<'e*^o400>
;				...V8=...V8+'r+<000*^o400>
;	.EVEN
;.IFF
;L1:	.ASCIZ	"?DECUS-U-Pirated system"
;				...V8=...V8+'?+<'D*^o400>
;				...V8=...V8+'E+<'C*^o400>
;				...V8=...V8+'U+<'S*^o400>
;				...V8=...V8+'-+<'U*^o400>
;				...V8=...V8+'-+<'P*^o400>
;				...V8=...V8+'i+<'r*^o400>
;				...V8=...V8+'a+<'t*^o400>
;				...V8=...V8+'e+<'d*^o400>
;				...V8=...V8+' +<'s*^o400>
;				...V8=...V8+'y+<'s*^o400>
;				...V8=...V8+'t+<'e*^o400>
;				...V8=...V8+'m+<000*^o400>
;.ENDC
;L2:	MOV	(SP)+,R0	;Restore work reg
;				...V8=...V8+MOV+2600+00
;.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$..CMZ:	.Asciz	"%SYSMAC-I-Testing ...CMZ"
.PSect	Active
	Mov	#$..CMZ,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
.If	NE	MAC$ER
;Expect P error
...CMZ	MON=XXX
.EndC
;-TEST
.SbTtl	.ABTIO	Abort I/O on a channel
.MACRO	.ABTIO	CHAN
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM3	<CHAN>,11.
.ENDM

;+TEST
.PAGE
.Enabl	LSB
.PSect	Text
$ABTIO:	.Asciz	"%SYSMAC-I-Testing .ABTIO"
.PSect	Active
	Mov	#$ABTIO,R0	;Ident the test(s)
	Call	BegTst
	Mov	#Patter,R0
ABTIO1:	.ABTIO	#0
	.=.-2			;squash EMT
	Cmp	#.ABTIO*^o400+0,R0 ;Is R0 right?
	Beq	10$
	Call	Err1
10$:
	Mov	#Patter,R0
ABTIO2:	.ABTIO	#1
	.=.-2			;squash EMT
	Cmp	#.ABTIO*^o400+1,R0 ;Is R0 right?
	Beq	20$
	Call	Err2
20$:
	Mov	#Patter,R0
ABTIO3:	.ABTIO	#^o377
	.=.-2			;squash EMT
	Cmp	#.ABTIO*^o400+^o377,R0 ;Is R0 right?
	Beq	30$
	Call	Err3
30$:
	Mov	#12,R0
ABTIO4:	.ABTIO	R0
	.=.-2			;squash EMT
	Cmp	#.ABTIO*^o400+12,R0 ;Is R0 right?
	Beq	40$
	Call	Err4
40$:
	Mov	#Patter,R0
	Mov	#1,R1
ABTIO5:	.ABTIO	R1
	.=.-2			;squash EMT
	Cmp	#.ABTIO*^o400+1,R0 ;Is R0 right?
	Beq	50$
	Call	Err5
50$:
	Mov	#Patter,R0
ABTIO6:	.ABTIO	65$		;try getting chan from an odd addr
	.=.-2			;squash EMT
.PSect	Data
	.Odd
65$:	.Byte	2		;Channel 2 at an odd addr
	.Even
.PSect	Active
	Cmp	#.ABTIO*^o400+2.,R0 ;Is R0 right?
	Beq	60$
	Call	Err6
60$:
.PSect	Data
ABTIO7:	.ABTIO
.=.-2.
73$:
.=.+2.
75$:
.PSect	Active
	Cmp	#EMT+...R0,73$	;was the correct EMT generated?
	Beq	70$		;Yes
	Call	Err7
70$:
	Call	EndTst
.Dsabl	LSB
	Mov	R5,SP

;-TEST
.Page
.SbTtl	.ADDR	Generate PIC equivalent of MOV #___,<reg ref>
.MACRO	.ADDR	ADR,REG,TYPE
.NTYPE	...V2,ADR
.IIF NE	...V2-^o27 .ERROR ...V2; ?SYSMAC-E-Invalid A D R, expecting #..., found - ADR;
.NTYPE	...V2,REG
.IF EQ	...V2-^o46
.IF  IDN <TYPE>,<ADD>
	ADD	PC,-(SP)
.ERROR ; ?SYSMAC-W-This operation may produce random results;
.IFF
	MOV	PC,-(SP)
.ENDC
	ADD	ADR-.,@SP
.MEXIT
.ENDC
.IF IDN <TYPE>,<PUSH>
.IF GT	...V2-5.
	MOV	REG,-(SP)
.IFF
	JSR	REG,@PC
	ADD	ADR-.,REG
.MEXIT
.ENDC
.ENDC
.IF IDN	<TYPE>,<ADD>
	ADD	PC,REG
.IFF
	MOV	PC,REG
.ENDC
	ADD	ADR-.,REG
.IRP	X,<0,1,2,3,4,5,10,11,12,13,14,15,16>
.IIF EQ	...V2-^o'x ...V2=0
.ENDR
.IIF NE ...V2 .ERROR ; ?SYSMAC-E-Invalid R E G, expecting Rx/@Rx/-(SP), found - REG;
.ENDM

;+TEST
.PSect	Static
.If	NE	MAC$ER
;Expect P error
.ADDR	1,R0
;Expect P error
.ADDR	R0,R0
;Expect P error
.ADDR	@R0,R0
;Expect P error
.ADDR	1(R0),R0
;Expect P error
.ADDR	@(R0),R0
;Expect P error
.ADDR	-(R0),R0
;Expect P error
.ADDR	(R0)+,R0
;Expect P error
.ADDR	#1,-(SP),ADD
;Expect P error
.ADDR	#1,SP
;Expect P error
.ADDR	#1,1
;Expect P error
.ADDR	#1,#1
;Expect P error
.ADDR	#1,-(R0)
;Expect P error
.ADDR	#1,(R0)+
;Expect P error
.ADDR	#1,1(R0)
.EndC
;-TEST
.Page
.SbTtl	.ASSUME	Verify assumption at assembly time
.MACRO	.ASSUME	A,REL,C,MESSAGE
.IF REL	<<A>>-<<C>>
.IFF
.IF B <MESSAGE>
.ERROR;?SYSMAC-W-"A REL C" is not true;
.IFF
.ERROR	;?SYSMAC-MESSAGE;
.ENDC
.ENDC
.ENDM	.ASSUME

;+TEST
.PSect	Static
.If	NE	MAC$ER
;Expect P error
.ASSUME	1 EQ 0
;Expect P error
.ASSUME 1 EQ 0 MESSAGE=<...V1 ; this is a test>
;Expect P error
.ASSUME 1 EQ 0 MESSAGE=<...V1; this is another test>
.EndC
;-TEST
.Page
.SbTtl	.AUDIT	Generate module audit information in abs 110+
;++
;	.AUDIT
;
;	macro to generate list of versions starting at abs 110
;
;	up to 26 names
;
;	First reference generates a RAD50 value for 110 of release
;--

.MACRO	.AUDIT	Q,W,E,R,T,Y,U,I,O,P,A,S,D,F,G,H,J,K,L,Z,X,C,V,B,N,M
.SAVE
.ASECT
.IIF	NDF	...V5	...V5=^o110
.=...V5
.IF	EQ	.-^o110
	.GLOBL	.AUDIT
	.WORD	.AUDIT
.ENDC
.IRP	...V2 <Q,W,E,R,T,Y,U,I,O,P,A,S,D,F,G,H,J,K,L,Z,X,C,V,B,N,M>
.IF	NB	<...V2>
	.GLOBL	'...V2'
	.WORD	'...V2'
.ENDC
.ENDR
...V5=.
	.WORD	-1
.RESTORE
.ENDM	.AUDIT

;+TEST
;>>>no static test
;-TEST
.Page
.SbTtl	.BR	Verify assumption of "Drop through" coding
.MACRO	.BR	TO
.IF P2
.IF DF	TO
.IF NE	TO-.
.ERROR;?SYSMAC-E-Not at location TO;
.ENDC
.IFF
.ERROR;?SYSMAC-E-TO is not defined;
.ENDC
.ENDC
.ENDM	.BR

;+TEST
.PSect	Static
.If	NE	MAC$ER
;Expect P error
	.BR	10$
	.Word	
10$:
	.Globl	Global
	.BR	Global
.EndC
;-TEST
.Page
.SbTtl	.CALLK	Call a routine in kernel mapping
.MACRO	.CALLK	Dest,Pic
.IF NDF	.MACS
.MCALL	.MACS
.MACS
.ENDC
.IF NB <Dest>
.IF B <Pic>
...CM0	Dest
.IFF
.MCALL	.ADDR
	.ADDR	Dest,-(SP)
.ENDC
.ENDC
	EMT	^o373
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CALLK:	.Asciz	"%SYSMAC-I-Testing .CALLK"
.PSect	Active
	Mov	#$CALLK,R0	;Ident the test(s)
	Call	BegTst
.PSect	Data
CALLK1:	.CallK
.PSect	Active
	Cmp	#EMT+...CAL,CALLK1 ;correct EMT generated?
	Beq	20$		;yes
	Call	Err1
20$:
	Mov	SP,R1		;save stack pointer
CALLK2:	.CallK
	.=.-2			;squash EMT
	Cmp	SP,R1		;stack aligned?
	Beq	30$		;yes	
	Call	Err2
30$:
	Mov	SP,R1		;save stack pointer
CALLK3:	.CallK	#CALLK3
	.=.-2			;squash EMT
	Cmp	(SP)+,#CALLK3	;correct value stacked?
	Beq	40$		;yes
	Call	Err3.1
40$:
	Cmp	SP,R1		;stack aligned?
	Beq	50$		;yes	
	Call	Err3.2
50$:
.PSect	Data
CALLK4:	.CallK	,PIC
.PSect	Active
	Cmp	#EMT+...CALL,CALLK4 ;correct EMT generated?
	Beq	70$		;yes
	Call	Err4
70$:
	Mov	SP,R1		;save stack pointer
CALLK5:	.CallK	,PIC
	.=.-2			;squash EMT
	Cmp	SP,R1		;stack aligned?
	Beq	80$		;yes	
	Call	Err5
80$:
	Mov	SP,R1		;save stack pointer
CALLK6:	.CallK	#CALLK6,PIC
	.=.-2			;squash EMT
	Cmp	(SP)+,#CALLK6	;correct value stacked?
	Beq	90$		;yes
	Call	Err6.1
90$:
	Cmp	SP,R1		;stack aligned?
	Beq	100$		;yes	
	Call	Err6.2
100$:
	Call	EndTst		;end of test
.Dsabl LSB
;-TEST
.Page
.SBTTL	.CALLS	call to supervisor mode
;+
;	.CALLS
;
;	This macro generates a standardized call to supervisor mode
;	that is designed to interface with the SHANDL interrupt
;	handler.
;
;	It may called in two forms:
;
;	.CALLS	#0		;special "do anything call"
;	.CALLS	#non-zero	;standard call
;
;	The #0 form requires that a PS and PC be pushed on the stack.
;	These will be RTIed after the transfer to supervisor mode.
;
;	The #non-zero form specifies a virtual address in supervisor I
;	space to transfer to.  The # addressing mode is recommended, as
;	other addressing modes will not be simulated on non-CSM machines
;
;	As part of the return path from a supervisor mode routine, SHANDL
;	moves all or part of the condition code settings from the Supy PS
;	to the User PS.  The condition codes to be transferred are listed
;	in the RETURN argument.  It defaults to NZVC.
;-

.MACRO	.CALLS	DEST,RETURN=NZVC
.IF DIF <DEST>,<#0>
...V4=0
.IF	DIF	<A>,<a>
	...V4 = 1
	.DSABL	LCM
.ENDC
...V2=0
.IF NB <RETURN>
.IRPC x,'RETURN'
...V3=0
.IIF IDN x,C	...V3=2.
.IIF IDN x,V	...V3=4.
.IIF IDN x,Z	...V3=8.
.IIF IDN x,N	...V3=16.
.IIF EQ ...V3,.ERROR;?SYSMAC-E-Invalid R E T U R N, expecting N,Z,V,C found - 'return';
...V2=...V2!...V3
.ENDR
.ENDC
.IIF NE ...V4 .ENABL LCM
	MOV	#...V2,-(SP)
.ENDC
	CSM	DEST
.ENDM

;+TEST
.PAGE
.Enabl	LSB
.list meb;**DEBUG**
.PSect	Text
$CALLS:	.Asciz	"%SYSMAC-I-Testing .CALLS"
$CCNIL=0*2
$CCC=1.*2
$CCV=2.*2
$CCVC=3.*2
$CCZ=4.*2
$CCZC=5.*2
$CCZV=6.*2
$CCZVC=7.*2
$CCN=8.*2
$CCNC=9.*2
$CCNV=10.*2
$CCNVC=11.*2
$CCNZ=12.*2
$CCNZC=13.*2
$CCNZV=14.*2
$CCALL=15.*2
.PSect	Active
	Mov	#$CALLS,R0	;Ident the test(s)
	Call	BegTst
.PSect	Data
CALLS1:	.CALLS	#0
10$:
.=.-4.
20$:
.=.+4.
.PSect	Active
	Cmp	#4,#10$-CALLS1	;was only one instruction generated?
	Beq	30$		;yes
	Call	Err1.1
30$:
	Cmp	#CSM+27,20$	;was the correct opcode generated?
	Beq	40$		;Yes
	Call	Err1.2
40$:
	Cmp	#0,20$+2	;was the correct immediate value generated?
	Beq	50$		;Yes
	Call	Err1.3
50$:
.PSect	Data
CALLS2:	.CALLS	#1
60$:
.=.-4.
70$:
.=.+4.
.PSect	Active
	Cmp	#8.,#60$-CALLS2	;were two instructions generated?
	Beq	80$		;yes
	Call	Err2.1
80$:
	Cmp	#MOV+2700+46,CALLS2 ;was the correct opcode generated?
	Beq	90$		;Yes
	Call	Err2.2
90$:
	Cmp	#$CCALL,CALLS2+2 ;was the correct immediate value generated?
	Beq	100$		;Yes
	Call	Err2.3
100$:
	Cmp	#CSM+27,70$	;was the correct opcode generated?
	Beq	110$		;Yes
	Call	Err2.4
110$:
	Cmp	#1,70$+2	;was the correct immediate value generated?
	Beq	120$		;Yes
	Call	Err2.5
120$:
	Mov	SP,R5
CALLS3:	.CALLS	#1,RETURN=<>
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCNIL	;correct return address?
	Beq	130$		;yes
	Call	Err3.1
130$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	140$		;yes
	Call	Err3.2
	Mov	R5,SP
140$:
	Mov	SP,R5
	.CALLS	#1,RETURN=c
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCC	;correct return address?
	Beq	150$		;yes
	Call	Err3.3
150$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	160$		;yes
	Call	Err3.4
	Mov	R5,SP
160$:
	Mov	SP,R5
	.CALLS	#1,RETURN=V
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCV	;correct return address?
	Beq	170$		;yes
	Call	Err3.5
170$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	180$		;yes
	Call	Err3.6
	Mov	R5,SP
180$:
	Mov	SP,R5
	.CALLS	#1,RETURN=Cv
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCVC	;correct return address?
	Beq	190$		;yes
	Call	Err3.7
190$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	200$		;yes
	Call	Err3.8
	Mov	R5,SP
200$:
	Mov	SP,R5
CALLS4:	.CALLS	#1,RETURN=Z
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCZ	;correct return address?
	Beq	210$		;yes
	Call	Err4.1
210$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	220$		;yes
	Call	Err4.2
	Mov	R5,SP
220$:
	Mov	SP,R5
	.CALLS	#1,RETURN=zC
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCZC	;correct return address?
	Beq	230$		;yes
	Call	Err4.3
230$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	240$		;yes
	Call	Err4.4
	Mov	R5,SP
240$:
	Mov	SP,R5
	.CALLS	#1,RETURN=VZ
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCZV	;correct return address?
	Beq	250$		;yes
	Call	Err4.5
250$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	260$		;yes
	Call	Err4.6
	Mov	R5,SP
260$:
	Mov	SP,R5
	.CALLS	#1,RETURN=cZV
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCZVC	;correct return address?
	Beq	270$		;yes
	Call	Err4.7
270$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	280$		;yes
	Call	Err4.8
	Mov	R5,SP
280$:
	Mov	SP,R5
CALLS5:	.CALLS	#1,RETURN=N
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCN	;correct return address?
	Beq	290$		;yes
	Call	Err5.1
290$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	300$		;yes
	Call	Err5.2
	Mov	R5,SP
300$:
	Mov	SP,R5
	.CALLS	#1,RETURN=Cn
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCNC	;correct return address?
	Beq	310$		;yes
	Call	Err5.3
310$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	320$		;yes
	Call	Err5.4
	Mov	R5,SP
320$:
	Mov	SP,R5
	.CALLS	#1,RETURN=NV
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCNV	;correct return address?
	Beq	330$		;yes
	Call	Err5.5
330$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	340$		;yes
	Call	Err5.6
	Mov	R5,SP
340$:
	Mov	SP,R5
	.CALLS	#1,RETURN=CvN
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCNVC	;correct return address?
	Beq	350$		;yes
	Call	Err5.7
350$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	360$		;yes
	Call	Err5.8
	Mov	R5,SP
360$:
	Mov	SP,R5
CALLS6:	.CALLS	#1,RETURN=ZN
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCNZ	;correct return address?
	Beq	370$		;yes
	Call	Err6.1
370$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	380$		;yes
	Call	Err6.2
	Mov	R5,SP
380$:
	Mov	SP,R5
	.CALLS	#1,RETURN=zNC
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCNZC	;correct return address?
	Beq	390$		;yes
	Call	Err6.3
390$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	400$		;yes
	Call	Err6.4
	Mov	R5,SP
400$:
	Mov	SP,R5
	.CALLS	#1,RETURN=NVZ
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCNZV	;correct return address?
	Beq	410$		;yes
	Call	Err6.5
410$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	420$		;yes
	Call	Err6.6
	Mov	R5,SP
420$:
	Mov	SP,R5
CALLS7:	.CALLS	#1,RETURN=nczv
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCALL	;correct return address?
	Beq	430$		;yes
	Call	Err7.1
430$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	440$		;yes
	Call	Err7.2
440$:
	Mov	R5,SP
	Mov	SP,R5
	.CALLS	#1
	.=.-4			;crush CSM
	Cmp	(SP)+,#$CCALL	;correct return address?
	Beq	450$		;yes
	Call	Err7.3
450$:
	Cmp	SP,R5		;stack alignment correct?
	Beq	460$		;yes
	Call	Err7.4
	Mov	R5,SP
460$:
	Call	EndTst
.nlist meb;**DEBUG**
.Dsabl	LSB
	Mov	R5,SP
.If	NE	MAC$ER
;Expect P errors
	.CALLS	#1,test
.EndC;	NE	MAC$ER
;-TEST
.Page
.SbTtl	.CDFN	Channel definition request
.MACRO	.CDFN	AREA,ADDR,NUM,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,13.,0.,<CODE>,<ADDR>
...CM2	<NUM>,4,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CDFN:	.Asciz	"%SYSMAC-I-Testing .CDFN"
.PSect	Active
	Mov	#$CDFN,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
CDFN1:	.CDFN	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.CDFN*^o400,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
CDFN2:	.CDFN	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.CDFN*^o400,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
CDFN3:	.CDFN	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.CDFN*^o400,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
CDFN4:	.CDFN
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	AreaM1		;set area to -1s
CDFN5:	.CDFN	#Area,#123456,#121654
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	120$		;yes
	Call	Err5.1		;no
120$:
	Cmp	#.CDFN*^o400,(R1)+ ;is the subcode correct?
	Beq	130$		;yes
	Call	Err5.2		;no
130$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	140$		;yes
	Call	Err5.3
140$:
	Cmp	#121654,(R1)+	;is the address correct?
	Beq	150$		;yes
	Call	Err5.4
150$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CHAIN	Chain to another job request
.MACRO	.CHAIN
	MOV	#^o4000,R0
	EMT	^o374
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CHAIN:	.Asciz	"%SYSMAC-I-Testing .CHAIN"
.PSect	Active
	Mov	#$CHAIN,R0	;Ident the test(s)
	Call	BegTst
	Mov	#Patter,R0
CHAIN1:	.CHAIN
	.=.-2			;squash EMT
	Cmp	#.CHAIN*^o400,R0 ;Is R0 right?
	Beq	10$
	Call	Err1
10$:
.PSect	Data
CHAIN2:	.CHAIN
.=.-2.
23$:
.=.+2.
25$:
.PSect	Active
	Cmp	#EMT+...R0,23$	;was the correct EMT generated?
	Beq	20$		;Yes
	Call	Err2
20$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.CHCOPY	Channel copy request
.MACRO	.CHCOP	AREA,CHAN,OCHAN,JOBBLK,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,11,<CHAN>,<CODE>,<OCHAN>
.IF NB <JOBBLK>
...CM2	<JOBBLK>,4,E
.IFF
...CM2	#0,4,E
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CHCOP:	.Asciz	"%SYSMAC-I-Testing .CHCOPY"
.PSect	Active
	Mov	#$CHCOP,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
CHCO1:	.CHCOPY	#Area,#123,#123456,#23456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.CHCOP,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is OCHAN set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#23456,(R1)+	;is JOBBLK set?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Call	AreaM1
	Mov	#Area,R0
CHCO2:	.CHCOPY	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	80$		;yes
	Call	Err2.3		;no
80$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	90$		;yes
	Call	Err2.4		;no
90$:
	Cmp	#0,(R1)+	;is JOBBLK set to 0?
	Beq	100$		;yes
	Call	Err2.4		;no
100$:
	Call	AreaM1
	Mov	#Area,R0
CHCO3:	.CHCOPY	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	130$		;yes
	Call	Err3.3		;no
130$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	140$		;yes
	Call	Err3.4		;no
140$:
.PSect	Data
CHCO4:	.CHCOPY	CODE=NOSET
150$:
.PSect	Active
	Cmp	#EMT+...AR0,150$-2	;correct EMT?
	Beq	160$		;yes
	Call	Err4		;no
160$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CKXX	Meta-Macro to generate CK.__ macro definitions
.SbTtl	.		which are used to verify auto-(inc/dec)
.SbTtl	.		assumptions
.MACRO	.CKXX	REG,LIST
.MCALL	.ASSUME
.IRP	X,<REG>
.IF IDN <LIST>,<YES>
.MACRO	CK.'X	LABEL,CHANGE,RESULT
.IF NB <CHANGE>
.IF LT CHANGE
.LIST
CK.'X=CK.'X''CHANGE
.NLIST
.ENDC
.IFTF
.IIF NB <LABEL>,				.Assume CK.'X EQ LABEL
.IFT
.IF GT CHANGE
.LIST
CK.'X=CK.'X''CHANGE
.NLIST
.ENDC
.ENDC
.IF NB <RESULT>
.LIST
RESULT=CK.'X
.NLIST
.ENDC
.ENDM
.IFF
.MACRO	CK.'X	LABEL,CHANGE,RESULT
.IF NB <CHANGE>
.IIF LT CHANGE,CK.'X=CK.'X''CHANGE
.IFTF
.IIF NB <LABEL>,				.Assume CK.'X EQ LABEL
.IFT
.IIF GT CHANGE,CK.'X=CK.'X''CHANGE
.ENDC
.IIF NB <RESULT>	RESULT=CK.'X
.ENDM
.ENDC
CK.'X=152525
.ENDR
.ENDM

;+TEST
.If	NE	MAC$ER
.CKXX	R0
CK.R0=1
;Expect P error
	CK.R0	0
;Expect P error
	CK.R0	0,+1
;Expect P error
	CK.R0	0,-1
.EndC
;-TEST
.Page
.SbTtl	.CLOSE	Channel close request
.MACRO	.CLOSE	CHAN
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NE ...V1-1
...CM3 <CHAN>,6.
.MEXIT
.ENDC
	EMT	^o<160+CHAN>
.ENDM

;+TEST
.PAGE
.Enabl	LSB
;NOTE: V1 version is not tested
...V1=3.
.PSect	Text
$CLOSE:	.Asciz	"%SYSMAC-I-Testing .CLOSE"
.PSect	Active
	Mov	#$CLOSE,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	Mov	#Patter,R0
CLOSE1:	.CLOSE	#0
	.=.-2			;squash EMT
	Cmp	#.CLOSE*^o400+0,R0 ;Is R0 right?
	Beq	10$
	Call	Err1
10$:
	Mov	#Patter,R0
CLOSE2:	.CLOSE	#1
	.=.-2			;squash EMT
	Cmp	#.CLOSE*^o400+1,R0 ;Is R0 right?
	Beq	20$
	Call	Err2
20$:
	Mov	#Patter,R0
CLOSE3:	.CLOSE	#^o377
	.=.-2			;squash EMT
	Cmp	#.CLOSE*^o400+^o377,R0 ;Is R0 right?
	Beq	30$
	Call	Err3
30$:
	Mov	#7,R0
CLOSE4:	.CLOSE	R0
	.=.-2			;squash EMT
	Cmp	#.CLOSE*^o400+7,R0 ;Is R0 right?
	Beq	40$
	Call	Err4
40$:
	Mov	#Patter,R0
	Mov	#1,R1
CLOSE5:	.CLOSE	R1
	.=.-2			;squash EMT
	Cmp	#.CLOSE*^o400+1,R0 ;Is R0 right?
	Beq	50$
	Call	Err5
50$:
	Mov	#Patter,R0
CLOSE6:	.CLOSE	65$		;try getting chan from an odd addr
	.=.-2			;squash EMT
.PSect	Data
	.Odd
65$:	.Byte	2		;Channel 2 at an odd addr
	.Even
.PSect	Active
	Cmp	#.CLOSE*^o400+2.,R0 ;Is R0 right?
	Beq	60$
	Call	Err6
60$:
.PSect	Data
CLOSE7:	.CLOSE
.=.-2.
73$:
.=.+2.
75$:
.PSect	Active
	Cmp	#EMT+...R0,73$	;was the correct EMT generated?
	Beq	70$		;Yes
	Call	Err7
70$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CLOSZ	Close file and set file saize
.MACRO	.CLOSZ	AREA,CHAN,SIZE,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,37,<CHAN>,<CODE>,<SIZE>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CLOSZ:	.Asciz	"%SYSMAC-I-Testing .CLOSZ"
.PSect	Active
	Mov	#$CLOSZ,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
CLZO1:	.CLOSZ	#Area,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.CLOSZ,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is SZIE set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0
CLZO2:	.CLOSZ	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#123456,(R1)+	;is SIZE set?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0
CLZO3:	.CLOSZ	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#123456,(R1)+	;is SIZE set?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
.PSect	Data
CLZO4:	.CLOSZ	CODE=NOSET
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2 ;correct EMT?
	Beq	140$		;yes
	Call	Err4		;no
140$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CMAP	control extended mapping status
.MACRO	.CMAP	AREA,CMAP,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...V2=0
.IIF IDN <CODE>,<SP>	...V2=1
.IIF IDN <CODE>,<STACK>	...V2=1
.IF EQ ...V2
...CM6	<AREA>,38.,0.,<CODE>,<CMAP>,E
.MEXIT
.ENDC
.IIF NB <AREA>,.ERROR;?SYSMAC-W-A R E A ignored when stack form used;
...CM0	<CMAP>
...CM0	<#^o<46*400>>
	MOV	SP,R0
	EMT	^o375
	BIT	(SP)+,(SP)+
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$CMAP:	.Asciz	"%SYSMAC-I-Testing .CMAP"
.PSect	Active
	Mov	#$CMAP,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
CMAP1:	.CMAP	#Area,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.CMAP,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is CMAP set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0
CMAP2:	.CMAP	,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#377,(R1)+	;is channel unchanged?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#123456,(R1)+	;is CMAP set?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0
CMAP3:	.CMAP	,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#377,(R1)+	;is channel unchanged?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#123456,(R1)+	;is CMAP set?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
.PSect	Data
CMAP4:	.CMAP	CODE=NOSET
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2 ;correct EMT?
	Beq	140$		;yes
	Call	Err4		;no
140$:
	Mov	SP,R5		;save the stack alignment
CMAP5:	.CMAP	,#123,CODE=STACK
.=.-4
	NOP			;Zap the EMT
.=.+2				;save the BIT
	Cmp	SP,R5		;is the stack alignment preserved?
	Beq	150$		;yes
	Call	Err5		;nope
150$:
	Mov	R5,SP		;restore it
	Mov	SP,R5		;save the stack alignment
CMAP6:	.CMAP	,#123,CODE=SP
.=.-4
	NOP			;Zap the EMT
.=.+2				;save the BIT
	Cmp	SP,R5		;is the stack alignment preserved?
	Beq	160$		;yes
	Call	Err6		;nope
160$:
	Mov	R5,SP		;restore it
	Mov	SP,R5		;save the stack alignment
CMAP7:	.CMAP	,#123456,CODE=STACK
.=.-4				;ZAP EMT and BIT
	Mov	R0,R1		;point to argument area
	Cmp	R0,SP		;R0 correct?
	Beq	170$		;yes
	Call	Err7.1		;no
170$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	180$		;yes
	Call	Err7.2		;no
180$:
	CmpB	#.CMAP,(R1)+	;is subcode set?
	Beq	190$		;yes
	Call	Err7.3		;no
190$:
	Cmp	#123456,(R1)+	;is CMAP set?
	Beq	200$		;yes
	Call	Err7.4		;no
200$:
	Mov	R5,SP		;restore stack alignment	
	Mov	SP,R5		;save the stack alignment
CMAP8:	.CMAP	,,CODE=SP
.=.-4				;ZAP EMT and BIT
	Mov	R0,R1		;point to argument area
	Cmp	R0,SP		;R0 correct?
	Beq	210$		;yes
	Call	Err8.1		;no
210$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	220$		;yes
	Call	Err8.2		;no
220$:
	CmpB	#.CMAP,(R1)+	;is subcode set?
	Beq	230$		;yes
	Call	Err8.3		;no
230$:
	Cmp	#0,(R1)+	;is CMAP defaulted?
	Beq	240$		;yes
	Call	Err8.4		;no
240$:
	Mov	R5,SP		;restore stack alignment	
	Call	EndTst
.Dsabl	LSB
.If	NE	MAC$ER
;Expect P errors
.CMAP	AREA,CODE=STACK
.CMAP	AREA,CODE=SP
.EndC
;-TEST
.Page
.SbTtl	.CMKT	Cancel mark-time request request
.MACRO	.CMKT	AREA,ID,TIME=#0,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,19.,0.,<CODE>,<ID>
...CM2	<TIME>,4,E,C
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CMKT:	.Asciz	"%SYSMAC-I-Testing .CMKT"
.PSect	Active
	Mov	#$CMKT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
CMKT1:	.CMKT	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.CMKT*^o400,(R1)+;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
CMKT2:	.CMKT	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.CMKT*^o400,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
CMKT3:	.CMKT	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.CMKT*^o400,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
CMKT4:	.CMKT
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	AreaM1		;set area to -1s
CMKT5:	.CMKT	#Area,#123456,#121654
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	120$		;yes
	Call	Err5.1		;no
120$:
	Cmp	#.CMKT*^o400,(R1)+ ;is the subcode correct?
	Beq	130$		;yes
	Call	Err5.2		;no
130$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	140$		;yes
	Call	Err5.3
140$:
	Cmp	#121654,(R1)+	;is the address correct?
	Beq	150$		;yes
	Call	Err5.4
150$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CMPDF Defines bit pattern for .CMAP/.GCMAP/.MSDS requests
;		and for a field in the impure area
.MACRO	.CMPDF	LIST,E=<=:>
.IIF	IDN <LIST>,<YES>	.LIST
CM.PAR	E	^o377
CM.S	E	^o1400
CM.DUS	E	^o4000
CM.SUP	E	^o30000
CM.U	E	^o140000
CM.PR0	E	^o1
CM.PR1	E	^o2
CM.PR2	E	^o4
CM.PR3	E	^o10
CM.PR4	E	^o20
CM.PR5	E	^o40
CM.PR6	E	^o100
CM.PR7	E	^o200
CM.SXX	E	^o1000
CM.SII	E	^o1000
CM.SID	E	^o1400
CM.XXS	E	^o20000
CM.NOS	E	^o20000
CM.JAS	E	^o30000
CM.UXX	E	^o100000
CM.UII	E	^o100000
CM.UID	E	^o140000
.IIF	IDN <LIST>,<YES>	.LIST
.ENDM	.CMPDF

;+TEST
.Enabl	LSB
.PSect	Text
$CMPDF:	.Asciz	"%SYSMAC-I-Testing .CMPDF"
.PSect	Active
	.CMpDf			;value(s) used in tests
	Mov	#$CMPDF,R0	;Ident the test
	Call	BegTst
	Call	TemTst
;-TEST
.Page
.SbTtl	.CNTXST	Context switching list specifying request
.MACRO	.CNTXS	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,27.,0.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CNTXS:	.Asciz	"%SYSMAC-I-Testing .CNTXST"
.PSect	Active
	Mov	#$CNTXS,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
CNTX1:	.CNTXST	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.CNTXS*^o400,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
CNTX2:	.CNTXST	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.CNTXS*^o400,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
CNTX3:	.CNTXST	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.CNTXS*^o400,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
CNTX4:	.CNTXST
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CRAW	Create address window request
.MACRO	.CRAW	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,30.,2.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CRAW:	.Asciz	"%SYSMAC-I-Testing .CRAW"
.PSect	Active
	Mov	#$CRAW,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
CRAW:	.CRAW	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.CRAW*^o400+..CRAW,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
CRAW2:	.CRAW	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.CRAW*^o400+..CRAW,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
CRAW3:	.CRAW	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.CRAW*^o400+..CRAW,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
CRAW4:	.CRAW
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CRRG	Create region request
.MACRO	.CRRG	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,30.,0.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CRRG:	.Asciz	"%SYSMAC-I-Testing .CRRG"
.PSect	Active
	Mov	#$CRRG,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
CRRG1:	.CRRG	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.CRRG*^o400+..CRRG,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
CRRG2:	.CRRG	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.CRRG*^o400+..CRRG,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
CRRG3:	.CRRG	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.CRRG*^o400+..CRRG,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
CRRG4:	.CRRG
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CSIGEN	CSI parsing and file opening request
.MACRO	.CSIGE	DEVSPC,DEFEXT,CSTRNG,LINBUF
.IIF IDN <DEVSPC> <#0> .ERROR;?SYSMAC-E-Invalid argument, #0 in first argument position;
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NB <LINBUF>
...CM0	<LINBUF>
.NTYPE	...V2,DEVSPC
.IF EQ ...V2-^o27
...CM0	<DEVSPC'+1>
.IFF
...CM0	<DEVSPC>
	INC	(SP)
.ENDC
.IFF
...CM0	<DEVSPC>
.ENDC
...CM0	<DEFEXT>
...CM0	<CSTRNG>,344
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CSIGE:	.Asciz	"%SYSMAC-I-Testing .CSIGEN"
.PSect	Active
	Mov	#$CSIGE,R0	;Ident the test
	Call	BegTst
	Mov	SP,R5		;save Stack pointer
CSIG1:	.CSIGEN	#200,#400,#600
	.=.-2
	Cmp	#600,(SP)+	;is CSTRNG at top of stack?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#400,(SP)+	;is DEFEXT next on stack?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#200,(SP)+	;is DEFSPC next on stack?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Mov	R5,SP		;force alignment
	Mov	SP,R5		;save Stack pointer
	Mov	#CSIG2,R1
CSIG2:	.CSIGEN	R1,#400,#600,#1000
	.=.-2
	Cmp	#600,(SP)+	;is LINBUF at top of stack?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	Cmp	#400,(SP)+	;is CSTRNG next on stack?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	Cmp	#CSIG2+1,(SP)+	;is DEFSPC next on stack?
				;and is the low bit set?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#1000,(SP)+	;is DEFEXT next on stack?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	90$		;yes
	Call	Err2.5		;no
90$:
	Mov	R5,SP		;force alignment
	Mov	SP,R5		;save Stack pointer
	Mov	SP,R5		;save Stack pointer
CSIG3:	.CSIGEN	#CSIG3,#400,#600,#1000
	.=.-2
	Cmp	#600,(SP)+	;is LINBUF at top of stack?
	Beq	100$		;yes
	Call	Err3.1		;no
100$:
	Cmp	#400,(SP)+	;is CSTRNG next on stack?
	Beq	110$		;yes
	Call	Err3.2		;no
110$:
	Cmp	#CSIG3+1,(SP)+	;is DEFSPC next on stack?
				;and is the low bit set?
	Beq	120$		;yes
	Call	Err3.3		;no
120$:
	Cmp	#1000,(SP)+	;is DEFEXT next on stack?
	Beq	130$		;yes
	Call	Err3.4		;no
130$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	140$		;yes
	Call	Err3.5		;no
140$:
	Mov	R5,SP		;force alignment
	Call	EndTst
.PSect	Data
CSIG4:	.CSIGEN
150$:
.PSect	Active
	Cmp	#EMT+...CSG,150$-2 ;correct EMT generated?
	Beq	160$		;yes
	Call	Err4		;no
160$:
.If	NE	MAC$ER
;Expect P error
.CSIGEN	#0
.EndC
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CSISPC	CSI parsing (only) request
.MACRO	.CSISP	OUTSPC,DEFEXT,CSTRNG,LINBUF
.IIF IDN <OUTSPC> <#0> .ERROR;?SYSMAC-E-Invalid argument, #0 in first argument position;
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NB <LINBUF>
...CM0	<LINBUF>
.NTYPE	...V2,OUTSPC
.IF EQ ...V2-^o27
...CM0	<OUTSPC'+1>
.IFF
...CM0	<OUTSPC>
	INC	(SP)
.ENDC
.IFF
...CM0	<OUTSPC>
.ENDC
...CM0	<DEFEXT>
...CM0	<CSTRNG>,345
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CSISP:	.Asciz	"%SYSMAC-I-Testing .CSISPC"
.PSect	Active
	Mov	#$CSISP,R0	;Ident the test
	Call	BegTst
	Mov	SP,R5		;save Stack pointer
CSIS1:	.CSISPC	#200,#400,#600
	.=.-2
	Cmp	#600,(SP)+	;is CSTRNG at top of stack?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#400,(SP)+	;is DEFEXT next on stack?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#200,(SP)+	;is DEFSPC next on stack?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Mov	R5,SP		;force alignment
	Mov	SP,R5		;save Stack pointer
	Mov	#CSIG2,R1
CSIS2:	.CSISPC	R1,#400,#600,#1000
	.=.-2
	Cmp	#600,(SP)+	;is LINBUF at top of stack?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	Cmp	#400,(SP)+	;is CSTRNG next on stack?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	Cmp	#CSIG2+1,(SP)+	;is DEFSPC next on stack?
				;and is the low bit set?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#1000,(SP)+	;is DEFEXT next on stack?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	90$		;yes
	Call	Err2.5		;no
90$:
	Mov	R5,SP		;force alignment
	Mov	SP,R5		;save Stack pointer
	Mov	SP,R5		;save Stack pointer
CSIS3:	.CSISPC	#CSIG3,#400,#600,#1000
	.=.-2
	Cmp	#600,(SP)+	;is LINBUF at top of stack?
	Beq	100$		;yes
	Call	Err3.1		;no
100$:
	Cmp	#400,(SP)+	;is CSTRNG next on stack?
	Beq	110$		;yes
	Call	Err3.2		;no
110$:
	Cmp	#CSIG3+1,(SP)+	;is DEFSPC next on stack?
				;and is the low bit set?
	Beq	120$		;yes
	Call	Err3.3		;no
120$:
	Cmp	#1000,(SP)+	;is DEFEXT next on stack?
	Beq	130$		;yes
	Call	Err3.4		;no
130$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	140$		;yes
	Call	Err3.5		;no
140$:
	Mov	R5,SP		;force alignment
.PSect	Data
CSIS4:	.CSISPC
150$:
.PSect	Active
	Cmp	#EMT+...CSS,150$-2 ;correct EMT generated?
	Beq	160$		;yes
	Call	Err4		;no
160$:
	Call	EndTst
.If	NE	MAC$ER
;Expect P error
.CSISPC	#0
.EndC
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CSTATUS Channel status request
.MACRO	.CSTAT	AREA,CHAN,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,23,<CHAN>,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CSTAT:	.Asciz	"%SYSMAC-I-Testing .CSTATUS"
.PSect	Active
	Mov	#$CSTAT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
CSTA1:	.CSTATUS #Area,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.CSTAT,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0
CSTA2:	.CSTATUS ,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0
CSTA3:	.CSTATUS ,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
.PSect	Data
CSTA4:	.CSTATUS CODE=NOSET
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2 ;correct EMT?
	Beq	140$		;yes
	Call	Err4		;no
140$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.CTIMIO	Cancel timer for I/O call		**Handler only**
.MACRO	.CTIMI	TBK
	JSR	R5,@$TIMIT
	.WORD	TBK-.
	.WORD	1
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$CTIMI:	.Asciz	"%SYSMAC-I-Testing .CTIMI"
.PSect	Active
	Mov	#$CTIMI,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DATE	Current date request
.MACRO	.DATE
	MOV	#^o5000,R0
	EMT	^o374
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DATE:	.Asciz	"%SYSMAC-I-Testing .DATE"
.PSect	Active
	Mov	#$DATE,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	Mov	#Patter,R0
DATE1:	.DATE
	.=.-2			;squash EMT
	Cmp	#.DATE*^o400,R0	;Is R0 right?
	Beq	10$
	Call	Err1
10$:
.PSect	Data
DATE2:	.DATE
.=.-2.
23$:
.=.+2.
25$:
.PSect	Active
	Cmp	#EMT+^o374,23$	;was the correct EMT generated?
	Beq	20$		;Yes
	Call	Err2
20$:
	Call	EndTst
.DSABL LSB
.PSect	Static
;-TEST
.Page
.SbTtl	.DEBUG debugging prolog macro
;+
;
;	.DEBUG
;
;	The .DEBUG macro is used to set up the environment for the
;	.DPRINT macro.  It may be used with no arguments.
;
;	The symbol ...V23 controls the generation of .DPrint macros.
;	If ...V23 = 0, then .DPrint macros will generate no code.
;	If ...V23 = 177777, then all .DPrint macros will generate.
;	Other values for ...V23 may be used to select one or more
;	class(es) of .DPrint macros to generate.
;	
;
;	SWITCH	(omit)	default ...V23 to 0
;		ON/on	set ...V23 to value specified for CLASS
;		OFF/off	set ...V23 to 0
;
;	CLASS   (177777) select all classes
;		xxxxxx	bit mask to select classes
;
;	PIC	(omit)	do not generate PIC code in .DPRINT macros
;		YES	do generate PIC code in .DPRINT macros
;
;	ID	(omit)	do not generate code for separated I&D modes
;		YES	do generate code for separated I&D modes
;
;	Value	(omit)	do not generate support subroutines for value printing
;		YES	do generate support subroutines for value printing
;
;	PSect  (Deb$ug)	psect used for text strings generated by .DPRINT
;
;	Code   (Deb.ug)	psect used for support subroutines
;
;	L1--L4 (xxxxx$)	local labels used for support routines
;
;	This macro also defines the .DPSec macro which is used by the .DPRINT
;	macro to define the PSECT for the data strings.
;-
.page
.Macro	.Debug	Switch,Class=-1,PIC,ID,Value,PSect=<Deb$ug,D,RO>,Code=<Deb.ug,I,RO>,?L1,?L2,?L3,?L4
	.MCall	.DPrint
...V24 = 0
.If	nb	<PIC>
...V24 = 1
	.MCall	.Addr
.EndC
.If	b	<Switch>
.IIf	ndf	...V23	...V23 = 0
.EndC
...v2 = 0
.If	dif	<A>,<a>
	...v2 = 1
	.Dsabl	LCM
.EndC
...v3 = 0
.IIf	idn	<ON>,<Switch>	...V23 = Class
.IIf	idn	<ON>,<Switch>	...V3 = 1
.IIf	idn	<OFF>,<Switch>	...V23 = 0
.IIf	idn	<OFF>,<Switch>	...V3 = 1
.IIf eq ...v3	.ERROR;?SYSMAC-E-S W I T C H value unknown, use ON or OFF;
.IIf ne ...v2 .enabl lcm
 .Macro	.DPSec
	.PSect	PSect
 .EndM	.DPSec
.If	nb	<Value>
	.Save
	.PSect	Code
.If	nb	<ID>
Deb$8:	Jsr	R3,L1			;save R3, point to oct table
	.Word	^o100000,^o10000,^o1000,^o100,^o10,^o1,0
;This assumes that the high byte of JSR is 0
Deb$10=:.
	Jsr	R3,L1			;save R3, point to dec table
	.Word	10000.,1000.,100.,10.,1.,0,'.*^o400
.IfF
Deb$8:	Mov	R3,-(SP)		;save R3
.If	nb	<PIC>
	.Addr	#Deb.8,R3		;point to octal table
.IfF
	Mov	#Deb.8,R3		;point to octal table
.EndC
	Br	L1			;join common c o d e

Deb$10:	Mov	R3,-(SP)		;save R3
.If	nb	<PIC>
	.Addr	#Deb.10,R3		;point to decimal table
.IfF
	Mov	#Deb.10,R3		;point to decimal table
.EndC

.PSect	PSect
Deb.8:	.Word	^o100000,^o10000,^o1000,^o100,^o10,^o1,0,0
Deb.10:	.Word	10000.,1000.,100.,10.,1.,0,'.*^o400
.PSect	Code
.EndC
L1:	Mov	R2,-(SP)		;save work regs
	Mov	R1,-(SP)		; ...
	Sub	#8.,SP			;reserve 8 bytes on stack
	Mov	SP,R1			;point to char buffer on stack
 L2:	 Clr	R2			;accumulate here
	 Tst	@R3			;done? - end of table
	 Beq	L4			;yep end of digits
  L3:	  Inc	R2			;count
	  Sub	@R3,R0			;reduce
	  Bhis	L3			;unsigned output
	 Add	(R3)+,R0		;correct overage
	 Add	#'0-1,R2		;make ASCII
	 MovB	R2,(R1)+		;stuff char away
	 Br	L2			;and back for loop
 
L4:	MovB	3(R3),(R1)+		;decimal point or nothing
	ClrB	(R1)+			;end string with zero
	Mov	SP,R0			;point to string
	Emt	^o351			;print it
	Add	#8.,SP			;restore stack
	Mov	(SP)+,R1		;restore regs
	Mov	(SP)+,R2
	Mov	(SP)+,R3
	Return
	.Restore
.EndC
.EndM	.Debug

;+TEST
.Enabl	LSB
.PSect	Text
$DEBUG:	.Asciz	"%SYSMAC-I-Testing .DEBUG"
.PSect	Active
	Mov	#$DEBUG,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
.If	NE	MAC$ER
;Expect P error
.DEBUG SWITCH=YES
.EndC
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.DELETE	File deletion request
.MACRO	.DELET	AREA,CHAN,DBLK,SEQNUM,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NE ...V1-1
...CM5	<AREA>
.IF IDN <CHAN>,#0
	CLR	@R0
.IFF
.IIF IDN <CHAN> <0> .ERROR;?SYSMAC-W-Invalid argument, use #0, not 0;
...V2=0
.IF B <CODE>
.IIF B <AREA>,...V2=1
.IFF
.IIF DIF <CODE>,SET,...V2=1
.ENDC
.IF NE ...V2
.IF NB <CHAN>
	MOVB	CHAN,@R0
.ENDC
.IFF
.IF B <CHAN>
	CLRB	1(R0)
.IFF
.NTYPE ...V2,CHAN
.IF EQ ...V2-^o27
	MOV	CHAN,@R0
.IFF
	CLR	@R0
	MOVB	CHAN,@R0
.ENDC
.ENDC
.ENDC
.ENDC
...CM2	<DBLK>,2
...CM2	<SEQNUM>,4,E,C
.MEXIT
.ENDC
...CM5	<CHAN>,<AREA>
.ENDM

;+TEST
;NOTE: V1 version is not tested
.Enabl	LSB
.PSect	Text
$DELET:	.Asciz	"%SYSMAC-I-Testing .DELETE"
.PSect	Active
	Mov	#$DELET,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Area,R0	;load R0
DELE2:	.DELETE	CODE=SET
	.=.-2
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	10$		;yes
	Call	Err2.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes	
	Call	Err2.2		;no
20$:
	CmpB	#.DELET,(R1)+	;is IC set?
	Beq	30$		;yes
	Call	Err2.3		;no
30$:
	Cmp	#-1,(R1)+	;is DBLK unchanged?
	Beq	40$		;yes
	Call	Err2.4		;no
40$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	50$		;yes
	Call	Err2.5		;no
50$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
DELE3:	.DELETE	CODE=NOSET
	.=.-2
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	60$		;yes
	Call	Err3.1		;no
60$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	70$		;yes	
	Call	Err3.2		;no
70$:
	CmpB	#-1.,(R1)+	;is IC unchanged?
	Beq	80$		;yes
	Call	Err3.3		;no
80$:
	Cmp	#-1,(R1)+	;is DBLK unchanged?
	Beq	90$		;yes
	Call	Err3.4		;no
90$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	100$		;yes
	Call	Err3.5		;no
100$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
DELE4:	.DELETE	,#277
	.=.-2
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	110$		;yes
	Call	Err4.1		;no
110$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	120$		;yes	
	Call	Err4.2		;no
120$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	130$		;yes
	Call	Err4.3		;no
130$:
	Cmp	#-1,(R1)+	;is DBLK unchanged?
	Beq	140$		;yes
	Call	Err4.4		;no
140$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	150$		;yes
	Call	Err4.5		;no
150$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
DELE5:	.DELETE	,#277,CODE=SET
	.=.-2
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	160$		;yes
	Call	Err5.1		;no
160$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	170$		;yes	
	Call	Err5.2		;no
170$:
	CmpB	#.DELET,(R1)+	;is IC set?
	Beq	180$		;yes
	Call	Err5.3		;no
180$:
	Cmp	#-1,(R1)+	;is DBLK unchanged?
	Beq	190$		;yes
	Call	Err5.4		;no
190$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	200$		;yes
	Call	Err5.5		;no
200$:
	Call	AreaM1
	Mov	#Area,R0	;load R0
DELE6:	.DELETE	,#277,CODE=NOSET
	.=.-2
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	210$		;yes
	Call	Err6.1		;no
210$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	220$		;yes	
	Call	Err6.2		;no
220$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	230$		;yes
	Call	Err6.3		;no
230$:
	Cmp	#-1,(R1)+	;is DBLK unchanged?
	Beq	240$		;yes
	Call	Err6.4		;no
240$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	250$		;yes
	Call	Err6.5		;no
250$:
	Call	AreaM1
DELE7:	.DELETE	#Area
	.=.-2
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	260$		;yes
	Call	Err7.1		;no
260$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	270$		;yes	
	Call	Err7.2		;no
270$:
	CmpB	#.DELET,(R1)+	;is IC set?
	Beq	280$		;yes
	Call	Err7.3		;no
280$:
	Cmp	#-1,(R1)+	;is DBLK unchanged?
	Beq	290$		;yes
	Call	Err7.4		;no
290$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	300$		;yes
	Call	Err7.5		;no
300$:
	Call	AreaM1
DELE8:	.DELETE	#Area,#0,CODE=SET
	.=.-2			;smash EMT
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	310$		;yes
	Call	Err8.1		;no
310$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	320$		;yes	
	Call	Err8.2		;no
320$:
	CmpB	#.DELET,(R1)+	;is IC set?
	Beq	330$		;yes
	Call	Err8.3		;no
330$:
	Cmp	#-1,(R1)+	;is DBLK unchanged?
	Beq	340$		;yes
	Call	Err8.4		;no
340$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	350$		;yes
	Call	Err8.4		;no
350$:
.PSect	Data
	.DELETE
360$:
.PSect	Active
	Cmp	#EMT+...AR0,360$-2 ;is the EMT generated correctly?
	Beq	370$		;yes
	Call	Err8.5		;no
370$:
	Call	AreaM1
DELE9:	.DELETE	#Area,,#123456,CODE=NOSET
	.=.-2			;smash EMT
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	380$		;yes
	Call	Err9.1		;no
380$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	390$		;yes	
	Call	Err9.2		;no
390$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	400$		;yes
	Call	Err9.3		;no
400$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	410$		;yes
	Call	Err9.4		;no
410$:
	Cmp	#-1,(R1)+	;is SEQNUM set?
	Beq	420$		;yes
	Call	Err9.5		;no
420$:
	Call	AreaM1
	Mov	#277,R3
DELEA:	.DELETE	#Area,R3
	.=.-2
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	430$		;yes
	Call	ErrA.1		;no
430$:
	CmpB	#277,(R1)+	;is CHAN set?
	Beq	440$		;yes	
	Call	ErrA.2		;no
440$:
	CmpB	#.DELET,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	ErrA.3		;no
450$:
	Cmp	#-1,(R1)+	;is ARG unchanged?
	Beq	460$		;yes
	Call	ErrA.4		;no
460$:
	Cmp	#-1,(R1)+	;is SEQNUM set?
	Beq	470$		;yes
	Call	ErrA.5		;no
470$:
	Call	AreaM1
DELEC:	.DELETE	#Area,#0,CODE=NOSET
	.=.-2
	Mov	#Area,R1
	Cmp	R1,R0		;Is R0 correct?
	Beq	480$		;yes
	Call	ErrC.1		;no
480$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	490$		;yes	
	Call	ErrC.2		;no
490$:
	CmpB	#.DELET,(R1)+	;is IC set?
	Beq	500$		;yes
	Call	ErrC.3		;no
500$:
	Cmp	#-1,(R1)+	;is DBLK  unchanged?
	Beq	510$		;yes
	Call	ErrC.4		;no
510$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	520$		;yes
	Call	ErrC.5		;no
520$:
	Call	AreaM1
	Mov	#Patter,R0
DELED:	.DELETE	#Area,#123,#123456,#0
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	530$		;yes
	Call	ErrD.1		;no
530$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	540$		;yes
	Call	ErrD.2		;no
540$:
	CmpB	#.DELET,(R1)+	;is subcode set?
	Beq	550$		;yes
	Call	ErrD.3		;no
550$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	560$		;yes
	Call	ErrD.4		;no
560$:
	Cmp	#0,(R1)+	;is SEQNUM set?
	Beq	570$		;yes
	Call	ErrD.5		;no
570$:
	Call	EndTst
.If	NE	MAC$ER
;Expect P error
.DELETE	,0
.EndC
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.DEVICE	Exit/Abort modification list specifying request
.MACRO	.DEVIC	AREA,ADDR,LINK,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF B LINK
...CM6	<AREA>,12.,0.,<CODE>,<ADDR>,E
.IFF
...CM6	<AREA>,12.,1.,<CODE>,<ADDR>,E
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DEVIC:	.Asciz	"%SYSMAC-I-Testing .DEVICE"
.PSect	Active
	Mov	#$DEVIC,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
DEVI1:	.DEVICE	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.DEVIC*^o400+..DNLK,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
DEVI2:	.DEVICE	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.DEVIC*^o400+..DNLK,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
DEVI3:	.DEVICE	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.DEVIC*^o400+..DNLK,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
DEVI4:	.DEVICE
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	AreaM1		;set area to -1s
DEVI5:	.DEVICE	#Area,#123456,LINK=YES
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	120$		;yes
	Call	Err5.1		;no
120$:
	Cmp	#.DEVIC*^o400+..DLNK,(R1)+ ;is the subcode correct?
	Beq	130$		;yes
	Call	Err5.2		;no
130$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	140$		;yes
	Call	Err5.3
140$:
	Call	AreaM1		;set area to -1s
DEVI6:	.DEVICE	#Area,LINK=YES
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	150$		;yes
	Call	Err6.1		;no
150$:
	Cmp	#.DEVIC*^o400+..DLNK,(R1)+ ;is the subcode correct?
	Beq	160$		;yes
	Call	Err6.2		;no
160$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	170$		;yes
	Call	Err6.3
170$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
DEVI7:	.DEVICE	,#123456,CODE=SET,LINK=YES
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	180$		;yes
	Call	Err7.1		;no
180$:
	Cmp	#.DEVIC*^o400+..DLNK,(R1)+ ;is the subcode correct?
	Beq	190$		;yes
	Call	Err7.2		;no
190$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	200$		;yes
	Call	Err7.3
200$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.page
;+
;
;	.DPRINT
;
;	This macro is designed to conditionally generate code to
;	print a string.  Its purpose is to make debug prints easy
;	to install in modules and easy to suppress. It may be used
;	display decimal or octal values from word sources.  It may
;	also be partitioned into up to 16 classes so that debug
;	prints can be easily subset.
;
;	String		string to print, enclosed in <>
;			.Asci is generated with "" as delimiters
;
;	Value	(omit)	value to print if non-blank.
;			Use R0 to print value in R0.
;			Avoid stack references.
;
;	Type	(OCT)	display value in octal format
;		DEC	display value in decimal format
;
;	Class  (177777)	generate code if any class enabled
;		xxxxxx	generate code if ...V23 .and. Class non-zero
;
;	L1     (xxxxx$)	local symbol.  If .ENABLE LSB is not
;			in effect, supply symbol
;-
.page 
.Macro	.DPrint	String,Value,Type=OCT,Class=-1,?L1
.If ndf	...V23
.Error;?SYSMAC-E-.DEBUG must be used before .DPRINT;
.MExit
.EndC
.If ne	...V23&<Class>
 .If ne	...V24
	.Addr	#L1,R0,PUSH
 .IfF
	Mov	R0,-(SP)
	Mov	#L1,R0
 .EndC
	Emt	^o351
 .If nb <Value>
  .If idn <R0>,<Value>
	Mov	@SP,R0
  .IfF
	Mov	Value,R0
  .EndC
  .If idn <OCT>,<Type>
	Call	Deb$8
  .IfF
   .If idn <DEC>,<Type>
	Call	Deb$10
   .IfF
	Call	Deb$8
	.Error;?SYSMAC-E-Invalid T Y P E, expecting OCT/DEC, found - TYPE;
   .EndC
  .EndC
 .IfTF
	Mov	(SP)+,R0
	.Save
	.DPSec
 .IfF
L1:	.Asciz "String"
 .IfT
L1:	.Ascii "String"<^o200>
 .EndC
	.Restore
.EndC
.EndM	.DPrint
;TEST+
.Enabl	LSB
.PSect	Text
$DPRIN:	.Asciz	"%SYSMAC-I-Testing .DPRINT"
.PSect	Active
	Mov	#$DPRIN,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
.Dsabl	LSB
;TEST-
.Page
.SbTtl	.DRAST	Define interrupt entry point		**Handler only**
.MACRO	.DRAST	NAME,PRI,ABT
.GLOBL	$INPTR
.IF B <ABT>
	RETURN
.IFF
	BR	ABT
.ENDC
NAME'INT::JSR	R5,@$INPTR
	.WORD	^C<PRI*^o40>&^o340
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRAST:	.Asciz	"%SYSMAC-I-Testing .DRAST"
.PSect	Active
	Mov	#$DRAST,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRBEG	Define QMANGR entry point		**Handler only**
;
;NOTE: the DSIZE contained in the body of his macro is a subtle hack:
; There is an argument to the macro with the name DSIZ, and it is
; desired to generate a reference to the symbol xxDSIZ if the argument
; DSIZ is blank.  If DSIZ is used, it matches the DSIZ agument and becomes
; blank...
;
.MACRO	.DRBEG	NAME,VEC,DSIZ,DSTS,VTBL,ADDRCK,SPFUN,CODE,?L1,LDTBL,NSPFUN
.IIF NDF ...V9 ...V9=0
.IIF NDF ...V19 ...V19=0
.IIF NDF ...V22 ...V22=0
.ASECT
.=^o52
.GLOBL	NAME'END,NAME'INT
	.WORD	<NAME'END-NAME'STRT>
.IF B	<DSIZ>
	.WORD	NAME'DSIZE
.IFF
	.WORD	DSIZ
.ENDC
.IF B	<DSTS>
	.WORD	NAME'STS
.IFF
	.WORD	DSTS
.ENDC
	.WORD	^o<ERL$G+<MMG$T*2>+<TIM$IT*4>+<RTE$M*10>>
.PSECT	NAME'DVR
NAME'STRT::
.IF NB	VTBL
.GLOBL	VTBL
	.WORD	<VTBL-.>/2.-1+^o100000
.IFF
.IF NB	<VEC>
.IIF NE	VEC&3.,.ERROR	VEC;?SYSMAC-E-Odd or invalid vector specified;
	.WORD	VEC&^C3.
.IFF
.IF DF	NAME'$VTB
.GLOBL	NAME'$VTB
	.WORD	<NAME'$VTB-.>/2.-1+^o100000
.IFF
.IIF NE	NAME'$VEC&3.,.ERROR	NAME'$VEC;?SYSMAC-E-Odd or invalid vector specified;
	.WORD	NAME'$VEC&^C3.
.ENDC
.ENDC
.ENDC
	.WORD	NAME'INT-.,^o340
NAME'SYS::
NAME'LQE::	.WORD	0
.IRP	X,\...V19
NAME'CQE::	.WORD	x
.ENDR
...V2=0
.IIF NB <ADDRCK'SPFUN'LDTBL'NSPFUN> ...V2=^o20
.IIF NE ...V22 ...V2=^o20

.IRP	X,\<^o240!...V2!...V9>
		.WORD	x
.ENDR
.IF NE ...V2
.IF B <CODE>
	BR	L1
.IFF
	BR	CODE
.ENDC
...V2=0
.IIF NB <ADDRCK> ...V2=1
.IIF NB <SPFUN> ...V2=...V2!^o2
.IIF NB	<LDTBL>	...V2=...V2!^o4
.IIF NB <NSPFUN> ...V2=...V2!^o10
.IRP	X,\<...V22!...V2>
	.WORD	X
.ENDR
.IF NE	...V2&^o17
	.WORD	ADDRCK
.ENDC
.IF NE	...V2&^o16
	.WORD	SPFUN
.ENDC
.IF NE	...V2&^o14
	.WORD	LDTBL
.ENDC
.IF NE	...V2&^o10
	.WORD	NSPFUN
.ENDC
.IF B <CODE>
L1:
.ENDC
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRBEG:	.Asciz	"%SYSMAC-I-Testing .DRBEG"
.PSect	Active
	Mov	#$DRBEG,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
.If	NE	MAC$ER
XXVEC=^o3
;Expect P error
.DRBEG	XX
;Expect P error
.DRBEG	YY,^o3
.EndC
;-TEST
.Page
.SbTtl	.DRBOT	Define beginning of Boot Code		**Handler only**
;++
;	.DRBOT
;
;	CONTROL= is used to generate the controller description bits
;	in the boot block.  The default value is correct for nearly
;	all RT supported devices. As many options may be specified as
;	are supported by the boot code:
;
;	<UBUS>	Unibus device
;	<QBUS>	Q-Bus device
;	<CBUS>	PC-Bus device
;	<UMSCP>	Unibus MSCP device
;	<QMSCP>	Q-Bus MSCP device
;	<CMSCP>	PC-Bus MSCP device
;
;	SIDES= is used to indicate the number of sides supported in
;	floppy disk drive.  Valid values are 1 and 2.  Hard media
;	sidedness is not coded.
;
;	OFFSET= is used to indicate if the bootstrap will accept
;	block offset and length information for a softboot from
;	a file (or a softboot from some other o/s).  The values
;	are:
;
;	OFFSET=NO		; default, offset not supported
;	OFFSET=YES		; offset is supported
;
;	OFFSET=NO places 4 words of -1 as the last 4 words of the
;	bootblock, OFFSET=YES places 4 words of 0.
;
;	FORCE is used to force the generation of the vector table.
;	Assigning a value to FORCE causes the associated sysgen bit
;	value to be "forced" on for purposes of generating the table.
;
;	FORCE=1 will force generation of the error logging vector
;	for instance.
;
;	PSECT is used to force the DREND macro to be in a different
;	PSECT from the expected dd'DVR one.  This is used for cases
;	when the memory resident part of a handler is built from 
;	several psects.
;
;	NOTE: the definition of a code does NOT imply any present
;	or future product committment.
;--
.MACRO	.DRBOT	NAME,ENTRY,READ,CONTROL=<UBUS,QBUS>,SIDES=1,OFFSET=NO,FORCE=0,PSECT
...V7=-1
.IIF IDN OFFSET,YES,...V7=0
	.DREND	NAME,FORCE,PSECT
.IIF NDF TPS,TPS=:^o177564
.IIF NDF TPB,TPB=:^o177566
LF=:^o12
CR=:^o15
B$BOOT=:^o1000
B$DEVN=:^o4716
B$DEVU=:^o4722
B$READ=:^o4730
.IF NDF B$DNAM
.IF EQ	MMG$T
B$DNAM=:^R'NAME
.IFF
B$DNAM=:^R'NAME'X
.ENDC ; EQ MMG$T
.ENDC ; NDF B$DNAM
.ASECT
.=^o62
	.WORD	NAME'BOOT,NAME'BEND-NAME'BOOT,READ-NAME'BOOT
.PSECT	NAME'BOOT
NAME'BOOT::NOP
	BR	ENTRY-2.
...V2=^o100
.IRP	X	<CONTROL>
...V3=0
.IIF	IDN	<X>	<UBUS>	...V3=1.
.IIF	IDN	<X>	<QBUS>	...V3=2.
.IIF	IDN	<X>	<CBUS>	...V3=4.
.IIF	IDN	<X>	<UMSCP>	...V3=^o10
.IIF	IDN	<X>	<QMSCP>	...V3=^o20
.IIF	IDN	<X>	<CMSCP>	...V3=^o40
.IIF	EQ	...V3	.ERROR;?SYSMAC-E-Invalid C O N T R O L, found - CONTROL;
...V2=...V2!...V3
.ENDR
.=ENTRY-6.
	.BYTE	^o20,...V2,^o20,^o^C<20+...V2+20>
.IF	EQ	<SIDES-1>
	BR	ENTRY
.IFF
.IF	EQ	<SIDES-2.>
	BMI	ENTRY
.IFF
	.ERROR;?SYSMAC-E-Invalid S I D E S, expecting 1/2, found - SIDES;
.ENDC
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRBOT:	.Asciz	"%SYSMAC-I-Testing .DRBOT"
.PSect	Active
	Mov	#$DRBOT,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRDEF	Define lots of handler info, .MCALL others **Handler only**
;+
;	CSR=*NO* means don't place any value in 176
;-
.MACRO	.DRDEF	NAME,CODE,STAT,SIZE,CSR,VEC,UNIT64=NO,DMA,PERMUMR,SERIAL=NO
.MCALL	.DRAST,.DRBEG,.DRBOT,.DREND,.DREST,.DRFIN,.DRFMS,.DRFMT
.MCALL	.DRINS,.DRPTR,.DRSET,.DRSPF,.DRTAB,.DRUSE,.DRVTB
.MCALL	.FORK,.QELDF
.IIF NDF RTE$M RTE$M=0
.IIF NE RTE$M RTE$M=1
.IIF NDF TIM$IT TIM$IT=0
.IIF NE TIM$IT TIM$IT=1
.IIF NDF MMG$T MMG$T=0
.IIF NE MMG$T MMG$T=1
.IIF NDF ERL$G ERL$G=0
.IIF NE ERL$G ERL$G=1
.IIF NE TIM$IT,	.MCALL	.TIMIO,.CTIMI
.QELDF
HDERR$=:1
EOF$=:^o20000
VARSZ$=:^o400
ABTIO$=:^o1000
SPFUN$=:^o2000
HNDLR$=:^o4000
SPECL$=:^o10000
WONLY$=:^o20000
RONLY$=:^o40000
FILST$=:^o100000
NAME'DSIZ=:SIZE
NAME'$COD=:CODE
NAME'STS=:<CODE>!<STAT>
.IIF NDF NAME'$VEC,NAME'$VEC=VEC
.GLOBL	NAME'$VEC
.ASECT
...V2=0
...V19=0
...V20=0
...V21=0
...V22=0
.IIF NDF NAME'$NAM,NAME'$NAM=^r'NAME
.IF DF NAME'$N64
.IF NE NAME'$N64
.IF IDN <UNIT64> <YES>
...V22= 40000
.=^o76
	.WORD	NAME'$X64
.IF NDF NAME'$PN2
NAME'$PN2=NAME'$NAM
.IF LT NAME'$PN2
NAME'$PN2=NAME'$PN2-^rT
.IFTF
NAME'$PN2=NAME'$PN2/^rA*^rA
.IFT
NAME'$PN2=NAME'$PN2+^rT  
.ENDC
.ENDC
...V2=NAME'$PN2
.IF LT ...V2
...V2=...V2-^rT
.IFTF
...V2=...V2/^rA*^rA
.IFT
...V2=...V2+^rT  
.ENDC
.IIF NE ...V2-NAME'$PN2 .ERROR ;?SYSMAC-E-NAME'$PN2 is not a single character device;
.IFF
.IF DIF <UNIT64> <NO>
.ERROR ;?SYSMAC-E-Invalid U N I T 6 4, expecting YES/NO, found - UNIT64;
.IFF
.ERROR ;?SYSMAC-E-U N I T 6 4 = N O and NAME'$N64 = 1
.ENDC
.ENDC
.ENDC
.ENDC
.IF NB <DMA>
.IF IDN <DMA> <YES> 
...V2=...V2!^o60
...V19=...V19!^o10000
...V22=...V22!^o10000
.ENDC
.IIF IDN <DMA> <NO> ...V2=...V2!^o40
.IIF EQ ...V2 .ERROR ;?SYSMAC-E-Invalid D M A, expecting YES/NO, found - DMA;
.ENDC
.IF NB <PERMUMR>
.IIF GT <PERMUMR>-7. .ERROR PERMUMR;?SYSMAC-E-P E R M U M R value > 7;
...V2=...V2!^o60!<PERMUMR>
...V19=...V19!^o10000
...V22=...V22!^o10000
.ENDC
.IIF IDN <SERIAL> <YES> ...V22=...V22!^o4000
.IRP	x,\...V2
.=^o100
	.WORD	x
.ENDR
.=^o176
.IF DIF <CSR>,<*NO*>
.IIF NDF NAME'$CSR,NAME'$CSR=CSR
.GLOBL	NAME'$CSR
	.WORD	NAME'$CSR
.ENDC
.ENDM

;+TEST
DRDE1:	.DRDEF AA,377,FILST$!VARSZ$,0,172150,154
AA$X64:
.IIF NE ...V22 .ERROR ...V22 ; . . . V 2 2 not zero
.IIF NE ...V2 .ERROR ...V2 ; . . . V 2 unexpected value

.IF NE MAC$ER
 AB$N64= 1
;Expect P error
DRDE2:	.DRDEF AB,377,FILST$!VARSZ$,0,172150,154
AB$X64:
.IIF NE ...V22 .ERROR ...V22 ; . . . V 2 2 not zero
.IIF NE ...V2 .ERROR ...V2 ; . . . V 2 unexpected value
.ENDC

DRDE3:	.DRDEF AC,377,FILST$!VARSZ$,0,172150,154,UNIT64=XXX
AC$X64:
.IIF NE ...V22 .ERROR ...V22 ; . . . V 2 2 not zero
.IIF NE ...V2 .ERROR ...V2 ; . . . V 2 unexpected value

.IF NE MAC$ER
 AD$N64= 1
;Expect P error
DRDE4:	.DRDEF AD,377,FILST$!VARSZ$,0,172150,154,UNIT64=XXX
AD$X64:
.IIF NE ...V22 .ERROR ...V22 ; . . . V 2 2 not zero
.IIF NE ...V2 .ERROR ...V2 ; . . . V 2 unexpected value
.ENDC

DRDE5:	.DRDEF AE,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
AE$X64:
.IIF NE ...V22 .ERROR ...V22 ; . . . V 2 2 not zero
.IIF NE ...V2 .ERROR ...V2 ; . . . V 2 unexpected value

AF$N64= 1
DRDE6:	.DRDEF AF,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
AF$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rA  > .ERROR ...V2 ; . . . V 2 unexpected value

BA$N64= 1
BA$NAM= ^RZ9 
DRDE7:	.DRDEF BA,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
BA$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rZ  > .ERROR ...V2 ; . . . V 2 unexpected value

BB$N64= 1
BB$NAM= ^RZA 
DRDE8:	.DRDEF BB,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
BB$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rZ  > .ERROR ...V2 ; . . . V 2 unexpected value

BC$N64= 1
BC$NAM= ^RZ  
DRDE9:	.DRDEF BC,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
BC$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rZ  > .ERROR ...V2 ; . . . V 2 unexpected value

BD$N64= 1
BD$NAM= ^R   
DRDEA:	.DRDEF BD,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
BD$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^r   > .ERROR ...V2 ; . . . V 2 unexpected value

BE$N64= 1
BE$NAM= ^RA  
DRDEB:	.DRDEF BE,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
BE$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rA  > .ERROR ...V2 ; . . . V 2 unexpected value

BF$N64= 1
BF$NAM= ^RTS 
DRDEC:	.DRDEF BF,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
BF$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rT  > .ERROR ...V2 ; . . . V 2 unexpected value

BG$N64= 1
BG$NAM= ^RTT 
DRDED:	.DRDEF BG,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
BG$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rT  > .ERROR ...V2 ; . . . V 2 unexpected value

BH$N64= 1
BH$NAM= ^RU  
DRDEE:	.DRDEF BH,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
BH$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rU  > .ERROR ...V2 ; . . . V 2 unexpected value

CA$N64= 1
CA$PN2= ^RP  
DRDEF:	.DRDEF CA,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
CA$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rP  > .ERROR ...V2 ; . . . V 2 unexpected value

.IF NE MAC$ER
CB$N64= 1
CB$PN2= ^RPA 
;Expect P error
DRDEG:	.DRDEF CB,377,FILST$!VARSZ$,0,172150,154,UNIT64=YES
CB$X64:
.IIF NE ...V22-<^o040000> .ERROR ...V22 ; . . . V 2 2 not 040000
.IIF NE ...V2-<^rP  > .ERROR ...V2 ; . . . V 2 unexpected value
.ENDC
.Enabl	LSB
.PSect	Text
$DRDEF:	.Asciz	"%SYSMAC-I-Testing .DRDEF"
.PSect	Active
	Mov	#$DRDEF,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DREND	Define end of mem-res code & boot code	**Handler only**
;++
;	.DREND
;
;	FORCE is used to force the generation of the vector table.
;	Assigning a value to FORCE causes the associated sysgen bit
;	value to be "forced" on for purposes of generating the table.
;
;	FORCE=1 will force generation of the error logging vector
;	for instance.
;
;	PSECT is used to force the DREND macro to be in a different
;	PSECT from the expected dd'DVR one.  This is used for cases
;	when the memory resident part of a handler is built from 
;	several psects.
;
;	The setting of OFFSET= in .DRBOT controls the generation of
;	the last 4 words of the boot block image.  If .DRBOT has not
;	been invoked or OFFSET=NO has been chosen (perhaps by default)
;	the last 4 words will contain -1s. If OFFSET=YES has been
;	chosen, the last 4 words will contain 0s.
;--

.MACRO	.DREND	NAME,FORCE=0,PSECT,?L1,?L2
.IF B <PSECT>
.PSECT	NAME'DVR
.IFF
.PSECT	PSECT
.ENDC
.IIF NDF NAME'$END,NAME'$END::
.IF EQ	.-NAME'$END
.IF NE MMG$T!<FORCE&2.>
$RLPTR::.WORD	0
$MPPTR::.WORD	0
$GTBYT::.WORD	0
$PTBYT::.WORD	0
$PTWRD::.WORD	0
.ENDC
.IF NE ERL$G!<FORCE&1>
$ELPTR::.WORD	0
.ENDC
.IF NE TIM$IT!<FORCE&4.>
$TIMIT::.WORD	0
.ENDC
$INPTR::.WORD	0
$FKPTR::.WORD	0
.IIF NDF ...V22 ...V22=0
.IF NE	...V22&^o40000
NAME'$X64 =:.
.REPT	16.
	.WORD	0
.ENDR
.ENDC
.GLOBL	NAME'STRT
NAME'END==.
.IFF
.PSECT	NAME'BOOT
.IIF LT	<NAME'BOOT-.+^o664>,.ERROR;?SYSMAC-E-Primary boot too large;
.=NAME'BOOT+^o664
BIOERR:	JSR	R1,REPORT
	 .WORD	IOERR-NAME'BOOT
REPORT:	MOV	#BOOTF-NAME'BOOT,R0
	MOV	#L2-NAME'BOOT,R2
	CALL	@R2
	MOV	@R1,R0
	CALL	@R2
	MOV	#CRLFLF-NAME'BOOT,R0
	CALL	@R2
L1:	HALT
	BR	L1
L2:	TSTB	@#TPS
	BPL	L2
	MOVB	(R0)+,@#TPB
	BNE	L2
	RETURN
BOOTF:	.ASCIZ	<CR><LF>"?BOOT-U-"
IOERR:	.ASCII	"I/O error"
CRLFLF:	.ASCIZ	<CR><LF><LF>
	.EVEN
.IIF NDF ...V7,...V7=-1
.REPT	4.
	.WORD	...V7
.ENDR
NAME'BEND::
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DREND:	.Asciz	"%SYSMAC-I-Testing .DREND"
.PSect	Active
	Mov	#$DREND,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DREST	Define handler extended status		**Handler only**
;++
; Replace table format
;
;	.BYTE	some	if 0 all blocks replacable (like RL01/2)
;			if 1 some blocks replacable (like RK06/7)
;			other bits reserved and 0
;	.BYTE	sluff	bad sector file at last_block+sluff
;	.BYTE	numsec	bad sector file numsec sectors long
;	.BYTE	tpc	tracks per cylinder
;	.BYTE	spt	sectors per track
;	.BYTE	hack	2**hack sectors per block
;
;	The replacement table must be contained within block 0 of
;	the handler.
;
;	MOD2 places values in the high byte of xxCQE,
;
;	DVM.NF*^o400	100000	is placed there if FETCH=*NO* found
;	DV2.V2		040000	is placed there if MOD2=DV2.V2 is
;				specified and means (to RESORC only)
;				that there is an additional vector
;				table to display that follows the
;				standard vector table.
;--

.MACRO	.DREST	CLASS=0,MOD=0,DATA=0,TYPE,SIZE=0,REPLACE=0,MOD2=0,STAT2=0
DVC.UK	=:0
DVC.NL	=:1
DVC.TT	=:^o2
DVC.TP	=:^o3
DVC.DK	=:^o4
DVC.MT	=:^o5
DVC.CT	=:^o6
DVC.LP	=:^o7
DVC.DE	=:^o10
DVC.DP	=:^o11
DVC.DL	=:^o12
DVC.NI	=:^o13
DVC.PS	=:^o14
DVC.VT	=:^o15
DVC.SI	=:^o16
DVC.SO	=:^o17
DVC.SB	=:^o20

DVM.NS	=:1
DVM.DX	=:1
DVM.DM	=:^o2
DVM.NF	=:^o200

DV2.V2	=:^o40000

HS2.BI	=:1
HS2.KI	=:^o2
HS2.KL	=:^o4
HS2.KU	=:^o10
HS2.MO	=:^o20

.IIF NDF ...V18,...V18=0
.IIF NDF ...V19,...V19=0
...V18=...V18!<MOD>
...V19=...V19!<MOD2>
.ASECT
.=0
	.RAD50	"HAN"
.=^o20
	.BYTE	CLASS
.IRP	X,\...V18
	.BYTE	X
.ENDR
.=^o32
	.WORD	REPLACE
.=^o36
	.WORD	STAT2
.=^o70
...V2=.
	.RAD50	"TYPE"
.=...V2+2.
	.WORD	DATA
	.WORD	SIZE
.IF B <TYPE>
.IIF DIF <DATA>,<0> .ERROR ;?SYSMAC-W-D A T A table specified, but no T Y P E;
.ENDC

.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DREST:	.Asciz	"%SYSMAC-I-Testing .DREST"
.PSect	Active
	Mov	#$DREST,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRFIN	Define return to COMPLT exit		**Handler only**
.MACRO	.DRFIN	NAME
.GLOBL	NAME'CQE
	MOV	PC,R4
	ADD	#NAME'CQE-.,R4
	MOV	@#^o54,R5
	JMP	@^o270(R5)
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRFIN:	.Asciz	"%SYSMAC-I-Testing .DRFIN"
.PSect	Active
	Mov	#$DRFIN,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRFMS	Define FORMAT switch table		**Handler only**

.MACRO	.DRFMS	SWITCH
.MCALL	...CM9
.IF NE ...V26-1
...V26=3.
.IRPC	X,QWERTYUIOPASDFGHJKLZXCVBNM
.IIF DF ...V1'X ...V1'X=0
.ENDR
.ENDC
.IF EQ ...V25
...V25=1
.IRPC	X,OOOOOOOOPPPPPPPPVWY
...CM9	0,X
.ENDR
.ENDC
.IRP	X,<SWITCH>
...CM9	1,X
.ENDR
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRFMS:	.Asciz	"%SYSMAC-I-Testing .DRFMS"
.PSect	Active
	Mov	#$DRFMS,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	...CM9	Support macro for .DRFMS		**Handler only**
.MACRO	...CM9	Z,L,V
.IF NDF	SWI.'L
SWI.'L:
...V1'L=0
.ENDC
...V2=0
.IRPC	X,OPVWY
.IIF IDN <L>,<X> ...V2=1
.ENDR
.IF EQ ...V2*Z
	.WORD	''L,0,0,0
.ENDC
...V2=.
.=...V1'L*8.+6.+SWI.'L
	.WORD	V
.=...V2
...V1'L=...V1'L+1
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$..CM9:	.Asciz	"%SYSMAC-I-Testing ...CM9"
.PSect	Active
	Mov	#$..CM9,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRFMT	Define FORMAT Argument block		**Handler only**
.MACRO	.DRFMT	SETUP,SWITCH,SCCA,FMTCODE,DEVCK,VFYBEGIN,VFYREAD,VFYWRITE,VFYEND,FMTBEGIN,SIZE,?L1=$FMT$
...V25=0
.IIF NDF ...V26 ...V26=0
...V26=...V26+1
.SAVE
.ASECT
.=^o12
	.WORD	L1
.RESTORE
L1::
	.BYTE	0,0
	.WORD	SETUP
	.WORD	SWITCH
	.WORD	SCCA
	.WORD	FMTCODE
	.WORD	DEVCK
	.WORD	VFYBEGIN
	.WORD	VFYREAD
	.WORD	VFYWRITE
	.WORD	VFYEND
	.WORD	FMTBEGIN
	.WORD	SIZE
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRFMT:	.Asciz	"%SYSMAC-I-Testing .DRFMT"
.PSect	Active
	Mov	#$DRFMT,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRINS	Define installation code area		**Handler only**
;++
;	.DRINS
;
;	If the NAME parameter is specified with a "-" prefix,
;	the installation CSR is 0 and the first display CSR is
;	the value of NAME'$CSR
;--
.MACRO	.DRINS	NAME,CSRS
.ASECT
.=^o172
	.WORD	0
...V2=0
.IRPC X,<NAME>
.IIF IDN <->,<X> ...V2=1
.ENDR
.IF NE ...V2
DISCSR:	.WORD	-<NAME'$CSR>
INSCSR:	.WORD	0
.IFF
DISCSR:	.WORD	NAME'$CSR
INSCSR:	.WORD	NAME'$CSR
.ENDC
...V2=2.
...V3=^o170
.IRP X,<CSRS>
.IRP Y,\...V2
.=...V3
	.WORD	0
DISCS'Y:	.WORD	X
.ENDR
...V2=...V2+1
...V3=...V3-^o2
.ENDR
.=^o202
INSSYS:
.=^o200
INSDAT:
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRINS:	.Asciz	"%SYSMAC-I-Testing .DRINS"
.PSect	Active
	Mov	#$DRINS,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRPTR	Define added handler entry points	**Handler only**
.MACRO	.DRPTR	FETCH=0,RELEASE=0,LOAD=0,UNLOAD=0
...V2=0
.IIF NDF ...V9,...V9=0
.IIF NDF ...V18,...V18=0
.IIF NDF ...V19,...V19=0
.ASECT
.=0
	.RAD50	"HAN"
.IF IDN <FETCH>,<*NO*>
...V2=1
...V18=...V18!^o200
...V19=...V19!^o100000
	.WORD	0
.IFF
	.WORD	FETCH
.IF DIF <FETCH>,<0>
...V9=...V9!1
.ENDC
.ENDC
	.WORD	RELEASE
.IF IDN <LOAD>,<*NO*>
.IF EQ ...V2
...V18=...V18!^o100
...V19=...V19!^o20000
.IFTF
	.WORD	0
.IFF
.ERROR ;?SYSMAC-W-L O A D and F E T C H both *NO* - L O A D = 0 forced;
.ENDC
.IFF
	.WORD	LOAD
.IF DIF <LOAD>,<0>
...V9=...V9!^o4
.ENDC
.ENDC
	.WORD	UNLOAD
.IIF DIF <RELEASE>,<0>	...V9=...V9!^o2
.IIF DIF <UNLOAD>,<0>	...V9=...V9!^o10
.=^o21
.IRP	X,\...V18
	.BYTE	X
.ENDR
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRPTR:	.Asciz	"%SYSMAC-I-Testing .DRPTR"
.PSect	Active
	Mov	#$DRPTR,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRSET	Define SET option table entry		**Handler only**
.MACRO	.DRSET	OPTION,VAL,RTN,MODE
.ASECT
.IF LE	.-^o400
.=^o400
.IFF
.=.-2.
.ENDC
	VAL
...V2=.
	.RAD50	\OPTION\
.=...V2+4.
	.BYTE	<RTN-^o400>/2.
...V2=0
.IRP X,<MODE>
.IF IDN <X>,<NUM>
...V2=...V2!^o100
.IFF
.IF IDN <X>,<NO>
...V2=...V2!^o200
.IFF
.IF IDN <X>,<OCT>
...V2=...V2!^o140
.IFF
.ERROR;?SYSMAC-E-Invalid O P T I O N, expecting NO/NUM/OCT, found - X;
.ENDC
.ENDC
.ENDC
.ENDR
	.BYTE	...V2
	.WORD	0
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRSET:	.Asciz	"%SYSMAC-I-Testing .DRSET"
.PSect	Active
	Mov	#$DRSET,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRSPF	Define supported SPFUN request numbers	**Handler only**
.MACRO	.DRSPF	ARG,ARG2,TYPE=O
	.MCALL	...CM8
		...V10=0
	.IRPC	X,<ARG>
	 .IIF IDN <X>,<+> ...V10=1
	 .IIF IDN <X>,<-> ...V10=2.
	 .MEXIT
	.ENDR
	.IF EQ ...V10-1
		.=30
		.WORD	0'ARG'
	 .MEXIT
	.ENDC
		...V4 = -1
		...V3 =  0
	.IRPC X,<ORWMT>
	 .IIF 	IDN <X>,<TYPE>	...V4 = ...V3
		...V3 = ...V3 + 1
	.ENDR
	.IIF EQ ...V4+1 .ERROR	;?SYSMAC-E-Invalid T Y P E, expecting O/R/W/M/T, found - TYPE;

	.IF EQ ...V10-2.
		...V2=0
		...V3=0
	 .IRP X,<ARG2>
		...V10=0
		...V11=<X&^o370>
		...CM8	X,...V3,...V2
	  .IF EQ ...V10
	   .IF EQ ...V2
		...V2=...V11
	   .IFF
	    .IIF NE ...V2-...V11 .ERROR ;?SYSMAC-E-Too many different NN_ SPFUN codes;
	   .ENDC
	  .ENDC
		...CM8	X,...V3,...V2
	 .ENDR
	 .IRP	X,\...V3
		.BYTE	X
	 .ENDR
	 .IRP	X,\...V2
	  .IRP	Y,\...V4
		.BYTE	X!Y
	  .ENDR
	 .ENDR
	 .MEXIT
	.ENDC

	.IF NDF ...V15
		...V15=0
		...V16=0
		...V17=0
		...V12=0
		...V13=0
		...V14=0
	.ENDC
	.IRP	X,<ARG>
		...V10=0
		...V11=<X&^o370>!...V4
		...CM8	X,...V15,...V12
		...CM8	X,...V16,...V13
		...CM8	X,...V17,...V14
	 .IF EQ ...V10			;...V10 = 0 implies that this is an
	  .IF EQ ...V12			;as yet unknow .spfun group
		...V12=...V11
	  .IFF
	   .IF EQ ...V13
		...V13=...V11
	   .IFF
	    .IF EQ ...V14
		...V14=...V11
	    .IFF
		.ERROR ;?SYSMAC-F-Too many different NN_ SPFUN codes;
	    .ENDC
	   .ENDC
	  .ENDC
	 .ENDC
		...CM8	X,...V15,...V12
		...CM8	X,...V16,...V13
		...CM8	X,...V17,...V14
	.ENDR

		.ASECT
		.=^o22


	.IRP	X,<...V15,...V12,...V16,...V13,...V17,...V14>
		.IRP	Y,\X
		.BYTE	Y
		.ENDR
	.ENDR

		.WORD	000000
	.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRSPF:	.Asciz	"%SYSMAC-I-Testing .DRSPF"
.PSect	Active
	Mov	#$DRSPF,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	...CM8	Support macro for .DRSPF		**Handler only**
;++
;	...CM8
;
;	Verifies VAL to be negative
;	Study .DRSPF & ...CM8 for further information (Tough luck?)
;	Defines XXN as bottom octade of VAL
;++

.MACRO	...CM8	VAL,XXN,NNX
.IIF EQ ...V11&^o200 .ERROR VAL ;?SYSMAC-E-SPFUN values must be negative;
.IF EQ ...V11-NNX
...V10=1
.REPT VAL-<...V11&^o370>
...V10=...V10+...V10
.ENDR
XXN=XXN!...V10
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$..CM8:	.Asciz	"%SYSMAC-I-Testing ...CM8"
.PSect	Active
	Mov	#$..CM8,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST

.Page
.SbTtl	.DRTAB	Define DEC table pointer table		**Handler only**
;++
;	.DRTAB
;
;	Used to setup a pointer for DEC defined handler data tables.
;
;	The first argument is a RAD50 value.
;	The second argument is a poiniter to a table.
;	The third argument is the size in bytes
;	of the table pointed to by the second argument.
;
;
;	The table is terminated with an invocation of .DRTAB
;	without any arguments.
;
;	.DRTAB	JFW,JIMS,SZJIM
;	.DRTAB	JBM,JIMS2,SZJIM2
;	.DRTAB
;
;	The first invocation of .DRTAB also sets up locations 70--74
;	in block 0.  70 is set to -1 to indicate that 72 points to
;	one or more entries generated by .DRTAB; 72 is the pointer to
;	the first .DRTAB entry; and 74 is length of all the .DRTAB
;	entries in bytes.
;
;	DO NOT INVOKE in .ASECT (.SAVE /.RESTORE *B*U*G*)
;--

.MACRO	.DRTAB	TYPE,ADDR,SIZE,L1=$DEC$
.IF	EQ	...V21
...V21=1
.SAVE
.ASECT
.=^o070
	.WORD	-1
	.WORD	L1
	.WORD	L1'Z-L1
.RESTORE
L1:
.ENDC
.IF	NB	<TYPE>
...V2=.
	.RAD50	"TYPE"
.=...V2+2.
	.WORD	ADDR
	.WORD	SIZE
.IFF
	.WORD	000000
L1'Z:
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRTAB:	.Asciz	"%SYSMAC-I-Testing .DRTAB"
.PSect	Active
	Mov	#$DRTAB,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRUSE	Define user pointer table		**Handler only**
;++
;	.DRUSE
;
;	Used to setup a pointer for user defined pointers.
;
;	To define a user pointer, define the type as the
;	first argument and the value or pointer as the second
;	argument.  The first argument is a RAD50 value.
;	The third argument is, by convention the size in bytes
;	of any table pointed to by the second argument.
;
;
;	The table is terminated with an invocation of .DRUSE
;	without any arguments.
;
;	.DRUSE	JFW,JIMS,SZJIM
;	.DRUSE	JBM,JIMS2,SZJIM2
;	.DRUSE
;
;JIMS:	.WORD	^rJFW,1,2,3,4,5,6,7,8.
;SZJIM=:.-JIMS
;JIMS2:	.WORD	^rJBM,10,1000,100000
;SZJIM2=:.-JIMS2
;
;	The first invocation of .DRUSE sets up location 106 in block
;	0 of the handler to point to the first .DRUSE entry.
;
;	DO NOT INVOKE in .ASECT (.SAVE /.RESTORE *B*U*G*)
;--

.MACRO	.DRUSE	TYPE,ADDR,SIZE,L1=$USER$
.IF	EQ	...V20
...V20=1
.SAVE
.ASECT
.=^o106
	.WORD	L1
.RESTORE
L1:
.ENDC
.IF	NB	<TYPE>
...V2=.
	.RAD50	"TYPE"
.=...V2+2.
	.WORD	ADDR
	.WORD	SIZE
.IFF
	.WORD	000000
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRUSE:	.Asciz	"%SYSMAC-I-Testing .DRUSE"
.PSect	Active
	Mov	#$DRUSE,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DRVTB	Define entry in multi vector table	**Handler only**
.MACRO	.DRVTB	NAME,VEC,INT,PS=0,SLOTID
.IF NB	NAME
NAME'$VTB::
.IF NB	SLOTID
	.WORD	^o100000,SLOTID
.ENDC
.IFF
.=.-2.
.ENDC
.IIF NE	VEC&3.	.ERROR	VEC;?SYSMAC-E-Odd or invalid vector specified;
	.WORD	VEC&^C3.,INT-.,^o340!PS,^o100000
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DRVTB:	.Asciz	"%SYSMAC-I-Testing .DRVTB"
.PSect	Active
	Mov	#$DRVTB,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.DSTATUS Get device status request
.MACRO	.DSTAT	RETSPC,DNAM
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CMC	<RETSPC>,<DNAM>,342
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$DSTAT:	.Asciz	"%SYSMAC-I-Testing .DSTATUS"
.PSect	Active
	Mov	#$DSTAT,R0	;Ident the test
	Call	BegTst
	Mov	SP,R5		;save stack pointer
	Mov	#Patter,R0	;init R0
DSTA1:	.DSTATUS #111111,#123456
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	SP,R5		;is stack correct?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Mov	SP,R5		;save stack pointer
	Mov	#123456,R0	;init R0
DSTA2:	.DSTATUS #111111,R0
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	SP,R5		;is stack correct?
	Beq	60$		;yes
	Call	Err2.3		;no
60$:
	Mov	SP,R5		;save stack pointer
	Mov	#123456,R0	;init R0
DSTA3:	.DSTATUS #111111
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	SP,R5		;is stack correct?
	Beq	90$		;yes
	Call	Err3.3		;no
90$:
.PSect	Data
DSTA4:	.DSTATUS
100$:
.PSect	Active
	Cmp	#EMT+...DST,100$-2	;correct EMT?
	Beq	110$		;yes
	Call	Err4		;no
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.ELAW	Eliminate address window request
.MACRO	.ELAW	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,30.,3.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$ELAW:	.Asciz	"%SYSMAC-I-Testing .ELAW"
.PSect	Active
	Mov	#$ELAW,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
ELAW1:	.ELAW	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.ELAW*^o400+..ELAW,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
ELAW2:	.ELAW	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.ELAW*^o400+..ELAW,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
ELAW3:	.ELAW	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.ELAW*^o400+..ELAW,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
ELAW4:	.ELAW
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.ELRG	Eliminate region request
.MACRO	.ELRG	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,30.,1.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$ELRG:	.Asciz	"%SYSMAC-I-Testing .ELRG"
.PSect	Active
	Mov	#$ELRG,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
ELRG1:	.ELRG	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.ELRG*^o400+..ELRG,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
ELRG2:	.ELRG	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.ELRG*^o400+..ELRG,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
ELRG3:	.ELRG	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.ELRG*^o400+..ELRG,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
ELRG4:	.ELRG
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.ENTER	Create file request
.MACRO	.ENTER	AREA,CHAN,DBLK,LEN,SEQNUM,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NE ...V1-1
...CM1	<AREA>,2,<CHAN>,<CODE>,<DBLK>
...CM2	<LEN>,4,,C
...CM2	<SEQNUM>,6,E,C
.MEXIT
.ENDC
...CM5	<CHAN>
...CM0	<DBLK>,<40+AREA>
.ENDM

;+TEST
;V1 not tested
.Enabl	LSB
.PSect	Text
$ENTER:	.Asciz	"%SYSMAC-I-Testing .ENTER"
.PSect	Active
	Mov	#$ENTER,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
ENTE1:	.ENTER	#Area,#123,#123456,#0,#101010
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.ENTER,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#0,(R1)+	;is LEN set?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#101010,(R1)+	;is SEQNUM set?
	Beq	51$		;yes
	Call	Err1.6		;no
51$:
	Call	AreaM1
	Mov	#Area,R0
ENTE2:	.ENTER	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	80$		;yes
	Call	Err2.3		;no
80$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	90$		;yes
	Call	Err2.4		;no
90$:
	Cmp	#-1,(R1)+	;is LEN unchanged?
	Beq	100$		;yes
	Call	Err2.5		;no
100$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	52$		;yes
	Call	Err2.6		;no
52$:
	Call	AreaM1
	Mov	#Area,R0
ENTE3:	.ENTER	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	130$		;yes
	Call	Err3.3		;no
130$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	140$		;yes
	Call	Err3.4		;no
140$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	150$		;yes
	Call	Err3.5		;no
150$:
.PSect	Data
ENTE4:	.ENTER	CODE=NOSET
160$:
.PSect	Active
	Cmp	#EMT+...AR0,160$-2 ;correct EMT?
	Beq	170$		;yes
	Call	Err4		;no
170$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.EXIT	Return to monitor request
.MACRO	.EXIT
	EMT	^o350
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$EXIT:	.Asciz	"%SYSMAC-I-Testing .EXIT"
.PSect	Active
	Mov	#$EXIT,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
.PSect	Data
EXIT1:	.EXIT
.=.-2.
13$:
.=.+2.
15$:
.PSect	Active
	Cmp	#EMT+...EXI,13$	;was the correct EMT generated?
	Beq	10$		;Yes
	Call	Err1
10$:
	Call	EndTst
.DSABL LSB
.PSect	Static
;-TEST
.Page
.SbTtl	.FETCH	Fetch device handler request
.MACRO	.FETCH	ADDR,DNAM
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CMC	<ADDR>,<DNAM>,343
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$FETCH:	.Asciz	"%SYSMAC-I-Testing .FETCH"
.PSect	Active
	Mov	#$FETCH,R0	;Ident the test
	Call	BegTst
	Mov	SP,R5		;save stack pointer
	Mov	#Patter,R0	;init R0
FETC1:	.FETCH	#111111,#123456
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	SP,R5		;is stack correct?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Mov	SP,R5		;save stack pointer
	Mov	#123456,R0	;init R0
FETC2:	.FETCH #111111,R0
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	SP,R5		;is stack correct?
	Beq	60$		;yes
	Call	Err2.3		;no
60$:
	Mov	SP,R5		;save stack pointer
	Mov	#123456,R0	;init R0
FETC3:	.FETCH	#111111
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	SP,R5		;is stack correct?
	Beq	90$		;yes
	Call	Err3.3		;no
90$:
.PSect	Data
FETC4:	.FETCH
100$:
.PSect	Active
	Cmp	#EMT+...FET,100$-2	;correct EMT?
	Beq	110$		;yes
	Call	Err4		;no
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.FORK	Switch to completion routine status call *Handler mostly**
.MACRO	.FORK	FKBLK
	JSR	R5,@$FKPTR
	.WORD	FKBLK-.
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$FORK:	.Asciz	"%SYSMAC-I-Testing .FORK"
.PSect	Active
	Mov	#$FORK,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.FPROT	Set/Clear file protection request
.MACRO	.FPROT	AREA,CHAN,DBLK,PROT=#1,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,35,<CHAN>,<CODE>,<DBLK>
...CM2	<PROT>,4,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$FPROT:	.Asciz	"%SYSMAC-I-Testing .FPROTECT"
.PSect	Active
	Mov	#$FPROT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
FPRO1:	.FPROT	#Area,#123,#123456,#0
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.FPROT,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	CmpB	#..PROT,(R1)+	;is PROT set?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Call	AreaM1
	Mov	#Area,R0
FPRO2:	.FPROT	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	80$		;yes
	Call	Err2.3		;no
80$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	90$		;yes
	Call	Err2.4		;no
90$:
	CmpB	#..UNPR,(R1)+	;is PROT defaulted to 1?
	Beq	100$		;yes
	Call	Err2.5		;no
100$:
	Call	AreaM1
	Mov	#Area,R0
FPRO3:	.FPROT	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	130$		;yes
	Call	Err3.3		;no
130$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	140$		;yes
	Call	Err3.4		;no
140$:
	CmpB	#..UNPR,(R1)+	;is PROT defaulted to 1?
	Beq	150$		;yes
	Call	Err3.5		;no
150$:
.PSect	Data
FPRO4:	.FPROT	CODE=NOSET
160$:
.PSect	Active
	Cmp	#EMT+...AR0,160$-2	;correct EMT?
	Beq	170$		;yes
	Call	Err4		;no
170$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.GCMAP	return extended mapping status
.MACRO	.GCMAP	AREA,CODE
.MCALL	.CMAP
.IIF IDN <CODE>,NOSET .CMAP	<AREA>,,<CODE>
.IIF DIF <CODE>,NOSET .CMAP	<AREA>,#0,<CODE>
.ENDM
.Enabl	LSB
.PSect	Text
$GCMAP:	.Asciz	"%SYSMAC-I-Testing .GCMAP"
.PSect	Active
	Mov	#$GCMAP,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
GCMA1:	.GCMAP	#Area
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.GCMAP,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#0,(R1)+	;is CMAP set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0
GCMA2:	.GCMAP	
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#377,(R1)+	;is channel unchanged?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#0,(R1)+	;is CMAP set?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0
GCMA3:	.GCMAP	CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#377,(R1)+	;is channel unchanged?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#177777,(R1)+	;is CMAP unchanged?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
.PSect	Data
GCMA4:	.GCMAP	CODE=NOSET
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2 ;correct EMT?
	Beq	140$		;yes
	Call	Err4		;no
140$:
	Mov	SP,R5		;save the stack alignment
GCMA5:	.GCMAP	CODE=STACK
.=.-4
	NOP			;Zap the EMT
.=.+2				;save the BIT
	Cmp	SP,R5		;is the stack alignment preserved?
	Beq	150$		;yes
	Call	Err5		;nope
150$:
	Mov	R5,SP		;restore it
	Mov	SP,R5		;save the stack alignment
GCMA6:	.GCMAP	CODE=SP
.=.-4
	NOP			;Zap the EMT
.=.+2				;save the BIT
	Cmp	SP,R5		;is the stack alignment preserved?
	Beq	160$		;yes
	Call	Err6		;nope
160$:
	Mov	R5,SP		;restore it
	Mov	SP,R5		;save the stack alignment
GCMA7:	.GCMAP	CODE=STACK
.=.-4				;ZAP EMT and BIT
	Mov	R0,R1		;point to argument area
	Cmp	R0,SP		;R0 correct?
	Beq	170$		;yes
	Call	Err7.1		;no
170$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	180$		;yes
	Call	Err7.2		;no
180$:
	CmpB	#.GCMAP,(R1)+	;is subcode set?
	Beq	190$		;yes
	Call	Err7.3		;no
190$:
	Cmp	#0,(R1)+	;is CMAP set?
	Beq	200$		;yes
	Call	Err7.4		;no
200$:
	Mov	R5,SP		;restore stack alignment	
	Call	EndTst
.Dsabl	LSB
.If	NE	MAC$ER
;Expect P errors
.GCMAP	AREA,CODE=STACK
.GCMAP	AREA,CODE=SP
.EndC
;-TEST
.Page
.SbTtl	.GFDATE	Get file entry date word request
.MACRO	.GFDAT	AREA,CHAN,DBLK,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,36,<CHAN>,<CODE>,<DBLK>
...CM2	#0,4
...CM2	#12.*^o400,6,E
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$GFDAT:	.Asciz	"%SYSMAC-I-Testing .GFDAT"
.PSect	Active
	Mov	#$GFDAT,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.GFINFO	Get file entry request
.MACRO	.GFINF	AREA,CHAN,DBLK,OFFSE,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,36,<CHAN>,<CODE>,<DBLK>
...CM2	#0,4
...CM2	#0,6,,,B
...CM2	<OFFSE>,7,E,,B
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$GFINF:	.Asciz	"%SYSMAC-I-Testing .GFINF"
.PSect	Active
	Mov	#$GFINF,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.GFSTAT	Get file entry status word request
.MACRO	.GFSTAT	AREA,CHAN,DBLK,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,36,<CHAN>,<CODE>,<DBLK>
...CM2	#0,4
...CM2	#0,6,E
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$GFSTA:	.Asciz	"%SYSMAC-I-Testing .GFSTA"
.PSect	Active
	Mov	#$GFSTA,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.GMCX	Get mapping context request
.MACRO	.GMCX	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,30.,6.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$GMCX:	.Asciz	"%SYSMAC-I-Testing .GMCX"
.PSect	Active
	Mov	#$GMCX,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
GMCX1:	.GMCX	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.GMCX*^o400+..GMCX,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
GMCX2:	.GMCX	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.GMCX*^o400+..GMCX,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
GMCX3:	.GMCX	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.GMCX*^o400+..GMCX,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
GMCX4:	.CRAW
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.GTIM	Get current time request
.MACRO	.GTIM	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,17.,0.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$GTIM:	.Asciz	"%SYSMAC-I-Testing .GTIM"
.PSect	Active
	Mov	#$GTIM,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
GTIM1:	.GTIM	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.GTIM*^o400+0,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
GTIM2:	.GTIM	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.GTIM*^o400+0,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
GTIM3:	.GTIM	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.GTIM*^o400+0,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
GTIM4:	.GTIM
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2	;Correct EMT?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.GTJB	Get job information request
.MACRO	.GTJB	AREA,ADDR,JOBBLK,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,16.,1.,<CODE>,<ADDR>
.IF NB  <JOBBLK>
.IF IDN <JOBBLK>,<ME>
...CM2	#-1,4,E
.IFF
...CM2	<JOBBLK>,4,E
.ENDC
.IFF
...CM2	#-3.,4,E
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$GTJB:	.Asciz	"%SYSMAC-I-Testing .GTJB"
.PSect	Active
	Mov	#$GTJB,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
GTJB1:	.GTJB	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.GTJB*^o400+..GTJB,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Cmp	#..GTV3,(R1)+	;is the address correct?
	Beq	40$		;yes
	Call	Err1.4
40$:
	Call	AreaM1		;set area to -1s
GTJB2:	.GTJB	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	Cmp	#.GTJB*^o400+..GTJB,(R1)+ ;is the subcode correct?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	70$		;yes
	Call	Err2.3
70$:
	Cmp	#..GTV3,(R1)+	;is the address correct?
	Beq	80$		;yes
	Call	Err2.4
80$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
GTJB3:	.GTJB	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	Cmp	#.GTJB*^o400+..GTJB,(R1)+ ;is the subcode correct?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	110$		;yes
	Call	Err3.3
110$:
	Cmp	#..GTV3,(R1)+	;is the address correct?
	Beq	120$		;yes
	Call	Err3.4
120$:
.PSect	Data
GTJB4:	.GTJB
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2 ;correct EMT code?
	Beq	140$		;yes
	Call	Err4
140$:
	Call	AreaM1		;set area to -1s
GTJB5:	.GTJB	#Area,#123456,#121654
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	150$		;yes
	Call	Err5.1		;no
150$:
	Cmp	#.GTJB*^o400+..GTJB,(R1)+ ;is the subcode correct?
	Beq	160$		;yes
	Call	Err5.2		;no
160$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	170$		;yes
	Call	Err5.3
170$:
	Cmp	#121654,(R1)+	;is the address correct?
	Beq	180$		;yes
	Call	Err5.4
180$:
	Call	AreaM1		;set area to -1s
GTJB6:	.GTJB	#Area,#123456,ME
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	190$		;yes
	Call	Err6.1		;no
190$:
	Cmp	#.GTJB*^o400+..GTJB,(R1)+ ;is the subcode correct?
	Beq	200$		;yes
	Call	Err6.2		;no
200$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	210$		;yes
	Call	Err6.3
210$:
	Cmp	#..GTME,(R1)+	;is the address correct?
	Beq	220$		;yes
	Call	Err6.4
220$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.GTLINE	Get a line of input request
.MACRO	.GTLIN	LINBUF,PROMPT,TYPE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM0	<LINBUF>
.IF	NB	<TYPE>
...CM0	#3.
.IFF
...CM0	#1
.ENDC
...CM0	<PROMPT>
...CM0	,345
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$GTLIN:	.Asciz	"%SYSMAC-I-Testing .GTLINE"
.PSect	Active
	Mov	#$GTLIN,R0	;Ident the test
	Call	BegTst
	Mov	SP,R5		;save Stack pointer
GTLI1:	.GTLIN	#200
	.=.-2
	Cmp	#..GTIS,(SP)+	;is 0 on top of stack?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#0,(SP)+	;is PROMPT next on stack?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#..GTAT,(SP)+	;is "TYPE" next on stack?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#200,(SP)+	;is LINBUF next on stack?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Mov	R5,SP		;force alignment
	Mov	SP,R5		;save Stack pointer
GTLI2:	.GTLIN	#200,#400
	.=.-2
	Cmp	#..GTIS,(SP)+	;is 0 on top of stack?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	Cmp	#400,(SP)+	;is PROMPT at top of stack?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	Cmp	#..GTAT,(SP)+	;is "TYPE" next on stack?
	Beq	80$		;yes
	Call	Err2.3		;no
80$:
	Cmp	#200,(SP)+	;is LINBUF next on stack?
	Beq	90$		;yes
	Call	Err2.4		;no
90$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	100$		;yes
	Call	Err2.5		;no
100$:
	Mov	R5,SP		;force alignment
	Mov	SP,R5		;save Stack pointer
GTLI3:	.GTLIN	#200,#400,TYPE=TERM
	.=.-2
	Cmp	#..GTIS,(SP)+	;is 0 on top of stack?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	Cmp	#400,(SP)+	;is PROMPT at top of stack?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	Cmp	#..GTTT,(SP)+	;is "TYPE" next on stack?
	Beq	130$		;yes
	Call	Err3.3		;no
130$:
	Cmp	#200,(SP)+	;is LINBUF next on stack?
	Beq	140$		;yes
	Call	Err3.4		;no
140$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	150$		;yes
	Call	Err3.5		;no
150$:
	Mov	R5,SP		;force alignment
	Mov	SP,R5		;save Stack pointer
GTLI4:	.GTLIN	#200,TYPE=TERM
	.=.-2
	Cmp	#..GTIS,(SP)+	;is 0 on top of stack?
	Beq	160$		;yes
	Call	Err4.1		;no
160$:
	Cmp	#0,(SP)+	;is PROMPT at top of stack?
	Beq	170$		;yes
	Call	Err4.2		;no
170$:
	Cmp	#..GTTT,(SP)+	;is "TYPE" next on stack?
	Beq	180$		;yes
	Call	Err4.3		;no
180$:
	Cmp	#200,(SP)+	;is LINBUF next on stack?
	Beq	190$		;yes
	Call	Err4.4		;no
190$:
	Cmp	SP,R5		;is stack now aligned?
	Beq	200$		;yes
	Call	Err4.5		;no
200$:
	Mov	R5,SP		;force alignment
.PSect	Data
GTLI5:	.GTLIN
210$:
.PSect	Active
	Cmp	#EMT+...GTL,210$-2	;correct EMT generated?
	Beq	220$		;yes
	Call	Err5		;no
220$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.GVAL	Get contents of location in RMON request
.MACRO	.GVAL	AREA,OFFSE,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,28.,0.,<CODE>,<OFFSE>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$GVAL:	.Asciz	"%SYSMAC-I-Testing .GVAL"
.PSect	Active
	Mov	#$GVAL,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
GVAL1:	.GVAL	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.GVAL*^o400+..GVAL,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
GVAL2:	.GVAL	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.GVAL*^o400+..GVAL,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
GVAL3:	.GVAL	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.GVAL*^o400+..GVAL,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
GVAL4:	.GVAL
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.HERR	Set hard error action request
.MACRO	.HERR
	MOV	#^o2400,R0
	EMT	^o374
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$HERR:	.Asciz	"%SYSMAC-I-Testing .HERR"
.PSect	Active
	Mov	#$HERR,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	Mov	#Patter,R0
HERR1:	.HERR
	.=.-2			;squash EMT
	Cmp	#.HERR*^o400,R0	;Is R0 right?
	Beq	10$
	Call	Err1
10$:
.PSect	Data
HERR2:	.HERR
.=.-2.
23$:
.=.+2.
25$:
.PSect	Active
	Cmp	#EMT+...R0,23$	;was the correct EMT generated?
	Beq	20$		;Yes
	Call	Err2
20$:
	Call	EndTst
.Dsabl LSB
.PSect	Static
;-TEST
.Page
.SbTtl	.HRESET	Do a hard reset request
.MACRO	.HRESE
	EMT	^o357
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$HRESE:	.Asciz	"%SYSMAC-I-Testing .HRESE"
.PSect	Active
	Mov	#$HRESE,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
.PSect	Data
HRESE1:	.HRESE
.=.-2.
13$:
.=.+2.
15$:
.PSect	Active
	Cmp	#EMT+...HRE,13$	;was the correct EMT generated?
	Beq	10$		;Yes
	Call	Err1
10$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.INTEN	Enter system state, lowering priority call
.MACRO	.INTEN	PRIO,PIC
.IF B PIC
	JSR	R5,@^o54
.IFF
	MOV	@#^o54,-(SP)
	JSR	R5,@(SP)+
.ENDC
	.WORD	^C<PRIO*32.>&224.
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$INTEN:	.Asciz	"%SYSMAC-I-Testing .INTEN"
.PSect	Active
	Mov	#$INTEN,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.LOCK	Lock USR in memory and owned by this job
.MACRO	.LOCK
	EMT	^o346
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$LOCK:	.Asciz	"%SYSMAC-I-Testing .LOCK"
.PSect	Active
	Mov	#$LOCK,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
.PSect	Data
LOCK1:	.LOCK
.=.-2.
13$:
.=.+2.
15$:
.PSect	Active
	Cmp	#EMT+...LOC,13$	;was the correct EMT generated?
	Beq	10$		;Yes
	Call	Err1
10$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.LOOKUP	Find an existing file request
.MACRO	.LOOKU	AREA,CHAN,DBLK,SEQNUM,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NE ...V1-1
...CM1	<AREA>,1,<CHAN>,<CODE>,<DBLK>
...CM2	<SEQNUM>,4,E,C
.MEXIT
.ENDC
...CM5	<CHAN>,<20+AREA>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$LOOKU:	.Asciz	"%SYSMAC-I-Testing .LOOKUP"
.PSect	Active
	Mov	#$LOOKU,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
LOOK1:	.LOOKUP	#Area,#123,#123456,#0
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.LOOKU,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#0,(R1)+	;is SEQNUM set?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Call	AreaM1
	Mov	#Area,R0
LOOK2:	.LOOKUP	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	80$		;yes
	Call	Err2.3		;no
80$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	90$		;yes
	Call	Err2.4		;no
90$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	100$		;yes
	Call	Err2.5		;no
100$:
	Call	AreaM1
	Mov	#Area,R0
LOOK3:	.LOOKUP	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	130$		;yes
	Call	Err3.3		;no
130$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	140$		;yes
	Call	Err3.4		;no
140$:
	Cmp	#-1,(R1)+	;is SEQNUM unchanged?
	Beq	150$		;yes
	Call	Err3.5		;no
150$:
.PSect	Data
LOOK4:	.LOOKUP	CODE=NOSET
160$:
.PSect	Active
	Cmp	#EMT+...AR0,160$-2 ;correct EMT?
	Beq	170$		;yes
	Call	Err4		;no
170$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MAP	Map extended memory request
.MACRO	.MAP	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,30.,4.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MAP:	.Asciz	"%SYSMAC-I-Testing .MAP"
.PSect	Active
	Mov	#$MAP,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MAP1:	.MAP	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MAP*^o400+..MAP,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
MAP2:	.MAP	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.MAP*^o400+..MAP,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MAP3:	.MAP	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.MAP*^o400+..MAP,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
MAP4:	.MAP
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MFPS	Move from PS (processor independent) call
.MACRO	.MFPS	ADDR
	MOV	@#^o54,-(SP)
	ADD	#^o362,(SP)
	CALL	@(SP)+
.IF NB	<ADDR>
	MOVB	(SP)+,ADDR
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MFPS:	.Asciz	"%SYSMAC-I-Testing .MFPS"
.PSect	Active
	Mov	#$MFPS,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.MODULE	Define symbols and macros for module identification
.SbTtl	.	Meta-Macro which defines:
.SbTtl	.		.NLCSI	Define ASCII ident strings
.SbTtl	.		.RMODULE Generate RAD50 of module name
;++
;	.MODULE
;
;	Macro to define a standard identification for all
;	modules.
;
;	Inputs:
;
;	MODULE  1-5 character symbol name	(KEDIO)
;	RELEASE 3 char release identification	(X05)
;	VERSION 2 char version number		(09)
;	COMMENT n char title string		<I/O Module>
;
;	TITLE=YES generate .TITLE		(default)
;	TITLE=NO  do not generate .TITLE
;
;	IDENT=YES generate .IDENT		(default)
;	IDENT=NO  do not generate .IDENT
;
;	AUDIT=NO  generate .AUDIT call		(default)
;	AUDIT=YES generate .AUDIT call
;
;	LIB=NO	generate .AUDIT global value	(default)
;	LIB=YES	do not generate .AUDIT
;
;	GLOBAL	  not specified 		(default)
;	GLOBAL=gname substitutes gname for .'MODULE'
;
;	MODNAME   not specified uses MODULE	(default)
;	MODNAME=module name for .TITLE
;
;	Outputs:
;
;	.TITLE	'MODULE' - 'COMMENT'		title for module
;	.IDENT	"'RELEASE'.'VERSION'"		ident for module
;	.'MODULE' ==:	'VERSION'.		version value symbol Binary
;	.AUDIT	==:	^R'RELEASE'		release value symbol RAD50
;
;	.MCALL	.AUDIT				get .AUDIT definition
;	.AUDIT	.AUDIT	.'MODULE'		generate audit information
;
;
;	definition of .NLCSI macro		generate program ID string
;
;	.NLCSI	TYPE=,PART=
;	TYPE=Z	generate .ASCIZ	(default)	.ASCIZ "KEDIO X05.09 "
;	TYPE=I	generate .ASCII			.ASCII "KEDIO X05.09 "
;
;	PART=ALL    generate std ID (default)	.ASCIZ "KEDIO X05.09 "
;	PART=NAME   generate name		.ASCIZ "KEDIO"
;	PART=RLSVER generate release & version	.ASCIZ "X05.09"
;	PART=PREFIX generate message prefix	.ASCIZ "?KEDIO-"
;
;	definition of .RMODULE macro		generate RAD50 for 'MODULE'
;
;	.RMODULE
;--

.MACRO	.MODULE	MODULE,VERSION,COMMENT,TITLE=YES,IDENT=YES,AUDIT=NO,GLOBAL,LIB=NO,MODNAME,RELEASE=V05
.MCALL	.AUDIT
.IF	NDF	...V27
...V27 = 0
...V28 = 0
...V2 = 0
.IRPC	X,'MODULE'
.IF LT ...V2-6
...V28 = ...V28*^o50+^r  'X
...V2 = ...V2+1
.IF EQ	...V2-3
...V27 = ...V28
...V28 = 0
.ENDC
.ENDC
.ENDR
...V5 = ^o110
.IFF
...V6 = 0
...V2 = 0
.IRPC	X,'MODULE'
.IF LT ...V2-6
...V6 = ...V6*^o50+^r  'X
...V2 = ...V2+1
.IF EQ	...V2-3
.IIF NE ...V6-...V27, ...V2 = ^o77777
...V6 = 0
.ENDC
.ENDC
.ENDR
.IIF NE ...V2-^o77777, .IIF EQ ...V6-...V28, ...V5 = ^o110
.ENDC
.IF	NB	<MODNAME>
.IIF	IDN	<TITLE> <YES>,	.TITLE	'MODNAME' - 'COMMENT'
.IFF
.IIF	IDN	<TITLE> <YES>,	.TITLE	'MODULE' - 'COMMENT'
.ENDC
.IIF	IDN	<IDENT> <YES>,	.IDENT	"'RELEASE'.'VERSION'"
.IIF	IDN	<LIB> <NO>,.AUDIT==:^R'RELEASE'
.IF	NB	<GLOBAL>
'GLOBAL'==:'VERSION'.
.IIF	IDN	<AUDIT> <YES>,	.AUDIT	'GLOBAL'
.IFF
.'MODULE'==:'VERSION'.
.IIF	IDN	<AUDIT> <YES>,	.AUDIT	.'MODULE'
.ENDC
.MACRO	.NLCSI	TYPE=Z,PART=ALL
.IF	IDN	<PART> <ALL>
	.ASCI'TYPE'	"'MODULE' 'RELEASE'.'VERSION' "
.ENDC
.IF	IDN	<PART> <NAME>
	.ASCI'TYPE'	"'MODULE'"
.ENDC
.IF	IDN	<PART> <RLSVER>
	.ASCI'TYPE'	"'RELEASE'.'VERSION' "
.ENDC
.IF	IDN	<PART> <PREFIX>
	.ASCI'TYPE'	"?'MODULE'-"
.ENDC
.ENDM
.MACRO	.RMODULE
	.RAD50	"'MODULE'"
.ENDM
.ENDM

;>>> here convert RT$PRE||RT$??? to RAD50 and compare with .AUDIT

;+TEST
.Enabl	LSB
.PSect	Text
$MODUL:	.Asciz	"%SYSMAC-I-Testing .MODUL"
.PSect	Active
	Mov	#$MODUL,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
.Enabl	LSB
.PSect	Text
$NLCSI:	.Asciz	"%SYSMAC-I-Testing .NLCSI"
.PSect	Active
	Mov	#$NLCSI,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
.Enabl	LSB
.PSect	Text
$RMODU:	.Asciz	"%SYSMAC-I-Testing .RMODU"
.PSect	Active
	Mov	#$RMODU,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MRKT	Queue a timer completion routine request
.MACRO	.MRKT	AREA,TIME,CRTN,ID,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,18.,0.,<CODE>,<TIME>
...CM2	<CRTN>,4
...CM2	<ID>,6,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MRKT:	.Asciz	"%SYSMAC-I-Testing .MRKT"
.PSect	Active
	Mov	#$MRKT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MRKT1:	.MRKT	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MRKT*^o400,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
MRKT2:	.MRKT	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.MRKT*^o400,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MRKT3:	.MRKT	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.MRKT*^o400,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
MRKT4:	.MRKT
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	AreaM1		;set area to -1s
MRKT5:	.MRKT	#Area,#123456,#121654,#154236
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	120$		;yes
	Call	Err5.1		;no
120$:
	Cmp	#.MRKT*^o400,(R1)+ ;is the subcode correct?
	Beq	130$		;yes
	Call	Err5.2		;no
130$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	140$		;yes
	Call	Err5.3
140$:
	Cmp	#121654,(R1)+	;is the address correct?
	Beq	150$		;yes
	Call	Err5.4
150$:
	Cmp	#154236,(R1)+	;is the address correct?
	Beq	160$		;yes
	Call	Err5.5
160$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MSDS	control mapping of U/S D mode
.MACRO	.MSDS	AREA,CMAP,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...V2=0
.IIF IDN <CODE>,<SP>	...V2=1
.IIF IDN <CODE>,<STACK>	...V2=1
.IF EQ ...V2
.IF NB	<CMAP>
.NTYPE	...V2,CMAP
.IFF
...V2=0
.ENDC
.IF EQ	...V2-^o27
.MCALL	.CMAP
	.CMAP	<AREA>,<CMAP!^o4000>,<CODE>
.IFF
...CM6	<AREA>,38.,0.,<CODE>,<CMAP>
.IF DIF <CODE>,<NOSET>
	BIS	#^o4000,2(R0)
.ENDC
	EMT	^o375
.ENDC
.MEXIT
.ENDC
.IIF NB <AREA>,.ERROR;?SYSMAC-W-A R E A ignored when stack form used;
...CM0	<CMAP>
	BIS	#^o4000,@SP
...CM0	<#^o<46*400>>
	MOV	SP,R0
	EMT	375
	BIT	(SP)+,(SP)+
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$MSDS:	.Asciz	"%SYSMAC-I-Testing .MSDS"
.PSect	Active
	Mov	#$MSDS,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
MSDS1:	.MSDS	#Area,#123
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.MSDS,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#000123!CM.DUS,(R1)+	;is CMAP set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0
MSDS2:	.MSDS	,#123
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#377,(R1)+	;is channel unchanged?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#000123!CM.DUS,(R1)+	;is CMAP set?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0
MSDS3:	.MSDS	,#123,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#377,(R1)+	;is channel unchanged?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#000123!CM.DUS,(R1)+	;is CMAP set?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
.PSect	Data
MSDS4:	.MSDS	CODE=NOSET
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2	;correct EMT?
	Beq	140$		;yes
	Call	Err4		;no
140$:
	Mov	SP,R5		;save the stack alignment
MSDS5:	.MSDS	,#123,CODE=STACK
.=.-4
	NOP			;Zap the EMT
.=.+2				;save the BIT
	Cmp	SP,R5		;is the stack alignment preserved?
	Beq	150$		;yes
	Call	Err5		;nope
150$:
	Mov	R5,SP		;restore it
	Mov	SP,R5		;save the stack alignment
MSDS6:	.MSDS	,#123,CODE=SP
.=.-4
	NOP			;Zap the EMT
.=.+2				;save the BIT
	Cmp	SP,R5		;is the stack alignment preserved?
	Beq	160$		;yes
	Call	Err6		;nope
160$:
	Mov	R5,SP		;restore it
	Mov	SP,R5		;save the stack alignment
MSDS7:	.MSDS	,#123,CODE=STACK
.=.-4				;ZAP EMT and BIT
	Mov	R0,R1		;point to argument area
	Cmp	R0,SP		;R0 correct?
	Beq	170$		;yes
	Call	Err7.1		;no
170$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	180$		;yes
	Call	Err7.2		;no
180$:
	CmpB	#.MSDS,(R1)+	;is subcode set?
	Beq	190$		;yes
	Call	Err7.3		;no
190$:
	Cmp	#000123!CM.DUS,(R1)+	;is CMAP set?
	Beq	200$		;yes
	Call	Err7.4		;no
200$:
	Mov	R5,SP		;restore stack alignment	
	Mov	SP,R5		;save the stack alignment
MSDS8:	.MSDS	,,CODE=SP
.=.-4				;ZAP EMT and BIT
	Mov	R0,R1		;point to argument area
	Cmp	R0,SP		;R0 correct?
	Beq	210$		;yes
	Call	Err8.1		;no
210$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	220$		;yes
	Call	Err8.2		;no
220$:
	CmpB	#.MSDS,(R1)+	;is subcode set?
	Beq	230$		;yes
	Call	Err8.3		;no
230$:
	Cmp	#CM.DUS,(R1)+	;is CMAP defaulted?
	Beq	240$		;yes
	Call	Err8.4		;no
240$:
	Mov	R5,SP		;restore stack alignment	
	Mov	SP,R5		;save the stack alignment
	Mov	#123,R2
MSDS9:	.MSDS	,R2,CODE=STACK
.=.-4				;ZAP EMT and BIT
	Mov	R0,R1		;point to argument area
	Cmp	R0,SP		;R0 correct?
	Beq	250$		;yes
	Call	Err9.1		;no
250$:
	CmpB	#0,(R1)+	;is channel set?
	Beq	260$		;yes
	Call	Err9.2		;no
260$:
	CmpB	#.MSDS,(R1)+	;is subcode set?
	Beq	270$		;yes
	Call	Err9.3		;no
270$:
	Cmp	#000123!CM.DUS,(R1)+	;is CMAP set?
	Beq	280$		;yes
	Call	Err9.4		;no
280$:
	Mov	R5,SP		;restore stack alignment	
	Call	EndTst
.Dsabl	LSB
.If	NE	MAC$ER
;Expect P errors
.MSDS	AREA,CODE=STACK
.MSDS	AREA,CODE=SP
.EndC
;-TEST
.Page
.SbTtl	.MTATCH	Attach to a Multi-Terminal LUN request
.MACRO	.MTATC	AREA,ADDR,UNIT,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,5.,<CODE>,<ADDR>
...CM2	<UNIT>,4,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTATC:	.Asciz	"%SYSMAC-I-Testing .MTATCH"
.PSect	Active
	Mov	#$MTATC,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTAT1:	.MTATCH	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTATC*^o400+..MTAT,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	40$		;yes
	Call	Err1.4
40$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	50$		;yes
	Call	Err1.5
50$:
	Call	AreaM1		;set area to -1s
MTAT2:	.MTATCH	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	Cmp	#.MTATC*^o400+..MTAT,(R1)+ ;is the subcode correct?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	80$		;yes
	Call	Err2.3
80$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	90$		;yes
	Call	Err2.4
90$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	100$		;yes
	Call	Err2.5
100$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTAT3:	.MTATCH	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	Cmp	#.MTATC*^o400+..MTAT,(R1)+ ;is the subcode correct?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	130$		;yes
	Call	Err3.3
130$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	140$		;yes
	Call	Err3.4
140$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	150$		;yes
	Call	Err3.5
150$:
.PSect	Data
MTAT4:	.MTATCH
160$:
.PSect	Active
	Cmp	#EMT+...AR0,160$-2 ;correct EMT code?
	Beq	170$		;yes
	Call	Err4
170$:
	Call	AreaM1		;set area to -1s
MTAT5:	.MTATCH	#Area,#123456,#12
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	180$		;yes
	Call	Err5.1		;no
180$:
	Cmp	#.MTATC*^o400+..MTAT,(R1)+ ;is the subcode correct?
	Beq	190$		;yes
	Call	Err5.2		;no
190$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	200$		;yes
	Call	Err5.3
200$:
	CmpB	#12,(R1)+	;is the address correct?
	Beq	210$		;yes
	Call	Err5.4
210$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	220$		;yes
	Call	Err5.5
220$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MTDTCH	Detach from a Multi-Terminal LUN request
.MACRO	.MTDTC	AREA,UNIT,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,6.,<CODE>
...CM2	<UNIT>,4,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTDTC:	.Asciz	"%SYSMAC-I-Testing .MTDTCH"
.PSect	Active
	Mov	#$MTDTC,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTDT1:	.MTDTCH	#Area,#123
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTDTC*^o400+..MTDT,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Tst	(R1)+		;skip unused word
	CmpB	#123,(R1)+	;is the LUN correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	32$		;yes
	Call	Err1.5
32$:
	CmpB	#-1,(R1)+	;Is the high byte unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1		;set area to -1s
MTDT2:	.MTDTCH	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	Cmp	#.MTDTC*^o400+..MTDT,(R1)+ ;is the subcode correct?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	70$		;yes
	Call	Err2.3
70$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	71$		;yes
	Call	Err2.4
71$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	72$		;yes
	Call	Err2.5
72$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTDT3:	.MTDTCH	,#123,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	80$		;yes
	Call	Err3.1		;no
80$:
	Cmp	#.MTDTC*^o400+..MTDT,(R1)+ ;is the subcode correct?
	Beq	90$		;yes
	Call	Err3.2		;no
90$:
	Tst	(R1)+		;skip unused word
	CmpB	#123,(R1)+	;is the LUN correct?
	Beq	100$		;yes
	Call	Err3.3
100$:
	CmpB	#-1,(R1)+	;Is the high byte unchanged?
	Beq	110$		;yes
	Call	Err3.4		;no
110$:
.PSect	Data
MTDT4:	.MTDTCH
120$:
.PSect	Active
	Cmp	#EMT+...AR0,120$-2 ;correct EMT code?
	Beq	130$		;yes
	Call	Err4
130$:
	Call	AreaM1		;set area to -1s
MTDT5:	.MTDTCH	#Area,#123
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	140$		;yes
	Call	Err5.1		;no
140$:
	Cmp	#.MTDTC*^o400+..MTDT,(R1)+ ;is the subcode correct?
	Beq	150$		;yes
	Call	Err5.2		;no
150$:
	Tst	(R1)+		;skip unused word
	CmpB	#123,(R1)+	;is the LUN correct?
	Beq	160$		;yes
	Call	Err5.3
160$:
	CmpB	#-1,(R1)+	;Is the high byte unchanged?
	Beq	170$		;yes
	Call	Err5.4		;no
170$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MTGET	Get status information about a Multi-Terminal LUN request
.MACRO	.MTGET	AREA,ADDR,UNIT,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,1.,<CODE>,<ADDR>
...CM2	<UNIT>,4,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTGET:	.Asciz	"%SYSMAC-I-Testing .MTGET"
.PSect	Active
	Mov	#$MTGET,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTGE1:	.MTGET	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTGET*^o400+..MTGE,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	31$		;yes
	Call	Err1.4
31$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	32$		;yes
	Call	Err1.5
32$:
	Call	AreaM1		;set area to -1s
MTGE2:	.MTGET	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.MTGET*^o400+..MTGE,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	61$		;yes
	Call	Err2.4
61$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	62$		;yes
	Call	Err2.5
62$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTGE3:	.MTGET	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.MTGET*^o400+..MTGE,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	91$		;yes
	Call	Err3.4
91$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	92$		;yes
	Call	Err3.5
92$:
.PSect	Data
MTGE4:	.MTGET
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	AreaM1		;set area to -1s
MTGE5:	.MTGET	#Area,#123456,#12
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	120$		;yes
	Call	Err5.1		;no
120$:
	Cmp	#.MTGET*^o400+..MTGE,(R1)+ ;is the subcode correct?
	Beq	130$		;yes
	Call	Err5.2		;no
130$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	140$		;yes
	Call	Err5.3
140$:
	CmpB	#12,(R1)+	;is the address correct?
	Beq	150$		;yes
	Call	Err5.4
150$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	102$		;yes
	Call	Err5.5
102$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MTIN	Get char(s) from a Multi-Terminal LUN request
.MACRO	.MTIN	AREA,ADDR,UNIT,CHRCNT,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,2.,<CODE>,<ADDR>
...CM2	<UNIT>,4,,,B
...CM2	<CHRCNT>,5,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTIN:	.Asciz	"%SYSMAC-I-Testing .MTIN"
.PSect	Active
	Mov	#$MTIN,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTIN1:	.MTIN	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTIN*^o400+..MTIN,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	40$		;yes
	Call	Err1.4
40$:
	CmpB	#-1,(R1)+	;is the chrcnt unchanged?
	Beq	50$		;yes
	Call	Err1.5
50$:
	Call	AreaM1		;set area to -1s
MTIN2:	.MTIN	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	Cmp	#.MTIN*^o400+..MTIN,(R1)+ ;is the subcode correct?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	80$		;yes
	Call	Err2.3
80$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	90$		;yes
	Call	Err2.4
90$:
	CmpB	#-1,(R1)+	;is the chrcnt unchanged?
	Beq	100$		;yes
	Call	Err2.5
100$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTIN3:	.MTIN	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	Cmp	#.MTIN*^o400+..MTIN,(R1)+ ;is the subcode correct?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	130$		;yes
	Call	Err3.3
130$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	140$		;yes
	Call	Err3.4
140$:
	CmpB	#-1,(R1)+	;is the chrcnt unchanged?
	Beq	150$		;yes
	Call	Err3.5
150$:
.PSect	Data
MTIN4:	.MTIN
160$:
.PSect	Active
	Cmp	#EMT+...AR0,160$-2 ;correct EMT code?
	Beq	170$		;yes
	Call	Err4
170$:
	Call	AreaM1		;set area to -1s
MTIN5:	.MTIN	#Area,#123456,#12
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	180$		;yes
	Call	Err5.1		;no
180$:
	Cmp	#.MTIN*^o400+..MTIN,(R1)+ ;is the subcode correct?
	Beq	190$		;yes
	Call	Err5.2		;no
190$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	200$		;yes
	Call	Err5.3
200$:
	CmpB	#12,(R1)+	;is the address correct?
	Beq	210$		;yes
	Call	Err5.4
210$:
	CmpB	#-1,(R1)+	;is the chrcnt unchanged?
	Beq	220$		;yes
	Call	Err5.5
220$:
	Call	AreaM1		;set area to -1s
MTIN6:	.MTIN	#Area,#123456,,#55
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	230$		;yes
	Call	Err6.1		;no
230$:
	Cmp	#.MTIN*^o400+..MTIN,(R1)+ ;is the subcode correct?
	Beq	240$		;yes
	Call	Err6.2		;no
240$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	250$		;yes
	Call	Err6.3
250$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	260$		;yes
	Call	Err6.4
260$:
	CmpB	#55,(R1)+	;is the chrcnt set?
	Beq	270$		;yes
	Call	Err6.5
270$:
	Call	AreaM1		;set area to -1s
MTIN7:	.MTIN	#Area,,,#55
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	280$		;yes
	Call	Err7.1		;no
280$:
	Cmp	#.MTIN*^o400+..MTIN,(R1)+ ;is the subcode correct?
	Beq	290$		;yes
	Call	Err7.2		;no
290$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	300$		;yes
	Call	Err7.3
300$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	310$		;yes
	Call	Err7.4
310$:
	CmpB	#55,(R1)+	;is the chrcnt set?
	Beq	320$		;yes
	Call	Err7.5
320$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTIN8:	.MTIN	,#123456,,#55,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	330$		;yes
	Call	Err8.1		;no
330$:
	Cmp	#.MTIN*^o400+..MTIN,(R1)+ ;is the subcode correct?
	Beq	340$		;yes
	Call	Err8.2		;no
340$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	350$		;yes
	Call	Err8.3
350$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	360$		;yes
	Call	Err8.4
360$:
	CmpB	#55,(R1)+	;is the chrcnt set?
	Beq	370$		;yes
	Call	Err8.5
370$:
	Call	AreaM1		;set area to -1s
MTIN9:	.MTIN	#Area,#123456,#12,#55
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	380$		;yes
	Call	Err9.1		;no
380$:
	Cmp	#.MTIN*^o400+..MTIN,(R1)+ ;is the subcode correct?
	Beq	390$		;yes
	Call	Err9.2		;no
390$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	400$		;yes
	Call	Err9.3
400$:
	CmpB	#12,(R1)+	;is the address correct?
	Beq	410$		;yes
	Call	Err9.4
410$:
	CmpB	#55,(R1)+	;is the chrcnt set?
	Beq	420$		;yes
	Call	Err9.5
420$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MTOUT	Send char(s) to a Multi-Terminal LUN request
.MACRO	.MTOUT	AREA,ADDR,UNIT,CHRCNT,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,3.,<CODE>,<ADDR>
...CM2	<UNIT>,4,,,B
...CM2	<CHRCNT>,5,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTOUT:	.Asciz	"%SYSMAC-I-Testing .MTOUT"
.PSect	Active
	Mov	#$MTOUT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTOU1:	.MTOUT	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTOUT*^o400+..MTOU,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	40$		;yes
	Call	Err1.4
40$:
	CmpB	#-1,(R1)+	;is the chrcnt unchanged?
	Beq	50$		;yes
	Call	Err1.5
50$:
	Call	AreaM1		;set area to -1s
MTOU2:	.MTOUT	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	Cmp	#.MTOUT*^o400+..MTOUT,(R1)+ ;is the subcode correct?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	80$		;yes
	Call	Err2.3
80$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	90$		;yes
	Call	Err2.4
90$:
	CmpB	#-1,(R1)+	;is the chrcnt unchanged?
	Beq	100$		;yes
	Call	Err2.5
100$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTOU3:	.MTOUT	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	Cmp	#.MTOUT*^o400+..MTOUT,(R1)+ ;is the subcode correct?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	130$		;yes
	Call	Err3.3
130$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	140$		;yes
	Call	Err3.4
140$:
	CmpB	#-1,(R1)+	;is the chrcnt unchanged?
	Beq	150$		;yes
	Call	Err3.5
150$:
.PSect	Data
MTOU4:	.MTOUT
160$:
.PSect	Active
	Cmp	#EMT+...AR0,160$-2 ;correct EMT code?
	Beq	170$		;yes
	Call	Err4
170$:
	Call	AreaM1		;set area to -1s
MTOU5:	.MTOUT	#Area,#123456,#12
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	180$		;yes
	Call	Err5.1		;no
180$:
	Cmp	#.MTOUT*^o400+..MTOU,(R1)+ ;is the subcode correct?
	Beq	190$		;yes
	Call	Err5.2		;no
190$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	200$		;yes
	Call	Err5.3
200$:
	CmpB	#12,(R1)+	;is the address correct?
	Beq	210$		;yes
	Call	Err5.4
210$:
	CmpB	#-1,(R1)+	;is the chrcnt unchanged?
	Beq	220$		;yes
	Call	Err5.5
220$:
	Call	AreaM1		;set area to -1s
MTOU6:	.MTOUT	#Area,#123456,,#55
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	230$		;yes
	Call	Err6.1		;no
230$:
	Cmp	#.MTOUT*^o400+..MTOU,(R1)+ ;is the subcode correct?
	Beq	240$		;yes
	Call	Err6.2		;no
240$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	250$		;yes
	Call	Err6.3
250$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	260$		;yes
	Call	Err6.4
260$:
	CmpB	#55,(R1)+	;is the chrcnt set?
	Beq	270$		;yes
	Call	Err6.5
270$:
	Call	AreaM1		;set area to -1s
MTOU7:	.MTOUT	#Area,,,#55
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	280$		;yes
	Call	Err7.1		;no
280$:
	Cmp	#.MTOUT*^o400+..MTOU,(R1)+ ;is the subcode correct?
	Beq	290$		;yes
	Call	Err7.2		;no
290$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	300$		;yes
	Call	Err7.3
300$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	310$		;yes
	Call	Err7.4
310$:
	CmpB	#55,(R1)+	;is the chrcnt set?
	Beq	320$		;yes
	Call	Err7.5
320$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTOU8:	.MTOUT	,#123456,,#55,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	330$		;yes
	Call	Err8.1		;no
330$:
	Cmp	#.MTOUT*^o400+..MTOU,(R1)+ ;is the subcode correct?
	Beq	340$		;yes
	Call	Err8.2		;no
340$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	350$		;yes
	Call	Err8.3
350$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	360$		;yes
	Call	Err8.4
360$:
	CmpB	#55,(R1)+	;is the chrcnt set?
	Beq	370$		;yes
	Call	Err8.5
370$:
	Call	AreaM1		;set area to -1s
MTOU9:	.MTOUT	#Area,#123456,#12,#55
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	380$		;yes
	Call	Err9.1		;no
380$:
	Cmp	#.MTOUT*^o400+..MTOU,(R1)+ ;is the subcode correct?
	Beq	390$		;yes
	Call	Err9.2		;no
390$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	400$		;yes
	Call	Err9.3
400$:
	CmpB	#12,(R1)+	;is the address correct?
	Beq	410$		;yes
	Call	Err9.4
410$:
	CmpB	#55,(R1)+	;is the chrcnt set?
	Beq	420$		;yes
	Call	Err9.5
420$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MTPRNT	Print an ASCIZ string on a Multi-Terminal LUN request
.MACRO	.MTPRN	AREA,ADDR,UNIT,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,7.,<CODE>,<ADDR>
...CM2	<UNIT>,4,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTPRN:	.Asciz	"%SYSMAC-I-Testing .MTPRNT"
.PSect	Active
	Mov	#$MTPRN,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTPR1:	.MTPRNT	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTPRN*^o400+..MTPR,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	31$		;yes
	Call	Err1.4
31$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	32$		;yes
	Call	Err1.5
32$:
	Call	AreaM1		;set area to -1s
MTPR2:	.MTPRNT	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.MTPRN*^o400+..MTPR,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	61$		;yes
	Call	Err2.4
61$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	62$		;yes
	Call	Err2.5
62$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTPR3:	.MTPRNT	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.MTPRN*^o400+..MTPR,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	91$		;yes
	Call	Err3.4
91$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	92$		;yes
	Call	Err3.5
92$:
.PSect	Data
MTPR4:	.MTPRNT
100$:
.PSect	Active
	Cmp	#EMT+375,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	AreaM1		;set area to -1s
MTPR5:	.MTPRNT	#Area,#123456,#12
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	120$		;yes
	Call	Err5.1		;no
120$:
	Cmp	#.MTPRN*^o400+..MTPR,(R1)+ ;is the subcode correct?
	Beq	130$		;yes
	Call	Err5.2		;no
130$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	140$		;yes
	Call	Err5.3
140$:
	CmpB	#12,(R1)+	;is the address correct?
	Beq	150$		;yes
	Call	Err5.4
150$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	82$		;yes
	Call	Err5.5
82$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MTPS	Move to PS (processor independent) call
.MACRO	.MTPS	ADDR
.IF NB	<ADDR>
	CLR	-(SP)
.ENDC
.IF NB	<ADDR>
	MOVB	ADDR,(SP)
.ENDC
	MOV	@#^o54,-(SP)
	ADD	#^o360,(SP)
	CALL	@(SP)+
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTPS:	.Asciz	"%SYSMAC-I-Testing .MTPS"
.PSect	Active
	Mov	#$MTPS,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.MTRCTO	Reset ^o on a Multi-Terminal LUN request
.MACRO	.MTRCT	AREA,UNIT,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,4.,<CODE>
...CM2	<UNIT>,4,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTRCT:	.Asciz	"%SYSMAC-I-Testing .MTRCTO"
.PSect	Active
	Mov	#$MTRCT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTRC1:	.MTRCTO	#Area,#12
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTRCT*^o400+..MTRC,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Tst	(R1)+		;skip unused area
	CmpB	#12,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
MTRC2:	.MTRCTO	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.MTRCT*^o400+..MTRC,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Tst	(R1)+		;skip unused area
	CmpB	#-1,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTRC3:	.MTRCTO	,#12,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.MTRCT*^o400+..MTRC,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Tst	(R1)+		;skip unused area
	CmpB	#12,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
MTRC4:	.MTRCTO
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MTSET	Set information on a Multi-Terminal LUN request
.MACRO	.MTSET	AREA,ADDR,UNIT,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,0.,<CODE>,<ADDR>
...CM2	<UNIT>,4,E,,B
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTSET:	.Asciz	"%SYSMAC-I-Testing .MTSET"
.PSect	Active
	Mov	#$MTSET,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTSE1:	.MTSET	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTSET*^o400+..MTSE,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	31$		;yes
	Call	Err1.4
31$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	32$		;yes
	Call	Err1.5
32$:
	Call	AreaM1		;set area to -1s
MTSE2:	.MTSET	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.MTSET*^o400+..MTSE,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	61$		;yes
	Call	Err2.4
61$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	62$		;yes
	Call	Err2.5
62$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTSE3:	.MTSET	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.MTSET*^o400+..MTSE,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
	CmpB	#-1,(R1)+	;is the LUN unchanged?
	Beq	91$		;yes
	Call	Err3.4
91$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	92$		;yes
	Call	Err3.5
92$:
.PSect	Data
MTSE4:	.MTSET
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	AreaM1		;set area to -1s
MTSE5:	.MTSET	#Area,#123456,#12
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	120$		;yes
	Call	Err5.1		;no
120$:
	Cmp	#.MTSET*^o400+..MTSE,(R1)+ ;is the subcode correct?
	Beq	130$		;yes
	Call	Err5.2		;no
130$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	140$		;yes
	Call	Err5.3
140$:
	CmpB	#12,(R1)+	;is the address correct?
	Beq	150$		;yes
	Call	Err5.4
150$:
	CmpB	#-1,(R1)+	;is the reserved area unchanged?
	Beq	132$		;yes
	Call	Err5.5
132$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MTSTAT	Get general Multi-Terminal information request
.MACRO	.MTSTA	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,31.,8.,<CODE>,<ADDR>
...CM2	#0,4,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MTSTA:	.Asciz	"%SYSMAC-I-Testing .MTSTAT"
.PSect	Active
	Mov	#$MTSTA,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
MTST1:	.MTSTAT	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.MTSTA*^o400+..MTST,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Cmp	#0,(R1)+	;is the reserved area cleared?
	Beq	31$		;yes
	Call	Err1.4
31$:
	Call	AreaM1		;set area to -1s
MTST2:	.MTSTAT	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.MTSTA*^o400+..MTST,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address unchanged?
	Beq	60$		;yes
	Call	Err2.3
60$:
	Cmp	#0,(R1)+	;is the reserved area cleared?
	Beq	32$		;yes
	Call	Err1.4
32$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
MTST3:	.MTSTAT	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.MTSTA*^o400+..MTST,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
	Cmp	#0,(R1)+	;is the reserved area cleared?
	Beq	91$		;yes
	Call	Err1.4
91$:
.PSect	Data
MTST4:	.MTSTAT
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.MWAIT	Wait for a SDAT/RCVD request to finish request
.MACRO	.MWAIT
	MOV	#^o4400,R0
	EMT	^o374
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$MWAIT:	.Asciz	"%SYSMAC-I-Testing .MWAIT"
.PSect	Active
	Mov	#$MWAIT,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	Mov	#Patter,R0
MWAIT1:	.MWAIT
	.=.-2			;squash EMT
	Cmp	#.MWAIT*^o400,R0 ;Is R0 right?
	Beq	10$
	Call	Err1
10$:
.PSect	Data
MWAIT2:	.MWAIT
.=.-2.
23$:
.=.+2.
25$:
.PSect	Active
	Cmp	#EMT+...R0,23$	;was the correct EMT generated?
	Beq	20$		;Yes
	Call	Err2
20$:
	Call	EndTst
.Dsabl LSB
;-TEST

.Page
.SbTtl	.PEEK	Get a word from system mapping request
.MACRO	.PEEK	AREA,ADDR,CODE
.IF NDF	...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,28.,1.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$PEEK:	.Asciz	"%SYSMAC-I-Testing .PEEK"
.PSect	Active
	Mov	#$PEEK,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
PEEK1:	.PEEK	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.PEEK*^o400+..PEEK,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
PEEK2:	.PEEK	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.PEEK*^o400+..PEEK,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
PEEK3:	.PEEK	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.PEEK*^o400+..PEEK,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
PEEK4:	.PEEK
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.POKE	Modify a word in system mapping request
.MACRO	.POKE	AREA,ADDR,VALUE,TYPE=MOV,CODE
.IF NDF	...V1
.MCALL	.MACS
.MACS
.ENDC
...V2=1000.
...V3=3.
.IRP	x,<MOV,BIC,BIS>
.IF	IDN <x> <TYPE>
...V2=0
.MEXIT
.ENDC
...V3=...V3+2.
.ENDR
.IIF	GT ...V3-7.+...V2 .ERROR;?SYSMAC-E-Invalid T Y P E, expecting MOV/BIC/BIS, found - TYPE;
...CM6	<AREA>,28.,\...V3,<CODE>,<ADDR>
...CM2	<VALUE>,4,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$POKE:	.Asciz	"%SYSMAC-I-Testing .POKE"
.PSect	Active
	Mov	#$POKE,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
POKE1:	.POKE	#Area,#123456,#101010
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.POKE*^o400+..POKE,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Cmp	#101010,(R1)+	;is the value correct?
	Beq	40$		;yes
	Call	Err1.4
40$:
	Call	AreaM1		;set area to -1s
POKE2:	.POKE	#Area,TYPE=BIC
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	Cmp	#.POKE*^o400+..BICO,(R1)+ ;is the subcode correct?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	70$		;yes
	Call	Err2.3
70$:
	Cmp	#177777,(R1)+	;is the value correct?
	Beq	80$		;yes
	Call	Err2.4
80$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
POKE3:	.POKE	,#123456,CODE=SET,TYPE=BIS
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	Cmp	#.POKE*^o400+..BISO,(R1)+ ;is the subcode correct?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	110$		;yes
	Call	Err3.3
110$:
	Cmp	#-1,(R1)+	;is the value correct?
	Beq	120$		;yes
	Call	Err3.4
120$:
	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
POKE4:	.POKE	,#123456,CODE=SET,TYPE=MOV
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	130$		;yes
	Call	Err4.1		;no
130$:
	Cmp	#.POKE*^o400+..POKE,(R1)+ ;is the subcode correct?
	Beq	140$		;yes
	Call	Err4.2		;no
140$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	150$		;yes
	Call	Err4.3
150$:
	Cmp	#-1,(R1)+	;is the value correct?
	Beq	160$		;yes
	Call	Err4.4
160$:
.PSect	Data
POKE5:	.POKE
170$:
.PSect	Active
	Cmp	#EMT+...AR0,170$-2 ;correct EMT code?
	Beq	180$		;yes
	Call	Err5
180$:
	Call	EndTst

.Dsabl	LSB
;-TEST
.Page
.SbTtl	.PRINT	Print an ASCIZ string on the console request
.MACRO	.PRINT	ADDR
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM5	<ADDR>,351
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$PRINT:	.Asciz	"%SYSMAC-I-Testing .PRINT"
.PSect	Active
	Mov	#$PRINT,R0	;Ident the test
	Call	BegTst
	Mov	#Patter,R0	;init R0
PRIN1:	.PRINT	#123456
	.=.-2
	Cmp	#123456,R0	;R0 set?
	Beq	10$		;yes
	Call	Err1		;no
10$:
	Mov	#123456,R0	;init R0
PRIN2:	.PRINT
	.=.-2
	Cmp	#123456,R0	;R0 set?
	Beq	20$		;yes
	Call	Err2		;no
20$:
	Mov	#123456,R0	;init R0
PRIN3:	.PRINT	R0
	.=.-2
	Cmp	#123456,R0	;R0 set?
	Beq	30$		;yes
	Call	Err3		;no
30$:
.PSect	Data
PRIN4:	.PRINT
40$:
.PSect	Active
	Cmp	#EMT+...PRI,40$-2 ;correct EMT?
	Beq	50$		;yes
	Call	Err4		;no
50$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.PROTECT Protect a vector request
.MACRO	.PROTE	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,25.,0.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$PROTE:	.Asciz	"%SYSMAC-I-Testing .PROTECT"
.PSect	Active
	Mov	#$PROTE,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
PROT1:	.PROTE	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.PROTE*^o400+..PROT,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
PROT2:	.PROTE	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.PROTE.*^o400+..PROT,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
PROT3:	.PROTE	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.PROTE*^o400+..PROT,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
PROT4:	.PROTE
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.PURGE	Disconnect a channel request
.MACRO	.PURGE	CHAN
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM3	<CHAN>,3.
.ENDM

;+TEXT
.Enabl	LSB
;NOTE: V1 version is not tested
.PSect	Text
$PURGE:	.Asciz	"%SYSMAC-I-Testing .PURGE"
.PSect	Active
	MOV	#$PURGE,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	MOV	#PATTER,R0
PURGE1:	.PURGE	#0
	.=.-2			;squash EMT
	CMP	#.PURGE*^o400+0,R0	;Is R0 right?
	BEQ	10$
	Call	ERR1
10$:
	MOV	#PATTER,R0
PURGE2:	.PURGE	#1
	.=.-2			;squash EMT
	CMP	#.PURGE*^o400+1,R0	;Is R0 right?
	BEQ	20$
	Call	ERR2
20$:
	MOV	#PATTER,R0
PURGE3:	.PURGE	#^o377
	.=.-2			;squash EMT
	CMP	#.PURGE*^o400+^o377,R0 ;Is R0 right?
	BEQ	30$
	Call	ERR3
30$:
	MOV	#4,R0
PURGE4:	.PURGE	R0
	.=.-2			;squash EMT
	CMP	#.PURGE*^o400+4,R0	;Is R0 right?
	BEQ	40$
	Call	ERR4
40$:
	MOV	#PATTER,R0
	MOV	#1,R1
PURGE5:	.PURGE	R1
	.=.-2			;squash EMT
	CMP	#.PURGE*^o400+1,R0	;Is R0 right?
	BEQ	50$
	Call	ERR5
50$:
	MOV	#PATTER,R0
PURGE6:	.PURGE	65$		;try getting chan from an odd addr
	.=.-2			;squash EMT
.PSect	Data
	.ODD
65$:	.BYTE	2		;Channel 2 at an odd addr
	.EVEN
.PSect	Active
	CMP	#.PURGE*^o400+2.,R0 ;Is R0 right?
	BEQ	60$
	Call	ERR6
60$:
.PSect	Data
PURGE7:	.PURGE
.=.-2.
73$:
.=.+2.
75$:
.PSect	Active
	CMP	#EMT+...R0,73$	;was the correct EMT generated?
	BEQ	70$		;Yes
	Call	ERR7
70$:
	Call	EndTst
.DSABL	LSB
;-TEST
.Page
.SbTtl	.PVAL	Modify a word in the resident monitor request
.MACRO	.PVAL	AREA,OFFSE,VALUE,TYPE=MOV,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...V2=1000.
...V3=2.
.IRP	x,<MOV,BIC,BIS>
.IF	IDN <x> <TYPE>
...V2=0
.MEXIT
.ENDC
...V3=...V3+2.
.ENDR
.IIF	GT ...V3-6.+...V2 .ERROR;?SYSMAC-E-Invalid T Y P E, expecting MOV/BIC/BIS, found - TYPE;
...CM6	<AREA>,28.,\...V3,<CODE>,<OFFSE>
...CM2	<VALUE>,4,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$PVAL:	.Asciz	"%SYSMAC-I-Testing .PVAL"
.PSect	Active
	Mov	#$PVAL,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.QELDF	Define offsets in I/O Queue elements
.MACRO	.QELDF	LIST,E=<=:>
.IIF NDF MMG$T,MMG$T=1
.IIF NE MMG$T,MMG$T=1
.IIF IDN <LIST>,<YES>	.LIST
Q.LINK E 0
Q.CSW E 2.
Q.BLKN E 4.
Q.FUNC E 6.
Q.2UNI E Q.FUNC
Q.TYPE E Q.FUNC
Q.FMSK E ^o17
Q.2MSK E ^o160
Q.TMSK E ^o200
Q.JNUM E 7.
Q.UNIT E Q.JNUM
Q.UMSK E ^o3400
Q.JMSK E ^o74000
Q.BUFF E ^o10
Q.WCNT E ^o12
Q.COMP E ^o14
.IIF IDN <LIST>,<YES>	.NLIST
.IRP	X,<LINK,CSW,BLKN,FUNC,2UNI,TYPE,JNUM,UNIT,BUFF,WCNT,COMP>
.IIF IDN <LIST>,<YES>	.LIST
Q$'X E Q.'X-^o4
.IIF IDN <LIST>,<YES>	.NLIST
.ENDR
.IF EQ MMG$T
.IIF IDN <LIST>,<YES>	.LIST
Q.ELGH E ^o16
.IIF IDN <LIST>,<YES>	.NLIST
.IFF
.IIF IDN <LIST>,<YES>	.LIST
Q.PAR E ^o16
Q.MEM E ^o20
.IIF IDN <LIST>,<YES>	.NLIST
.IRP	X,<PAR,MEM>
.IIF IDN <LIST>,<YES>	.LIST
Q$'X E Q.'X-^o4
.IIF IDN <LIST>,<YES>	.NLIST
.ENDR
.IIF IDN <LIST>,<YES>	.LIST
Q.ELGH E ^o24
.IIF IDN <LIST>,<YES>	.NLIST
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$QELDF:	.Asciz	"%SYSMAC-I-Testing .QELDF"
.PSect	Active
	Mov	#$QELDF,R0	;Ident the test
	Call	BegTst
	Call	TemTst
;-TEST
.Page
.SbTtl	.QSET	Add elements to the available queue request
.MACRO	.QSET	ADDR,LEN
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
	MOV	ADDR,-(SP)
...CM5	<LEN>,353
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$QSET:	.Asciz	"%SYSMAC-I-Testing .QSET"
.PSect	Active
	Mov	#$QSET,R0	;Ident the test
	Call	BegTst
	Mov	SP,R5		;save stack pointer
	Mov	#Patter,R0	;init R0
QSET1:	.QSET	#111111,#123456
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	SP,R5		;is stack correct?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Mov	SP,R5		;save stack pointer
	Mov	#123456,R0	;init R0
QSET2:	.QSET	#111111,R0
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	SP,R5		;is stack correct?
	Beq	60$		;yes
	Call	Err2.3		;no
60$:
	Mov	SP,R5		;save stack pointer
	Mov	#123456,R0	;init R0
QSET3:	.QSET	#111111
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#111111,(SP)+	;is top of stack correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	SP,R5		;is stack correct?
	Beq	90$		;yes
	Call	Err3.3		;no
90$:
.PSect	Data
QSET4:	.QSET	#111111
100$:
.PSect	Active
	Cmp	#EMT+...QSE,100$-2 ;correct EMT?
	Beq	110$		;yes
	Call	Err4		;no
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.RCTRLO	Reset ^o status on the console request
.MACRO	.RCTRL
	EMT	^o355
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$RCTRL:	.Asciz	"%SYSMAC-I-Testing .RCTRL"
.PSect	Active
	Mov	#$RCTRL,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
.PSect	Data
RCTRL1:	.RCTRL
.=.-2.
13$:
.=.+2.
15$:
.PSect	Active
	CMP	#EMT+...RCT,13$	;was the correct EMT generated?
	BEQ	10$		;Yes
	Call	ERR1
10$:
	Call	EndTst
.DSABL LSB
;-TEST
.Page
.SbTtl	.RCVD	Queue a message receive request
.MACRO	.RCVD	AREA,BUF,WCNT,CRTN=#1,CODE,BMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM4 <AREA>,<BUF>,<WCNT>,<CRTN>,22,<CODE>,<BMODE>
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$RCVD:	.Asciz	"%SYSMAC-I-Testing .RCVD"
.PSect	Active
	Mov	#$RCVD,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVD1:	.RCVD	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVD2:	.RCVD	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVD3:	.RCVD	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#.RCVD,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVD4:	.RCVD	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.RCVD,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVD5:	.RCVD	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVD6:	.RCVD	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.RCVD,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVD7:	.RCVD	#Area,#010000,#020000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.RCVD,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
RCVD8:	.RCVD
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVD9:	.RCVD	#Area,#010000,#020000,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.RCVD,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
RCVDA:	.RCVD	BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.RCVDC	Queue a message receive, specify a completion routine request
.MACRO	.RCVDC	AREA,BUF,WCNT,CRTN,CODE,BMODE,CMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM4 <AREA>,<BUF>,<WCNT>,<CRTN>,22,<CODE>,<BMODE>,<CMODE>
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$RCVDC:	.Asciz	"%SYSMAC-I-Testing .RCVDC"
.PSect	Active
	Mov	#$RCVDC,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVDC1:	.RCVDC
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVDC2:	.RCVDC	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVDC3:	.RCVDC	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#.RCVDC,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDC4:	.RCVDC	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.RCVDC,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDC5:	.RCVDC	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDC6:	.RCVDC	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.RCVDC,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDC7:	.RCVDC	#Area,#010000,#020000,#030000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.RCVDC,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#030000,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
RCVDC8:	.RCVDC
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDC9:	.RCVDC	#Area,#010000,#020000,#030000,BMODE=UI,CMODE=S
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.RCVDC,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#030000+1,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
RCVDCA:	.RCVDC	,BMODE=SI,CMODE=S
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.RCVDW	Wait for a message request
.MACRO	.RCVDW	AREA,BUF,WCNT,CRTN=#0,CODE,BMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM4 <AREA>,<BUF>,<WCNT>,<CRTN>,22,<CODE>,<BMODE>
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$RCVDW:	.Asciz	"%SYSMAC-I-Testing .RCVDW"
.PSect	Active
	Mov	#$RCVDW,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVDW1:	.RCVDW	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVDW2:	.RCVDW	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
RCVDW3:	.RCVDW	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#.RCVDW,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDW4:	.RCVDW	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.RCVDW,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDW5:	.RCVDW	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDW6:	.RCVDW	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.RCVDW,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDW7:	.RCVDW	#Area,#010000,#020000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.RCVDW,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
RCVDW8:	.RCVDW
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
RCVDW9:	.RCVDW	#Area,#010000,#020000,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.RCVDW,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
RCVDWA:	.RCVDW	,BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.RDBBK	Generate a region definition block
.MACRO	.RDBBK	RGSIZ,RGSTA=0,NAME,BASE=0
.MCALL	.RDBDF
.RDBDF
	.WORD
	.WORD	RGSIZ
...V2=0
.IIF NE BASE ...V2=RS.BAS
	.WORD	RGSTA!...V2
	.WORD	0,0
	.WORD	BASE
.=.-6.
...V2=.
	.RAD50	\NAME\
.=...V2+6.
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$RDBBK:	.Asciz	"%SYSMAC-I-Testing .RDBBK"
.PSect	Active
	Mov	#$RDBBK,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.RDBDF	Define bit patterns and offsets for a RDB
.MACRO	.RDBDF	LIST,E=<=:>
.IIF IDN <LIST>,<YES>	.LIST
R.GID E 0
R.GSIZ E 2.
R.GSTS E 4.
R.GLLN E 6.
R.GNAM E 6.
R.GBAS E 10.
R.GLGH E 12.
RS.CRR E ^o100000
RS.UNM E ^o40000
RS.NAL E ^o20000
RS.NEW E ^o10000
RS.GBL E ^o4000
RS.CGR E ^o2000
RS.AGE E ^o1000
RS.EGR E ^o400
RS.EXI E ^o200
RS.CAC E ^o100
RS.BAS E ^o40
RS.NSM E ^o20
RS.DSP E ^o2
RS.PVT E ^o1
.IIF IDN <LIST>,<YES>	.NLIST
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$RDBDF:	.Asciz	"%SYSMAC-I-Testing .RDBDF"
.PSect	Active
	Mov	#$RDBDF,R0	;Ident the test
	Call	BegTst
	Call	TemTst
;-TEST
.Page
.SbTtl	.READ	Queue a read request
.MACRO	.READ	AREA,CHAN,BUF,WCNT,BLK,CRTN=#1,CODE,BMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM7	<AREA>,<CHAN>,<BUF>,<WCNT>,<BLK>,<CRTN>,8,<CODE>,200,<BMODE>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$READ:	.Asciz	"%SYSMAC-I-Testing .READ"
.PSect	Active
	Mov	#$READ,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READ1:	.READ	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READ2:	.READ	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READ3:	.READ	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#.READ,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READ4:	.READ	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.READ,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READ5:	.READ	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READ6:	.READ	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.READ,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READ7:	.READ	#Area,#0,#010000,#020000,#030000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.READ,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#030000,(R1)+	;is BLK set?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
READ8:	.READ
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READ9:	.READ	#Area,#0,#010000,#020000,#0,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.READ,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#0,(R1)+	;is BLK set?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
READA:	.READ	,BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.READC	Queue a read request, specifying a completion routine
.MACRO	.READC	AREA,CHAN,BUF,WCNT,CRTN,BLK,CODE,BMODE,CMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM7	<AREA>,<CHAN>,<BUF>,<WCNT>,<BLK>,<CRTN>,8,<CODE>,200,<BMODE>,<CMODE>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$READC:	.Asciz	"%SYSMAC-I-Testing .READC"
.PSect	Active
	Mov	#$READC,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READC1:	.READC	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READC2:	.READC	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READC3:	.READC	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#.READC,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READC4:	.READC	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.READC,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READC5:	.READC	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READC6:	.READC	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.READC,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READC7:	.READC	#Area,#0,#010000,#020000,#123456,#030000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.READC,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#030000,(R1)+	;is BLK set?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#123456,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
READC8:	.READC
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READC9:	.READC	#Area,#0,#010000,#020000,#123456,#0,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.READC,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#0,(R1)+	;is BLK set?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#123456,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
READCA:	.READC	,BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
;-TEST
.Page
.SbTtl	.READW	Wait for a read request
.MACRO	.READW	AREA,CHAN,BUF,WCNT,BLK,CRTN=#0,CODE,BMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM7	<AREA>,<CHAN>,<BUF>,<WCNT>,<BLK>,<CRTN>,8,<CODE>,200,<BMODE>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$READW:	.Asciz	"%SYSMAC-I-Testing .READW"
.PSect	Active
	Mov	#$READW,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READW1:	.READW	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READW2:	.READW	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
READW3:	.READW	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#.READW,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READW4:	.READW	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.READW,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READW5:	.READW	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READW6:	.READW	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.READW,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READW7:	.READW	#Area,#0,#010000,#020000,#030000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.READW,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#030000,(R1)+	;is BLK set?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
READW8:	.READW
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
READW9:	.READW	#Area,#0,#010000,#020000,#0,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.READW,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#0,(R1)+	;is BLK set?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
READWA:	.READW	,BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.REGDEF	Ancient compatibility macro - defined reg symbols
.MACRO	.REGDEF
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$REGDE:	.Asciz	"%SYSMAC-I-Testing .REGDEF"
.PSect	Active
	Mov	#$REGDE,R0	;Ident the test
	Call	BegTst
	Call	EndTst
;-TEST
.Page
.SbTtl	.RELEASE Release a handler from memory request
.MACRO	.RELEA	DNAM
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM5	<DNAM>
...CM0	,343
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$RELEA:	.Asciz	"%SYSMAC-I-Testing .RELEASE"
.PSect	Active
	Mov	#$RELEA,R0	;Ident the test
	Call	BegTst
	Mov	SP,R5		;save stack pointer
	Mov	#Patter,R0	;init R0
RELE1:	.RELEASE #123456
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#0,(SP)+	;is top of stack correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	SP,R5		;is stack correct?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Mov	SP,R5		;save stack pointer
	Mov	#123456,R0	;init R0
RELE2:	.RELEASE R0
	.=.-2			;crush EMT
	Cmp	#123456,R0	;is R0 set?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#0,(SP)+	;is top of stack correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	SP,R5		;is stack correct?
	Beq	60$		;yes
	Call	Err2.3		;no
60$:
.PSect	Data
RELE3:	.RELEASE
70$:
.PSect	Active
	Cmp	#EMT+...REL,70$-2	;correct EMT?
	Beq	80$		;yes
	Call	Err3		;no
80$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.RENAME	Rename a file request
.MACRO	.RENAM	AREA,CHAN,DBLK,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NE ...V1-1
...CM1	<AREA>,4,<CHAN>,<CODE>,<DBLK>,E
.MEXIT
.ENDC
...CM5	<CHAN>,<100+AREA>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$RENAM:	.Asciz	"%SYSMAC-I-Testing .RENAME"
.PSect	Active
	Mov	#$RENAM,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
RENA1:	.RENAME	#Area,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.RENAM,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0
RENA2:	.RENAME	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0
RENA3:	.RENAME	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
.PSect	Data
RENA4:	.RENAME	CODE=NOSET
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2	;correct EMT?
	Beq	140$		;yes
	Call	Err4		;no
140$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.REOPEN	Reopen a channel that was SAVESTATUSed request
.MACRO	.REOPE	AREA,CHAN,CBLK,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NE ...V1-1
...CM1	<AREA>,6,<CHAN>,<CODE>,<CBLK>,E
.MEXIT
.ENDC
...CM5	<CHAN>,<140+AREA>
.ENDM

.PAGE
;+TEST
.Enabl	LSB
.PSect	Text
$REOPE:	.Asciz	"%SYSMAC-I-Testing .REOPEN"
.PSect	Active
	Mov	#$REOPE,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
REOP1:	.REOPEN	#Area,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.REOPE,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0
REOP2:	.REOPEN	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0
REOP3:	.REOPEN	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
.PSect	Data
REOP4:	.REOPEN	CODE=NOSET
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2	;correct EMT?
	Beq	140$		;yes
	Call	Err4		;no
140$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.RSUM	Resume a suspended job request
.MACRO	.RSUM
	MOV	#^o1000,R0
	EMT	^o374
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$RSUM:	.Asciz	"%SYSMAC-I-Testing .RSUM"
.PSect	Active
	Mov	#$RSUM,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	Mov	#Patter,R0
RSUM1:	.RSUM
	.=.-2			;squash EMT
	Cmp	#.RSUM*^o400,R0	;Is R0 right?
	Beq	10$
	Call	Err1
10$:
.PSect	Data
RSUM2:	.RSUM
.=.-2.
23$:
.=.+2.
25$:
.PSect	Active
	CMP	#EMT+...R0,23$	;was the correct EMT generated?
	BEQ	20$		;Yes
	Call	ERR2
20$:
	Call	EndTst
.DSABL LSB
;-TEST
.Page
.SbTtl	.SAVESTATUS Close a channel and save channel status request
.MACRO	.SAVES	AREA,CHAN,CBLK,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NE ...V1-1
...CM1	<AREA>,5,<CHAN>,<CODE>,<CBLK>,E
.MEXIT
.ENDC
...CM5	<CHAN>,<120+AREA>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SAVES:	.Asciz	"%SYSMAC-I-Testing .SAVESTATUS"
.PSect	Active
	Mov	#$SAVES,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
SAVE1:	.SAVEST	#Area,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.SAVES,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Call	AreaM1
	Mov	#Area,R0
SAVE2:	.SAVEST	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	50$		;yes
	Call	Err2.1		;no
50$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	60$		;yes
	Call	Err2.2		;no
60$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	70$		;yes
	Call	Err2.3		;no
70$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	80$		;yes
	Call	Err2.4		;no
80$:
	Call	AreaM1
	Mov	#Area,R0
SAVE3:	.SAVEST	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	90$		;yes
	Call	Err3.1		;no
90$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	100$		;yes
	Call	Err3.2		;no
100$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	110$		;yes
	Call	Err3.3		;no
110$:
	Cmp	#123456,(R1)+	;is Addr set?
	Beq	120$		;yes
	Call	Err3.4		;no
120$:
.PSect	Data
SAVE4:	.SAVEST	CODE=NOSET
130$:
.PSect	Active
	Cmp	#EMT+...AR0,130$-2	;correct EMT?
	Beq	140$		;yes
	Call	Err4		;no
140$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SCCA	Set ^C blocking and flag word request
.MACRO	.SCCA	AREA,ADDR,TYPE,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF	IDN 	<TYPE>,<GLOBAL>
...CM6	<AREA>,29.,1.,<CODE>,<ADDR>,E
.IFF
...CM6	<AREA>,29.,0.,<CODE>,<ADDR>,E
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SCCA:	.Asciz	"%SYSMAC-I-Testing .SCCA"
.PSect	Active
	Mov	#$SCCA,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
SCCA1:	.SCCA	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.SCCA*^o400,(R1)+	;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
SCCA2:	.SCCA	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.SCCA*^o400+..LSCC,(R1)+	;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
SCCA3:	.SCCA	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.SCCA*^o400+..LSCC,(R1)+	;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
SCCA4:	.SCCA
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	AreaM1		;set area to -1s
SCCA5:	.SCCA	#Area,#123456,TYPE=GLOBAL
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	120$		;yes
	Call	Err5.1		;no
120$:
	Cmp	#.SCCA*^o400+..GSCC,(R1)+ ;is the subcode correct?
	Beq	130$		;yes
	Call	Err5.2		;no
130$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	140$		;yes
	Call	Err5.3
140$:
	Call	AreaM1		;set area to -1s
SCCA6:	.SCCA	#Area,TYPE=GLOBAL
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	150$		;yes
	Call	Err6.1		;no
150$:
	Cmp	#.SCCA*^o400+..GSCC,(R1)+ ;is the subcode correct?
	Beq	160$		;yes
	Call	Err6.2		;no
160$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	170$		;yes
	Call	Err6.3
170$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
SCCA7:	.SCCA	,#123456,CODE=SET,TYPE=GLOBAL
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	180$		;yes
	Call	Err7.1		;no
180$:
	Cmp	#.SCCA*^o400+..GSCC,(R1)+ ;is the subcode correct?
	Beq	190$		;yes
	Call	Err7.2		;no
190$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	200$		;yes
	Call	Err7.3
200$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SDAT	Queue a message send request
.MACRO	.SDAT	AREA,BUF,WCNT,CRTN=#1,CODE,BMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM4 <AREA>,<BUF>,<WCNT>,<CRTN>,21,<CODE>,<BMODE>
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$SDAT:	.Asciz	"%SYSMAC-I-Testing .SDAT"
.PSect	Active
	Mov	#$SDAT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDAT1:	.SDAT	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDAT2:	.SDAT	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDAT3:	.SDAT	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#.SDAT,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDAT4:	.SDAT	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.SDAT,(R1)+	;is IC set?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDAT5:	.SDAT	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDAT6:	.SDAT	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.SDAT,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDAT7:	.SDAT	#Area,#010000,#020000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.SDAT,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
SDAT8:	.SDAT
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDAT9:	.SDAT	#Area,#010000,#020000,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.SDAT,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
SDATA:	.SDAT	BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SDATC	Queue a message send, specifying a completion routine request
.MACRO	.SDATC	AREA,BUF,WCNT,CRTN,CODE,BMODE,CMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM4 <AREA>,<BUF>,<WCNT>,<CRTN>,21,<CODE>,<BMODE>,<CMODE>
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$SDATC:	.Asciz	"%SYSMAC-I-Testing .SDATC"
.PSect	Active
	Mov	#$SDATC,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDATC1:	.SDATC
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDATC2:	.SDATC	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDATC3:	.SDATC	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#.SDATC,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATC4:	.SDATC	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.SDATC,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATC5:	.SDATC	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATC6:	.SDATC	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.SDATC,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATC7:	.SDATC	#Area,#010000,#020000,#030000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.SDATC,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#030000,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
SDATC8:	.SDATC
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATC9:	.SDATC	#Area,#010000,#020000,#030000,BMODE=UI,CMODE=S
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.SDATC,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	590$		;yes
	Call	Err9.7		;no
590$:
	Cmp	#030000+1,(R1)+	;is CRTN set?
	Beq	580$		;yes
	Call	Err9.8		;no
580$:
.PSect	Data
SDATCA:	.SDATC	,BMODE=SI,CMODE=S
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SDATW	Send a message, wait for for completion request
.MACRO	.SDATW	AREA,BUF,WCNT,CRTN=#0,CODE,BMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM4 <AREA>,<BUF>,<WCNT>,<CRTN>,21,<CODE>,<BMODE>
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$SDATW:	.Asciz	"%SYSMAC-I-Testing .SDATW"
.PSect	Active
	Mov	#$SDATW,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDATW1:	.SDATW	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDATW2:	.SDATW	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.3		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.4		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.5		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.6		;no
130$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	140$		;yes
	Call	Err2.7		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
SDATW3:	.SDATW	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err3.1		;no
150$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	160$		;yes
	Call	Err3.2		;no
160$:
	CmpB	#21.,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err3.3		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err3.4		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err3.5		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err3.6		;no
200$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	210$		;yes
	Call	Err3.7		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATW4:	.SDATW	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#21.,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATW5:	.SDATW	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.3		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.4		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.5		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.6		;no
340$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	350$		;yes
	Call	Err5.7		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATW6:	.SDATW	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#0,(R1)+	;is CHAN cleared?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#21.,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.3		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.4		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.5		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.6		;no
410$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	420$		;yes
	Call	Err6.7		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATW7:	.SDATW	#Area,#010000,#020000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#21.,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.3		;no
450$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	460$		;yes
	Call	Err7.4		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.5		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.6		;no
480$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.7		;no
490$:
.PSect	Data
SDATW8:	.SDATW
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
SDATW9:	.SDATW	#Area,#010000,#020000,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.SDATW,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#-1,(R1)+	;is BLK skipped?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
SDATWA:	.SDATW	,BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SDTTM	Set system date and/or time request
.MACRO	.SDTTM	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,32.,0.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SDTTM:	.Asciz	"%SYSMAC-I-Testing .SDTTM"
.PSect	Active
	Mov	#$SDTTM,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
SDTT1:	.SDTTM	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.SDTTM*^o400+0,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
SDTT2:	.SDTTM	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.SDTTM*^o400+0,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
SDTT3:	.SDTTM	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.SDTTM*^o400+0,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
SDTT4:	.SDTTM
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SERR	Select soft error handling request
.MACRO	.SERR
	MOV	#^o2000,R0
	EMT	^o374
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SERR:	.Asciz	"%SYSMAC-I-Testing .SERR"
.PSect	Active
	Mov	#$SERR,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	Mov	#Patter,R0
SERR1:	.SERR
	.=.-2			;squash EMT
	Cmp	#.SERR*^o400,R0	;Is R0 right?
	Beq	10$
	Call	Err1
10$:
.PSect	Data
SERR2:	.SERR
.=.-2.
23$:
.=.+2.
25$:
.PSect	Active
	Cmp	#EMT+...R0,23$	;was the correct EMT generated?
	Beq	20$		;Yes
	Call	Err2
20$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.SETTOP	Ask for memory request
.MACRO	.SETTO	ADDR
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM5	<ADDR>,354
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SETTO:	.Asciz	"%SYSMAC-I-Testing .SETTOP"
.PSect	Active
	Mov	#$SETTO,R0	;Ident the test
	Call	BegTst
	Mov	#Patter,R0	;init R0
SETT1:	.SETTOP	#123456
	.=.-2
	Cmp	#123456,R0	;R0 set?
	Beq	10$		;yes
	Call	Err1		;no
10$:
	Mov	#123456,R0	;init R0
SETT2:	.SETTOP
	.=.-2
	Cmp	#123456,R0	;R0 set?
	Beq	20$		;yes
	Call	Err2		;no
20$:
	Mov	#123456,R0	;init R0
SETT3:	.SETTOP	R0
	.=.-2
	Cmp	#123456,R0	;R0 set?
	Beq	30$		;yes
	Call	Err3		;no
30$:
.PSect	Data
SETT4:	.SETTOP
40$:
.PSect	Active
	Cmp	#EMT+...SET,40$-2 ;correct EMT?
	Beq	50$		;yes
	Call	Err4		;no
50$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SFDAT	Set file date request
.MACRO	.SFDAT	AREA,CHAN,DBLK,DATE=#0,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,34,<CHAN>,<CODE>,<DBLK>
...CM2	<DATE>,4,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SFDAT:	.Asciz	"%SYSMAC-I-Testing .SFDAT"
.PSect	Active
	Mov	#$SFDAT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1
	Mov	#Patter,R0
SFDA1:	.SFDAT	#Area,#123,#123456,#1
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#.SFDAT,(R1)+	;is subcode set?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#1,(R1)+	;is DATE set?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Call	AreaM1
	Mov	#Area,R0
SFDA2:	.SFDAT	,#123,#123456
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	60$		;yes
	Call	Err2.1		;no
60$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	70$		;yes
	Call	Err2.2		;no
70$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	80$		;yes
	Call	Err2.3		;no
80$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	90$		;yes
	Call	Err2.4		;no
90$:
	Cmp	#0,(R1)+	;is DATE defaulted?
	Beq	100$		;yes
	Call	Err2.5		;no
100$:
	Call	AreaM1
	Mov	#Area,R0
SFDA3:	.SFDAT	,#123,#123456,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to argument area
	Cmp	R0,R1		;R0 correct?
	Beq	110$		;yes
	Call	Err3.1		;no
110$:
	CmpB	#123,(R1)+	;is channel set?
	Beq	120$		;yes
	Call	Err3.2		;no
120$:
	CmpB	#377,(R1)+	;is subcode unchanged?
	Beq	130$		;yes
	Call	Err3.3		;no
130$:
	Cmp	#123456,(R1)+	;is DBLK set?
	Beq	140$		;yes
	Call	Err3.4		;no
140$:
	Cmp	#0,(R1)+	;is DATE defaulted?
	Beq	150$		;yes
	Call	Err3.5		;no
150$:
.PSect	Data
SFDA4:	.SFDAT	CODE=NOSET
160$:
.PSect	Active
	Cmp	#EMT+...AR0,160$-2	;correct EMT?
	Beq	170$		;yes
	Call	Err4		;no
170$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SFINFO	Set file entry request
.MACRO	.SFINF	AREA,CHAN,DBLK,VALUE,TYPE=GET,OFFSE,UCODE,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,36,<CHAN>,<CODE>,<DBLK>
...CM2	<VALUE>,4
...V2=1000.
...V3=0
.IRP	x,<$GET,$BIC,$BIS,$MOV,$USER>
.IF	IDN <x> <$'TYPE>
...V2=0
.MEXIT
.ENDC
...V3=...V3+1
.ENDR
.IIF	GT ...V3-4.+...V2 .ERROR;?SYSMAC-E-Invalid T Y P E, expecting GET/MOV/BIC/BIS/USER, found - TYPE;
.IF	EQ ...V3-4.
...CM2	<UCODE>,6,,,B
.IFF
...CM2	#...V3,6,,,B
.IIF NB <UCODE> .ERROR ;?SYSMAC-W-Value specified for U C O D E, but T Y P E=TYPE;
.ENDC
...CM2	<OFFSE>,7,E,,B
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$SFINF:	.Asciz	"%SYSMAC-I-Testing .SFINF"
.PSect	Active
	Mov	#$SFINF,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.SFPA	Set FP exception address request
.MACRO	.SFPA	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,24.,0.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SFPA:	.Asciz	"%SYSMAC-I-Testing .SFPA"
.PSect	Active
	Mov	#$SFPA,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
SFPA1:	.SFPA	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.SFPA*^o400+0,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
SFPA2:	.SFPA	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.SFPA*^o400+0,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
SFPA3:	.SFPA	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.SFPA*^o400+0,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
SFPA4:	.SFPA
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SFSTAT	Set file entry status word request
.MACRO	.SFSTA	AREA,CHAN,DBLK,VALUE,TYPE=GET,UCODE,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,36,<CHAN>,<CODE>,<DBLK>
...CM2	<VALUE>,4
...V2=1000.
...V3=0
.IRP	x,<$GET,$BIC,$BIS,$MOV,$USER>
.IF	IDN <x> <$'TYPE>
...V2=0
.MEXIT
.ENDC
...V3=...V3+1
.ENDR
.IIF	GT ...V3-4.+...V2 .ERROR;?SYSMAC-E-Invalid T Y P E, expecting GET/MOV/BIC/BIS/USER, found - TYPE;
.IF	EQ ...V3-4.
...CM2	<UCODE>,6,,,B
.IFF
...CM2	#...V3,6,,,B
.IIF NB <UCODE> .ERROR ;?SYSMAC-W-Value specified for U C O D E, but T Y P E=TYPE;
.ENDC
...CM2	<#0>,7,E,,B
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$SFSTA:	.Asciz	"%SYSMAC-I-Testing .SFSTA"
.PSect	Active
	Mov	#$SFSTA,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	SOB	Provide compatibility for processors w/o SOB instruction
.MACRO	SOB	R,DST
	DEC	R
	BNE	DST
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SOB:	.Asciz	"%SYSMAC-I-Testing .SOB"
.PSect	Active
	Mov	#$SOB,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.SPCPS	Set PC/PS derail from a completion routine request
.MACRO	.SPCPS	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,33.,0.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SPCPS:	.Asciz	"%SYSMAC-I-Testing .SPCPS"
.PSect	Active
	Mov	#$SPCPS,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
SPCP1:	.SPCPS	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.SPCPS*^o400+0,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
SPCP2:	.SPCPS	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.SPCPS*^o400+0,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
SPCP3:	.SPCPS	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.SPCPS*^o400+0,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
SPCP4:	.SPCPS
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST

.Page
.SbTtl	.SPFUN	Issue a special device function request
.MACRO	.SPFUN	AREA,CHAN,FUNC,BUF,WCNT,BLK,CRTN=#0,CODE,BMODE,CMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM1	<AREA>,26,<CHAN>,<CODE>,<BLK>
...CM2	<BUF>,4
...CM2	<WCNT>,6
...CMB	<BMODE>,<CMODE>,<CRTN>,<FUNC>,S,<CODE>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SPFUN:	.Asciz	"%SYSMAC-I-Testing .SPFUN"
.PSect	Active
	Mov	#$SPFUN,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	MovB	#-2,Area+8.	;init marker byte to -2
	Mov	#Area,R0	;point to area
SPFUN1:	.SPFUN	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	CmpB	#-2,(R1)+	;is the marker unchanged?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	CmpB	#-1,(R1)+	;is FUNC unchanged?
	Beq	80$		;yes
	Call	Err1.8		;no
80$:
	Cmp	#..WTIO,(R1)+	;is CRTN set to wait?
	Beq	90$		;yes
	Call	Err1.9		;no
90$:
	Call	AreaM1		;init area
	MovB	#-2,Area+8.	;init marker byte to -2
	Mov	#Area,R0	;point to area
SPFUN2:	.SPFUN	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	100$		;yes
	Call	Err2.1		;no
100$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	110$		;yes
	Call	Err2.2		;no
110$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	120$		;yes
	Call	Err2.3		;no
120$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	130$		;yes
	Call	Err2.4		;no
130$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	140$		;yes
	Call	Err2.5		;no
140$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	150$		;yes
	Call	Err2.6		;no
150$:
	CmpB	#-2,(R1)+	;is the marker unchanged?
	Beq	160$		;yes
	Call	Err2.7		;no
160$:
	CmpB	#-1,(R1)+	;is FUNC unchanged?
	Beq	170$		;yes
	Call	Err2.8		;no
170$:
	Cmp	#..WTIO,(R1)+	;is CRTN unchanged?
	Beq	180$		;yes
	Call	Err2.9		;no
180$:
	Call	AreaM1		;init area
	MovB	#-2,Area+8.	;init marker byte to -2
	Mov	#Area,R0	;point to area
SPFUN3:	.SPFUN	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	190$		;yes
	Call	Err3.1		;no
190$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	200$		;yes
	Call	Err3.2		;no
200$:
	CmpB	#.SPFUN,(R1)+	;is IC set?
	Beq	210$		;yes
	Call	Err3.3		;no
210$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	220$		;yes
	Call	Err3.4		;no
220$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	230$		;yes
	Call	Err3.5		;no
230$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	240$		;yes
	Call	Err3.6		;no
240$:
	CmpB	#-2,(R1)+	;is the marker set?
	Beq	250$		;yes
	Call	Err3.7		;no
250$:
	CmpB	#-1,(R1)+	;is FUNC unchanged?
	Beq	260$		;yes
	Call	Err3.8		;no
260$:
	Cmp	#..WTIO,(R1)+	;is CRTN unchanged?
	Beq	270$		;yes
	Call	Err3.9		;no
270$:
	Call	AreaM1		;init area
	MovB	#-2,Area+8.	;init marker byte to -2
	Mov	#Patter,R0	;init R0
SPFUN4:	.SPFUN	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	280$		;yes
	Call	Err4.1		;no
280$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	290$		;yes
	Call	Err4.2		;no
290$:
	CmpB	#.SPFUN,(R1)+	;is IC unchanged?
	Beq	300$		;yes
	Call	Err4.3		;no
300$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	310$		;yes
	Call	Err4.4		;no
310$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	320$		;yes
	Call	Err4.5		;no
320$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	330$		;yes
	Call	Err4.6		;no
330$:
	CmpB	#-2,(R1)+	;is the marker set?
	Beq	340$		;yes
	Call	Err4.7		;no
340$:
	CmpB	#-1,(R1)+	;is FUNC unchanged?
	Beq	350$		;yes
	Call	Err4.8		;no
350$:
	Cmp	#..WTIO,(R1)+	;is CRTN unchanged?
	Beq	360$		;yes
	Call	Err4.9		;no
360$:
	Call	AreaM1		;init area
	MovB	#-2,Area+8.	;init marker byte to -2
	Mov	#Patter,R0	;init R0
SPFUN5:	.SPFUN	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	370$		;yes
	Call	Err5.1		;no
370$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	380$		;yes
	Call	Err5.2		;no
380$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	390$		;yes
	Call	Err5.3		;no
390$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	400$		;yes
	Call	Err5.4		;no
400$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	410$		;yes
	Call	Err5.5		;no
410$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	420$		;yes
	Call	Err5.6		;no
420$:
	CmpB	#-2,(R1)+	;is the marker set?
	Beq	430$		;yes
	Call	Err5.7		;no
430$:
	CmpB	#-1,(R1)+	;is FUNC unchanged?
	Beq	440$		;yes
	Call	Err5.8		;no
440$:
	Cmp	#..WTIO,(R1)+	;is CRTN unchanged?
	Beq	450$		;yes
	Call	Err5.9		;no
450$:
	Call	AreaM1		;init area
	MovB	#-2,Area+8.	;init marker byte to -2
	Mov	#Patter,R0	;init R0
SPFUN6:	.SPFUN	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	460$		;yes
	Call	Err6.1		;no
460$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	470$		;yes
	Call	Err6.2		;no
470$:
	CmpB	#.SPFUN,(R1)+	;is IC set?
	Beq	480$		;yes
	Call	Err6.3		;no
480$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	490$		;yes
	Call	Err6.4		;no
490$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	500$		;yes
	Call	Err6.5		;no
500$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	510$		;yes
	Call	Err6.6		;no
510$:
	CmpB	#-2,(R1)+	;is the marker unchanged?
	Beq	520$		;yes
	Call	Err6.7		;no
520$:
	CmpB	#-1,(R1)+	;is FUNC unchanged?
	Beq	530$		;yes
	Call	Err6.8		;no
530$:
	Cmp	#..WTIO,(R1)+	;is CRTN set to wait?
	Beq	540$		;yes
	Call	Err6.9		;no
540$:
	Call	AreaM1		;init area
	MovB	#-2,Area+8.	;init marker byte to -2
	Mov	#Patter,R0	;init R0
SPFUN7:	.SPFUN	#Area,#0,#202,#010000,#020000,#030000,#123456
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	550$		;yes
	Call	Err7.1		;no
550$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	560$		;yes
	Call	Err7.2		;no
560$:
	CmpB	#.SPFUN,(R1)+	;is IC set?
	Beq	570$		;yes
	Call	Err7.3		;no
570$:
	Cmp	#030000,(R1)+	;is BLK set?
	Beq	580$		;yes
	Call	Err7.4		;no
580$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	590$		;yes
	Call	Err7.5		;no
590$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	600$		;yes
	Call	Err7.6		;no
600$:
	CmpB	#..SPFV,(R1)+	;is the marker unchanged?
	Beq	610$		;yes
	Call	Err7.7		;no
610$:
	CmpB	#202,(R1)+	;is FUNC set?
	Beq	620$		;yes
	Call	Err7.8		;no
620$:
	Cmp	#123456,(R1)+	;is CRTN set to wait?
	Beq	630$		;yes
	Call	Err7.9		;no
630$:
.PSect	Data
SPFUN8:	.SPFUN
640$:
.PSect	Active
	Cmp	#EMT+...AR0,640$-2	;correct EMT?
	Beq	650$		;yes
	Call	Err8		;no
650$:
	Call	AreaM1		;init area
	MovB	#-2,Area+8.	;init marker byte to -2
	Mov	#Patter,R0	;init R0
	Mov	#333,R3		;FUNC from a register
SPFUN9:	.SPFUN	#Area,#0,R3,#010000,#020000,#0,#123456,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	660$		;yes
	Call	Err9.1		;no
660$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	670$		;yes
	Call	Err9.2		;no
670$:
	CmpB	#.SPFUN,(R1)+	;is IC set?
	Beq	680$		;yes
	Call	Err9.3		;no
680$:
	Cmp	#0,(R1)+	;is BLK set?
	Beq	690$		;yes
	Call	Err9.4		;no
690$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	700$		;yes
	Call	Err9.5		;no
700$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	710$		;yes
	Call	Err9.6		;no
710$:
SPFUNA:	CmpB	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	720$		;yes
	Call	ErrA.1		;no
720$:
	CmpB	#333,(R1)+	;is FUNC unchanged?
	Beq	730$		;yes
	Call	ErrA.2		;no
730$:
	Cmp	#123456,(R1)+	;is SRTN set to wait?
	Beq	740$		;yes
	Call	ErrA.3		;no
740$:
.PSect	Data
SPFUNB:	.SPFUN	,BMODE=SI
750$:
.PSect	Active
	Cmp	#EMT+...AR0,750$-2	;correct EMT?
	Beq	760$		;yes
	Call	ErrB.1		;no
760$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.SPND	Suspend a job request
.MACRO	.SPND
	MOV	#^o400,R0
	EMT	^o374
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SPND:	.Asciz	"%SYSMAC-I-Testing .SPND"
.PSect	Active
	Mov	#$SPND,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	Mov	#Patter,R0
SPND1:	.SPND
	.=.-2			;squash EMT
	Cmp	#.SPND*^o400,R0	;Is R0 right?
	Beq	10$
	Call	Err1
10$:
.PSect	Data
SPND2:	.SPND
.=.-2.
23$:
.=.+2.
25$:
.PSect	Active
	Cmp	#EMT+...R0,23$	;was the correct EMT generated?
	Beq	20$		;Yes
	Call	Err2
20$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.SRESET	Soft reset request
.MACRO	.SRESE
	EMT	^o352
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SRESE:	.Asciz	"%SYSMAC-I-Testing .SRESE"
.PSect	Active
	Mov	#$SRESE,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
.PSect	Data
SRESE1:	.SRESE
.=.-2.
13$:
.=.+2.
15$:
.PSect	Active
	Cmp	#EMT+...SRE,13$	;was the correct EMT generated?
	Beq	10$		;Yes
	Call	Err1
10$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.SYNCH	Synchronize with the specified job call
.MACRO	.SYNCH	AREA,PIC
.IF B PIC
.IF NB <AREA>
	MOV	AREA,R4
.ENDC
.IFF
.IF NB AREA
	MOV	PC,R4
.NTYPE ...V2,AREA
.IF EQ ...V2-^o27
	ADD	AREA-.,R4
.IFF
	ADD	#AREA-.,R4
.ENDC
.ENDC
.ENDC
	MOV	@#^o54,R5
	JSR	R5,@^o324(R5)
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$SYNCH:	.Asciz	"%SYSMAC-I-Testing .SYNCH"
.PSect	Active
	Mov	#$SYNCH,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.TIMIO	Time an I/O request call		**Handler only**
.MACRO	.TIMIO	TBK,HI,LO
	JSR	R5,@$TIMIT
	.WORD	TBK-.
	.WORD	0
	.WORD	HI
	.WORD	LO
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$TIMIO:	.Asciz	"%SYSMAC-I-Testing .TIMIO"
.PSect	Active
	Mov	#$TIMIO,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.TLOCK	Test for USR available, if so, lock in memory for this job
.SbTtl	.		request
.MACRO	.TLOCK
	MOV	#^o3400,R0
	EMT	^o374
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$TLOCK:	.Asciz	"%SYSMAC-I-Testing .TLOCK"
.PSect	Active
	Mov	#$TLOCK,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
	Mov	#Patter,R0
TLOCK1:	.TLOCK
	.=.-2			;squash EMT
	Cmp	#.TLOCK*^o400,R0	;Is R0 right?
	Beq	10$
	Call	Err1
10$:
.PSect	Data
TLOCK2:	.TLOCK
.=.-2.
23$:
.=.+2.
25$:
.PSect	Active
	Cmp	#EMT+...R0,23$	;was the correct EMT generated?
	Beq	20$		;Yes
	Call	Err2
20$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.TRPSET	Set trap 4 and 10 address request
.MACRO	.TRPSE	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,3.,0.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$TRPSE:	.Asciz	"%SYSMAC-I-Testing .TRPSET"
.PSect	Active
	Mov	#$TRPSE,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
TRPS1:	.TRPSET	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.TRPSE*^o400+0,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
TRPS2:	.TRPSET	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.TRPSE*^o400+0,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
TRPS3:	.TRPSET	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.TRPSE*^o400+0,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
TRPS4:	.TRPSET
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.TTINR	Get a character for console, report if none available request
.MACRO	.TTINR
	EMT	^o340
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$TTINR:	.Asciz	"%SYSMAC-I-Testing .TTINR"
.PSect	Active
	Mov	#$TTINR,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
.PSect	Data
TTINR1:	.TTINR
.=.-2.
13$:
.=.+2.
.PSect	Active
	Cmp	#EMT+...TTI,13$	;was the correct EMT generated?
	Beq	10$		;Yes
	Call	Err1
10$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.TTOUTR	Send a char to console, report if buffer full request
.MACRO	.TTOUT
	EMT	^o341
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$TTOUT:	.Asciz	"%SYSMAC-I-Testing .TTOUT"
.PSect	Active
	Mov	#$TTOUT,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
.PSect	Data
TTOUT1:	.TTOUT
.=.-2.
13$:
.=.+2.
.PSect	Active
	Cmp	#EMT+...TTO,13$	;was the correct EMT generated?
	Beq	10$		;Yes
	Call	Err1
10$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.TTYIN	Get a char from console, wait until available request
.MACRO	.TTYIN	CHAR
	EMT	^o340
	BCS	.-2.
.IF NB <CHAR>
.IF DIF <CHAR>,R0
	MOVB	R0,CHAR
.ENDC
.ENDC
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$TTYIN:	.Asciz	"%SYSMAC-I-Testing .TTYIN"
.PSect	Active
	Mov	#$TTYIN,R0	;Ident the test
	Call	BegTst
.PSect	Data
TTYI1:	.TTYIN
.PSect	Active
	Cmp	#EMT+...TTI,TTYI1 ;correct EMT generated?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#BCS!376,TTYI1+2 ;and the branch?
	Beq	20$		;yes
20$:
	Mov	#Patter,R1	;init R1 to odd pattern
	Mov	#100340,R0	;init R0 to different pattern
TTYI2:	.TTYIN	R1
	.=.-6			;smash EMT and BCS
	Nop			;smash EMT
	Nop			;smash BCS
	.=.+2			;allow MOV
	Cmp	#177600!340,R1	;R1 loaded correctly?
	Beq	30$		;yes
	Call	Err2		;no
30$:
	Mov	#100340,R0	;init R0 to different pattern
TTYI3:	.TTYIN	R0
	.=.-4			;smash EMT and BCS
	Nop			;smash EMT
	Nop			;smash BCS
	Cmp	#100340,R0	;R0 loaded correctly?
				;Note: MOV R0,R0 suppressed
	Beq	40$		;yes
	Call	Err3		;no
40$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.TTYOUT	Send a char to the console, wait until in buffer request
.MACRO	.TTYOU	CHAR
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM5	<CHAR>,341,B
	BCS	.-2.
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$TTYOU:	.Asciz	"%SYSMAC-I-Testing .TTYOUT"
.PSect	Active
	Mov	#$TTYOU,R0	;Ident the test
	Call	BegTst
.PSect	Data
TTYO1:	.TTYOUT
.PSect	Active
	Cmp	#EMT+...TTO,TTYO1	;correct EMT generated?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#BCS!376,TTYO1+2 ;and the branch?
	Beq	20$		;yes
20$:
	Mov	#Patter,R0	;init R0 to odd pattern
TTY02:	.TTYOUT	#123456
	.=.-4			;smash EMT and BCS
	Cmp	#056,R0		;R0 loaded correctly?
	Beq	30$		;yes
	Call	Err2		;no
30$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.TWAIT	Wait for specified time interval request
.MACRO	.TWAIT	AREA,TIME,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,20.,0.,<CODE>,<TIME>,E
.ENDM

.PAGE
;+TEST
.Enabl	LSB
.PSect	Text
$TWAIT:	.Asciz	"%SYSMAC-I-Testing .TWAIT"
.PSect	Active
	Mov	#$TWAIT,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
TWAI1:	.TWAIT	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.TWAIT*^o400+0,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
TWAI2:	.TWAIT	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.TWAIT*^o400+0,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
TWAI3:	.TWAIT	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.TWAIT*^o400+0,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
TWAI4:	.TWAIT
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.UNLOCK	Release USR from memory and job request
.MACRO	.UNLOC
	EMT	^o347
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$UNLOC:	.Asciz	"%SYSMAC-I-Testing .UNLOCK"
.PSect	Active
	Mov	#$UNLOC,R0	;Ident the test(s)
	Call	BegTst		;Assume no errors
.PSect	Data
UNLOC1:	.UNLOC
.=.-2.
13$:
.=.+2.
.PSect	Active
	Cmp	#EMT+...UNL,13$	;was the correct EMT generated?
	Beq	10$		;Yes
	Call	Err1
10$:
	Call	EndTst
.Dsabl LSB
;-TEST
.Page
.SbTtl	.UNMAP	Unmap extended memory request
.MACRO	.UNMAP	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,30.,5.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$UNMAP:	.Asciz	"%SYSMAC-I-Testing .UNMAP"
.PSect	Active
	Mov	#$UNMAP,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
UNMA1:	.UNMAP	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.UNMAP*^o400+..UNMAP,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
UNMA2:	.UNMAP	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.UNMAP*^o400+..UNMAP,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
UNMA3:	.UNMAP	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.UNMAP*^o400+..UNMA,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
UNMA4:	.UNMAP
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.UNPROTECT Unprotect specified vector request
.MACRO	.UNPRO	AREA,ADDR,CODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM6	<AREA>,25.,1.,<CODE>,<ADDR>,E
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$UNPRO:	.Asciz	"%SYSMAC-I-Testing .UNPROTECT"
.PSect	Active
	Mov	#$UNPRO,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;set area to -1s
UNPR1:	.UNPRO	#Area,#123456
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	Cmp	#.UNPRO*^o400+..UNPR,(R1)+ ;is the subcode correct?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	30$		;yes
	Call	Err1.3
30$:
	Call	AreaM1		;set area to -1s
UNPR2:	.UNPRO	#Area
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	40$		;yes
	Call	Err2.1		;no
40$:
	Cmp	#.UNPRO*^o400+..UNPR,(R1)+ ;is the subcode correct?
	Beq	50$		;yes
	Call	Err2.2		;no
50$:
	Cmp	#177777,(R1)+	;is the address correct?
	Beq	60$		;yes
	Call	Err2.3
60$:

	Call	AreaM1		;set area to -1s
	Mov	#Area,R0
UNPR3:	.UNPRO	,#123456,CODE=SET
	.=.-2			;crush EMT
	Mov	R0,R1		;point to area
	Cmp	R0,#Area	;was area pointed to correctly?
	Beq	70$		;yes
	Call	Err3.1		;no
70$:
	Cmp	#.UNPRO*^o400+..UNPR,(R1)+ ;is the subcode correct?
	Beq	80$		;yes
	Call	Err3.2		;no
80$:
	Cmp	#123456,(R1)+	;is the address correct?
	Beq	90$		;yes
	Call	Err3.3
90$:
.PSect	Data
UNPR4:	.UNPRO
100$:
.PSect	Active
	Cmp	#EMT+...AR0,100$-2 ;correct EMT code?
	Beq	110$		;yes
	Call	Err4
110$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.WAIT	Wait for I/O completion
.MACRO	.WAIT	CHAN
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
.IF NE ...V1-1
.IF B <CHAN>
	CLR	R0
.IFF
.NTYPE ...V2,CHAN
.IF EQ ...V2-^o27
.IF IDN <CHAN>,#0
	CLR	R0
.IFF
.IIF IDN <CHAN>,0,.ERROR;?SYSMAC-W-Invalid argument, use #0, not 0;
	MOV	CHAN,R0
.ENDC
.IFF
.IF EQ ...V2&^o7
.IF NE ...V2
	MOV	CHAN,R0
.ENDC
	BIC	#^c^o377,R0
.IFF
	CLR	R0
	BISB	CHAN,R0
.ENDC
.ENDC
.ENDC
	EMT	^o374
.MEXIT
.ENDC
	EMT	^o<240+CHAN>
.ENDM
;+TEST
.Enabl	LSB
.PSect	Text
$WAIT:	.Asciz	"%SYSMAC-I-Testing .WAIT"
.PSect	Active
	Mov	#$WAIT,R0	;Ident the test
	Call	BegTst
	Mov	#Patter,R0	;trash R0
WAIT1:	.WAIT
	.=.-2			;crush EMT
			.Assume .WAIT EQ 0
	Tst	R0		;zeroed?
	Beq	10$		;yes
	Call	Err1		;no
10$:
	Mov	#Patter,R0	;trash R0
WAIT2:	.WAIT	#0
	.=.-2			;crush EMT
			.Assume .WAIT EQ 0
	Tst	R0		;zeroed?
	Beq	20$		;yes
	Call	Err2		;no
20$:
	Mov	#Patter,R0	;trash R0
WAIT3:	.WAIT	#Zero
	.=.-2			;crush EMT
			.Assume .WAIT EQ 0
	Tst	R0		;zeroed?
	Beq	30$		;yes
	Call	Err3		;no
30$:
	Mov	#3,R0		;load R0
WAIT4:	.WAIT	R0
	.=.-2			;crush EMT
			.Assume .WAIT EQ 0
	Cmp	#3,R0		;loaded correctly?
	Beq	40$		;yes
	Call	Err4		;no
40$:
	Mov	#Patter,R0	;trash R0
	Mov	#3,R1		;load R0
WAIT5:	.WAIT	R1
	.=.-2			;crush EMT
			.Assume .WAIT EQ 0
	Cmp	#3,R0		;zeroed?
	Beq	50$		;yes
	Call	Err5		;no
50$:
	Mov	#60$,R0		;load address in R0
.PSect	Data
60$:	.Word	3
.PSect	Active
WAIT6:	.WAIT	@R0
	.=.-2			;crush EMT
			.Assume .WAIT EQ 0
	Cmp	#3,R0		;zeroed?
	Beq	70$		;yes
	Call	Err6		;no
70$:
	Call	EndTst
.Dsabl	LSB
;>>>emt test?
;-TEST
.Page
.SbTtl	.WDBBK	generate a Window Definition Block
.MACRO	.WDBBK	WNAPR,WNSIZ,WNRID,WNOFF,WNLEN,WNSTS
.MCALL	.WDBDF
.WDBDF
	.BYTE
	.BYTE	WNAPR
	.WORD
	.WORD	WNSIZ
	.WORD	WNRID
	.WORD	WNOFF
	.WORD	WNLEN
	.WORD	WNSTS
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$WDBBK:	.Asciz	"%SYSMAC-I-Testing .WDBBK"
.PSect	Active
	Mov	#$WDBBK,R0	;Ident the test
	Call	BegTst
	Call	SkpTst
;-TEST
.Page
.SbTtl	.WDBDF	Define bits and offsets for a WDB
.MACRO	.WDBDF	LIST,E=<=:>
.IIF IDN <LIST>,<YES>	.LIST
W.NID E 0
W.NAPR E 1
W.NBAS E 2.
W.NSIZ E 4.
W.NRID E 6.
W.NOFF E ^o10
W.NLEN E ^o12
W.NSTS E ^o14
W.NLGH E ^o16
WS.CRW E ^o100000
WS.UNM E ^o40000
WS.ELW E ^o20000
WS.DSI E ^o10000
WS.IDD E ^o4000
WS.OVR E ^o2000
WS.RO E ^o1000
WS.MAP E ^o400
WS.SPA E ^o14
WS.DEF E 0
WS.D E ^o10
WS.I E ^o4
WS.MOD E ^o3
WS.U E ^o0
WS.S E ^o1
WS.C E ^o2
.IIF IDN <LIST>,<YES>	.NLIST
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$WDBDF:	.Asciz	"%SYSMAC-I-Testing .WDBDF"
.PSect	Active
	Mov	#$WDBDF,R0	;Ident the test
	Call	BegTst
	Call	TemTst
;-TEST
.Page
.SbTtl	.WRITC	Queue a write operation, specifying completion routine request
.MACRO	.WRITC	AREA,CHAN,BUF,WCNT,CRTN,BLK,CODE,BMODE,CMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM7	<AREA>,<CHAN>,<BUF>,<WCNT>,<BLK>,<CRTN>,9,<CODE>,220,<BMODE>,<CMODE>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$WRITC:	.Asciz	"%SYSMAC-I-Testing .WRITC"
.PSect	Active
	Mov	#$WRITC,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITC1:	.WRITC	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITC2:	.WRITC	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.2		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.3		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.4		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.5		;no
130$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	140$		;yes
	Call	Err2.6		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITC3:	.WRITC	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err2.1		;no
150$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	160$		;yes
	Call	Err2.2		;no
160$:
	CmpB	#.WRITC,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err2.2		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err2.3		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err2.4		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err2.5		;no
200$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	210$		;yes
	Call	Err2.6		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITC4:	.WRITC	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.WRITC,(R1)+	;is IC set?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITC5:	.WRITC	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.2		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.3		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.4		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.5		;no
340$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	350$		;yes
	Call	Err5.6		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITC6:	.WRITC	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.WRITC,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.2		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.3		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.4		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.5		;no
410$:
	Cmp	#-1,(R1)+	;is CRTN unchanged?
	Beq	420$		;yes
	Call	Err6.6		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITC7:	.WRITC	#Area,#0,#010000,#020000,#123456,#030000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.WRITC,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.2		;no
450$:
	Cmp	#030000,(R1)+	;is BLK set?
	Beq	460$		;yes
	Call	Err7.3		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.4		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.5		;no
480$:
	Cmp	#123456,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.6		;no
490$:
.PSect	Data
WRITC8:	.WRITC
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITC9:	.WRITC	#Area,#0,#010000,#020000,#123654,#0,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.WRITC,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#0,(R1)+	;is BLK set?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#123654,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
WRITCA:	.WRITC	,BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.WRITE	Queue a write operation request
.MACRO	.WRITE	AREA,CHAN,BUF,WCNT,BLK,CRTN=#1,CODE,BMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM7	<AREA>,<CHAN>,<BUF>,<WCNT>,<BLK>,<CRTN>,9,<CODE>,220,<BMODE>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$WRITE:	.Asciz	"%SYSMAC-I-Testing .WRITE"
.PSect	Active
	Mov	#$WRITE,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITE1:	.WRITE	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITE2:	.WRITE	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.2		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.3		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.4		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.5		;no
130$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	140$		;yes
	Call	Err2.6		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITE3:	.WRITE	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err2.1		;no
150$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	160$		;yes
	Call	Err2.2		;no
160$:
	CmpB	#.WRITE,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err2.2		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err2.3		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err2.4		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err2.5		;no
200$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	210$		;yes
	Call	Err2.6		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITE4:	.WRITE	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.WRITE,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITE5:	.WRITE	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.2		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.3		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.4		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.5		;no
340$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	350$		;yes
	Call	Err5.6		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITE6:	.WRITE	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.WRITE,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.2		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.3		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.4		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.5		;no
410$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	420$		;yes
	Call	Err6.6		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITE7:	.WRITE	#Area,#0,#010000,#020000,#030000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.WRITE,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.2		;no
450$:
	Cmp	#030000,(R1)+	;is BLK set?
	Beq	460$		;yes
	Call	Err7.3		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.4		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.5		;no
480$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.6		;no
490$:
.PSect	Data
WRITE8:	.WRITE
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITE9:	.WRITE	#Area,#0,#010000,#020000,#0,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.WRITE,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#0,(R1)+	;is BLK set?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#..ISIO,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
WRITEA:	.WRITE	,BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
.SbTtl	.WRITW	Issue a write operation, wait for completion request
.MACRO	.WRITW	AREA,CHAN,BUF,WCNT,BLK,CRTN=#0,CODE,BMODE
.IF NDF ...V1
.MCALL	.MACS
.MACS
.ENDC
...CM7	<AREA>,<CHAN>,<BUF>,<WCNT>,<BLK>,<CRTN>,9,<CODE>,220,<BMODE>
.ENDM

;+TEST
.Enabl	LSB
.PSect	Text
$WRITW:	.Asciz	"%SYSMAC-I-Testing .WRITW"
.PSect	Active
	Mov	#$WRITW,R0	;Ident the test
	Call	BegTst
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITW1:	.WRITW	
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	10$		;yes
	Call	Err1.1		;no
10$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	20$		;yes
	Call	Err1.2		;no
20$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	30$		;yes
	Call	Err1.3		;no
30$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	40$		;yes
	Call	Err1.4		;no
40$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	50$		;yes
	Call	Err1.5		;no
50$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	60$		;yes
	Call	Err1.6		;no
60$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	70$		;yes
	Call	Err1.7		;no
70$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITW2:	.WRITW	,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	80$		;yes
	Call	Err2.1		;no
80$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	90$		;yes
	Call	Err2.2		;no
90$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	100$		;yes
	Call	Err2.2		;no
100$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	110$		;yes
	Call	Err2.3		;no
110$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	120$		;yes
	Call	Err2.4		;no
120$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	130$		;yes
	Call	Err2.5		;no
130$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	140$		;yes
	Call	Err2.6		;no
140$:
	Call	AreaM1		;init area
	Mov	#Area,R0	;point to area
WRITW3:	.WRITW	,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	150$		;yes
	Call	Err2.1		;no
150$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	160$		;yes
	Call	Err2.2		;no
160$:
	CmpB	#.WRITW,(R1)+	;is IC set?
	Beq	170$		;yes
	Call	Err2.2		;no
170$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	180$		;yes
	Call	Err2.3		;no
180$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	190$		;yes
	Call	Err2.4		;no
190$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	200$		;yes
	Call	Err2.5		;no
200$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	210$		;yes
	Call	Err2.6		;no
210$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITW4:	.WRITW	#Area
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	220$		;yes
	Call	Err4.1		;no
220$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	230$		;yes
	Call	Err4.2		;no
230$:
	CmpB	#.WRITW,(R1)+	;is IC unchanged?
	Beq	240$		;yes
	Call	Err4.3		;no
240$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	250$		;yes
	Call	Err4.4		;no
250$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	260$		;yes
	Call	Err4.5		;no
260$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	270$		;yes
	Call	Err4.6		;no
270$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	280$		;yes
	Call	Err4.7		;no
280$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITW5:	.WRITW	#Area,CODE=NOSET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	290$		;yes
	Call	Err5.1		;no
290$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	300$		;yes
	Call	Err5.2		;no
300$:
	CmpB	#-1,(R1)+	;is IC unchanged?
	Beq	310$		;yes
	Call	Err5.2		;no
310$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	320$		;yes
	Call	Err5.3		;no
320$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	330$		;yes
	Call	Err5.4		;no
330$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	340$		;yes
	Call	Err5.5		;no
340$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	350$		;yes
	Call	Err5.6		;no
350$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITW6:	.WRITW	#Area,CODE=SET
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	360$		;yes
	Call	Err6.1		;no
360$:
	CmpB	#-1,(R1)+	;is CHAN unchanged?
	Beq	370$		;yes
	Call	Err6.2		;no
370$:
	CmpB	#.WRITW,(R1)+	;is IC set?
	Beq	380$		;yes
	Call	Err6.2		;no
380$:
	Cmp	#-1,(R1)+	;is BLK unchanged?
	Beq	390$		;yes
	Call	Err6.3		;no
390$:
	Cmp	#-1,(R1)+	;is BUF unchanged?
	Beq	400$		;yes
	Call	Err6.4		;no
400$:
	Cmp	#-1,(R1)+	;is WCNT unchanged?
	Beq	410$		;yes
	Call	Err6.5		;no
410$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	420$		;yes
	Call	Err6.6		;no
420$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITW7:	.WRITW	#Area,#0,#010000,#020000,#030000
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	430$		;yes
	Call	Err7.1		;no
430$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	440$		;yes
	Call	Err7.2		;no
440$:
	CmpB	#.WRITW,(R1)+	;is IC set?
	Beq	450$		;yes
	Call	Err7.2		;no
450$:
	Cmp	#030000,(R1)+	;is BLK set?
	Beq	460$		;yes
	Call	Err7.3		;no
460$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	470$		;yes
	Call	Err7.4		;no
470$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	480$		;yes
	Call	Err7.5		;no
480$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	490$		;yes
	Call	Err7.6		;no
490$:
.PSect	Data
WRITW8:	.WRITW
500$:
.PSect	Active
	Cmp	#EMT+...AR0,500$-2	;correct EMT?
	Beq	510$		;yes
	Call	Err8		;no
510$:
	Call	AreaM1		;init area
	Mov	#Patter,R0	;init R0
WRITW9:	.WRITW	#Area,#0,#010000,#020000,#0,BMODE=UI
	.=.-2
	Mov	#Area,R1	;point to area
	Cmp	R0,R1		;R0 ok?
	Beq	520$		;yes
	Call	Err9.1		;no
520$:
	CmpB	#0,(R1)+	;is CHAN set?
	Beq	530$		;yes
	Call	Err9.2		;no
530$:
	CmpB	#.WRITW,(R1)+	;is IC set?
	Beq	540$		;yes
	Call	Err9.3		;no
540$:
	Cmp	#0,(R1)+	;is BLK set?
	Beq	550$		;yes
	Call	Err9.4		;no
550$:
	Cmp	#010000,(R1)+	;is BUF set?
	Beq	560$		;yes
	Call	Err9.5		;no
560$:
	Cmp	#020000,(R1)+	;is WCNT set?
	Beq	570$		;yes
	Call	Err9.6		;no
570$:
	Cmp	#..USER!..ISPA!^o3,(R1)+ ;is FLAG set?
	Beq	580$		;yes
	Call	Err9.7		;no
580$:
	Cmp	#..WTIO,(R1)+	;is CRTN set?
	Beq	590$		;yes
	Call	Err9.8		;no
590$:
.PSect	Data
WRITWA:	.WRITW	,BMODE=SI
600$:
.PSect	Active
	Cmp	#EMT+...AR0,600$-2	;correct EMT?
	Beq	610$		;yes
	Call	ErrA.1		;no
610$:
	Call	EndTst
.Dsabl	LSB
;-TEST
.Page
;+TEST
.Enabl	LSB
.PSect	Active
	.Debug	SWITCH=ON,VALUE=YES
	.DPrint	<>
	.DPrint	<%SYSMAC-I-Warnings issued >,WarCnt,DEC
	.DPrint	<%SYSMAC-I-Errors issued >,ErrCnt,DEC
	.Exit			;done
.Dsabl	LSB
.End Active
;-TEST
.End