Google
 

Trailing-Edge - PDP-10 Archives - BB-R595B-SM_11-9-85 - mcb/nmx/nmxine.lst
There is 1 other file named nmxine.lst in the archive. Click here to see a list.
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   1
								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (1)

;	  0001	module NMXINE (					! Database Maintenance
;	  0002			ident = 'X01110'
;	  0003			) =
;	  0004	begin
;	  0005	!
;	  0006	!                    COPYRIGHT (c) 1980, 1981, 1982
;	  0007	!                    DIGITAL EQUIPMENT CORPORATION
;	  0008	!                        Maynard, Massachusetts
;	  0009	!
;	  0010	!     This software is furnished under a license and may  be  used
;	  0011	!     and copied only in accordance with the terms of such license
;	  0012	!     and with the inclusion of the above copyright notice.   This
;	  0013	!     software  or any other copies thereof may not be provided or
;	  0014	!     otherwise made available to any other person.  No  title  to
;	  0015	!     and ownership of the software is hereby transferred.
;	  0016	!
;	  0017	!     The information  in  this  software  is  subject  to  change
;	  0018	!     without  notice  and should not be construed as a commitment
;	  0019	!     by DIGITAL EQUIPMENT CORPORATION.
;	  0020	!
;	  0021	!     DIGITAL assumes no responsibility for the use or reliability
;	  0022	!     of  its  software  on  equipment  which  is  not supplied by
;	  0023	!     DIGITAL.
;	  0024	!
;	  0025	
;	  0026	!++
;	  0027	!
;	  0028	! FACILITY: MCB Network Management
;	  0029	!
;	  0030	! ABSTRACT:
;	  0031	!
;	  0032	!	NMXINI supplies functions which allow maintenance of the NMX
;	  0033	!	LINE/CIRCUIT/MODULE data bases.
;	  0034	!
;	  0035	! ENVIRONMENT: MCB V3.2
;	  0036	!
;	  0037	! AUTHOR: Scott G. Robinson	CREATION DATE: 12-FEB-81
;	  0038	!
;	  0039	! MODIFIED BY:
;	  0040	!
;	  0041	! 01 - Add additional routines to support interrogation of Entity Data bases
;	  0042	! 02 - Add yet another routine for interrogation of Entity Data Bases
;	  0043	! 03 - Fix routines to call GET_??? correctly
;	  0044	! 04 - Add support for DLX items
;	  0045	! 05 - Add parameter services for DLL.
;	  0046	!      NOTE: Unable to complete because of no access to executor number/name.
;	  0047	! 06 - Fix to not include name length in name in $NPNAM.
;	  0048	! 07 - Create JMPs to routine from special psect to allow easy modification.
;	  0049	! 08 - Change line/circuit references to common link block
;	  0050	! 09 - Use new entity data bases.
;	  0051	!       Alan D. Peckham, 14-Apr-82
;	  0052	! 10 - Rework for NM support.
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   2
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (1)

;	  0053	!      Data bases restructured.
;	  0054	! 11 - Check input id string lengths for all calls.
;	  0055	!--
;	  0056	
;	  0057	!
;	  0058	! INCLUDE FILES:
;	  0059	!
;	  0060	
;	  0061	library 'XPORTX';
;	  0062	
;	  0063	library 'MCBLIB';
;	  0064	
;	  0065	library 'NMXPAR';
;	  0066	
;	  0067	library 'NMXLIB';
;	  0068	
;	  0069	literal
;	  0070	    NMX$ID_lo = min (NMX$ID_owner, NMX$ID_provider),
;	  0071	    NMX$ID_hi = max (NMX$ID_owner, NMX$ID_provider);
;	  0072	
;	  0073	!
;	  0074	! TABLE OF CONTENTS:
;	  0075	!
;	  0076	
;	  0077	forward routine
;	  0078	    NMX$$CREATE : CALL$,	    ! NMX$CREATE functions
;	  0079	    NMX$$DESTROY : CALL$,	    ! NMX$DESTROY functions
;	  0080	    NMX$$MAP : CALL$,		    ! NMX$MAP functions
;	  0081	    NMX$$MODIFY_ID : CALL$,	    ! NMX$MODIFY id functions
;	  0082	    NMX$$MODIFY_NAME : CALL$,	    ! NMX$MODIFY name functions
;	  0083	    NMX$$OBTAIN : CALL$,	    ! NMX$OBTAIN functions
;	  0084	    NMX$$PARAMETER_NAME : CALL$,    ! NMX$PARAMETER_x
;	  0085	    NMX$$PARAMETER_OWNER : CALL$,   ! NMX$PARAMETER_x_OWNER
;	  0086	    NMX$$PARAMETER_USER : CALL$;    ! NMX$_x_USER
;	  0087	
;	  0088	literal JUMP_TO = %o'137';
;	  0089	
;	  0090	psect
;	  0091	    global = NMXJMP (nowrite, execute);
;	  0092	
;	  0093	global
;	  0094	    $NMCRE : vector [2] initial (JUMP_TO, NMX$$CREATE),
;	  0095	    $NMDES : vector [2] initial (JUMP_TO, NMX$$DESTROY),
;	  0096	    $NMMID : vector [2] initial (JUMP_TO, NMX$$MODIFY_ID),
;	  0097	    $NMMNA : vector [2] initial (JUMP_TO, NMX$$MODIFY_NAME),
;	  0098	    $NMMAP : vector [2] initial (JUMP_TO, NMX$$MAP),
;	  0099	    $NMGID : vector [2] initial (JUMP_TO, NMX$$OBTAIN),
;	  0100	    $NPNAM : vector [2] initial (JUMP_TO, NMX$$PARAMETER_NAME),
;	  0101	    $NPOWN : vector [2] initial (JUMP_TO, NMX$$PARAMETER_OWNER),
;	  0102	    $NPUSR : vector [2] initial (JUMP_TO, NMX$$PARAMETER_USER);
;	  0103	
;	  0104	undeclare JUMP_TO;
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   3
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (1)

;	  0105	!
;	  0106	! Externals
;	  0107	!
;	  0108	
;	  0109	external
;	  0110	    MCB$GAW_PROCESS_DATA_BASE : vector [2];
;	  0111	
;	  0112	macro				    ! Map to NMXPAR's representation
;	  0113	    $true = true %,
;	  0114	    $false = false %;
;	  0115	
;	  0116	!
;	  0117	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   4
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (2)

;	  0118	routine NMX$$CREATE (IN_TYPE, IN_PTR, IN_FLAGS, OUT_NMXID) : CALL$ = 	! NMX$CREATE
;	  0119	
;	  0120	!++
;	  0121	! FUNCTIONAL DESCRIPTION:
;	  0122	!
;	  0123	!    NMX$$CREATE processes the creation of an NMX database entry for
;	  0124	!    an entity. This routine is called from the following interprocess
;	  0125	!    synchronous calls:
;	  0126	!
;	  0127	!        NMX$CREATE_CIRCUIT  (NMXPIX, NAME_PTR, FLAGS, NMXID);
;	  0128	!        NMX$CREATE_LINE
;	  0129	!        NMX$CREATE_MODULE
;	  0130	!
;	  0131	! FORMAL PARAMETERS:
;	  0132	!
;	  0133	!    .IN_TYPE - the type of entity (CIRCUIT, LINE, or MODULE)
;	  0134	!    .IN_PTR  - a pointer to the name string in I-16 format
;	  0135	!    .IN_FLAGS - the flags associated with this entity
;	  0136	!    .OUT_NMXID - the address of where to return NMX's Internal Id
;	  0137	!
;	  0138	! IMPLICIT INPUTS:
;	  0139	!
;	  0140	!	NMXDB items pointing to database entries
;	  0141	!
;	  0142	! IMPLICIT OUTPUTS:
;	  0143	!
;	  0144	!       NMXDB items created
;	  0145	!
;	  0146	! ROUTINE VALUE:
;	  0147	!
;	  0148	!	$true - operation successful
;	  0149	!       $false - operation failed
;	  0150	!
;	  0151	! SIDE EFFECTS:
;	  0152	!
;	  0153	!	None
;	  0154	!--
;	  0155	
;	  0156	    begin
;	  0157	
;	  0158	    map
;	  0159	        IN_TYPE : NMX_TYPE_BLOCK;
;	  0160	
;	  0161	    macro
;	M 0162		$return (VALUE) =
;	M 0163		    begin
;	M 0164	            local STATUS; STATUS = VALUE;
;	M 0165		    MAP$ (.PREVIOUS_MAP);
;	M 0166	            .OUT_NMXID = .NMXID;
;	M 0167		    return .STATUS
;	  0168		    end %;
;	  0169	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   5
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (2)

;	  0170	    local
;	  0171		ID : vector [byt$allocation (17)],
;	  0172		ENTBLK : ref NMX_GENERAL_BLOCK,
;	  0173		NMXID,
;	  0174		PREVIOUS_MAP;
;	  0175	
;	  0176	    bind
;	  0177	        FREE_PTR = byt$ptr (uplit (%char (0))),
;	  0178	        ID_PTR = byt$ptr (ID);
;	  0179	
;	  0180	!
;	  0181	! Copy items from calling process space to ours
;	  0182	!
;	  0183	    if ch$rchar (.IN_PTR) gtru 16 then return $false;
;	  0184	    ch$move ((ch$rchar (.IN_PTR) + 1), .IN_PTR, ID_PTR);
;	  0185	    NMXID = ..OUT_NMXID;
;	  0186	    SMAP$ (PREVIOUS_MAP);
;	  0187	!
;	  0188	! See if an entity currently exists for this creation and if so fail
;	  0189	! the creation otherwise create the data base.
;	  0190	!
;	  0191	
;	  0192	    if (ENTBLK = $NMX_MAP_ENTITY_ID (.IN_TYPE [N$IENT], ID_PTR)) neqa 0
;	  0193	    then
;	  0194	        $return ($false);
;	  0195	
;	  0196	    if (ENTBLK = $NMX_MAP_ENTITY_ID (.IN_TYPE [N$IENT], FREE_PTR)) eqla 0
;	  0197	    then
;	  0198	        $return ($false);
;	  0199	
;	  0200	    ENTBLK [GENERAL_SYSTEM_FLAGS] = .IN_FLAGS;
;	  0201	    ch$copy ((ch$rchar (ID_PTR) + 1), ID_PTR, 0, 17, byt$ptr (ENTBLK [GENERAL_NAME]));
;	  0202	    NMXID = .ENTBLK [GENERAL_ID];
;	  0203	!
;	  0204	! Now Exit
;	  0205	!
;	  0206	    $return ($true)
;	  0207	    end;					! of NMX$$CREATE


						.TITLE	NMXINE
						.IDENT	/X01110/


