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