000000						.PSECT	NMXJMP,  RO 
000000	000137 				$NMCRE::.WORD	137
000002	000000'					.WORD	NMX$$CREATE
000004	000137 				$NMDES::.WORD	137
000006	000000V					.WORD	NMX$$DESTROY
000010	000137 				$NMMID::.WORD	137
000012	000000V					.WORD	NMX$$MODIFY.ID
000014	000137 				$NMMNA::.WORD	137
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   6
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (2)

000016	000000V					.WORD	NMX$$MODIFY.NAME
000020	000137 				$NMMAP::.WORD	137
000022	000000V					.WORD	NMX$$MAP
000024	000137 				$NMGID::.WORD	137
000026	000000V					.WORD	NMX$$OBTAIN
000030	000137 				$NPNAM::.WORD	137
000032	000000V					.WORD	NMX$$PARAMETER.NAME
000034	000137 				$NPOWN::.WORD	137
000036	000000V					.WORD	NMX$$PARAMETER.OWNER
000040	000137 				$NPUSR::.WORD	137
000042	000000V					.WORD	NMX$$PARAMETER.USER



000000						.PSECT	$PLIT$,  RO ,  D  
000000	   000     000 			P.AAA:	.ASCII	<00><00>


						.GLOBL	.CRDAT, KISAR6, NM.ENT


	000000'				FREE.PTR=	    P.AAA


						.SBTTL	NMX$$CREATE
000000						.PSECT	$CODE$,  RO 

000000	162706  000024 			NMX$$CREATE:
						SUB	#24,SP				;					0118
000004	127527  000004  000020 			CMPB	@4(R5),#20			; IN.PTR(.AP.),*			0183
000012	101120 					BHI	3$
000014	005046 					CLR	-(SP)				;					0184
000016	117516  000004 				MOVB	@4(R5),(SP)			; IN.PTR(.AP.),*
000022	005216 					INC	(SP)
000024	016546  000004 				MOV	4(R5),-(SP)			; IN.PTR(.AP.),*
000030	012746  000010 				MOV	#10,-(SP)
000034	060616 					ADD	SP,(SP)				; ID.PTR,*
000036	004767  000000G				JSR	PC,BL$MOV
000042	016566  000010  000006 			MOV	10(R5),6(SP)			; OUT.NMXID(.AP.),*			0185
000050	017603  000006 				MOV	@6(SP),R3			; *,NMXID
000054	016704  000000G				MOV	KISAR6,R4			; *,PREVIOUS.MAP			0186
000060	016500  000002 				MOV	2(R5),R0			; IN.TYPE(.AP.),*			0192
000064	072027  177770 				ASH	#-10,R0
000070	042700  177760 				BIC	#177760,R0
000074	012701  000010 				MOV	#10,R1
000100	060601 					ADD	SP,R1				; ID.PTR,*
000102	004767  000000G				JSR	PC,NM.ENT
000106	010002 					MOV	R0,R2				; *,ENTBLK
000110	001014 					BNE	1$				;					0194
000112	016500  000002 				MOV	2(R5),R0			; IN.TYPE(.AP.),*			0196
000116	072027  177770 				ASH	#-10,R0
000122	042700  177760 				BIC	#177760,R0
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   7
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (2)

000126	012701  000000'				MOV	#FREE.PTR,R1
000132	004767  000000G				JSR	PC,NM.ENT
000136	010002 					MOV	R0,R2				; *,ENTBLK
000140	001010 					BNE	2$
000142	005000 				1$:	CLR	R0				; STATUS				0198
000144	010467  000000G				MOV	R4,KISAR6			; PREVIOUS.MAP,*
000150	010376  000006 				MOV	R3,@6(SP)			; NMXID,*
000154	062706  000006 				ADD	#6,SP				;					0196
000160	000436 					BR	4$				;					0198
000162	116562  000006  000021 		2$:	MOVB	6(R5),21(R2)			; IN.FLAGS(.AP.),*(ENTBLK)		0200
000170	005016 					CLR	(SP)				;					0201
000172	116616  000010 				MOVB	10(SP),(SP)			; ID.PTR,*
000176	005216 					INC	(SP)
000200	012746  000012 				MOV	#12,-(SP)
000204	060616 					ADD	SP,(SP)				; ID.PTR,*
000206	005046 					CLR	-(SP)
000210	012746  000021 				MOV	#21,-(SP)
000214	010246 					MOV	R2,-(SP)			; ENTBLK,*
000216	012746  177773 				MOV	#-5,-(SP)
000222	004767  000000G				JSR	PC,BL$CPY
000226	016203  000022 				MOV	22(R2),R3			; *(ENTBLK),NMXID			0202
000232	012700  000001 				MOV	#1,R0				; *,STATUS				0206
000236	010467  000000G				MOV	R4,KISAR6			; PREVIOUS.MAP,*
000242	010376  000020 				MOV	R3,@20(SP)			; NMXID,*
000246	062706  000020 				ADD	#20,SP				;					0118
000252	000401 					BR	4$				;					0156
000254	005000 				3$:	CLR	R0				;					0118
000256	062706  000024 			4$:	ADD	#24,SP
000262	000207 					RTS	PC
; Routine Size:  90 words,	Routine Base:  $CODE$ + 0000
; Maximum stack depth per invocation:  19 words


;	  0208	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   8
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (3)

;	  0209	routine NMX$$DESTROY (IN_TYPE, IN_PTR) : CALL$ = 	! NMX$DESTROY
;	  0210	
;	  0211	!++
;	  0212	! FUNCTIONAL DESCRIPTION:
;	  0213	!
;	  0214	!    NMX$$DESTROY invalidates an NMX entity database.
;	  0215	!    This routine is called from the following interprocess
;	  0216	!    synchronous calls:
;	  0217	!
;	  0218	!        NMX$DESTROY_CIRCUIT  (NMXPIX, NAME_PTR);
;	  0219	!        NMX$DESTROY_LINE
;	  0220	!        NMX$DESTROY_MODULE
;	  0221	!
;	  0222	! FORMAL PARAMETERS:
;	  0223	!
;	  0224	!    .IN_TYPE - the type of entity (CIRCUIT, LINE, or MODULE)
;	  0225	!    .IN_PTR  - a pointer to the name string in I-16 format
;	  0226	!
;	  0227	! IMPLICIT INPUTS:
;	  0228	!
;	  0229	!	NMXDB items pointing to database entries
;	  0230	!
;	  0231	! IMPLICIT OUTPUTS:
;	  0232	!
;	  0233	!       NMXDB items created
;	  0234	!
;	  0235	! ROUTINE VALUE:
;	  0236	!
;	  0237	!	$true - operation successful
;	  0238	!       $false - operation failed
;	  0239	!
;	  0240	! SIDE EFFECTS:
;	  0241	!
;	  0242	!	None
;	  0243	!--
;	  0244	
;	  0245	    begin
;	  0246	
;	  0247	    map
;	  0248	        IN_TYPE : NMX_TYPE_BLOCK;
;	  0249	
;	  0250	    macro
;	M 0251		$return (VALUE) =
;	M 0252		    begin
;	M 0253	            local STATUS; STATUS = VALUE;
;	M 0254		    MAP$ (.PREVIOUS_MAP);
;	M 0255		    return .STATUS
;	  0256		    end %;
;	  0257	
;	  0258	    local
;	  0259		ID : vector [byt$allocation (17)],
;	  0260		ENTBLK : ref NMX_GENERAL_BLOCK,
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page   9
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (3)

;	  0261		PREVIOUS_MAP;
;	  0262	
;	  0263	    bind
;	  0264	        ID_PTR = byt$ptr (ID);
;	  0265	
;	  0266	!
;	  0267	! Copy items from calling process space to ours
;	  0268	!
;	  0269	    if ch$rchar (.IN_PTR) gtru 16 then return $false;
;	  0270	    ch$move ((ch$rchar (.IN_PTR) + 1), .IN_PTR, ID_PTR);
;	  0271	    SMAP$ (PREVIOUS_MAP);
;	  0272	!
;	  0273	! See if an entity currently exists; if it doesn't return failure else
;	  0274	! invalidate the entity.
;	  0275	!
;	  0276	    if (ENTBLK = $NMX_MAP_ENTITY_ID (.IN_TYPE [N$IENT], ID_PTR)) eqla 0
;	  0277	    then
;	  0278		$return ($false);
;	  0279	
;	  0280	!
;	  0281	! Release the block by zeroing the ID length.
;	  0282	!
;	  0283	    ch$wchar (0, byt$ptr (ENTBLK [GENERAL_NAME]));
;	  0284	!
;	  0285	! Now Exit
;	  0286	!
;	  0287	    $return ($true)
;	  0288	    end;					! of NMX$$DESTROY


						.SBTTL	NMX$$DESTROY
000000	162706  000022 			NMX$$DESTROY:
						SUB	#22,SP				;					0209
000004	127527  000004  000020 			CMPB	@4(R5),#20			; IN.PTR(.AP.),*			0269
000012	101051 					BHI	2$
000014	005046 					CLR	-(SP)				;					0270
000016	117516  000004 				MOVB	@4(R5),(SP)			; IN.PTR(.AP.),*
000022	005216 					INC	(SP)
000024	016546  000004 				MOV	4(R5),-(SP)			; IN.PTR(.AP.),*
000030	012746  000006 				MOV	#6,-(SP)
000034	060616 					ADD	SP,(SP)				; ID.PTR,*
000036	004767  000000G				JSR	PC,BL$MOV
000042	016702  000000G				MOV	KISAR6,R2			; *,PREVIOUS.MAP			0271
000046	016500  000002 				MOV	2(R5),R0			; IN.TYPE(.AP.),*			0276
000052	072027  177770 				ASH	#-10,R0
000056	042700  177760 				BIC	#177760,R0
000062	012701  000006 				MOV	#6,R1
000066	060601 					ADD	SP,R1				; ID.PTR,*
000070	004767  000000G				JSR	PC,NM.ENT
000074	005700 					TST	R0				; ENTBLK
000076	001007 					BNE	1$
000100	005001 					CLR	R1				; STATUS				0278
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  10
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (3)

000102	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000106	062706  000006 				ADD	#6,SP				;					0276
000112	010100 					MOV	R1,R0				; STATUS,*				0278
000114	000411 					BR	3$
000116	105010 				1$:	CLRB	(R0)				; ENTBLK				0283
000120	012700  000001 				MOV	#1,R0				; *,STATUS				0287
000124	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000130	062706  000006 				ADD	#6,SP				;					0209
000134	000401 					BR	3$				;					0245
000136	005000 				2$:	CLR	R0				;					0209
000140	062706  000022 			3$:	ADD	#22,SP
000144	000207 					RTS	PC
; Routine Size:  51 words,	Routine Base:  $CODE$ + 0264
; Maximum stack depth per invocation:  13 words


;	  0289	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  11
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (4)

;	  0290	routine NMX$$MAP (IN_NMXID, OUT_TYPE, OUT_PTR) : CALL$ = 	! NMX$MAP functions
;	  0291	
;	  0292	!++
;	  0293	! FUNCTIONAL DESCRIPTION:
;	  0294	!
;	  0295	!    NMX$$MAP maps the NMXID back to the type and string.
;	  0296	!    This routine is called from the following interprocess
;	  0297	!    synchronous calls:
;	  0298	!
;	  0299	!        NMX$MAP_NMXID (NMXPIX, NMXID, TYPE, NAME_PTR);
;	  0300	!
;	  0301	! FORMAL PARAMETERS:
;	  0302	!
;	  0303	!    .IN_NMXID - NMX's Internal Id
;	  0304	!    .OUT_TYPE - address of where to store the NMX_TYPE fields
;	  0305	!    .OUT_PTR - pointer to where to store the Id string (must be 17 bytes long)
;	  0306	!
;	  0307	!
;	  0308	! IMPLICIT INPUTS:
;	  0309	!
;	  0310	!	NMXDB items pointing to database entries
;	  0311	!
;	  0312	! IMPLICIT OUTPUTS:
;	  0313	!
;	  0314	!       NMXDB items created
;	  0315	!
;	  0316	! ROUTINE VALUE:
;	  0317	!
;	  0318	!	$true - operation successful
;	  0319	!       $false - operation failed
;	  0320	!
;	  0321	! SIDE EFFECTS:
;	  0322	!
;	  0323	!	None
;	  0324	!--
;	  0325	
;	  0326	    begin
;	  0327	
;	  0328	    macro
;	M 0329		$return (VALUE) =
;	M 0330		    begin
;	M 0331	            local STATUS; STATUS = VALUE;
;	M 0332		    MAP$ (.PREVIOUS_MAP);
;	M 0333		    return .STATUS
;	  0334		    end %;
;	  0335	
;	  0336	    map
;	  0337		OUT_TYPE : ref NMX_TYPE_BLOCK;
;	  0338	
;	  0339	    local
;	  0340		ID : vector [byt$allocation (17)],
;	  0341		ENTBLK : ref NMX_GENERAL_BLOCK,
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  12
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (4)

;	  0342		PREVIOUS_MAP;
;	  0343	
;	  0344	    bind
;	  0345	       ID_PTR = byt$ptr (ID);
;	  0346	
;	  0347	!
;	  0348	! Copy items from calling process space to ours
;	  0349	!
;	  0350	    SMAP$ (PREVIOUS_MAP);
;	  0351	!
;	  0352	! Search appropriate data base for entity
;	  0353	!
;	  0354	
;	  0355	    if (ENTBLK = $NMX_MAP_NMXID (.IN_NMXID)) eqla 0
;	  0356	    then
;	  0357		$return ($false);
;	  0358	
;	  0359	!
;	  0360	! Ok, copy the ID string to local storage
;	  0361	!
;	  0362	    ch$move ((.ENTBLK [GENERAL_NAME_LENGTH] + 1), byt$ptr (ENTBLK [GENERAL_NAME]), ID_PTR);
;	  0363	!
;	  0364	! Now Exit and return information
;	  0365	!
;	  0366	    MAP$ (.PREVIOUS_MAP);
;	  0367	    OUT_TYPE [N$IENT] = .IN_NMXID<8, 8, 0>;
;	  0368	    ch$move ((ch$rchar (ID_PTR) + 1), ID_PTR, .OUT_PTR);
;	  0369	    $true
;	  0370	    end;					! of NMX$$MAP


						.GLOBL	NM.NMX


						.SBTTL	NMX$$MAP
000000	162706  000022 			NMX$$MAP:
						SUB	#22,SP				;					0290
000004	016702  000000G				MOV	KISAR6,R2			; *,PREVIOUS.MAP			0350
000010	016501  000002 				MOV	2(R5),R1			; IN.NMXID(.AP.),*			0355
000014	004767  000000G				JSR	PC,NM.NMX
000020	005700 					TST	R0				; ENTBLK
000022	001005 					BNE	1$
000024	005001 					CLR	R1				; STATUS				0357
000026	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000032	010100 					MOV	R1,R0				; STATUS,*
000034	000445 					BR	2$
000036	111001 				1$:	MOVB	(R0),R1				; ENTBLK,*				0362
000040	010146 					MOV	R1,-(SP)
000042	005216 					INC	(SP)
000044	010046 					MOV	R0,-(SP)			; ENTBLK,*
000046	012746  000006 				MOV	#6,-(SP)
000052	060616 					ADD	SP,(SP)				; ID.PTR,*
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  13
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (4)

000054	004767  000000G				JSR	PC,BL$MOV
000060	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*			0366
000064	116500  000003 				MOVB	3(R5),R0			; IN.NMXID(.AP.),*			0367
000070	072027  000010 				ASH	#10,R0
000074	042700  170377 				BIC	#170377,R0
000100	042775  007400  000004 			BIC	#7400,@4(R5)			; *,OUT.TYPE(.AP.)
000106	050075  000004 				BIS	R0,@4(R5)			; *,OUT.TYPE(.AP.)
000112	005016 					CLR	(SP)				;					0368
000114	116616  000006 				MOVB	6(SP),(SP)			; ID.PTR,*
000120	005216 					INC	(SP)
000122	012746  000010 				MOV	#10,-(SP)
000126	060616 					ADD	SP,(SP)				; ID.PTR,*
000130	016546  000006 				MOV	6(R5),-(SP)			; OUT.PTR(.AP.),*
000134	004767  000000G				JSR	PC,BL$MOV
000140	062706  000012 				ADD	#12,SP				;					0326
000144	012700  000001 				MOV	#1,R0				;					0290
000150	062706  000022 			2$:	ADD	#22,SP
000154	000207 					RTS	PC
; Routine Size:  55 words,	Routine Base:  $CODE$ + 0432
; Maximum stack depth per invocation:  15 words


;	  0371	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  14
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (5)

;	  0372	routine NMX$$MODIFY_ID (IN_TYPE, IN_PTR, IN_ID, OUT_NMXID) : CALL$ = 	! NMX$MODIFY id
;	  0373	
;	  0374	!++
;	  0375	! FUNCTIONAL DESCRIPTION:
;	  0376	!
;	  0377	!    NMX$$MODIFY_ID modifies an NMX entity data base entry.
;	  0378	!    This routine is called from the following interprocess
;	  0379	!    synchronous calls:
;	  0380	!
;	  0381	!        NMX$MODIFY_CIRCUIT_{OWNER or PROVIDER}  (NMXPIX, NAME_PTR, ID, NMXID);
;	  0382	!        NMX$MODIFY_LINE
;	  0383	!        NMX$MODIFY_MODULE
;	  0384	!
;	  0385	! FORMAL PARAMETERS:
;	  0386	!
;	  0387	!    .IN_TYPE - the type of entity (CIRCUIT, LINE, or MODULE)
;	  0388	!                                  and ID (OWNER or PROVIDER)
;	  0389	!    .IN_PTR  - a pointer to the name string in I-16 format
;	  0390	!    .IN_ID  - the ID to put in NMX's data base
;	  0391	!    .OUT_NMXID - the address of where to return NMX's ID for this entity
;	  0392	!
;	  0393	! IMPLICIT INPUTS:
;	  0394	!
;	  0395	!	NMXDB items pointing to database entries
;	  0396	!
;	  0397	! IMPLICIT OUTPUTS:
;	  0398	!
;	  0399	!       NMXDB items created
;	  0400	!
;	  0401	! ROUTINE VALUE:
;	  0402	!
;	  0403	!	$true - operation successful
;	  0404	!       $false - operation failed
;	  0405	!
;	  0406	! SIDE EFFECTS:
;	  0407	!
;	  0408	!	None
;	  0409	!--
;	  0410	
;	  0411	    begin
;	  0412	
;	  0413	    map
;	  0414	        IN_TYPE : NMX_TYPE_BLOCK;
;	  0415	
;	  0416	    macro
;	M 0417		$return (VALUE) =
;	M 0418		    begin
;	M 0419	            local STATUS; STATUS = VALUE;
;	M 0420		    MAP$ (.PREVIOUS_MAP);
;	M 0421	            .OUT_NMXID = .NMXID;
;	M 0422		    return .STATUS
;	  0423		    end %;
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  15
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (5)

;	  0424	
;	  0425	    local
;	  0426		ID : vector [byt$allocation (17)],
;	  0427		EID,
;	  0428		ENTBLK : ref block field (NMX_GENERAL_FIELDS, NMX_LINK_FIELDS, NMX_CIRCUIT_FIELDS, NMX_LINE_FIELDS, NMX_MODULE_FIE
;	  0429		NMXID,
;	  0430		PREVIOUS_MAP;
;	  0431	
;	  0432	    bind
;	  0433	       ID_PTR = byt$ptr (ID);
;	  0434	
;	  0435	!
;	  0436	! Copy items from calling process space to ours
;	  0437	!
;	  0438	    if ch$rchar (.IN_PTR) gtru 16 then return $false;
;	  0439	    ch$move ((ch$rchar (.IN_PTR) + 1), .IN_PTR, ID_PTR);
;	  0440	    EID = .IN_ID;
;	  0441	    NMXID = ..OUT_NMXID;
;	  0442	    SMAP$ (PREVIOUS_MAP);
;	  0443	!
;	  0444	! See if an entity currently exists; if it doesn't return failure else
;	  0445	! update the requested item.
;	  0446	!
;	  0447	    if (ENTBLK = $NMX_MAP_ENTITY_ID (.IN_TYPE [N$IENT], ID_PTR)) eqla 0
;	  0448	    then
;	  0449		$return ($false);
;	  0450	
;	  0451	!
;	  0452	! We now have the entity update according to requested item
;	  0453	!
;	  0454	
;	  0455	    case .IN_TYPE [N$FFNC] from NMX$ID_lo to NMX$ID_hi of
;	  0456		set
;	  0457	
;	  0458		[NMX$ID_owner] :
;	  0459		    begin
;	  0460	
;	  0461		    if (.IN_TYPE [N$IENT] eql NMX$ENT_ckt) or (.IN_TYPE [N$IENT] eql NMX$ENT_lin)
;	  0462		    then
;	  0463	
;	  0464			if .ENTBLK [LINK_LUN_BLOCK] eql 0 then ENTBLK [LINK_USER_ID] = .EID;
;	  0465	
;	  0466		    ENTBLK [GENERAL_OWNER_ID] = .EID;
;	  0467		    end;
;	  0468	
;	  0469		[NMX$ID_provider] :
;	  0470		    ENTBLK [GENERAL_PROVIDER_ID] = .EID;
;	  0471	
;	  0472		[inrange, outrange] :
;	  0473		    $return ($false);
;	  0474		tes;
;	  0475	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  16
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (5)

;	  0476	    NMXID = .ENTBLK [GENERAL_ID];
;	  0477	!
;	  0478	! Now Exit
;	  0479	!
;	  0480	    $return ($true)
;	  0481	    end;					! of NMX$$MODIFY_ID


						.SBTTL	NMX$$MODIFY.ID
000000	162706  000026 			NMX$$MODIFY.ID:
						SUB	#26,SP				;					0372
000004	127527  000004  000020 			CMPB	@4(R5),#20			; IN.PTR(.AP.),*			0438
000012	101125 					BHI	7$
000014	005046 					CLR	-(SP)				;					0439
000016	117516  000004 				MOVB	@4(R5),(SP)			; IN.PTR(.AP.),*
000022	005216 					INC	(SP)
000024	016546  000004 				MOV	4(R5),-(SP)			; IN.PTR(.AP.),*
000030	012746  000012 				MOV	#12,-(SP)
000034	060616 					ADD	SP,(SP)				; ID.PTR,*
000036	004767  000000G				JSR	PC,BL$MOV
000042	016504  000006 				MOV	6(R5),R4			; IN.ID(.AP.),EID			0440
000046	016566  000010  000010 			MOV	10(R5),10(SP)			; OUT.NMXID(.AP.),*			0441
000054	017603  000010 				MOV	@10(SP),R3			; *,NMXID
000060	016766  000000G 000006 			MOV	KISAR6,6(SP)			; *,PREVIOUS.MAP			0442
000066	016502  000002 				MOV	2(R5),R2			; IN.TYPE(.AP.),*			0447
000072	072227  177770 				ASH	#-10,R2
000076	042702  177760 				BIC	#177760,R2
000102	012701  000012 				MOV	#12,R1
000106	060601 					ADD	SP,R1				; ID.PTR,*
000110	010200 					MOV	R2,R0
000112	004767  000000G				JSR	PC,NM.ENT
000116	005700 					TST	R0				; ENTBLK
000120	001414 					BEQ	1$				;					0449
000122	116501  000002 				MOVB	2(R5),R1			; IN.TYPE(.AP.),*			0455
000126	006201 					ASR	R1
000130	042701  177600 				BIC	#177600,R1
000134	005301 					DEC	R1
000136	020127  000001 				CMP	R1,#1
000142	101003 					BHI	1$
000144	006301 					ASL	R1
000146	066107  000002'				ADD	P.AAB(R1),PC			; Case dispatch
000152	005001 				1$:	CLR	R1				; STATUS				0473
000154	016667  000006  000000G			MOV	6(SP),KISAR6			; PREVIOUS.MAP,*
000162	010376  000010 				MOV	R3,@10(SP)			; NMXID,*
000166	062706  000006 				ADD	#6,SP				;					0455
000172	010100 					MOV	R1,R0				; STATUS,*				0473
000174	000435 					BR	8$
000176	020227  000004 			2$:	CMP	R2,#4				;					0461
000202	001403 					BEQ	3$
000204	020227  000002 				CMP	R2,#2
000210	001005 					BNE	4$
000212	005760  000032 			3$:	TST	32(R0)				; *(ENTBLK)				0464
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  17
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (5)

000216	001002 					BNE	4$
000220	010460  000030 				MOV	R4,30(R0)			; EID,*(ENTBLK)
000224	010460  000026 			4$:	MOV	R4,26(R0)			; EID,*(ENTBLK)				0466
000230	000402 					BR	6$				;					0455
000232	010460  000024 			5$:	MOV	R4,24(R0)			; EID,*(ENTBLK)				0470
000236	016003  000022 			6$:	MOV	22(R0),R3			; *(ENTBLK),NMXID			0476
000242	012700  000001 				MOV	#1,R0				; *,STATUS				0480
000246	016667  000006  000000G			MOV	6(SP),KISAR6			; PREVIOUS.MAP,*
000254	010376  000010 				MOV	R3,@10(SP)			; NMXID,*
000260	062706  000006 				ADD	#6,SP				;					0372
000264	000401 					BR	8$				;					0411
000266	005000 				7$:	CLR	R0				;					0372
000270	062706  000026 			8$:	ADD	#26,SP
000274	000207 					RTS	PC
; Routine Size:  95 words,	Routine Base:  $CODE$ + 0610
; Maximum stack depth per invocation:  15 words


000002						.PSECT	$PLIT$,  RO ,  D  

					P.AAB:						; CASE Table for NMX$$MODIFY.ID+0146	0455
000002	000024 					.WORD	24				; [2$]
000004	000060 					.WORD	60				; [5$]



;	  0482	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  18
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (6)

;	  0483	routine NMX$$MODIFY_NAME (IN_TYPE, IN_PTR, IN_NEW, OUT_NMXID) : CALL$ = 	! NMX$MODIFY name
;	  0484	
;	  0485	!++
;	  0486	! FUNCTIONAL DESCRIPTION:
;	  0487	!
;	  0488	!    NMX$$MODIFY_NAME modifies the name of an entity without affecting
;	  0489	!    any other items in that data base.
;	  0490	!    This routine is called from the following interprocess
;	  0491	!    synchronous calls:
;	  0492	!
;	  0493	!        NMX$MODIFY_CIRCUIT_NAME  (NMXPIX, NAME_PTR, NEW_PTR, NMXID);
;	  0494	!        NMX$MODIFY_LINE_NAME
;	  0495	!        NMX$MODIFY_MODULE_NAME
;	  0496	!
;	  0497	! FORMAL PARAMETERS:
;	  0498	!
;	  0499	!    .IN_TYPE - the type of entity (CIRCUIT, LINE, or MODULE)
;	  0500	!    .IN_PTR  - a pointer to the name string in I-16 format
;	  0501	!    .IN_NEW  - a pointer to the new name string in I-16 format
;	  0502	!    .OUT_NMXID - address of where to return NMX's Internal Id
;	  0503	!
;	  0504	! IMPLICIT INPUTS:
;	  0505	!
;	  0506	!	NMXDB items pointing to database entries
;	  0507	!
;	  0508	! IMPLICIT OUTPUTS:
;	  0509	!
;	  0510	!       NMXDB items created
;	  0511	!
;	  0512	! ROUTINE VALUE:
;	  0513	!
;	  0514	!	$true - operation successful
;	  0515	!       $false - operation failed
;	  0516	!
;	  0517	! SIDE EFFECTS:
;	  0518	!
;	  0519	!	None
;	  0520	!--
;	  0521	
;	  0522	    begin
;	  0523	
;	  0524	    map
;	  0525	        IN_TYPE : NMX_TYPE_BLOCK;
;	  0526	
;	  0527	    macro
;	M 0528		$return (VALUE) =
;	M 0529		    begin
;	M 0530	            local STATUS; STATUS = VALUE;
;	M 0531		    MAP$ (.PREVIOUS_MAP);
;	M 0532	            .OUT_NMXID = .NMXID;
;	M 0533		    return .STATUS
;	  0534		    end %;
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  19
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (6)

;	  0535	
;	  0536	    local
;	  0537		OLD_ID : vector [byt$allocation (17)],
;	  0538		NEW_ID : vector [byt$allocation (17)],
;	  0539		ENTBLK : ref NMX_GENERAL_BLOCK,
;	  0540		NMXID,
;	  0541		PREVIOUS_MAP;
;	  0542	
;	  0543	    bind
;	  0544	       OLD_ID_PTR = byt$ptr (OLD_ID),
;	  0545	       NEW_ID_PTR = byt$ptr (NEW_ID);
;	  0546	
;	  0547	!
;	  0548	! Copy items from calling process space to ours
;	  0549	!
;	  0550	    if ch$rchar (.IN_PTR) gtru 16 then return $false;
;	  0551	    ch$move ((ch$rchar (.IN_PTR) + 1), .IN_PTR, OLD_ID_PTR);
;	  0552	    if ch$rchar (.IN_NEW) gtru 16 then return $false;
;	  0553	    ch$move ((ch$rchar (.IN_NEW) + 1), .IN_NEW, NEW_ID_PTR);
;	  0554	    NMXID = ..OUT_NMXID;
;	  0555	    SMAP$ (PREVIOUS_MAP);
;	  0556	!
;	  0557	! See if an entity currently exists; if it doesn't return failure else
;	  0558	! update the name.
;	  0559	!
;	  0560	    if (ENTBLK = $NMX_MAP_ENTITY_ID (.IN_TYPE [N$IENT], OLD_ID_PTR)) eqla 0
;	  0561	    then
;	  0562		$return ($false);
;	  0563	
;	  0564	!
;	  0565	! We now have the entity update the name
;	  0566	!
;	  0567	    ch$copy ((ch$rchar (NEW_ID_PTR) + 1), NEW_ID_PTR, 0, 17, byt$ptr (ENTBLK [GENERAL_NAME]));
;	  0568	    NMXID = .ENTBLK [GENERAL_ID];
;	  0569	!
;	  0570	! Now Exit
;	  0571	!
;	  0572	    $return ($true)
;	  0573	    end;					! of NMX$$MODIFY_NAME


						.SBTTL	NMX$$MODIFY.NAME
001106						.PSECT	$CODE$,  RO 

000000	162706  000044 			NMX$$MODIFY.NAME:
						SUB	#44,SP				;					0483
000004	127527  000004  000020 			CMPB	@4(R5),#20			; IN.PTR(.AP.),*			0550
000012	101117 					BHI	3$
000014	005046 					CLR	-(SP)				;					0551
000016	117516  000004 				MOVB	@4(R5),(SP)			; IN.PTR(.AP.),*
000022	005216 					INC	(SP)
000024	016546  000004 				MOV	4(R5),-(SP)			; IN.PTR(.AP.),*
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  20
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (6)

000030	012746  000030 				MOV	#30,-(SP)
000034	060616 					ADD	SP,(SP)				; OLD.ID.PTR,*
000036	004767  000000G				JSR	PC,BL$MOV
000042	127527  000006  000020 			CMPB	@6(R5),#20			; IN.NEW(.AP.),*			0552
000050	101403 					BLOS	1$
000052	062706  000006 				ADD	#6,SP
000056	000475 					BR	3$
000060	005016 				1$:	CLR	(SP)				;					0553
000062	117516  000006 				MOVB	@6(R5),(SP)			; IN.NEW(.AP.),*
000066	005216 					INC	(SP)
000070	016546  000006 				MOV	6(R5),-(SP)			; IN.NEW(.AP.),*
000074	012746  000012 				MOV	#12,-(SP)
000100	060616 					ADD	SP,(SP)				; NEW.ID.PTR,*
000102	004767  000000G				JSR	PC,BL$MOV
000106	016504  000010 				MOV	10(R5),R4			; OUT.NMXID(.AP.),*			0554
000112	011402 					MOV	(R4),R2				; *,NMXID
000114	016703  000000G				MOV	KISAR6,R3			; *,PREVIOUS.MAP			0555
000120	016500  000002 				MOV	2(R5),R0			; IN.TYPE(.AP.),*			0560
000124	072027  177770 				ASH	#-10,R0
000130	042700  177760 				BIC	#177760,R0
000134	012701  000034 				MOV	#34,R1
000140	060601 					ADD	SP,R1				; OLD.ID.PTR,*
000142	004767  000000G				JSR	PC,NM.ENT
000146	010001 					MOV	R0,R1				; *,ENTBLK
000150	001007 					BNE	2$
000152	005000 					CLR	R0				; STATUS				0562
000154	010367  000000G				MOV	R3,KISAR6			; PREVIOUS.MAP,*
000160	010214 					MOV	R2,(R4)				; NMXID,*
000162	062706  000012 				ADD	#12,SP				;					0560
000166	000432 					BR	4$				;					0562
000170	005016 				2$:	CLR	(SP)				;					0567
000172	116616  000012 				MOVB	12(SP),(SP)			; NEW.ID.PTR,*
000176	005216 					INC	(SP)
000200	012746  000014 				MOV	#14,-(SP)
000204	060616 					ADD	SP,(SP)				; NEW.ID.PTR,*
000206	005046 					CLR	-(SP)
000210	012746  000021 				MOV	#21,-(SP)
000214	010146 					MOV	R1,-(SP)			; ENTBLK,*
000216	012746  177773 				MOV	#-5,-(SP)
000222	004767  000000G				JSR	PC,BL$CPY
000226	016102  000022 				MOV	22(R1),R2			; *(ENTBLK),NMXID			0568
000232	012700  000001 				MOV	#1,R0				; *,STATUS				0572
000236	010367  000000G				MOV	R3,KISAR6			; PREVIOUS.MAP,*
000242	010214 					MOV	R2,(R4)				; NMXID,*
000244	062706  000024 				ADD	#24,SP				;					0483
000250	000401 					BR	4$				;					0522
000252	005000 				3$:	CLR	R0				;					0483
000254	062706  000044 			4$:	ADD	#44,SP
000260	000207 					RTS	PC
; Routine Size:  89 words,	Routine Base:  $CODE$ + 1106
; Maximum stack depth per invocation:  29 words
;	  0574	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  21
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (7)

;	  0575	routine NMX$$OBTAIN (IN_TYPE, IN_PTR, OUT_ID, OUT_NMXID) : CALL$ = 	! NMX$OBTAIN functions
;	  0576	
;	  0577	!++
;	  0578	! FUNCTIONAL DESCRIPTION:
;	  0579	!
;	  0580	!    NMX$$OBTAIN is called to obtain IDs from the Entity Data bases.
;	  0581	!    This routine is called from the following interprocess
;	  0582	!    synchronous calls:
;	  0583	!
;	  0584	!        NMX$OBTAIN_CIRCUIT_OWNER (NMXPIX, TYPE, NAME_PTR, OWNER_ID, NMXID);
;	  0585	!                   LINE    PROVIDER                       PROVIDER_ID
;	  0586	!                   MODULE
;	  0587	!
;	  0588	! FORMAL PARAMETERS:
;	  0589	!
;	  0590	!    .IN_TYPE - The NMX_TYPE fields
;	  0591	!    .IN_PTR - pointer to the Id string
;	  0592	!    .OUT_ID - points to where the returned OWNER or PROVIDER ID is stored
;	  0593	!    .OUT_NMXID - points to where the returned NMX Internal Id is stored
;	  0594	!
;	  0595	!
;	  0596	! IMPLICIT INPUTS:
;	  0597	!
;	  0598	!	NMXDB items pointing to database entries
;	  0599	!
;	  0600	! IMPLICIT OUTPUTS:
;	  0601	!
;	  0602	!       NMXDB items created
;	  0603	!
;	  0604	! ROUTINE VALUE:
;	  0605	!
;	  0606	!	$true - operation successful
;	  0607	!       $false - operation failed
;	  0608	!
;	  0609	! SIDE EFFECTS:
;	  0610	!
;	  0611	!	None
;	  0612	!--
;	  0613	
;	  0614	    begin
;	  0615	
;	  0616	    map
;	  0617	        IN_TYPE : NMX_TYPE_BLOCK;
;	  0618	
;	  0619	    macro
;	M 0620		$return (VALUE) =
;	M 0621		    begin
;	M 0622	            local STATUS; STATUS = VALUE;
;	M 0623		    MAP$ (.PREVIOUS_MAP);
;	M 0624		    return .STATUS
;	  0625		    end %;
;	  0626	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  22
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (7)

;	  0627	    local
;	  0628		ID : vector [byt$allocation (17)],
;	  0629		NMXID,
;	  0630		ENTITY_ID,
;	  0631		ENTBLK : ref NMX_GENERAL_BLOCK,
;	  0632		PREVIOUS_MAP;
;	  0633	
;	  0634	    bind
;	  0635	        ID_PTR = byt$ptr (ID);
;	  0636	
;	  0637	!
;	  0638	! Copy items from calling process space to ours
;	  0639	!
;	  0640	    if ch$rchar (.IN_PTR) gtru 16 then return $false;
;	  0641	    ch$move ((ch$rchar (.IN_PTR) + 1), .IN_PTR, ID_PTR);
;	  0642	    SMAP$ (PREVIOUS_MAP);
;	  0643	!
;	  0644	! Search appropriate data base for entity
;	  0645	!
;	  0646	
;	  0647	    if (ENTBLK = $NMX_MAP_ENTITY_ID (.IN_TYPE [N$IENT], ID_PTR)) eqla 0
;	  0648	    then
;	  0649		$return ($false);
;	  0650	
;	  0651	!
;	  0652	! We now have the entity update according to requested item
;	  0653	!
;	  0654	
;	  0655	    case .IN_TYPE [N$FFNC] from NMX$ID_lo to NMX$ID_hi of
;	  0656		set
;	  0657	
;	  0658		[NMX$ID_owner] :
;	  0659		    ENTITY_ID = .ENTBLK [GENERAL_OWNER_ID];
;	  0660	
;	  0661		[NMX$ID_provider] :
;	  0662		    ENTITY_ID = .ENTBLK [GENERAL_PROVIDER_ID];
;	  0663	
;	  0664		[inrange, outrange] :
;	  0665		    $return ($false);
;	  0666		tes;
;	  0667	
;	  0668	    NMXID = .ENTBLK [GENERAL_ID];
;	  0669	!
;	  0670	! Now Exit and return information
;	  0671	!
;	  0672	    MAP$ (.PREVIOUS_MAP);
;	  0673	    .OUT_ID = .ENTITY_ID;
;	  0674	    .OUT_NMXID = .NMXID;
;	  0675	    $true
;	  0676	    end;					! of NMX$$OBTAIN
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  23
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (7)

						.SBTTL	NMX$$OBTAIN
000000	162706  000022 			NMX$$OBTAIN:
						SUB	#22,SP				;					0575
000004	127527  000004  000020 			CMPB	@4(R5),#20			; IN.PTR(.AP.),*			0640
000012	101402 					BLOS	1$
000014	005000 					CLR	R0
000016	000476 					BR	6$
000020	005046 				1$:	CLR	-(SP)				;					0641
000022	117516  000004 				MOVB	@4(R5),(SP)			; IN.PTR(.AP.),*
000026	005216 					INC	(SP)
000030	016546  000004 				MOV	4(R5),-(SP)			; IN.PTR(.AP.),*
000034	012746  000006 				MOV	#6,-(SP)
000040	060616 					ADD	SP,(SP)				; ID.PTR,*
000042	004767  000000G				JSR	PC,BL$MOV
000046	016702  000000G				MOV	KISAR6,R2			; *,PREVIOUS.MAP			0642
000052	016500  000002 				MOV	2(R5),R0			; IN.TYPE(.AP.),*			0647
000056	072027  177770 				ASH	#-10,R0
000062	042700  177760 				BIC	#177760,R0
000066	012701  000006 				MOV	#6,R1
000072	060601 					ADD	SP,R1				; ID.PTR,*
000074	004767  000000G				JSR	PC,NM.ENT
000100	005700 					TST	R0				; ENTBLK
000102	001414 					BEQ	2$				;					0649
000104	116501  000002 				MOVB	2(R5),R1			; IN.TYPE(.AP.),*			0655
000110	006201 					ASR	R1
000112	042701  177600 				BIC	#177600,R1
000116	005301 					DEC	R1
000120	020127  000001 				CMP	R1,#1
000124	101003 					BHI	2$
000126	006301 					ASL	R1
000130	066107  000006'				ADD	P.AAC(R1),PC			; Case dispatch
000134	005001 				2$:	CLR	R1				; STATUS				0665
000136	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000142	062706  000006 				ADD	#6,SP				;					0655
000146	010100 					MOV	R1,R0				; STATUS,*				0665
000150	000421 					BR	6$
000152	016001  000026 			3$:	MOV	26(R0),R1			; *(ENTBLK),ENTITY.ID			0659
000156	000402 					BR	5$				;					0655
000160	016001  000024 			4$:	MOV	24(R0),R1			; *(ENTBLK),ENTITY.ID			0662
000164	016000  000022 			5$:	MOV	22(R0),R0			; *(ENTBLK),NMXID			0668
000170	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*			0672
000174	010175  000006 				MOV	R1,@6(R5)			; ENTITY.ID,OUT.ID(.AP.)		0673
000200	010075  000010 				MOV	R0,@10(R5)			; NMXID,OUT.NMXID(.AP.)			0674
000204	062706  000006 				ADD	#6,SP				;					0614
000210	012700  000001 				MOV	#1,R0				;					0575
000214	062706  000022 			6$:	ADD	#22,SP
000220	000207 					RTS	PC
; Routine Size:  73 words,	Routine Base:  $CODE$ + 1370
; Maximum stack depth per invocation:  13 words


000006						.PSECT	$PLIT$,  RO ,  D  
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  24
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (7)


					P.AAC:						; CASE Table for NMX$$OBTAIN+0130	0655
000006	000016 					.WORD	16				; [3$]
000010	000024 					.WORD	24				; [4$]
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  25
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (8)

;	  0677	routine NMX$$PARAMETER_NAME (IN_TYPE, IN_NMXID, IN_NUM) : CALL$ = 	! NMX$PARAMETER_x
;	  0678	
;	  0679	!++
;	  0680	! FUNCTIONAL DESCRIPTION:
;	  0681	!
;	  0682	!    NMX$$PARAMETER_NAME supplies the entity name for a specified
;	  0683	!    parameter number.  This routine is called from the following
;	  0684	!    interprocess synchronous calls:
;	  0685	!
;	  0686	!        NMX$PARAMETER_CIRCUIT (NMXPIX, NMXID, PRM_NUM);
;	  0687	!                      LINE
;	  0688	!                      MODULE
;	  0689	!
;	  0690	! FORMAL PARAMETERS:
;	  0691	!
;	  0692	!    .IN_TYPE - The NMX_TYPE fields
;	  0693	!    .IN_NMXID - NMX's Internal Id
;	  0694	!    .IN_NUM - The parameter number
;	  0695	!
;	  0696	!
;	  0697	! IMPLICIT INPUTS:
;	  0698	!
;	  0699	!	NMXDB items pointing to database entries
;	  0700	!
;	  0701	! IMPLICIT OUTPUTS:
;	  0702	!
;	  0703	!       NMXDB items created
;	  0704	!
;	  0705	! ROUTINE VALUE:
;	  0706	!
;	  0707	!	$true - operation successful
;	  0708	!       $false - operation failed
;	  0709	!
;	  0710	! SIDE EFFECTS:
;	  0711	!
;	  0712	!	None
;	  0713	!--
;	  0714	
;	  0715	    begin
;	  0716	
;	  0717	    map
;	  0718	        IN_TYPE : NMX_TYPE_BLOCK;
;	  0719	
;	  0720	    macro
;	M 0721		$return (VALUE) =
;	M 0722		    begin
;	M 0723	            local STATUS; STATUS = VALUE;
;	M 0724		    MAP$ (.PREVIOUS_MAP);
;	M 0725		    return .STATUS
;	  0726		    end %;
;	  0727	
;	  0728	    local
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  26
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (8)

;	  0729		ENTBLK : ref NMX_GENERAL_BLOCK,
;	  0730		PREVIOUS_MAP;
;	  0731	
;	  0732	    SMAP$ (PREVIOUS_MAP);
;	  0733	!
;	  0734	! Search appropriate data base for entity
;	  0735	!
;	  0736	
;	  0737	    if (ENTBLK = $NMX_MAP_NMXID (.IN_NMXID)) eqla 0
;	  0738	    then
;	  0739		$return ($false);
;	  0740	
;	  0741	!
;	  0742	! Ok, insert the name as the given parameter
;	  0743	!
;	  0744	    PARAMETER_AI (.IN_NUM, .ENTBLK [GENERAL_NAME_LENGTH], byt$ptr (ENTBLK [GENERAL_NAME], 1));
;	  0745	!
;	  0746	! Now Exit and return information
;	  0747	!
;	  0748	    $return ($true)
;	  0749	    end;					! of NMX$$PARAMETER_NAME


						.GLOBL	$DPAI


						.SBTTL	NMX$$PARAMETER.NAME
001612						.PSECT	$CODE$,  RO 

000000	016703  000000G			NMX$$PARAMETER.NAME:
						MOV	KISAR6,R3			; *,PREVIOUS.MAP			0732
000004	016501  000004 				MOV	4(R5),R1			; IN.NMXID(.AP.),*			0737
000010	004767  000000G				JSR	PC,NM.NMX
000014	010002 					MOV	R0,R2				; *,ENTBLK
000016	001004 					BNE	1$
000020	005000 					CLR	R0				; STATUS				0739
000022	010367  000000G				MOV	R3,KISAR6			; PREVIOUS.MAP,*
000026	000207 					RTS	PC
000030	016546  000006 			1$:	MOV	6(R5),-(SP)			; IN.NUM(.AP.),*			0744
000034	012701  000001 				MOV	#1,R1
000040	060201 					ADD	R2,R1				; ENTBLK,*
000042	111200 					MOVB	(R2),R0				; ENTBLK,*
000044	004767  000000G				JSR	PC,$DPAI
000050	012700  000001 				MOV	#1,R0				; *,STATUS				0748
000054	010367  000000G				MOV	R3,KISAR6			; PREVIOUS.MAP,*
000060	005726 					TST	(SP)+				;					0677
000062	000207 					RTS	PC
; Routine Size:  26 words,	Routine Base:  $CODE$ + 1612
; Maximum stack depth per invocation:  2 words
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  27
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (9)

;	  0750	routine NMX$$PARAMETER_OWNER (IN_TYPE, IN_NMXID, IN_NUM) : CALL$ = 	! NMX$PARAMETER_x_OWNER
;	  0751	
;	  0752	!++
;	  0753	! FUNCTIONAL DESCRIPTION:
;	  0754	!
;	  0755	!    NMX$$PARAMETER_OWNER supplies the entity owner for a specified
;	  0756	!    parameter number.  This routine is called from the following
;	  0757	!    interprocess synchronous calls:
;	  0758	!
;	  0759	!        NMX$PARAMETER_CIRCUIT_OWNER (NMXPIX, NMXID, PRM_NUM);
;	  0760	!
;	  0761	! FORMAL PARAMETERS:
;	  0762	!
;	  0763	!    .IN_TYPE - The NMX_TYPE fields
;	  0764	!    .IN_NMXID - NMX's Internal Id
;	  0765	!    .IN_NUM - The parameter number
;	  0766	!
;	  0767	!
;	  0768	! IMPLICIT INPUTS:
;	  0769	!
;	  0770	!	NMXDB items pointing to database entries
;	  0771	!
;	  0772	! IMPLICIT OUTPUTS:
;	  0773	!
;	  0774	!       NMXDB items created
;	  0775	!
;	  0776	! ROUTINE VALUE:
;	  0777	!
;	  0778	!	$true - operation successful
;	  0779	!       $false - operation failed
;	  0780	!
;	  0781	! SIDE EFFECTS:
;	  0782	!
;	  0783	!	None
;	  0784	!--
;	  0785	
;	  0786	    begin
;	  0787	
;	  0788	    map
;	  0789	        IN_TYPE : NMX_TYPE_BLOCK;
;	  0790	
;	  0791	    macro
;	M 0792		$return (VALUE) =
;	M 0793		    begin
;	M 0794	            local STATUS; STATUS = VALUE;
;	M 0795		    MAP$ (.PREVIOUS_MAP);
;	M 0796		    return .STATUS
;	  0797		    end %;
;	  0798	
;	  0799	    bind
;	  0800		NMXDB = MCB$GAW_PROCESS_DATA_BASE [1] : ref NMXDB_BLOCK;
;	  0801	
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  28
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (9)

;	  0802	    local
;	  0803		ENTBLK : ref NMX_CIRCUIT_BLOCK,
;	  0804		PREVIOUS_MAP;
;	  0805	
;	  0806	    SMAP$ (PREVIOUS_MAP);
;	  0807	!
;	  0808	! Search appropriate data base for entity
;	  0809	!
;	  0810	
;	  0811	    if (ENTBLK = $NMX_MAP_NMXID (.IN_NMXID)) eqla 0
;	  0812	    then
;	  0813		$return ($false);
;	  0814	
;	  0815	!
;	  0816	! Ok, insert the owner as the given parameter
;	  0817	!
;	  0818	
;	  0819	    if .ENTBLK [GENERAL_OWNER_ID] eql 0 then $return ($true);
;	  0820	
;	  0821	    if $true %(owner is Transport)%
;	  0822	    then
;	  0823		begin
;	  0824		PARAMETER_CM (.IN_NUM, 3);
;	  0825	        PARAMETER_C_1 (, uplit (0));    ! Node entity
;	  0826		PARAMETER_DU_2 (, NMXDB [NMX_EXECUTOR_NUMBER]);
;	P 0827		PARAMETER_AI (, .NMXDB [NMX_EXECUTOR_NAME_LENGTH],
;	  0828		    byt$ptr (NMXDB [NMX_EXECUTOR_NAME], 1));
;	  0829		end;
;	  0830	
;	  0831	!
;	  0832	! Now Exit and return information
;	  0833	!
;	  0834	    $return ($true)
;	  0835	    end;					! of NMX$$PARAMETER_OWNER



000012						.PSECT	$PLIT$,  RO ,  D  
000012	000000 				P.AAD:	.WORD	0


						.GLOBL	$DPCM, $TPC1, $TPDU2, $TPAI


						.SBTTL	NMX$$PARAMETER.OWNER
001676						.PSECT	$CODE$,  RO 

000000	016702  000000G			NMX$$PARAMETER.OWNER:
						MOV	KISAR6,R2			; *,PREVIOUS.MAP			0806
000004	016501  000004 				MOV	4(R5),R1			; IN.NMXID(.AP.),*			0811
000010	004767  000000G				JSR	PC,NM.NMX
000014	005700 					TST	R0				; ENTBLK
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  29
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (9)

000016	001005 					BNE	1$
000020	005001 					CLR	R1				; STATUS				0813
000022	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000026	010100 					MOV	R1,R0				; STATUS,*
000030	000207 					RTS	PC
000032	005760  000026 			1$:	TST	26(R0)				; *(ENTBLK)				0819
000036	001005 					BNE	2$
000040	012700  000001 				MOV	#1,R0				; *,STATUS
000044	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000050	000207 					RTS	PC
000052	016546  000006 			2$:	MOV	6(R5),-(SP)			; IN.NUM(.AP.),*			0824
000056	012700  000003 				MOV	#3,R0
000062	004767  000000G				JSR	PC,$DPCM
000066	116700  000012'				MOVB	P.AAD,R0			;					0825
000072	004767  000000G				JSR	PC,$TPC1
000076	016701  000002G				MOV	.CRDAT+2,R1			;					0826
000102	016100  000042 				MOV	42(R1),R0
000106	004767  000000G				JSR	PC,$TPDU2
000112	016705  000002G				MOV	.CRDAT+2,R5			;					0828
000116	012701  000045 				MOV	#45,R1
000122	060501 					ADD	R5,R1
000124	116500  000044 				MOVB	44(R5),R0
000130	004767  000000G				JSR	PC,$TPAI
000134	012700  000001 				MOV	#1,R0				; *,STATUS				0834
000140	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000144	005726 					TST	(SP)+				;					0750
000146	000207 					RTS	PC
; Routine Size:  52 words,	Routine Base:  $CODE$ + 1676
; Maximum stack depth per invocation:  2 words
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  30
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (10)

;	  0836	routine NMX$$PARAMETER_USER (IN_TYPE, IN_NMXID, IN_NUM) : CALL$ = 	! NMX$PARAMETER_x_USER
;	  0837	
;	  0838	!++
;	  0839	! FUNCTIONAL DESCRIPTION:
;	  0840	!
;	  0841	!    NMX$$PARAMETER_USER supplies the entity user for a specified
;	  0842	!    parameter number.  This routine is called from the following
;	  0843	!    interprocess synchronous calls:
;	  0844	!
;	  0845	!        NMX$PARAMETER_CIRCUIT_USER (NMXPIX, NMXID, PRM_NUM);
;	  0846	!
;	  0847	! FORMAL PARAMETERS:
;	  0848	!
;	  0849	!    .IN_TYPE - The NMX_TYPE fields
;	  0850	!    .IN_NMXID - NMX's Internal Id
;	  0851	!    .IN_NUM - The parameter number
;	  0852	!
;	  0853	!
;	  0854	! IMPLICIT INPUTS:
;	  0855	!
;	  0856	!	NMXDB items pointing to database entries
;	  0857	!
;	  0858	! IMPLICIT OUTPUTS:
;	  0859	!
;	  0860	!       NMXDB items created
;	  0861	!
;	  0862	! ROUTINE VALUE:
;	  0863	!
;	  0864	!	$true - operation successful
;	  0865	!       $false - operation failed
;	  0866	!
;	  0867	! SIDE EFFECTS:
;	  0868	!
;	  0869	!	None
;	  0870	!--
;	  0871	
;	  0872	    begin
;	  0873	
;	  0874	    map
;	  0875	        IN_TYPE : NMX_TYPE_BLOCK;
;	  0876	
;	  0877	    literal
;	  0878	        LINK_ON = 0,
;	  0879	        LINK_OFF = 1,
;	  0880	        LINK_SERVICE = 2,
;	  0881	        LINK_CLEARED = 3;
;	  0882	
;	  0883	    macro
;	M 0884		$return (VALUE) =
;	M 0885		    begin
;	M 0886	            local STATUS; STATUS = VALUE;
;	M 0887		    MAP$ (.PREVIOUS_MAP);
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  31
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (10)

;	M 0888		    return .STATUS
;	  0889		    end %;
;	  0890	
;	  0891	    bind
;	  0892		NMXDB = MCB$GAW_PROCESS_DATA_BASE [1] : ref NMXDB_BLOCK;
;	  0893	
;	  0894	    local
;	  0895		ENTBLK : ref NMX_CIRCUIT_BLOCK,
;	  0896		PREVIOUS_MAP;
;	  0897	
;	  0898	    SMAP$ (PREVIOUS_MAP);
;	  0899	!
;	  0900	! Search appropriate data base for entity
;	  0901	!
;	  0902	
;	  0903	    if (ENTBLK = $NMX_MAP_NMXID (.IN_NMXID)) eqla 0
;	  0904	    then
;	  0905		$return ($false);
;	  0906	
;	  0907	!
;	  0908	! Ok, insert the user as the given parameter
;	  0909	!
;	  0910	
;	  0911	    if .ENTBLK [GENERAL_OWNER_ID] eql 0 then $return ($true);
;	  0912	
;	  0913	    if .ENTBLK [LINK_STATE] neq LINK_ON then $return ($true);
;	  0914	
;	  0915	    if $true %(owner is Transport)%
;	  0916	    then
;	  0917		begin
;	  0918		PARAMETER_CM (.IN_NUM, 3);
;	  0919	        PARAMETER_C_1 (, uplit (0));    ! Node entity
;	  0920		PARAMETER_DU_2 (, NMXDB [NMX_EXECUTOR_NUMBER]);
;	P 0921		PARAMETER_AI (, .NMXDB [NMX_EXECUTOR_NAME_LENGTH],
;	  0922		    byt$ptr (NMXDB [NMX_EXECUTOR_NAME], 1));
;	  0923		end;
;	  0924	
;	  0925	!
;	  0926	! Now Exit and return information
;	  0927	!
;	  0928	    $return ($true)
;	  0929	    end;					! of NMX$$PARAMETER_USER



000014						.PSECT	$PLIT$,  RO ,  D  
000014	000000 				P.AAE:	.WORD	0


						.SBTTL	NMX$$PARAMETER.USER
002046						.PSECT	$CODE$,  RO 
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  32
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (10)

000000	016702  000000G			NMX$$PARAMETER.USER:
						MOV	KISAR6,R2			; *,PREVIOUS.MAP			0898
000004	016501  000004 				MOV	4(R5),R1			; IN.NMXID(.AP.),*			0903
000010	004767  000000G				JSR	PC,NM.NMX
000014	005700 					TST	R0				; ENTBLK
000016	001002 					BNE	1$
000020	005001 					CLR	R1				; STATUS				0905
000022	000405 					BR	2$
000024	005760  000026 			1$:	TST	26(R0)				; *(ENTBLK)				0911
000030	001006 					BNE	3$
000032	012701  000001 				MOV	#1,R1				; *,STATUS
000036	010267  000000G			2$:	MOV	R2,KISAR6			; PREVIOUS.MAP,*
000042	010100 					MOV	R1,R0				; STATUS,*
000044	000207 					RTS	PC
000046	105760  000034 			3$:	TSTB	34(R0)				; *(ENTBLK)				0913
000052	001405 					BEQ	4$
000054	012700  000001 				MOV	#1,R0				; *,STATUS
000060	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000064	000207 					RTS	PC
000066	016546  000006 			4$:	MOV	6(R5),-(SP)			; IN.NUM(.AP.),*			0918
000072	012700  000003 				MOV	#3,R0
000076	004767  000000G				JSR	PC,$DPCM
000102	116700  000014'				MOVB	P.AAE,R0			;					0919
000106	004767  000000G				JSR	PC,$TPC1
000112	016701  000002G				MOV	.CRDAT+2,R1			;					0920
000116	016100  000042 				MOV	42(R1),R0
000122	004767  000000G				JSR	PC,$TPDU2
000126	016705  000002G				MOV	.CRDAT+2,R5			;					0922
000132	012701  000045 				MOV	#45,R1
000136	060501 					ADD	R5,R1
000140	116500  000044 				MOVB	44(R5),R0
000144	004767  000000G				JSR	PC,$TPAI
000150	012700  000001 				MOV	#1,R0				; *,STATUS				0928
000154	010267  000000G				MOV	R2,KISAR6			; PREVIOUS.MAP,*
000160	005726 					TST	(SP)+				;					0836
000162	000207 					RTS	PC
; Routine Size:  58 words,	Routine Base:  $CODE$ + 2046
; Maximum stack depth per invocation:  2 words


;	  0930	
;	  0931	end
;	  0932	
;	  0933	eludom



;					OTS external references
						.GLOBL	BL$CPY, BL$MOV


;					PSECT SUMMARY
NMXINE								25-Jan-1983 09:28:43	TOPS-20 Bliss-16 3(552)		    Page  33
X01110								 4-Jan-1983 09:28:29	NETPKG:<NMX>NMXINE.BLI.7 (10)

;
;	Psect Name			Words	  Attributes
;	 NMXJMP				   18	    RO ,  I  ,  LCL,  REL,  CON
;	 $PLIT$				    7	    RO ,  D  ,  LCL,  REL,  CON
;	 $CODE$				  589	    RO ,  I  ,  LCL,  REL,  CON




;				LIBRARY STATISTICS
;
;					     -------- Symbols --------    Blocks
;	File				     Total    Loaded   Percent      Read
;
;  NETPKG:<MCB>XPORTX.L16.15		       599         3         0         0
;  NETPKG:<MCB>MCBLIB.L16.15		       372         4         1         0
;  NETPKG:<NMX>NMXPAR.L16.30		       968        74         7         0
;  NETPKG:<MCB>NMXLIB.L16.13		       200        18         9         0





;	  0934	! Local Modes:
;	  0935	! Comment Column:36
;	  0936	! Comment Start:!
;	  0937	! Mode:BLISS
;	  0938	! Auto Save Mode:2
;	  0939	! End:
; Size:		589 code + 25 data words
; Run Time:	   00:09.1
; Elapsed Time:	   00:23.7
; Memory Used:	33 pages
; Compilation Complete
BYT$ALLOCATION			 171	 259	 340	 426	 537	 538	 628
BYT$PTR				 177	 178	 201	 264	 283	 345	 362	 433	 544	 545	 567	 635
				 744	 828	 922
CALL$				  78	  79	  80	  81	  82	  83	  84	  85	  86	 118#	 209#	 290#
				 372#	 483#	 575#	 677#	 750#	 836#
CH$WCHAR			 283
EID				 427	 440#	 464	 466	 470
ENTBLK				 172	 192#	 196#	 200#	 201	 202	 260	 276#	 283	 341	 355#	 362
				 428	 447#	 464#	 466#	 470#	 476	 539	 560#	 567	 568	 631	 647#
				 659	 662	 668	 729	 737#	 744	 803	 811#	 819	 895	 903#	 911
				 913
ENTITY_ID			 630	 659#	 662#	 673
FALSE				 114
FREE_PTR			 177#	 196
GENERAL_ID			 202	 476	 568	 668
GENERAL_NAME			 201	 283	 362	 567	 744
GENERAL_NAME_LENGTH		 362	 744
GENERAL_OWNER_ID		 466	 659	 819	 911
GENERAL_PROVIDER_ID		 470	 662
GENERAL_SYSTEM_FLAGS		 200
ID				 171	 178	 259	 264	 340	 345	 426	 433	 628	 635
ID_PTR				 178#	 184	 192	 201	 264#	 270	 276	 345#	 362	 368	 433#	 439
				 447	 635#	 641	 647
IN_FLAGS			 118	 200
IN_ID				 372	 440
IN_NEW				 483	 552	 553
IN_NMXID			 290	 355	 367	 677	 737	 750	 811	 836	 903
IN_NUM				 677	 744	 750	 824	 836	 918
IN_PTR				 118	 183	 184	 209	 269	 270	 372	 438	 439	 483	 550	 551
				 575	 640	 641
IN_TYPE				 118	 159	 192	 196	 209	 248	 276	 372	 414	 447	 455	 461
				 483	 525	 560	 575	 617	 647	 655	 677	 718	 750	 789	 836
				 875
JUMP_TO				  88#	  94	  95	  96	  97	  98	  99	 100	 101	 102	 104
LINK_CLEARED			 881#
LINK_LUN_BLOCK			 464
LINK_OFF			 879#
LINK_ON				 878#	 913
LINK_SERVICE			 880#
LINK_STATE			 913
LINK_USER_ID			 464
MAP$				 165	 254	 332	 366	 420	 531	 623	 672	 724	 795	 887
MCB$GAW_PROCESS_DATA_BASE	 110	 800	 892
N$FFNC				 455	 655
N$IENT				 192	 196	 276	 367	 447	 461	 560	 647
NEW_ID				 538	 545
NEW_ID_PTR			 545#	 553	 567
NMX$$CREATE			  78	  94	 118*
NMX$$DESTROY			  79	  95	 209*
NMX$$MAP			  80	  98	 290*
NMX$$MODIFY_ID			  81	  96	 372*
NMX$$MODIFY_NAME		  82	  97	 483*
NMX$$OBTAIN			  83	  99	 575*
NMX$$PARAMETER_NAME		  84	 100	 677*
NMX$$PARAMETER_OWNER		  85	 101	 750*
NMX$$PARAMETER_USER		  86	 102	 836*
NMX$ENT_CKT			 461
NMX$ENT_LIN			 461
NMX$ID_HI			  71#	 455	 655
NMX$ID_LO			  70#	 455	 655
NMX$ID_OWNER			  70	  71	 458	 658
NMX$ID_PROVIDER			  70	  71	 469	 661
NMXDB_BLOCK			 800	 892
NMXDB				 800#	 826	 827	 828	 892#	 920	 921	 922
NMXID				 166	 173	 185#	 202#	 421	 429	 441#	 476#	 532	 540	 554#	 568#
				 629	 668#	 674
NMXINE				   1#
NMXJMP				  91
NMX_CIRCUIT_BLOCK		 803	 895
NMX_CIRCUIT_FIELDS		 428
NMX_EXECUTOR_NAME		 828	 922
NMX_EXECUTOR_NAME_LENGTH	 827	 921
NMX_EXECUTOR_NUMBER		 826	 920
NMX_GENERAL_BLOCK		 172	 260	 341	 539	 631	 729
NMX_GENERAL_FIELDS		 428
NMX_LINE_FIELDS			 428
NMX_LINK_FIELDS			 428
NMX_MODULE_FIELDS		 428
NMX_TYPE_BLOCK			 159	 248	 337	 414	 525	 617	 718	 789	 875
OLD_ID				 537	 544
OLD_ID_PTR			 544#	 551	 560
OUT_ID				 575	 673#
OUT_NMXID			 118	 166#	 185	 372	 421#	 441	 483	 532#	 554	 575	 674#
OUT_PTR				 290	 368
OUT_TYPE			 290	 337	 367#
PARAMETER_AI			 744	 827	 921
PARAMETER_CM			 824	 918
PARAMETER_C_1			 825	 919
PARAMETER_DU_2			 826	 920
PREVIOUS_MAP			 165	 174	 186	 254	 261	 271	 332	 342	 350	 366	 420	 430
				 442	 531	 541	 555	 623	 632	 642	 672	 724	 730	 732	 795
				 804	 806	 887	 896	 898
SMAP$				 186	 271	 350	 442	 555	 642	 732	 806	 898
STATUS				 164#	 167	 253#	 255	 331#	 333	 419#	 422	 530#	 533	 622#	 624
				 723#	 725	 794#	 796	 886#	 888
TRUE				 113
VALUE				 162	 164	 251	 253	 329	 331	 417	 419	 528	 530	 620	 622
				 721	 723	 792	 794	 884	 886
$FALSE				 114#	 183	 194	 198	 269	 278	 357	 438	 449	 473	 550	 552
				 562	 640	 649	 665	 739	 813	 905
$NMCRE				  94
$NMDES				  95
$NMGID				  99
$NMMAP				  98
$NMMID				  96
$NMMNA				  97
$NMX_MAP_ENTITY_ID		 192	 196	 276	 447	 560	 647
$NMX_MAP_NMXID			 355	 737	 811	 903
$NPNAM				 100
$NPOWN				 101
$NPUSR				 102
$RETURN				 162#	 194	 198	 206	 251#	 278	 287	 329#	 357	 417#	 449	 473
				 480	 528#	 562	 572	 620#	 649	 665	 721#	 739	 748	 792#	 813
				 819	 834	 884#	 905	 911	 913	 928
$TRUE				 113#	 206	 287	 369	 480	 572	 675	 748	 819	 821	 834	 911
				 913	 915	 928