Trailing-Edge
-
PDP-10 Archives
-
T10_704_DECNET_3-31-88
-
10,7/netgen/ngnprm.mac
There are 7 other files named ngnprm.mac in the archive. Click here to see a list.
; TITLE NGNPRM - NETGEN Parsing Parameters
; ======
SEARCH NGNMAC
INIGEN (NGNPRM) ; Initialize GLXLIB assembly options
;
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
; OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
;COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1980,1981,1982,1985,1986.
;ALL RIGHTS RESERVED.
;
;
;MODULE NGNPRM
;
; SUMMARY OF EDIT HISTORY - FOR FULL DETAILS SEE MODULE NETGEN.MAC
;
; EDIT # DATE
; 46. 24Oct82
; 4.1
; 1 03Nov82
; 2 23Nov82
; 4 08dec82
; 12 23Feb83
; 15 23Feb83
; 18. 01Mar83
; 20. 08Mar83
; 24. 07Apr83
; 27. 09Sep83
; 30. 30Jul84
; 31. 31Jul84
; 34. 26Nov84
; 35. 06Jan85
; 38. 15Jul85
;
SUBTTL Entity Blocks
;+
; Entities
;
; The following blocks are used to handle the entity part of an action.
;
; $SET ,PRSENT,1 ; This is an entity block.
; $SET ,ENTNUM,num ; Define the entity number.
; $SET ,ENTADR,adr ; Address of holding area for entity-id.
; $SET ENTDEF,,<PJRST adr> ; Routine for entity-id semantic parsing:
; $SET ,PRSMIN,min ; minimum value or string length.
; $SET ,PRSMAX,max ; maximum value or string length.
; $SET ENTKNO,,<PJRST adr> ; Routine to mark KNOWN entity.
; $SET ENTLIS,,<PJRST adr> ; Routine to list entity.
;-
KNOENT::$BUILD ENTSIZ ; KNOWN
$SET ,PRSENT,1
$SET ENTDEF,,<PJRST [
$CALL P$KEYW##
MOVEM S1,ENTBLK
PJRST ENTKNO(S1)]>
$EOB
ENTLIN::$BUILD ENTSIZ ; LINE line-id
$SET ,PRSENT,1
$SET ,ENTNUM,^D1
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,ENTADR,ENTNAM
$SET ENTDEF,,<PJRST GETENT>
$SET ENTKNO,,<$RETT>
$SET ENTLIS,,<PJRST LISKL>
$EOB
ENTCIR::$BUILD LSTSIZ ; CIRCUIT circuit-id
$SET ,PRSENT,1
$SET ,ENTNUM,^D3
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,ENTADR,ENTNAM
$SET ENTDEF,,<PJRST GETCIR>
$SET ENTKNO,,<$RETT>
$SET ENTLIS,,<PJRST LISKC>
$SET EMAX,,MXCIR##
$SET ECUR,,NUMCIR##
$SET ,EADR,<Z X25CIR##(I2)>
$SET EINC,,4
$SET ,EPRM,[
EXP XC1121,XC1122,XC1123,XC1120
EXP 0]
$EOB
ENTPRO::$BUILD ENTSIZ ; PROCESS process-id
$SET ,PRSENT,1
$SET ,PRSPRV,1
$SET ,ENTNUM,^D5
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D3
$SET ENTDEF,,<PJRST P$FLD##>
$EOB
PAGE
;
; NODE entity blocks
;
ENTEXE::$BUILD ENTSIZ ; EXECUTOR
$SET ,PRSENT,1
$SET ,ENTNUM,^D0
$SET ENTDEF,,<$RETT>
$SET ENTLIS,,<PJRST LISN>
$EOB
ENTNOD::$BUILD ENTSIZ ; NODE node-address
$SET ,PRSENT,1
$SET ,PRSPRV,1
$SET ,ENTNUM,^D0
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,ENTADR,ENTNAM
$SET ENTDEF,,<PJRST [
$CALL P$NUM## ; Get node number
JUMPF ENTNO1 ; (if there is one)
MOVEM S1,NODNUM ; and store.
$RETT ; Otherwise...
ENTNO1: $CALL P$FLD## ; Get name
SETZM NAMFLG## ; and
AOJ S1,
$CALL GETNOD## ; reformat.
SETZM NODNUM
LOAD T1,ENTNOD,ENTADR
DMOVEM S1,0(T1) ; Store it.
$RETT]>
$SET ENTKNO,,<PJRST [
SETOM NODNUM ; Known = -1.
$RETT]>
$SET ENTLIS,,<PJRST [
SKIPLE I1,NODNUM ; If specific node
PJRST LISN ; then list it
$CALL LISN ; otherwise list executor.
SKIPL NODNUM ; If KNOWN
$RETT ; then
SETZM NODNUM ; start at bottom.
ENTNO2: AOS I1,NODNUM ; Go on to next node
CAMLE I1,NTPNN## ; and if at end
$RETT ; then quit.
CAMN I1,NTPSLF## ; If not EXECUTOR
JRST ENTNO2 ; and
SKIPE @DNS14+PRMPTR ; there is something to show
$CALL LISN ; then show it.
JRST ENTNO2]>
$EOB
PAGE
;
; LOGGING entity blocks
;
ENTLOG::$BUILD ENTSIZ ; LOGGING logging-id
$SET ,PRSENT,1
$SET ,ENTNUM,^D2
$SET ENTDEF,,<$RETF>
$SET ENTKNO,,<$RETT>
$SET ENTLIS,,<PJRST LISLF>
$EOB
LOGCON::$BUILD ENTSIZ ; LOGGING CONSOLE
$SET ,PRSENT,1
$SET ,PRSPRV,1
$SET ,ENTNUM,^D2
$SET ENTDEF,,<$RETT>
$EOB
LOGFIL::$BUILD ENTSIZ ; LOGGING FILE
$SET ,PRSENT,1
$SET ,ENTNUM,^D2
$SET ENTDEF,,<$RETT>
$SET ENTLIS,,<PJRST LISLF>
$EOB
LOGMON::$BUILD ENTSIZ ; LOGGING MONITOR
$SET ,PRSENT,1
$SET ,PRSPRV,1
$SET ,ENTNUM,^D2
$SET ENTDEF,,<$RETT>
$EOB
PAGE
;
; MODULE entity blocks
;
KNOMOD::$BUILD ENTSIZ ; KNOWN MODULES
$SET ,PRSENT,1
$SET ,PRSTYP,NX25##
$SET ,ENTNUM,^D4
$SET ENTKNO,,<$RETT>
$SET ENTLIS,,<PJRST [
$CALL LISXSC
$CALL LISXPC
PJRST LISMC]>
$EOB
ENTMOD::$BUILD ENTSIZ ; MODULE module-id
$SET ,PRSENT,1
$SET ,ENTNUM,^D4
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ENTDEF,,<$RETF>
$SET ENTKNO,,<$RETT>
$SET ENTLIS,,<PJRST LISMC>
$EOB
MODXPR::$BUILD ENTSIZ ; MODULE X25-PROTOCOL
$SET ,PRSENT,1
$SET ,PRSTYP,NX25##
$SET ,ENTNUM,^D4
$SET ENTDEF,,<$RETT>
$SET ENTLIS,,<PJRST LISXPC>
$EOB
MODXSR::$BUILD ENTSIZ ; MODULE X25-SERVER
$SET ,PRSENT,1
$SET ,PRSTYP,NX25##
$SET ,ENTNUM,^D4
$SET ENTDEF,,<$RETT>
$SET ENTLIS,,<PJRST LISXSC>
$EOB
MODMCB::$BUILD ENTSIZ ; MODULE MCB-EXECUTIVE
$SET ,PRSENT,1
$SET ,PRSPRV,1
$SET ,ENTNUM,^D4
$SET ENTDEF,,<$RETT>
$SET ENTLIS,,<PJRST [
SKIPE @QUAPRO+PRMPTR
PJRST LISMP
PJRST LISMC]>
$EOB
MODRSX::$BUILD ENTSIZ ; MODULE RSX-EXECUTIVE
$SET ,PRSENT,1
$SET ,PRSPRV,1
$SET ,ENTNUM,^D4
$SET ENTDEF,,<$RETT>
$SET ENTLIS,,<PJRST LISRT>
$EOB
SUBTTL Qualifier Blocks
;+
; Qualifiers
;
;*******Describe qualifier block
;-
KNOQUA::$BUILD ENTSIZ ; KNOWN
$SET ,PRSQUA,1
$SET ENTDEF,,<PJRST [
$CALL P$KEYW##
MOVEM S1,QUABLK
PJRST ENTKNO(S1)]>
$EOB
QUASIN::$BUILD ENTSIZ ; SINK sink-id
$SET ,PRSQUA,1
$SET ,PRSPRV,1
$SET ,ENTADR,QUANAM
$SET ENTKNO,,<PJRST [
SETOM @QUASIN+PRMPTR
$RETT]>
$EOB
QUADST::$BUILD LSTSIZ ; DESTINATION destination-name
$SET ,PRSQUA,1
$SET ,PRSTYP,NX25##
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,ENTADR,QUANAM
$SET ENTDEF,,<PJRST GETQUA>
$SET ENTKNO,,<PJRST [
SETOM @QUADST+PRMPTR
$RETT]>
$SET EMAX,,DSSIZ##
$SET ECUR,,NUMDES##
$SET ,EADR,<Z DESNAM##(I2)>
$SET EINC,,4
$SET ,EPRM,[
EXP XS350,XS332,XS351,XS352,XS354,XS340,XS331
EXP XS355,XS330,XS353
EXP 0]
$EOB
QUADTE::$BUILD LSTSIZ ; DTE dte-address
$SET ,PRSQUA,1
$SET ,PRSTYP,NX25##
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,ENTADR,QUANAM
$SET ENTDEF,,<PJRST GETQUA>
$SET ENTKNO,,<PJRST [
SETOM @QUADTE+PRMPTR
$RETT]>
$SET ECUR,,[NUMDUP##]
$SET ,EADR,<Z DTEADR##(I2)>
$SET EINC,,4
$EOB
QUAGRP::$BUILD LSTSIZ ; GROUP Group Name
$SET ,PRSQUA,1
$SET ,PRSTYP,NX25##
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,ENTADR,QUANAM
$SET ENTDEF,,<PJRST GETQUA>
$SET ENTKNO,,<PJRST [
SETOM @QUAGRP+PRMPTR
$RETT]>
$SET EMAX,,GRPSIZ##
$SET ECUR,,NUMGRP##
$SET ,EADR,<Z GRPNAM##(I2)>
$SET EINC,,4
$EOB
QUAPRO::$BUILD LSTSIZ ; MODULE MCB-EXECUTIVE PROCESS process-id
$SET ,PRSQUA,1
$SET ,PRSPRV,1
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D3
$SET ,ENTADR,QUANAM
$SET ENTKNO,,<PJRST [
SETOM @QUAPRO+PRMPTR
$RETF]>
$SET EMAX,,NUMPRC##
$SET ECUR,,PRCPTR##
$SET ,EADR,<Z PRCNAM##(I1)>
$SET EINC,,1
$SET ,EPRM,[
EXP MPS0,MPS1
EXP 0]
$EOB
QUATAS::$BUILD LSTSIZ ; MODULE RSX-EXECUTIVE TASK task-id
$SET ,PRSQUA,1
$SET ,PRSPRV,1
$SET ,ENTADR,QUANAM
$SET ENTKNO,,<PJRST [
SETOM @QUATAS+PRMPTR
$RETF]>
$SET EMAX,,NUMPRC##
$SET ECUR,,RSTPTR##
$SET ,EADR,<Z RSTNAM##(I2)>
$SET EINC,,2
$SET ,EPRM,<[
EXP RTS0
EXP 0]>
$EOB
QUADRV::$BUILD LSTSIZ ; MODULE RSX-EXECUTIVE DRIVER driver-id
$SET ,PRSQUA,1
$SET ,PRSPRV,1
$SET ,ENTADR,QUANAM
$SET ENTKNO,,<PJRST [
SETOM @QUADRV+PRMPTR
$RETF]>
$SET EMAX,,NUMPRC##
$SET ECUR,,RSDPTR##
$SET ,EADR,<Z RSDNAM##(I1)>
$SET EINC,,1
$EOB
;
; Gather entity/qualifier identification into holding area
;
GETENT::SKIPA LP,ENTBLK
GETQUA::MOVE LP,QUABLK
$SAVE <T1,T2,T3,T4>
$CALL P$FLD##
LOAD T4,(LP),PRSMAX ; maximum number of characters,
MOVEI T2,1(S1) ; from address in (S1)+1
HRLI T2,(POINT 7,0)
LOAD T3,(LP),ENTADR ; to the receiving area.
HRLI T3,(POINT 7,0)
GTNAM1: MOVE S2,T2 ; Save pointer
ILDB T1,T2 ; and
SKIPN T1 ; if end of string
MOVE T2,S2 ; then back it up.
CAIL T1,"a" ; Raise lower case
CAILE T1,"z"
SKIPA
SUBI T1,<"a"-"A"> ; and
IDPB T1,T3 ; store in entity name.
SOJG T4,GTNAM1 ; Do for destination length.
$RETT
GETCIR: SETOM DEVTYP## ; Assume X.25 circuit
$CALL P$KEYW## ; and if not device keyword
JUMPF GETENT ; then we have guessed right.
GETDEV: MOVEM S1,DEVTYP## ; Save device type.
$CALL @GETDE1(S1) ; Collect ctl/unt
$RETIF ; and if successful,
$CALL DEVCHK## ; then check if valid.
$RETIT
JRST FNDCI9
GETDE1: $BUILD DEVMAX
$SET DTE,,GETDE3
$SET DMC,,GETDE2
$SET DMR,,GETDE2
$SET KDP,,GETDE3
$EOB
GETDE2: $CALL P$TOK##
$CALL P$NUM##
MOVEM S1,CTLNUM##
SETOM UNTNUM##
$RETT
GETDE3: $CALL P$TOK##
$CALL P$NUM##
MOVEM S1,CTLNUM##
$CALL P$TOK##
$CALL P$NUM##
MOVEM S1,UNTNUM##
$RETT
SUBTTL Parameter Blocks
;+
; Parameters
;
;*******Describe parameter block
;-
PAGE
SUBTTL - Node Parameters
DN100:: $BUILD PRMSIZ ; NODE IDENTIFICATION
$SET ,PRMTXT,[ITEXT(Identification = ^T/@DN100+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D32
TOPS20< $SET ,PRMINI,<[ASCIZ/DECnet-20 V3.0 Release /]-1>>
TOPS10< $SET ,PRMINI,<[ASCIZ/DECnet-10 V3.0 Release /]-1>>
$SET ,PRMADR,NODID##
$SET ,PRMDFL,NOISTA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXT>
$EOB
DN101:: $BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(Management Version = 3.0.0)]
$EOB
DN150:: $BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(Loop Count = 1)]
$EOB
DN151:: $BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(Loop Length = 127)]
$EOB
DN152:: $BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(Loop With = Mixed)]
$EOB
DN500:: $BUILD PRMSIZ ; EXECUTOR NAME
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D6
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,NODNAM##
$SET ,PRMDFL,NONSTA##
$SET PRMDEF,,<$CALL P$FLD##>
$SET PRMSTR,,<PJRST DEFNOD>
$EOB
DN502:: $BUILD PRMSIZ ; EXECUTOR ADDRESS
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMADR,NTPSLF##
$SET ,PRMDFL,NTDSLF##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
STORE S1,DN920,PRSMIN ; set MAXIMUM ADDRESS minimum,
MOVE S2,S1 ; copy to S2,
CAMGE S2,NTPNN## ; get max (S2, MAXIMUM ADDRESS)
MOVE S2,NTPNN##
IMULI S2,^D2 ; figure
ADDI S2,^D5 ; the routing message size,
CAIGE S2,^D290 ; get max (S2, 290),
MOVEI S2,^D290
STORE S2,DN931,PRSMIN ; and set BUFFER SIZE minimum.
PJRST DEFNUM]> ; and store the value.
$EOB
DN510:: $BUILD PRMSIZ ; EXECUTOR INCOMING TIMER
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Incoming Timer = ^D/@DN510+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D10
$SET ,PRMADR,NTPITM##
$SET ,PRMDFL,NTDITM##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMPUR,,<SETZ S1,>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DN511:: $BUILD PRMSIZ ; EXECUTOR OUTGOING TIMER
$SET ,PRMTXT,[ITEXT(Outgoing Timer = ^D/@DN511+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D60
$SET ,PRMADR,NTPOTM##
$SET ,PRMDFL,NTDOTM##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMPUR,,<SETZ S1,>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DN700:: $BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(NSP Version = 3.2.0)]
$EOB
DN710:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM LINKS
$SET ,PRMTXT,[ITEXT(Maximum Links = ^D/@DN710+PRMPTR/)]
$SET ,PRSMIN,^D3
$SET ,PRSMAX,^D23
$SET ,PRMINI,^D11
$SET ,PRMADR,NTPTPT##
$SET ,PRMDFL,NTDTPT##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DN720:: $BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(Delay Factor = 2)]
$EOB
DN721:: $BUILD PRMSIZ ; EXECUTOR DELAY WEIGHT
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Delay Weight = ^D/@DN721+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D3
$SET ,PRMADR,NTPWGT##
$SET ,PRMDFL,NTDWGT##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DN722:: $BUILD PRMSIZ ; EXECUTOR INACTIVITY TIMER
$SET ,PRMTXT,[ITEXT(Inactivity Timer = ^D/@DN722+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D30
$SET ,PRMADR,NTPACT##
$SET ,PRMDFL,NTDACT##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DN723:: $BUILD PRMSIZ ; EXECUTOR RETRANSMIT FACTOR
$SET ,PRMTXT,[ITEXT(Retransmit Factor = ^D/@DN723+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D15
$SET ,PRMINI,^D5
$SET ,PRMADR,NTPRET##
$SET ,PRMDFL,NTDRET##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DN900:: $BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(Routing Version = 1.3.0)]
$EOB
DN901:: $BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(Type = Routing)]
$EOB
DN910:: $BUILD PRMSIZ ; EXECUTOR ROUTING TIMER
$SET ,PRMTXT,[ITEXT(Routing Timer = ^D/@DN910+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D60
$SET ,PRMADR,NTPT1##
$SET ,PRMDFL,NTDT1##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DN920:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM ADDRESS
$SET ,PRMTXT,[ITEXT(Maximum Address = ^D/@DN920+PRMPTR/)]
$SET ,PRSMIN,^D2
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D255
$SET ,PRMADR,NTPNN##
$SET ,PRMDFL,NTDNN##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
MOVE S2,NTPBLK ; Figure maximum address
SUBI S2,^D5 ; that fits into BUFFER SIZE
IDIVI S2,^D2
CAMLE S2,S1 ; get min (S2, MAXIMUM ADDRESS),
MOVE S2,S1
STORE S2,DN502,PRSMAX ; set ADDRESS maximum,
STORE S2,ENTNOD,PRSMAX ; NODE maximum
MOVE S2,S1 ; copy to S2,
CAMGE S2,NTPSLF## ; get max (S2, ADDRESS)
MOVE S2,NTPSLF##
IMULI S2,^D2 ; figure
ADDI S2,^D5 ; the routing message size,
CAIGE S2,^D290 ; get max (S2, 290),
MOVEI S2,^D290
STORE S2,DN931,PRSMIN ; and set BUFFER SIZE minimum.
PJRST DEFNUM]> ; and store the value.
$EOB
DN921:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM CIRCUITS
$EOB
DN922:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM COST
$SET ,PRMTXT,[ITEXT(Maximum Cost = ^D/@DN922+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D1022
$SET ,PRMINI,^D100
$SET ,PRMADR,NTPMXC##
$SET ,PRMDFL,NTDMXC##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DN923:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM HOPS
$SET ,PRMTXT,[ITEXT(Maximum Hops = ^D/@DN923+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D30
$SET ,PRMINI,^D16
$SET ,PRMADR,NTPMXH##
$SET ,PRMDFL,NTDMXH##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
STORE S1,DN924,PRSMIN ; Set MAXIMUM VISITS minimum.
PJRST DEFNUM]>
$EOB
DN924:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM VISITS
$SET ,PRMTXT,[ITEXT(Maximum Visits = ^D/@DN924+PRMPTR/)]
$SET ,PRSMIN,^D16
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D32
$SET ,PRMADR,NTPMXV##
$SET ,PRMDFL,NTDMXV##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
MOVE S2,S1 ; Copy to S2,
CAILE S2,^D30 ; get min (S2, 30),
MOVEI S2,^D30
STORE S2,DN923,PRSMAX ; and set MAXIMUM HOPS maximum.
PJRST DEFNUM]>
$EOB
DN930:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM BUFFERS
$EOB
DN931:: $BUILD PRMSIZ ; EXECUTOR BUFFER SIZE
$SET ,PRMTXT,[ITEXT(Buffer Size = ^D/@DN931+PRMPTR/)]
$SET ,PRSMIN,<<^D255*^D2>+^D5>
$SET ,PRSMAX,^D576
$SET ,PRMINI,^D576
$SET ,PRMADR,NTPBLK##
$SET ,PRMDFL,NTDBLK##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
MOVE S2,S1 ; copy to S2,
STORE S2,XP1140,PRSMAX ;Store in protocol def data
STORE S2,XP1150,PRSMAX ; Store in protocol max data
SUBI S2,^D5 ; figure maximum node supported
IDIVI S2,^D2 ; for routing message this size,
CAILE S2,NUMNOD## ; get min (S2, NUMNOD)
MOVEI S2,NUMNOD##
SKIPN PRVLDG## ; If the user not privledged
CAIG S2,^D255 ; then get min (S2, 255),
SKIPA
MOVEI S2,^D255
STORE S2,DN920,PRSMAX ; set MAXIMUM ADDRESS maximum,
CAMLE S2,NTPNN## ; get min (S2, MAXIMUM ADDRESS),
MOVE S2,NTPNN##
STORE S2,DN502,PRSMAX ; and set ADDRESS maximum.
PJRST DEFNUM]> ; and store the value.
$EOB
DNS0:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM PHASE II LINKS
$SET ,PRMTXT,[ITEXT(Maximum Phase II Links = ^D/@DNS0+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D40
$SET ,PRMINI,^D20
$SET ,PRMADR,NTPMXP##
$SET ,PRMDFL,NTDMXP##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS1:: $BUILD PRMSIZ ; NODE TRANSMIT PASSWORD
$SET ,PRMTXT,[ITEXT(Transmit Password = ^T/@DNS1+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D8
$SET ,PRMINI,<[ASCIZ/DECNET20/]-1>
$SET ,PRMADR,XMTPSW##
$SET ,PRMDFL,PSXSTA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
DNS2:: $BUILD PRMSIZ ; NODE MANAGEMENT USER
$SET ,PRMTXT,[ITEXT(Management User = ^T/@DNS2+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,USRSTR##
$SET ,PRMDFL,USRSTA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
DNS3:: $BUILD PRMSIZ ; NODE MANAGEMENT ACCOUNT
$SET ,PRMTXT,[ITEXT(Management Account = ^T/@DNS3+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,ACTSTR##
$SET ,PRMDFL,ACTSTA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
DNS4:: $BUILD PRMSIZ ; NODE MANAGEMENT PASSWORD
$SET ,PRMTXT,[ITEXT(Management Password = (password set))]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D8
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,PASSTR##
$SET ,PRMDFL,PASSTA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
DNS5:: $BUILD PRMSIZ ; NODE RECEIVE PASSWORD
$SET ,PRMTXT,[ITEXT(Receive Password = ^T/@DNS5+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D8
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,RCVPSW##
$SET ,PRMDFL,PSRSTA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
DNS6:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM MODULES
$SET ,PRSPRV,1
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D2
$SET ,PRMINI,^D2
$SET ,PRMADR,NTPNMO##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS7:: $BUILD PRMSIZ ; EXECUTOR OPEN PORTS
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Open Ports = ^D/@DNS7+PRMPTR/)]
$SET ,PRSMIN,^D2
$SET ,PRSMAX,^D3
$SET ,PRMINI,^D2
$SET ,PRMADR,NTPOPN##
$SET ,PRMDFL,NTDOPN##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS8:: $BUILD PRMSIZ ; EXECUTOR SEGMENT SIZE
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Segment Size = ^D/@DNS8+PRMPTR/)]
$SET ,PRSMIN,^D256
$SET ,PRSMAX,^D512
$SET ,PRMINI,^D256
$SET ,PRMADR,NTPBUF##
$SET ,PRMDFL,NTDBUF##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS9:: $BUILD PRMSIZ ; EXECUTOR MAXIMUM RESERVED PORTS
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Maximum Reserved Ports = ^D/@DNS9+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D5
$SET ,PRMINI,^D3
$SET ,PRMADR,NTPTRS##
$SET ,PRMDFL,NTDTRS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS10:: $BUILD PRMSIZ ; EXECUTOR ROUTING DELAY
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Routing Delay = ^D/@DNS10+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D1
$SET ,PRMINI,^D1
$SET ,PRMADR,NTPT2##
$SET ,PRMDFL,NTDT2##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS11:: $BUILD PRMSIZ ; EXECUTOR CIRCUIT BUFFER QUOTA
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Circuit Buffer Quota = ^D/@DNS11+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D50
$SET ,PRMADR,NTPLBQ##
$SET ,PRMDFL,NTDLBQ##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS12:: $BUILD PRMSIZ ; EXECUTOR NSP INPUT BUFFER QUOTA
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(NSP Input Buffer Quota = ^D/@DNS12+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D8
$SET ,PRMADR,NTPEBQ##
$SET ,PRMDFL,NTDEBQ##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS13:: $BUILD PRMSIZ ; EXECUTOR NSP OUTPUT BUFFER QUOTA
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(NSP Output Buffer Quota = ^D/@DNS13+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D8
$SET ,PRMADR,NTPIBQ##
$SET ,PRMDFL,NTDIBQ##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DNS14:: $BUILD PRMSIZ ; NODE FENCE
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Fence = ^D/@DNS14+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D0
$SET ,PRMADR,<Z XPTMXA##-1(I1)>
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMPUR,,<SETZ S1,>
$SET PRMSTR,,<PJRST [
MOVE I1,NODNUM ; Get node number,
MOVE T1,PRMBLK ; parameter block,
MOVEM S1,@PRMPTR(T1) ; and store the number.
PJRST KDEFDN]>
$EOB
DNX2:: $BUILD PRMSIZ ; GATEWAY ACCESS USER
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Access User = ^T/@DNX2+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMADR,USRSXR##
$SET ,PRMDFL,USRSXA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
DNX3:: $BUILD PRMSIZ ; GATEWAY ACCESS ACCOUNT
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Access Account = ^T/@DNX3+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMADR,ACTSXR##
$SET ,PRMDFL,ACTSXA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
DNX4:: $BUILD PRMSIZ ; GATEWAY ACCESS PASSWORD
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Access Password = ^T/@DNX4+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMADR,PASSXR##
$SET ,PRMDFL,PASSXA##
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
PAGE
SUBTTL - Circuit Parameters
DC900:: $BUILD PRMSIZ ; CIRCUIT COST
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Cost = ^D/T1/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D25
$SET ,PRMINI,^D1
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
$CALL CIRDEV ; Get device
$RETIF ; (if there is one)
MOVE S2,DEVTYP##
CAIN S2,KDP
$CALL [MOVE LNTYP##(I1)
CAIN ^D5
$RETF
$RETT]
JUMPF NMEPNA
SKIPN CSTVEC(S2) ; If supported
JRST NMEPNA ; then
MOVEM S1,@CSTVEC(S2) ; set the cost.
$RETT]>
$EOB
CSTVEC: $BUILD DEVMAX
$SET DTE,,<Z DTECST##>
$SET DMC,,<Z DMCCST##(I1)>
$SET DMR,,<Z DMRCST##(I1)>
$SET KDP,,<Z DUPCST##(I1)>
$EOB
DKC906::$BUILD PRMSIZ ; KNOWN CIRCUITS HELLO TIMER
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Hello Timer = ^D/@DKC906+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D10
$SET ,PRMADR,NTPT3##
$SET ,PRMDFL,NTDT3##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DKC907::$BUILD PRMSIZ ; KNOWN CIRCUITS LISTEN TIMER
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Listen Timer = ^D/@DKC907+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D60
$SET ,PRMADR,NTPT4##
$SET ,PRMDFL,NTDT4##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DC1100::$BUILD PRMSIZ
$SET ,PRMTXT,[ITEXT(Owner = Node / ^D/NTPSLF/ / ^T/NODNAM/)]
$EOB
XC1111::$BUILD PRMSIZ ; CIRCUIT USAGE
$SET ,PRMTXT,[ITEXT(Usage = ^T/@CIRUSA+0/)]
$EOB
CIRUSA: EXP [ASCIZ/Permanent/]
EXP [ASCIZ/Incoming/]
EXP [ASCIZ/Outgoing/]
XC1112::$BUILD PRMSIZ ; CIRCUIT TYPE (define/purge name)
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Type = ^T/@LINPRO(T1)/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMADR,[^D3]
$SET PRMDEF,,<$CALL [
CALL P$NEXT##
MOVEI S1,^D3
$RETT]>
$SET PRMPUR,,<$CALL [
CALL P$NEXT##
MOVEI S1,^D4
$RETT]>
$SET PRMSTR,,<PJRST CIRTYP>
$EOB
XC1120::$BUILD PRMSIZ ; CIRCUIT DTE
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
MOVEI [ITEXT(DTE = (undefined))]
SKIPE DTECIR##(I2)
MOVEI [ITEXT(DTE = ^T/@XC1120+PRMPTR/)]
$RET]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z DTECIR##(I2)>
$SET PRMDEF,,<$CALL P$FLD##>
$SET PRMPUR,,<MOVEI S1,0>
$SET PRMSTR,,<PJRST [
$CALL CHKXC ; Verify unique DTE/channel
$RETIF
PJRST CIRFLD]>
$EOB
XC1121::$BUILD PRMSIZ ; CIRCUIT CHANNEL
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Channel = ^D/@XC1121+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D4095
$SET ,PRMINI,^D0
$SET ,PRMADR,<Z CIRCHP##(I1)>
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMPUR,,<SETZ S1,>
$SET PRMSTR,,<PJRST [
$CALL CHKXC ; Verify unique DTE/channel
$RETIF
PJRST CIRNUM
CHKXC: $RETT]>
$EOB
XC1122::$BUILD PRMSIZ ; CIRCUIT MAXIMUM DATA
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Data = ^D/@XC1122+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D128
$SET ,PRMADR,<Z MXDATP##(I1)>
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMPUR,,<SETZ S1,>
$SET PRMSTR,,<PJRST CIRNUM>
$EOB
XC1123::$BUILD PRMSIZ ; CIRCUIT MAXIMUM WINDOW
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Window = ^D/@XC1123+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D2
$SET ,PRMADR,<Z MXWINP##(I1)>
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMPUR,,<SETZ S1,>
$SET PRMSTR,,<PJRST CIRNUM>
$EOB
PAGE
SUBTTL - Line Parameters
DL1100::$BUILD PRMSIZ ; LINE DEVICE
$SET ,PRMTXT,[ITEXT(Device = ^I/@DL1100+PRMPTR/)]
$EOB
DL1105::$BUILD PRMSIZ ; LINE RECEIVE BUFFERS
$SET ,PRMTXT,[ITEXT(Receive Buffers = ^D/T1/)]
$SET PRMDEF,,<$CALL P$NUM##>
$EOB
DL1110::$BUILD PRMSIZ ; LINE CONTROLLER
$SET ,PRMTXT,[ITEXT(Controller = ^T/@LINCON+0/)]
$SET PRMDEF,,<$CALL P$KEYW##>
$EOB
LINCON: EXP [ASCIZ/Normal/]
EXP [ASCIZ/Loopback/]
DL1111::$BUILD PRMSIZ ; LINE DUPLEX
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Duplex = ^T/@LINDUP(T1)/)]
$SET ,PRMINI,^D0 ; default FULL
$SET PRMDEF,,<$CALL P$KEYW##>
$SET PRMSTR,,<PJRST [
$CALL LINDEV ; Get device typ
$RETIF ; (if there is one)
MOVE S2,DEVTYP##
SKIPN DUPVEC(S2) ; If supported
JRST NMEPNA ; then
MOVEM S1,@DUPVEC(S2) ; set the duplex.
$RETT]>
$EOB
DUPVEC: $BUILD DEVMAX
$SET DMC,,<Z DMCDUP##(I1)>
$SET DMR,,<Z DMRDUP##(I1)>
$SET KDP,,<Z DUPDUP##(I1)>
$EOB
LINDUP: EXP [ASCIZ/Full/]
EXP [ASCIZ/Half/]
DL1112::$BUILD PRMSIZ ; LINE PROTOCOL
$SET ,PRMTXT,[ITEXT(Protocol = ^T/@LINPRO(T1)/)]
$SET ,PRMINI,^D4 ; default DDCMP-DMC
$SET PRMDEF,,<$CALL P$KEYW##>
$SET PRMSTR,,<PJRST [
$CALL LINDEV ; Get device typ
$RETIF ; (if there is one)
MOVE S2,DEVTYP##
SKIPN LTYVEC(S2) ; If supported
JRST NMEPNA ; then
MOVEM S1,@LTYVEC(S2) ; set the protocol.
$RETT]>
$EOB
LTYVEC: $BUILD DEVMAX
$SET KDP,,<Z LNTYP##(I1)>
$EOB
LINPRO: EXP [ASCIZ/DDCMP-Point/]
EXP [ASCIZ/DDCMP-Control/]
EXP [ASCIZ/DDCMP-Tributary/]
EXP [ASCIZ/X25/]
EXP [ASCIZ/DDCMP-DMC/]
EXP [ASCIZ/LAPB/]
DL1113::$BUILD PRMSIZ ; LINE CLOCK
$SET ,PRMTXT,[ITEXT(Clock = ^T/@LINCLO+0/)]
$SET PRMDEF,,<$CALL P$KEYW##>
$EOB
LINCLO: EXP [ASCIZ/External/]
EXP [ASCIZ/Internal/]
DL1120::$BUILD PRMSIZ ; LINE SERVICE TIMER
$SET ,PRMTXT,[ITEXT(Service Timer = 3000)]
$SET PRMDEF,,<$CALL P$NUM##>
$EOB
DL1121::$BUILD PRMSIZ ; LINE RETRANSMIT TIMER
$SET ,PRMTXT,[ITEXT(Retransmit Timer = ^D/@DL1121+PRMPTR/)]
$SET ,PRMADR,[^D3000]
$SET PRMDEF,,<$CALL P$NUM##>
$EOB
XKL121:: ; KNOWN LINES RETRANSMIT TIMER
XL1121::$BUILD PRMSIZ
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Retransmit Timer = ^D/@XL1121+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D3000
$SET ,PRMADR,XTPIT1##
$SET ,PRMDFL,XTDIT1##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XKL130:: ; KNOWN LINES MAXIMUM BLOCK
XL1130::$BUILD PRMSIZ
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
MOVE NTPBLK##
ADDI <^D6+1>
ANDI ^-1
MOVEM XTPBLK##
MOVEI [ITEXT(Maximum Block = ^D/@XL1130+PRMPTR/)]
$RET]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D1024
$SET ,PRMADR,XTPBLK##
$SET ,PRMDFL,XTDBLK##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
MOVE S2,S1 ; copy to S2,
SUBI S2,^D3
STORE S2,XP1140,PRSMAX ; set DEFAULT DATA maximum
STORE S2,XP1150,PRSMAX ; set MAXIMUM DATA maximum
PJRST DEFNUM]> ; and store the value.
$EOB
XKL131:: ; KNOWN LINES MAX RETRANSMIT
XL1131::$BUILD PRMSIZ
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Retransmits = ^D/@XL1131+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D20
$SET ,PRMADR,XTPIRC##
$SET ,PRMDFL,XTDIRC##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XKL132:: ; KNOWN LINES MAXIMUM WINDOW
XL1132::$BUILD PRMSIZ
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Window = ^D/@XL1132+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D7
$SET ,PRMADR,XTPWS##
$SET ,PRMDFL,XTDWS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DL2650::$BUILD PRMSIZ ; LINE CONTROLLER REGISTER
$SET ,PRMTXT,[ITEXT(Controller Register = ^O/@DL2650+PRMPTR/)]
$SET ,PRMADR,DMXCSR##
$EOB
DL2651::$BUILD PRMSIZ ; LINE UNIT REGISTER
$SET ,PRMTXT,[ITEXT(Unit Register = ^O/@DL2651+PRMPTR/)]
$SET ,PRMADR,DUPCSR#
$EOB
DL2655::$BUILD PRMSIZ ; LINE INTERRUPT VECTOR
$SET ,PRMTXT,[ITEXT(Interrupt Vector = ^O/@DL2655+PRMPTR/)]
$SET ,PRMADR,DMXINT##
$EOB
DL2660::$BUILD PRMSIZ ; LINE INTERRUPT PRIORITY
$SET ,PRMTXT,[ITEXT(Interrupt Priority = ^O/@DL2660+PRMPTR/)]
$SET ,PRMADR,DMXPRI#
$EOB
DL2670::$BUILD PRMSIZ ; LINE PAUSE TIMER
$SET ,PRMTXT,[ITEXT(Pause Timer = ^D/@DL2670+PRMPTR/)]
$SET ,PRMADR,[^D30]
$EOB
DLS0:: $BUILD PRMSIZ ; LINE BAUD RATE
$SET ,PRSPRV,1
$SET ,PRMTXT,[ITEXT(Baud Rate = ^D/LINRAT(T1)/)]
$SET PRMDEF,,<$CALL P$KEYW##>
$SET PRMSTR,,<PJRST [
$CALL LINDEV ; Get device type
$RETIF ; (if there is one)
MOVE S2,DEVTYP##
SKIPN RATVEC(S2) ; If supported
JRST NMEPNA ; then
MOVEM S1,@RATVEC(S2) ; set the baud rate.
$RETT]>
$EOB
RATVEC: $BUILD DEVMAX
$SET KDP,,<Z DUPRAT##(I1)>
$EOB
LINRAT: $BUILD (20)
$SET (BD.12,,<^D1200>)
$SET (BD.18,,<^D1800>)
$SET (BD.192,,<^D19200>)
$SET (BD.24,,<^D2400>)
$SET (BD.36,,<^D3600>)
$SET (BD.48,,<^D4800>)
$SET (BD.72,,<^D7200>)
$SET (BD.96,,<^D9600>)
$EOB
;XT300:
$BUILD PRMSIZ ; LINE DTE COMMAND ADDRESS
$SET ,PRSPRV,1
$SET ,PRSTYP,NX25##
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D3
$SET ,PRMINI,^D3
$SET ,PRMADR,XTPDTC##
$SET ,PRMDFL,XTDDTC##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
;XT310:
$BUILD PRMSIZ ; LINE DCE COMMAND ADDRESS
$SET ,PRSPRV,1
$SET ,PRSTYP,NX25##
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D3
$SET ,PRMINI,^D1
$SET ,PRMADR,XTPDCC##
$SET ,PRMDFL,XTDDCC##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
;XT320:
$BUILD PRMSIZ ; LINE DTE RESPONSE ADDRESS
$SET ,PRSPRV,1
$SET ,PRSTYP,NX25##
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D3
$SET ,PRMINI,^D1
$SET ,PRMADR,XTPDTR##
$SET ,PRMDFL,XTDDTR##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
;XT330:
$BUILD PRMSIZ ; LINE DCE RESPONSE ADDRESS
$SET ,PRSPRV,1
$SET ,PRSTYP,NX25##
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D3
$SET ,PRMINI,^D3
$SET ,PRMADR,XTPDCR##
$SET ,PRMDFL,XTDDCR##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
PAGE
SUBTTL - Logging Parameters
LF201:: $BUILD PRMSIZ ; LOGGING EVENT
$SET PRMDEF,,<$CALL [
EVTMSK: $SAVE <T1,T2,T3,T4>
SETOM DEFRNG+0
SETOM DEFRNG+1
$CALL P$NUM##
JUMPF EVTMS9
MOVEM S1,DEFRNG+0
$CALL P$TOK##
$CALL P$TOK##
JUMPT EVTMS9
SETZM DEFRNG+1
EVTMS1: $CALL P$NUM##
MOVE T1,S1
MOVE T2,S1
$CALL P$TOK##
JUMPF EVTMS2
$CALL P$NUM##
MOVE T2,S1
EVTMS2: MOVEI T3,1
SUB T2,T1
AOJLE T2,[$DEFFAIL(Event type range not ascending)]
LSH T3,(T2)
SOS T3
LSH T3,(T1)
ORM T3,DEFRNG+1
$CALL P$COMMA##
JUMPT EVTMS1
EVTMS9: MOVEI S1,DEFRNG
$RETT]>
$SET PRMPUR,,<$CALL EVTMSK>
$SET PRMSTR,,<PJRST [
DMOVE T1,0(S1)
JUMPE T1,[$SEMFAIL(Event class ^D/T1/ cannot be changed)]
CAILE T1,6
JRST [ $SEMFAIL(Event class ^D/T1/ not supported)]
MOVX T4,^B11111111111111111111111111111111
ORCAM T4,GBLFLT##(T1)
SKIPLE DEFPUR#
ORB T2,GBLFLT##(T1)
SKIPGE DEFPUR#
ANDCAB T2,GBLFLT##(T1)
AOSE T2
ANDM T4,GBLFLT##(T1)
$RETT]>
$EOB
PAGE
SUBTTL - Module X25-Protocol Parameters
XP1100::$BUILD PRMSIZ ; MODULE X25-PROTOCOL DTE
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Dte = ^T/@XP1100+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMADR,<Z DTEADR##(I2)>
$EOB
XP1110::$BUILD PRMSIZ ; MODULE X25-PROTOCOL NETWORK
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
MOVEI [ITEXT(Network = (undefined))]
SKIPE NETNAM##
MOVEI [ITEXT(Network = ^T/@XP1110+PRMPTR/)]
$RET]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,NETNAM##
$SET PRMDEF,,<$CALL P$FLD##>
$SET PRMSTR,,<PJRST DEFTXU>
$EOB
XP1120::$BUILD PRMSIZ ; MODULE X25-PROTOCOL LINE
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
EXT <DEVTXT,CTLNUM,UNTNUM,NUMKDP,KDPLNM>
$SAVE <T1,T2,T3,T4>
MOVEM I1,T3
$CALL DEVKDP## ; Set device name
SKIPG T1,KDPNUM##
JRST XLNA9
XLNA1: $CALL DEVCTL##
SKIPG T2,KDPLNM(I1) ;ARE THERE ANY DUPS ON THIS LINE?
JRST XLNA3 ;NO - SKIP THIS KDP
SETZM UNTNUM## ; Start with unit #0
XLNA2: $CALL DEVUNT##
MOVEI [ITEXT(Line = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/)]
CAMN I1,T3 ; Is this the DUP?
$RET ; Yes, all done
AOS UNTNUM## ; On to the next unit.
SOJG T2,XLNA2
XLNA3: AOS CTLNUM## ; On to the next controller.
SOJG T1,XLNA1
XLNA9: SETZ
$RET]
$EOB
XP1130::$BUILD PRMSIZ ; MODULE X25-PROTOCOL CHANNELS
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
MOVE CHRAGH##(I1)
CAMN CHRAGL##(I1)
JRST [ MOVEI [ITEXT(Channels = ^D/CHRAGL##(I1)/)]
$RET]
MOVEI [ITEXT(Channels = ^D/CHRAGL##(I1)/-^D/CHRAGH##(I1)/)]
SKIPGE CHRAGL##(I1)
MOVEI [ITEXT(Channels = (undefined))]
$RET]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D4095
$SET ,PRMINI,[EXP -1,0]
$SET ,PRMADR,[
Z CHRAGL##(I1)
Z CHRAGH##(I1)]
$SET PRMDEF,,<$CALL [
$CALL P$NUM##
MOVEM S1,DEFRNG+0
MOVEM S1,DEFRNG+1
$CALL P$TOK##
JUMPF CH1
$CALL P$NUM##
MOVEM S1,DEFRNG+1
CH1: MOVEI S1,DEFRNG
MOVE S2,0(S1)
SUB S2,1(S1)
SKIPGE S2
MOVN S2,S2
ADDI S2,1
CAMLE S2,XTPLCN##
JRST [$DEFFAIL(Channel range exceeds maximum channels)]
LOAD ,XP1131,PRSMIN ; Adjust minumum channels
CAML S2
$RETT
STORE S2,XP1131,PRSMIN
$RETT]>
$SET PRMSTR,,<PJRST [
$CALL FNDQUA
MOVE S2,0(S1)
MOVEM S2,CHRAGL##(I1)
MOVE S2,1(S1)
MOVEM S2,CHRAGH##(I1)
$RETT]>
$EOB
XP1131::$BUILD PRMSIZ ; MODULE X25-PROTOCOL MAXIMUM CHANNELS
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Channels = ^D/@XP1131+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D20 ; (4095)
$SET ,PRMINI,^D20
$SET ,PRMADR,XTPLCN##
$SET ,PRMDFL,XTDLCN##
$SET PRMDEF,,<$CALL [
$CALL P$NUM## ;get number into S1
CAMGE S1,NCIR##
JRST [ $DEFWARN(Maximum channel number less than range of address already defined)]
$RETT]>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1140::$BUILD PRMSIZ ; MODULE X25-PROTOCOL DEFAULT DATA
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Default Data = ^D/@XP1140+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D128
$SET ,PRMADR,XTPDPS##
$SET ,PRMDFL,XTDDPS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
MOVE S2,S1 ; copy to S2,
ADDI S2,^D3
STORE S2,XL1130,PRSMIN ; set MAXIMUM BLOCK minimum
PJRST DEFNUM]> ; and store the value.
$EOB
XP1141::$BUILD PRMSIZ ; MODULE X25-PROTOCOL DEFAULT WINDOW
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Default Window = ^D/@XP1141+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D2
$SET ,PRMADR,XTPDWS##
$SET ,PRMDFL,XTDDWS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1150::$BUILD PRMSIZ ; MODULE X25-PROTOCOL MAXIMUM DATA
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Data = ^D/@XP1150+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D65535
$SET ,PRMINI,^D128
$SET ,PRMADR,XTPMPS##
$SET ,PRMDFL,XTDMPS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST [
PJRST DEFNUM]> ; and store the value.
$EOB
XP1151::$BUILD PRMSIZ ; MODULE X25-PROTOCOL MAXIMUM WINDOW
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Window = ^D/@XP1151+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D2
$SET ,PRMADR,XTPMWS##
$SET ,PRMDFL,XTDMWS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1152::$BUILD PRMSIZ ; MODULE X25-PROTOCOL MAXIMUM CLEARS
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Clears = ^D/@XP1152+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D6
$SET ,PRMADR,XTPRCL##
$SET ,PRMDFL,XTDRCL##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1153::$BUILD PRMSIZ ; MODULE X25-PROTOCOL MAXIMUM RESETS
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Resets = ^D/@XP1153+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D6
$SET ,PRMADR,XTPRRE##
$SET ,PRMDFL,XTDRRE##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1154::$BUILD PRMSIZ ; MODULE X25-PROTOCOL MAXIMUM RESTARTS
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Restarts = ^D/@XP1154+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D6
$SET ,PRMADR,XTPRRS##
$SET ,PRMDFL,XTDRRS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1160::$BUILD PRMSIZ ; MODULE X25-PROTOCOL CALL TIMER
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Call Timer = ^D/@XP1160+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D200
$SET ,PRMADR,XTPTCA##
$SET ,PRMDFL,XTDTCA##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1161::$BUILD PRMSIZ ; MODULE X25-PROTOCOL CLEAR TIMER
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Clear Timer = ^D/@XP1161+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D180
$SET ,PRMADR,XTPTCL##
$SET ,PRMDFL,XTDTCL##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1162::$BUILD PRMSIZ ; MODULE X25-PROTOCOL RESET TIMER
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Reset Timer = ^D/@XP1162+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D180
$SET ,PRMADR,XTPTRE##
$SET ,PRMDFL,XTDTRE##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1163::$BUILD PRMSIZ ; MODULE X25-PROTOCOL RESTART TIMER
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Restart Timer = ^D/@XP1163+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D180
$SET ,PRMADR,XTPTRS##
$SET ,PRMDFL,XTDTRS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XP1101::$BUILD PRMSIZ
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Group = ^T/@XP1101 + PRMPTR/)]
$SET ,PRMADR,<Z GRPNAM##(I2)>
$SET PRMPUR,,<JFCL>
$SET PRMSTR,,<PJRST GRPPUR>
$EOB
XP1170::$BUILD PRMSIZ
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(DTE = ^T/@XP1170 + PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z GRPDTE##(I2)>
$SET PRMDEF,,<$CALL UGDTE>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$EOB
XP1171::$BUILD PRMSIZ
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(NUMBER = ^D/@XP1171 + PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D99
$SET ,PRMINI,^D0
$SET ,PRMADR,<Z GRPNUM##(I1)>
$SET PRMDEF,,<$CALL UGNUM>
$SET PRMPUR,,<MOVEI S1,^D0>
$SET PRMSTR,,<$RETT>
$EOB
XP1172::$BUILD PRMSIZ ; CIRCUIT TYPE (define/purge name)
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
SKIPE GRPTYP##(I1)
MOVEI [ITEXT(TYPE = BILATERAL)]
$RET]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMADR,[^D5]
$SET PRMDEF,,<$CALL [
CALL P$NEXT##
MOVEI S1,^D5
$RETT]>
$SET PRMPUR,,<$CALL [
MOVEI S1,^D0
$RETT]>
$SET PRMSTR,,<PJRST UGTYP>
$EOB
XPS0:: $BUILD PRMSIZ ; MODULE X25-PROTOCOL MAXIMUM GROUPS
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Groups = ^D/@XPS0+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D20
$SET ,PRMINI,^D0
$SET ,PRMADR,XTPUGS##
$SET ,PRMDFL,XTDUGS##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
PAGE
SUBTTL - Module X25-Server Parameters
XS300:: $BUILD PRMSIZ ; MODULE X25-SERVER DESTINATION
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Destination = ^T/@XS300+PRMPTR/)]
$SET ,PRMADR,<Z DESNAM##(I2)>
$SET PRMPUR,,<JFCL>
$SET PRMSTR,,<PJRST DSTPUR>
$EOB
XS320:: $BUILD PRMSIZ ; MODULE X25-SERVER NODE
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
MOVEI [ITEXT(Node = (undefined))]
SKIPE DSNODE+1(I2)
MOVEI [ITEXT(Node = 0 (^T/DSNODE+1(I2)/))]
SKIPE DSNODE(I2)
MOVEI [ITEXT(Node = ^D/DSNODE(I2)/ ())]
$RET]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D0
$SET ,PRMADR,<Z DSNODE##(I2)>
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DSTNUM>
$EOB
XS330:: $BUILD PRMSIZ ; MODULE X25-SERVER USER
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(User = ^T/@XS330+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z DSUSER##(I2)>
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DSTFLD>
$EOB
XS331:: $BUILD PRMSIZ ; MODULE X25-SERVER PASSWORD
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Password = (password set))]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z DSPASS##(I2)>
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DSTFLD>
$EOB
XS332:: $BUILD PRMSIZ ; MODULE X25-SERVER ACCOUNT
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Account = ^T/@XS332+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z DSACCT##(I2)>
$SET PRMDEF,,<$CALL P$TEXT##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DSTFLD>
$EOB
XS340:: $BUILD PRMSIZ ; MODULE X25-SERVER OBJECT
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
MOVEI [ITEXT(Object = (undefined))]
SKIPE DSOBJN##(I1)
MOVEI [ITEXT(Object = ^D/DSOBJN(I1)/)]
SKIPE DSOBJS##(I2)
MOVEI [ITEXT(Object = ^T/DSOBJS(I2)/)]
$RET]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,^D0
$SET PRMDEF,,<$CALL [
$CALL P$NUM##
$RETIT
$CALL P$FLD##
HRLI S1,-1
$RET]>
$SET PRMSTR,,<PJRST [
$CALL FNDDST ; Get destination index
JUMPF [$RETT] ; if there is one...
JUMPL S1,OBJ1
MOVEM S1,DSOBJN##(I1) ; Save in table.
SETZM DSOBJS##(I2)
$RETT
OBJ1: SETZM DSOBJN##(I1)
$SAVEC
MOVE S2,PRMBLK
MOVEI C5,DSOBJS##(I2) ; to
HRLI C5,(POINT 7,0) ; the receiving area.
LOAD C4,(S2),PRSMAX ; maximum number of characters,
MOVEI C2,1(S1) ; get argument
HRLI C2,(POINT 7,0)
MOVE C1,C4 ; src to dest
EXTEND C1,[MOVSLJ 0 ; Move string left justified
0] ; with zero fill.
JFCL ; Ignore failure.
$RETT]>
$EOB
XS350:: $BUILD PRMSIZ ; MODULE X25-SERVER PRIORITY
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
MOVEI [ITEXT(Priority = ^D/@XS350+PRMPTR/)]
$RET]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D255
$SET ,PRMINI,^D0
$SET ,PRMADR,<Z DSPRIO##(I1)>
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMPUR,,<SETZ S1,>
$SET PRMSTR,,<PJRST DSTNUM>
$EOB
XS351:: $BUILD PRMSIZ ; MODULE X25-SERVER CALL MASK
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Call Mask = ^T/@XS351+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z DSMASK##(I2)>
$SET PRMDEF,,<$CALL P$FLD##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DSTHEX>
$EOB
XS352:: $BUILD PRMSIZ ; MODULE X25-SERVER CALL VALUE
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Call Value = ^T/@XS352+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z DSVAL##(I2)>
$SET PRMDEF,,<$CALL P$FLD##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DSTHEX>
$EOB
XS353:: $BUILD PRMSIZ ; MODULE X25-SERVER GROUP
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Group = ^T/@XS353+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z DSGRUP##(I2)>
$SET PRMDEF,,<$CALL P$FLD##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DSTFLD>
$EOB
XS354:: $BUILD PRMSIZ ; MODULE X25-SERVER NUMBER
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Number = ^T/@XS354+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z DSNUM##(I2)>
$SET PRMDEF,,<$CALL P$FLD##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DSTFLD>
$EOB
XS355:: $BUILD PRMSIZ ; MODULE X25-SERVER SUBADDRESSES
$SET ,PRSTYP,NX25##
$SET PRMDSP,,[
SKIPGE DSSUBL(I1)
$RET
MOVE DSSUBL(I1)
CAMN DSSUBH(I1)
JRST [ MOVEI [ITEXT(Subaddress = ^D/DSSUBL##(I1)/)]
$RET]
MOVEI [ITEXT(Subaddresses = ^D/DSSUBL##(I1)/-^D/DSSUBH##(I1)/)]
$RET]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,^D99
$SET ,PRMINI,[EXP -1,^D100]
$SET ,PRMADR,[
Z DSSUBL##(I1)
Z DSSUBH##(I1)]
$SET PRMDEF,,<$CALL [
$CALL P$NUM##
MOVEM S1,DEFRNG+0
MOVEM S1,DEFRNG+1
$CALL P$TOK##
JUMPF SBR1
$CALL P$NUM##
CAMGE S1,DEFRNG+0
JRST [ $DEFFAIL(Subaddress range must be ascending)]
MOVEM S1,DEFRNG+1
SBR1: MOVEI S1,DEFRNG
$RETT]>
$SET PRMPUR,,<MOVEI S1,[EXP -1,^D100]>
$SET PRMSTR,,<PJRST [
$CALL FNDDST ; Get destination index
JUMPF [$RETT] ; if there is one...
MOVE S2,PRMBLK ; Get parameter block
MOVE S2,PRMPTR(S2)
MOVE 0(S1)
MOVEM @0(S2) ; Save low
MOVE 1(S1)
MOVEM @1(S2) ; and high.
$RETT]>
$EOB
XSS0:: $BUILD PRMSIZ ; MODULE X25-SERVER MAXIMUM DESTINATIONS
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Destinations = ^D/@XSS0+PRMPTR/)]
$SET ,PRSMIN,^D0
$SET ,PRSMAX,DSSIZ##
$SET ,PRMINI,^D4
$SET ,PRMADR,XTPDST##
$SET ,PRMDFL,XTDDST##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
XSS1:: $BUILD PRMSIZ ; MODULE X25-SERVER MAXIMUM CIRCUITS
$SET ,PRSTYP,NX25##
$SET ,PRMTXT,[ITEXT(Maximum Circuits = ^D/@XSS1+PRMPTR/)]
$SET ,PRSMIN,^D1
$SET ,PRSMAX,DSSIZ##
$SET ,PRMINI,^D8
$SET ,PRMADR,XTDCKT##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
PAGE
SUBTTL - Module MCB-Executive Parameters
DMS0:: $BUILD PRMSIZ ; MCB-EXECUTIVE PROCESS
$SET ,PRSPRV,1
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D3
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z PRCNAM##(I1)>
$SET PRMDEF,,<$CALL KDEFMP>
$SET PRMPUR,,<$CALL KPURMP>
$SET PRMSTR,,<$RETT>
$EOB
MPS0:: $BUILD PRMSIZ ; MCB-EXECUTIVE PROCESS LLC
$SET ,PRSPRV,1
$SET ,PRMINI,-1
$SET ,PRMADR,<Z PRCUSE##(I1)>
$SET PRMDEF,,<SETZ S1,>
$SET PRMPUR,,<SETZ S1,>
$SET PRMSTR,,<PJRST DSTNUM>
$EOB
MPS1:: $BUILD PRMSIZ ; MCB-EXECUTIVE PROCESS DRIVER
$SET ,PRSPRV,1
$SET ,PRSMIN,1
$SET ,PRSMAX,2
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z PRCDRV##(I1)>
$SET PRMDEF,,<$CALL P$FLD##>
$SET PRMPUR,,<MOVEI S1,NULTXT-1>
$SET PRMSTR,,<PJRST DSTFLD>
$EOB
DMS1:: $BUILD PRMSIZ ; MCB-EXECUTIVE CCBS
$SET ,PRSPRV,1
$SET ,PRSMIN,^D20
$SET ,PRSMAX,^D200
$SET ,PRMINI,^D64
$SET ,PRMADR,CCBNUM##
$SET ,PRMDFL,CCBSTA##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
DMS2:: $BUILD PRMSIZ ; MCB-EXECUTIVE RDBS
$SET ,PRSPRV,1
$SET ,PRSMIN,^D6
$SET ,PRSMAX,^D200
$SET ,PRMINI,^D64
$SET ,PRMADR,RDBNUM##
$SET ,PRMDFL,RDBSTA##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
PAGE
SUBTTL - Module RSX-Executive Parameters
DMS3:: $BUILD PRMSIZ ; RSX-EXECUTIVE TASK
$SET ,PRSPRV,1
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D6
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z RSTNAM##(I2)>
$SET PRMDEF,,<PJRST KDEFRT>
$SET PRMPUR,,<PJRST KPURRT>
$EOB
RTS0:: $BUILD PRMSIZ ; RSX-EXECUTIVE TASK DELAY
$SET ,PRSPRV,1
$SET ,PRMINI,-1
$SET ,PRMADR,<Z RSTUSE##(I1)>
$EOB
DMS4:: $BUILD PRMSIZ ; RSX-EXECUTIVE DRIVER
$SET ,PRSPRV,1
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D2
$SET ,PRMINI,<NULTXT-1>
$SET ,PRMADR,<Z RSDNAM##(I2)>
$SET PRMDEF,,<$CALL KDEFRD>
$SET PRMPUR,,<$CALL KPURRD>
$SET PRMSTR,,<$RETT>
$EOB
PAGE
SUBTTL - Process DMC Parameters
DPD1:: $BUILD PRMSIZ ; PROCESS DMC TRANSMIT BUFFERS
$SET ,PRSPRV,1
$SET ,PRSMIN,^D1
$SET ,PRSMAX,^D16
$SET ,PRMINI,^D7
$SET ,PRMADR,DMCPXB##
$SET PRMDEF,,<$CALL P$NUM##>
$SET PRMSTR,,<PJRST DEFNUM>
$EOB
SUBTTL Top Level Semantic Parser
;
; Command semantic parser
;
ENTBLK::BLOCK 1 ;Entity block address
PRMBLK::BLOCK 1 ;Parameter block address
QUABLK::BLOCK 1 ;Qualifier block address
NODNUM: BLOCK 1 ;Parsed node number
ENTNAM: BLOCK <<^D16+1+4>/5> ;Parsed entity name
QUANAM: BLOCK <<^D16+1+4>/5> ;Parsed qualifier name
;GRPNAM:BLOCK <<^D16+1+4>/5> ;Parsed GROUP name
NULTXT: ASCII \\ ;Null string for purges
DEFRNG: BLOCK 2 ;Range holding area
KDEF:: SETZM DEFPUR#
AOSA DEFPUR#
KLIS:: SETZM DEFPUR#
SKIPA
KPUR:: SETOM DEFPUR#
SETZM ENTBLK
SETZM PRMBLK
SETZM QUABLK
SETZM NODNUM ; Clear out holding areas
SETZM ENTNAM
SETZM QUANAM
SETOM DEVTYP##
KDEF1: $CALL P$KEYW## ; Get parse block.
JUMPF KDEF7 ; If there is one
JUMPE S1,KDEF1 ; then
LOAD TF,PRSFLG(S1) ; pick up flags.
TXNE TF,PRSENT ; Entity:
JRST [ MOVEM S1,ENTBLK ; Save entity block
$CALL ENTDEF(S1) ; get individual entity
JRST KDEF1]
TXNE TF,PRSQUA ; Qualifier:
JRST [ MOVEM S1,QUABLK ; save qualifier block
$CALL ENTDEF(S1) ; get individual qualifier
JRST KDEF1]
MOVEM S1,PRMBLK ;Save parameter block
KDEF2: $CALL P$KEYW##
JUMPT [ CAIN S1,DEFSKP##
JRST KDEF2
$CALL P$PREV##
JRST .+1]
SETT
MOVE S1,PRMBLK
SKIPLE DEFPUR#
XCT PRMDEF(S1)
JUMPF [$RETT]
SKIPGE DEFPUR#
XCT PRMPUR(S1)
JUMPF [$RETT]
SKIPE DEFPUR#
MOVEM S1,DEFARG#
JRST KDEF1 ; Go back for more.
KDEF7: $CALL P$CFM## ; If not EOF,
JUMPF [ $SEMFAIL(End of line not found)] ; complain.
MOVE T3,QUABLK
MOVE T2,PRMBLK
MOVE T1,ENTBLK
JUMPE T2,KDEF8 ; If parameter
LOAD S1,(T2),PRSTYP ; is restricted,
JUMPE S1,KDEF8 ; then
CAME S1,NODTYP## ; notify against node type.
$TEXT ,<%Parameter only applicable to a ^T/@NTYTXT(S1)/ node>
KDEF8: MOVE S1,DEFARG#
SKIPN DEFPUR#
PJRST ENTLIS(T1) ; List or
PJRST PRMSTR(T2) ; Define/Purge.
NTYTXT: EXP 0
EXP [ASCIZ/DN20/]
EXP [ASCIZ/DN200/]
EXP [ASCIZ/X25/]
SUBTTL General Define/Purge Semantic Processors
;
; DEFINE/PURGE * * * * * * *
;
DEFNOD: SETZM NAMFLG## ;pad name with nulls [S.T. 28-Jan-81]
AOJ S1, ;point to string
$CALL GETNOD## ;EXTRACT NODE NAME INTO S1, S2
MOVE T1,PRMBLK ;Get parameter block
MOVEI T1,@PRMPTR(T1) ;for parameter address
DMOVEM S1,0(T1) ;REMEMBER IT
JRST KDEFDN
DEFNUM: MOVE S2,PRMBLK ; Get parameter block
MOVEM S1,@PRMPTR(S2) ; and save in table.
JRST KDEFDN
DEFTXU: MOVE T1,PRMBLK ; Get parameter block
LOAD T4,(T1),PRSMAX ; maximum number of characters,
MOVEI T2,1(S1) ; from address in (S1)+1
HRLI T2,(POINT 7,0)
MOVEI T3,@PRMPTR(T1) ; to the receiving area.
HRLI T3,(POINT 7,0)
DEFTX1: MOVE S2,T2 ; Save pointer
ILDB T1,T2 ; and
SKIPN T1 ; if end of string
MOVE T2,S2 ; then back it up.
CAIL T1,"a" ; Raise lower case
CAILE T1,"z"
SKIPA
SUBI T1,<"a"-"A"> ; and
IDPB T1,T3 ; store in destination.
SOJG T4,DEFTX1 ; Do for parameter length.
$RETT
DEFTXT: $SAVEC
MOVE S2,PRMBLK ;Get parameter block
LOAD C1,(S2),PRSMAX ;MAXIMUM NUMBER OF CHARACTERS,
MOVEI C2,1(S1) ;FROM ADDRESS IN (S1)+1
HRLI C2,(POINT 7,0)
MOVE C4,C1 ; src and dest
MOVEI C5,@PRMPTR(S2) ;TO
HRLI C5,(POINT 7,0) ;THE RECEIVING AREA
EXTEND C1,[MOVSLJ 0 ;MOVE STRING LEFT JUSTIFIED WITH
0] ; ZERO FILL
JFCL ;ignore failre
KDEFDN: MOVE S1,PRMBLK ;Get parameter block
LOAD S1,(S1),PRMDFL
SKIPE S1
SETZM 0(S1) ;Indicate not defaulted anymore
$RETT
SUBTTL Module MCB-Executive Semantic Processors
KDEFMP: CALL P$FLD## ;Get process name
AOJ S1, ;point to string
SETZM NAMFLG## ;pad w/nulls to 6 char [S.T. 28-Jan-81]
$CALL GETNOD## ;USE A COMMON ROUTINE TO GET MCB NAME
;IGNORE ERROR RETURN
AND S1,[BYTE (7) 177,177,177] ;JUST THREE CHARACTERS
CAMN S1,[ASCII/MDT/] ;If the debugger,
JRST [ SETZM PRCMDT## ;then special handling.
$RETT]
SETZ T1, ;INITIALIZE SCAN COUNT
MCBPR1: CAMLE T1,PRCPTR## ;FINISHED SCAN?
JRST MCBPR2 ;YES - STORE NEW INFO
CAMN S1,PRCNAM##(T1) ;CHECK NAME
$RETT
AOJA T1,MCBPR1 ;GO CHECK NEXT ENTRY
MCBPR2: AOS T1,PRCPTR## ;INCREMENT AND GET POINTER
CAIL T1,NUMPRC## ;ROOM FOR ANOTHER PROCESS?
JRST [SOS PRCPTR## ;NO - CORRECT FOR AOS
$SEMFAIL(No room for process)]
MOVE T2,PRMBLK ;Save
STORE T1,PRMPTR(T2) ;the index.
MOVEM S1,PRCNAM##(T1) ;New process
SETOM PRCUSE##(T1) ;not LLC
SETZM PRCDRV##(T1) ;and no driver.
CALL P$KEYW## ;If that is all
JUMPF [$RETT] ;then quit.
MOVE T2,PRMBLK ;Get then
LOAD T1,PRMPTR(T2) ;index back
SETZM PRCUSE##(T1) ;If is LLC
JUMPN S1,[$RETT] ;then done.
;Get RSX driver name
$RETT ;and return
KPURMP: $CALL P$FLD## ;get name
AOJ S1, ;point to name string
SETZM NAMFLG## ;pad w/nulls [S.T. 28-JAN-81]
$CALL GETNOD## ;USE S1 COMMON ROUTINE TO GET MCB NAME
;IGNORE ERROR RETURN
AND S1,[BYTE (7) 177,177,177] ;JUST THREE CHARACTERS
CAMN S1,[ASCII/MDT/] ;If the debugger,
JRST [ SETOM PRCMDT## ;then special handling.
$RETT]
SETZ T1, ;INITIALIZE SCAN COUNT
MCBPR3: CAMLE T1,PRCPTR## ;FINISHED SCAN?
JRST [$SEMFAIL(Unrecognized process)]
CAME S1,PRCNAM##(T1) ;CHECK NAME
AOJA T1,MCBPR3 ;NO - GO CHECK NEXT ENTRY
MCBPR4: CAMLE T1,PRCPTR## ;DONE SHUFFLING?
JRST [SOS PRCPTR## ;YES - ONE LESS PROCES
$RETT] ; AND WE ARE DONE
MOVE T2,PRCNAM##+1(T1) ;NO GET NEXT PROCESS ON LIST
MOVEM T2,PRCNAM##(T1) ;AND SHUFFLE UP ONE
MOVE T2,PRCUSE##+1(T1) ;ITS USE
MOVEM T2,PRCUSE##(T1) ;SHUFFLE
MOVE T2,PRCDRV##+1(T1) ;THE DRIVER
MOVEM T2,PRCDRV##(T1) ;SHUFFLE
AOJA T1,MCBPR4 ;BACK FOR NEXT PROCESS
SUBTTL Module RSX-Executive Semantic Processors
KDEFRT: CALL P$FLD## ;Get process name
AOJ S1, ;point to string
SETOM NAMFLG## ;pad w/blanks to 6 char
$CALL GETNOD## ;USE A COMMON ROUTINE TO GET RSX NAME
;IGNORE ERROR RETURN
CAMN S1,[ASCII/NML /] ;If NML,
CAME S2,[ASCII/ /]
SKIPA
JRST [SETZM NMLTYP## ;then special handling.
$RETT]
CAMN S1,[ASCII/NMS /] ;If NMS,
CAME S2,[ASCII/ /]
SKIPA
JRST [SETZM NMLTYP## ;then special handling.
AOS NMLTYP##
$RETT]
SETZB T1,T2 ;INITIALIZE SCAN COUNT
RSXTA1: CAMLE T1,RSTPTR## ;FINISHED SCAN?
JRST RSXTA2 ;YES - STORE NEW INFO
CAMN S1,RSTNAM##+0(T2) ;CHECK NAME
CAME S2,RSTNAM##+1(T2)
SKIPA
$RETT
ADDI T2,2
AOJA T1,RSXTA1 ;GO CHECK NEXT ENTRY
RSXTA2: AOS T1,RSTPTR## ;INCREMENT AND GET POINTER
CAIL T1,NUMPRC## ;ROOM FOR ANOTHER TASK?
JRST [SOS RSTPTR## ;NO - CORRECT FOR AOS
$SEMFAIL(No room for task)]
SETOM RSTUSE##(T1) ;not started
ADD T1,T1
MOVEM S1,RSTNAM##+0(T1) ;New task
MOVEM S2,RSTNAM##+1(T1)
$RETT ;and return
KPURRT: $CALL P$FLD## ;get name
AOJ S1, ;point to string
SETOM NAMFLG## ;pad w/blanks to 6 char
$CALL GETNOD## ;USE A COMMON ROUTINE TO GET RSX NAME
;IGNORE ERROR RETURN
CAMN S1,[ASCII/NML /] ;If NML,
CAME S2,[ASCII/ /]
SKIPA
JRST [SKIPE NMLTYP##
JRST RSXTA3+1
SETOM NMLTYP## ;then special handling.
$RETT]
CAMN S1,[ASCII/NMS /] ;If NMS,
CAME S2,[ASCII/ /]
SKIPA
JRST [SKIPG NMLTYP##
JRST RSXTA3+1
SETOM NMLTYP## ;then special handling.
$RETT]
SETZB T1,T2 ;INITIALIZE SCAN COUNT
RSXTA3: CAMLE T1,RSTPTR## ;FINISHED SCAN?
JRST [$SEMFAIL(Unrecognized task)]
CAMN S1,RSTNAM##+0(T2) ;CHECK NAME
CAME S2,RSTNAM##+1(T2)
SKIPA
JRST RSXTA4
ADDI T2,2
AOJA T1,RSXTA3 ;GO CHECK NEXT ENTRY
RSXTA4: CAMLE T1,RSTPTR## ;DONE SHUFFLING?
JRST [SOS RSTPTR## ;YES - ONE LESS TASK
$RETT] ; AND WE ARE DONE
MOVE S1,RSTNAM##+2(T2) ;NO GET NEXT TASK ON LIST
MOVE S2,RSTNAM##+3(T2)
MOVEM S1,RSTNAM##+0(T2) ;AND SHUFFLE UP ONE
MOVEM S2,RSTNAM##+1(T2)
MOVE S1,RSTUSE##+1(T1) ;ITS USE
MOVEM S1,RSTUSE##(T1) ;SHUFFLE
ADDI T2,2
AOJA T1,RSXTA4 ;BACK FOR NEXT TASK
KDEFRD: CALL P$FLD## ;Get driver name
AOJ S1, ;point to string
SETZM NAMFLG## ;pad w/nulls to 2 char
$CALL GETNOD## ;USE A COMMON ROUTINE TO GET RSX NAME
;IGNORE ERROR RETURN
CAMN S1,[ASCII/TT/] ;If TT,
JRST [ ;then special handling.
$RETT]
SETZ T1, ;INITIALIZE SCAN COUNT
RSXDR1: CAMLE T1,RSDPTR## ;FINISHED SCAN?
JRST RSXDR2 ;YES - STORE NEW INFO
CAMN S1,RSDNAM##(T1) ;CHECK NAME
$RETT
AOJA T1,RSXDR1 ;GO CHECK NEXT ENTRY
RSXDR2: AOS T1,RSDPTR## ;INCREMENT AND GET POINTER
CAIL T1,NUMPRC## ;ROOM FOR ANOTHER DRIVER?
JRST [SOS RSDPTR## ;NO - CORRECT FOR AOS
$SEMFAIL(No room for driver)]
MOVEM S1,RSDNAM##(T1) ;New driver
$RETT ;and return
KPURRD: $CALL P$FLD## ;get name
AOJ S1, ;point to string
SETZM NAMFLG## ;pad w/nulls to 2 char
$CALL GETNOD## ;USE A COMMON ROUTINE TO GET RSX NAME
;IGNORE ERROR RETURN
CAMN S1,[ASCII/TT/] ;If TT,
JRST [ ;then special handling.
$RETT]
SETZ T1, ;INITIALIZE SCAN COUNT
RSXDR3: CAMLE T1,RSDPTR## ;FINISHED SCAN?
JRST [$SEMFAIL(Unrecognized driver)]
CAMN S1,RSDNAM##(T1) ;CHECK NAME
$RETT
AOJA T1,RSXDR3 ;GO CHECK NEXT ENTRY
RSXDR4: CAMLE T1,RSDPTR## ;DONE SHUFFLING?
JRST [SOS RSDPTR## ;YES - ONE LESS DRIVER
$RETT] ; AND WE ARE DONE
MOVE S1,RSDNAM##+1(T1) ;NO GET NEXT DRIVER ON LIST
MOVEM S1,RSTNAM##(T1) ;AND SHUFFLE UP ONE
AOJA T1,RSXDR4 ;BACK FOR NEXT DRIVER
SUBTTL Entity/Qualifier List Processing
;
; Entity/Qualifier list processing
;
FNDENT::SKIPA LP,ENTBLK
FNDQUA::MOVE LP,QUABLK
$SAVEC
SETZB I1,I2 ; Start off at zero.
FNDLS1: CAMN I1,@ECUR(LP) ; For each defined item
$RETF
SKIPN EMAX(LP)
JRST [ SKIPN @EPTR(LP)
JRST FNDSL2
JRST .+1]
LOAD C1,(LP),PRSMAX ; source length
LOAD C2,(LP),ENTADR ; source pointer
HRLI C2,(POINT 7,0) ; (entity name)
MOVE C4,C1 ; destination length
MOVEI C5,@EPTR(LP) ; destination pointer
HRLI C5,(POINT 7,0) ; (list name)
EXTEND C1,[CMPSN 0 ; If equal
0,0] ; then
$RETT ; all done.
FNDSL2: ADD I2,EINC(LP)
AOJA I1,FNDLS1
SETQUA: MOVE LP,QUABLK
$SAVEC
LOAD C1,(LP),PRSMAX
MOVEI C2,@EPTR(LP)
HRLI C2,(POINT 7,0)
MOVE C4,C1
LOAD C5,(LP),ENTADR
HRLI C5,(POINT 7,0)
EXTEND C1,[MOVSLJ 0
0]
JFCL
$RET
ADDENT::SKIPA LP,ENTBLK
ADDQUA::MOVE LP,QUABLK
$SAVEC
SKIPN EMAX(LP)
JRST [ $CALL DEVUNT##
JRST ADDLS1]
MOVE I1,@ECUR(LP)
MOVE I2,I1
IMUL I2,EINC(LP)
AOS @ECUR(LP) ; One more item...
ADDLS1: LOAD C1,(LP),PRSMAX ; source length
LOAD C2,(LP),ENTADR ; source pointer
HRLI C2,(POINT 7,0) ; (entity name)
MOVE C4,C1 ; destination length
MOVEI C5,@EPTR(LP) ; destination pointer
HRLI C5,(POINT 7,0) ; (list name)
EXTEND C1,[MOVSLJ 0 ; Copy the string.
0]
JFCL
LOAD C5,(LP),EPRM
JUMPE C5,ADDLS9
MOVE C6,PRMBLK
ADDLS3: SKIPN S2,0(C5) ; For each parameter
JRST ADDLS8
MOVEM S2,PRMBLK
LOAD S1,(S2),PRMINI ; get the initial value
SKIPE PRMSTR(S2) ; and
$CALL PRMSTR(S2) ; store it.
AOJA C5,ADDLS3
ADDLS8: MOVEM C6,PRMBLK
ADDLS9: $RETT
LINDEV: SKIPL DEVTYP##
JRST DEVUNT##
$CALL DEVPRS##
JUMPF FNDLI9
$CALL DEVCHK##
JUMPT DEVUNT##
FNDLI9: $DEFFAIL(Line not defined)
CIRDEV: SKIPL DEVTYP##
JRST DEVUNT##
$CALL DEVPRS##
JUMPF CIRDE8
$CALL DEVCHK##
JUMPT DEVUNT##
PJRST FNDCI9
CIRDE8: $CALL FNDENT
JUMPF FNDCI9
NMEPNA: $DEFFAIL(Parameter not applicable)
SUBTTL X.25 Circuit Processors
;
; X.25 Circuit Entity handlers
;
CIRNUM: $CALL FNDCIR ; Get circuit index
JUMPF [$RETT] ; if there is one...
PJRST DEFNUM ; Store the number.
CIRFLD: $CALL FNDCIR ; Get circuit index
JUMPF [$RETT] ; if there is one...
PJRST DEFTXT ; Copy the text.
CIRTYP: CAIE S1,^D3 ; If not X25 circuit
PJRST DELCIR ; then delete the circuit.
MOVE T3,NODTYP## ; Otherwise
CAIN T3,NX25## ; if allowed
PJRST ADDCIR ; then add it.
$SEMFAIL(Only settable on a X25 node)
FNDCIR: $CALL DEVPRS##
JUMPT [ $CALL DEVCHK##
JUMPT NMEPNA
JRST FNDCI9]
$CALL FNDENT
$RETIT
FNDCI9: $DEFFAIL(Circuit not defined)
ADDCIR: $CALL FNDENT ; Add CIRCUIT.
JUMPT [ $SEMFAIL(Circuit name already exists)]
CAMN I1,EMAX(LP)
JRST [ $SEMFAIL(Maximum number of circuits exceeded)]
PJRST ADDENT ; Use common code.
DELCIR: $CALL FNDCIR ; Delete CIRCUIT.
JUMPF [$RETT]
$SAVEC
SOS @ECUR(LP)
DELCI1: CAMN I1,@ECUR(LP)
$RETT
LOAD C1,(LP),PRSMAX
MOVE C4,C1
MOVEI C5,@EPTR(LP)
HRLI C5,(POINT 7,0)
MOVEI C2,4(C5)
HRLI C2,(POINT 7,0)
EXTEND C1,[MOVSLJ 0
0]
JFCL
MOVE CIRCHP##+1(I1)
MOVEM CIRCHP##(I1)
MOVE MXDATP##+1(I1)
MOVEM MXDATP##(I1)
MOVE MXWINP##+1(I1)
MOVEM MXWINP##(I1)
ADD I2,EINC(LP)
AOJA I1,DELCI1
SUBTTL X.25 Destination Qualifier Processors
;
; X.25 Destination Qualifier Handlers
;
DSTNUM: $CALL FNDDST ; Get destination index
JUMPF [$RETT] ; if there is one...
PJRST DEFNUM ; Store number.
DSTFLD: $CALL FNDDST ; Get destination index
JUMPF [$RETT] ; if there is one...
PJRST DEFTXT ; Store the text.
DSTHEX: $CALL FNDDST ; Get destination index
JUMPF [$RETT] ; if there is one...
PJRST DEFTXU ; Store the text.
FNDDST: MOVE LP,QUABLK
$SAVE <S1,S2>
LOAD S1,(LP),ENTADR
SKIPN 0(S1)
JRST [ MOVE S1,@ECUR(LP)
SOJN S1,[$SEMFAIL(Destination not given)]
SETZB I1,I2
PJRST SETQUA]
$CALL FNDQUA ; Find DESTINATION.
$RETIT
CAME I1,EMAX(LP)
CAML I1,XTPDST##
JRST [$SEMFAIL(Maximum number of destinations exceeded)]
$CALL ADDQUA ; Use common code.
PJRST FNDQUA
DSTPUR: MOVE LP,QUABLK ; PURGE DESTINATION
SKIPG PRMPTR(LP) ; Was there a qualifier specfied?
PJRST [SETZM @ECUR(LP) ; Known destination purged.
$RETT]
DELDST: $CALL FNDQUA ; Delete DESTINATION.
JUMPF [$RETT]
$SAVEC
SOS @ECUR(LP)
DELDS1: CAMN I1,@ECUR(LP)
$RETT
MOVEI C5,@EPTR(LP)
HRLI C5,(POINT 7,0)
LOAD C4,(LP),PRSMAX
MOVE C2,C5
ADD C2,EINC(LP)
MOVE C1,C4
EXTEND C1,[MOVSLJ 0
0]
JFCL
MOVEI C5,DSACCT##(I1)
$CALL DCMPRS
MOVEI C5,DSMASK##(I1)
$CALL DCMPRS
MOVEI C5,DSVAL##(I1)
$CALL DCMPRS
MOVEI C5,DSNUM##(I1)
$CALL DCMPRS
MOVEI C5,DSOBJS##(I1)
$CALL DCMPRS
MOVEI C5,DSPASS##(I1)
$CALL DCMPRS
MOVEI C5,DSUSER##(I1)
$CALL DCMPRS
MOVEI C5,DSNODE##(I1)
$CALL DCMPRS
MOVEI C5,DSGRUP##(I1)
$CALL DCMPRS
MOVE DSOBJN##+1(I1)
MOVEM DSOBJN##(I1)
MOVE DSSUBL##+1(I1)
MOVEM DSSUBL##(I1)
MOVE DSSUBH##+1(I1)
MOVEM DSSUBH##(I1)
MOVE DSPRIO##+1(I1)
MOVEM DSPRIO##(I1)
ADD I2,EINC(LP)
AOJA I1,DELDS1
DCMPRS: HRLI C5,(point 7,0) ; Destination pointer
MOVEI C4,DSSSIZ##*5 ; Maximum string size
MOVE C2,C5
ADDI C2,DSSSIZ## ; Source pointer
MOVE C1,C4
EXTEND C1,[MOVSLJ 0
0]
JFCL
$RETT
SUBTTL X.25 Group Qualifier Processors
DGRPI: BLOCK 1
UGDTE: $CALL P$FLD ; Get the DTE address string
$CALL FNDDTE ; See if DTE id defined.
JUMPF [$SEMFAIL(DTE not defined)]
MOVEM I1,DGRPI ; Remember DTE number.
$CALL FNDQUA ; Find the Group qualifier if existent.
JUMPT GRPDT0 ; Already there, to set up DTE address.
CAME I1,EMAX(LP) ; Is there room for another?
CAML I1,XTPUGS## ; ---ditto---
JRST [$SEMFAIL(Maximum number of groups exceeded)]
$CALL ADDQUA ; Go add this one.
GRPDT0: $RETT ; Return okay.a
UGNUM: $CALL P$NUM ; Get the User Group Number
$CALL FNDQUA ; Find the Group. It must be there.
SETZM GRPTYP(I1) ; Initialize group type
MOVE I2,DGRPI
IMULI I2,NUMDUP
ADD I1,I2 ; For proper DTE
PJRST DEFNUM ; Go store the group number.
UGTYP: $CALL FNDQUA ; Find the Group. It must be there.
MOVEM S1,GRPTYP(I1) ; Store the Type
$RETT ; Return
GRPPUR: MOVE LP,QUABLK ; Get qualifier block
SKIPG PRMPTR(LP)
PJRST [SETZM @ECUR(LP)
$RETT]
DELGRP: $CALL FNDQUA ; Find the qualifier
JUMPF [$RETT] ; Not there, nothing to purge
$SAVEC
SOS @ECUR(LP) ; One less qualifier
DELGR1: CAMN I1,@ECUR(LP)
$RETT
MOVEI C5,@EPTR(LP)
HRLI C5,(POINT 7,0)
LOAD C4,(LP),PRSMAX
MOVE C2,C5
ADD C2,EINC(LP)
MOVE C1,C4
EXTEND C1,[MOVSLJ 0
0]
JFCL
MOVEI C5,GRPDTE##(I1)
$CALL DCMPRS
MOVE GRPNUM##+1(I1)
MOVEM GRPNUM##(I1)
MOVE GRPTYP##+1(I1)
MOVEM GRPTYP##(I1)
ADD I2,EINC(LP)
AOJA I1,DELGR1
FNDDTE: $SAVEC
SETZB I1,I2 ; Zero pointers
DTENXT: CAIN I2,NUMDUP*4 ; At end of DTEADR list yet?
$RETF ; Yes, not found
MOVE S2,PRMBLK
LOAD C1,(S2),PRSMAX ; Source length
MOVEI C2,1(S1) ; Source string address
HRLI C2,(POINT 7,0) ; Source string pointer
MOVEI C5,DTEADR(I2) ; Address in list
HRLI C5,(POINT 7,0) ; Pointer to entry in list
SETZM C3
SETZM C4
DTENX0: ILDB C3,C2
ILDB C4,C5
SKIPN C3
JUMPE C4,[$RETT]
CAMN C4,C3
SOJG C1,DTENX0
ADDI I2,4 ; Index to next entry in list
SKIPE DTEADR(I2) ;
AOS I1 ; Keep track of DTE number
JUMPA DTENXT ; Continue looking
SUBTTL General List Processors
;
; LIST * * * * * * * *
;
; Display parameters from list of parameter blocks
;
LISLD: SKIPN T3,0(T4) ; Get parameter block
$RETT ; (if there is one)
; LOAD T1,(T3),PRSPRV ; and get privledged bit.
; ANDCM T1,PRVLDG ; Determine if
; JUMPN T1,LISLD9 ; not allowed.
LOAD T1,(T3),PRSTYP ; Determine
JUMPE T1,LISLD2 ; node type preference
SKIPN PRVLDG(T1) ; and quit
JRST LISLD9 ; if not enabled.
LISLD2: LOAD TF,(T3),PRMTXT ; Get text pointer
MOVE T1,@PRMPTR(T3) ; and parameter.
JUMPN TF,LISLD3
SKIPE PRMDSP(T3)
$CALL @PRMDSP(T3)
JRST LISLD4
LISLD3: SKIPE PRMPUR(T3)
JUMPE T1,[SETZ TF,
JRST LISLD4]
LISLD4: SKIPE T2,TF
$TEXT ,< ^I/(T2)/>
LISLD9: AOJA T4,LISLD
SUBTTL List Node Processor
LISN: $CALL SETDFL## ;Make sure defaults are set
SKIPG I1,NODNUM
LOAD I1,@DN502+PRMPTR
CAMN I1,@DN502+PRMPTR
$TEXT ,<^M^J Executor Node = ^D/NTPSLF/ (^T/NODNAM/)^M^J>
CAME I1,@DN502+PRMPTR
$TEXT ,<^M^J Remote Node = ^D/NODNUM/ ()^M^J>
MOVEI T4,LDP
SKIPN PRVLDG##
MOVEI T4,LDE
CAME I1,@DN502+PRMPTR
MOVEI T4,LDN
PJRST LISLD
LDP: EXP DN100,DN101,DN150,DN151,DN152
EXP DN510,DN511
EXP DN700,DN710,DN720,DN721,DN722,DN723
EXP DN900,DN901,DN910,DN920,DN921,DN922,DN923,DN924,DN930,DN931
EXP DNS14,DNS0,DNS1,DNS5,DNS2,DNS3,DNS4,DNS7,DNS9,DNS8
EXP DNS10,DNS12,DNS13,DNS11
EXP 0
LDE: EXP DN100,DN101,DN150,DN151,DN152
EXP DN510,DN511
EXP DN700,DN710,DN720,DN721,DN722,DN723
EXP DN900,DN901,DN910,DN920,DN921,DN922,DN923,DN924,DN930,DN931
EXP DNS1,DNS5
EXP 0
LDN: EXP DNS14
EXP 0
SUBTTL List Circuit Processors
LISKC: $CALL LISXC ; List Known Circuits
PJRST LISDC
LISXC: SETZB I1,I2 ; Start off at zero.
LISXC1: CAMN I1,@ENTCIR+ECUR ; For each defined item
$RETT ; all done.
$TEXT ,<^M^J Circuit = ^T/X25CIR##(I2)/^M^J>
MOVEI T4,LDXC
$CALL LISLD
ADD I2,ENTCIR+EINC
AOJA I1,LISXC1
LDXC: EXP XC1111,XC1112,XC1120,XC1121,XC1122,XC1123
EXP 0
EXT <DEVTXT,CTLNUM,UNTNUM>
EXT <DTENUM,DTECST>
EXT <DMCNUM,NUMDMC,DMCUSE,DMCCST>
EXT <DMRNUM,NUMDMR,DMRUSE,DMRCST>
EXT <KDPNUM,NUMKDP,KDPLNM,DUPUSE,LNTYP,DUPCST>
EXT <NTPT3,NTPT4,NTPSLF,NODNAM>
LISDC: $CALL SETDFL## ;Make sure defaults are set
SKIPG S2,DTENUM##
JRST LKC1
$CALL DEVDTE##
$TEXT ,<^M^J Circuit = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/^M^J>
$TEXT ,< Cost = ^D/DTECST/>
$CALL LISXPT
$TEXT ,< Line = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/>
LKC1: SKIPG P1,DMCNUM ;DO WE HAVE DMC11S?
JRST LKC4 ;NO - DON'T SAY ANYTHING ABOUT THEM
$CALL DEVDMC##
LKC2: $CALL DEVUNT##
SKIPGE DMCUSE##(I1) ;THIS DMC IN USE?
JRST LKC3 ;NO
$TEXT ,<^M^J Circuit = ^T/DEVTXT/-^D/CTLNUM/^M^J>
$TEXT ,< Cost = ^D/DMCCST(I1)/>
$CALL LISXPT
$TEXT ,< Line = ^T/DEVTXT/-^D/CTLNUM/>
$TEXT ,< Type = DDCMP-DMC>
LKC3: AOS CTLNUM##
SOJG P1,LKC2 ;DO ALL DMC11S
LKC4: SKIPG P1,DMRNUM## ;DO WE HAVE DMR11S?
JRST LKC7 ;NO - DON'T SAY ANYTHING ABOUT THEM
$CALL DEVDMR##
LKC5: $CALL DEVUNT##
SKIPGE DMRUSE##(I1) ;THIS DMR IN USE?
JRST LKC6 ;NO
$TEXT ,<^M^J Circuit = ^T/DEVTXT/-^D/CTLNUM/^M^J>
$TEXT ,< Cost = ^D/DMRCST(I1)/>
$CALL LISXPT
$TEXT ,< Line = ^T/DEVTXT/-^D/CTLNUM/>
$TEXT ,< Type = DDCMP-DMC>
LKC6: AOS CTLNUM##
SOJG P1,LKC5 ;DO ALL DMR11S
LKC7: SKIPG P1,KDPNUM ;DO WE HAVE KDP11S?
JRST LKC12 ;NO - DON'T SAY ANYTHING ABOUT THEM
$CALL DEVKDP##
LKC8: $CALL DEVCTL##
SKIPG P2,KDPLNM(I1) ;ARE THERE ANY DUPS ON THIS LINE?
JRST LKC11 ;NO - SKIP THIS KDP
SETZM UNTNUM##
LKC9: $CALL DEVUNT##
SKIPGE DUPUSE##(I1) ;THIS DUP IN USE?
JRST LKC10 ;NO
MOVE S1,LNTYP##(I1)
CAIE S1,^D4
JRST LKC10
$TEXT ,<^M^J Circuit = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/^M^J>
$TEXT ,< Cost = ^D/DUPCST(I1)/>
$CALL LISXPT
$TEXT ,< Line = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/>
$TEXT ,< Type = DDCMP-DMC>
LKC10: AOS UNTNUM##
SOJG P2,LKC9 ;BACK FOR NEXT DUP WITHIN KDP
LKC11: AOS CTLNUM##
SOJG P1,LKC8 ;BACK FOR NEXT KDP
LKC12: $RETT
LISXPT: $TEXT ,< Hello Timer = ^D/NTPT3/>
$TEXT ,< Listen Timer = ^D/NTPT4/>
$TEXT ,< Owner = Node / ^D/NTPSLF/ / ^T/NODNAM/>
$RET
SUBTTL List Line Processors
EXT <DEVTXT,CTLNUM,UNTNUM,DMXCSR,DMXINT>
EXT <DTENUM>
EXT <DMCNUM,NUMDMC,DMCUSE,DMCDUP>
EXT <DMRNUM,NUMDMR,DMRUSE,DMRDUP>
EXT <KDPNUM,NUMKDP,KDPLNM,DUPUSE,DUPRAT,LNTYP>
EXT <XTPIT1,XTPBLK,XTPIRC,XTPWS>
LISKL: $CALL SETDFL## ;Make sure defaults are set
SKIPG S1,DTENUM
JRST LKL1
$CALL DEVDTE##
LSH S1,5 ;Compute CSR address
ADDI S1,174400
MOVEM S1,@DL2650+PRMPTR ;Set controller register
MOVN S1,UNTNUM##
LSH S1,2 ;Compute vector address
ADDI S1,774
MOVEM S1,@DL2655+PRMPTR ;Set interrupt vector
MOVEI ^D7
MOVEM @DL2660+PRMPTR ;Set interrupt priority
MOVEI T4,LKDTE
$CALL LLPRM
LKL1: MOVEI 160740 ;STARTING CSR ADDRESS
MOVEM @DL2650+PRMPTR ;Set controller register
MOVEI 670 ;STARTING INTERRUPT VECTOR
MOVEM @DL2655+PRMPTR ;Set interrupt vector
MOVEI ^D5
MOVEM @DL2660+PRMPTR ;Set interrupt priority
SKIPG P1,DMCNUM## ;DO WE HAVE DMC11S?
JRST LKL4 ;NO - DON'T SAY ANYTHING ABOUT THEM
$CALL DEVDMC##
LKL2: $CALL DEVUNT##
SKIPGE DMCUSE##(I1) ;THIS DMC IN USE?
JRST LKL3 ;NO
MOVEI [^D7]
MOVEM DL1105+PRMPTR ;Set receive buffers
MOVEI DMCDUP##(I1)
MOVEM DL1111+PRMPTR ;Set duplex
MOVEI [^D4]
MOVEM DL1112+PRMPTR ;Set protocol
MOVEI T4,LKDMX
$CALL LLPRM
LKL3: MOVEI S2,10
ADDM S2,@DL2650+PRMPTR
ADDM S2,@DL2655+PRMPTR
AOS CTLNUM##
SOJG P1,LKL2 ;DO ALL DMC11S
LKL4: SKIPG P1,DMRNUM## ;DO WE HAVE DMR11S?
JRST LKL7 ;NO - DON'T SAY ANYTHING ABOUT THEM
$CALL DEVDMR##
LKL5: $CALL DEVUNT##
SKIPGE DMRUSE##(I1) ;THIS DMR IN USE?
JRST LKL6 ;NO
MOVEI [^D10]
MOVEM DL1105+PRMPTR ;Set receive buffers
MOVEI DMRDUP##(I1)
MOVEM DL1111+PRMPTR ;Set duplex
MOVEI [^D4]
MOVEM DL1112+PRMPTR ;Set protocol
MOVEI T4,LKDMX
$CALL LLPRM
LKL6: MOVEI S2,10
ADDM S2,@DL2650+PRMPTR
ADDM S2,@DL2655+PRMPTR
AOS CTLNUM##
SOJG P1,LKL5 ;DO ALL DMR11S
LKL7: SKIPG P1,KDPNUM## ;DO WE HAVE KDP11S?
JRST LKL12 ;NO - DON'T SAY ANYTHING ABOUT THEM
$CALL DEVKDP##
LKL8: $CALL DEVCTL##
SKIPG P2,KDPLNM##(I1) ;ARE THERE ANY DUPS ON THIS LINE?
JRST LKL11 ;NO - SKIP THIS KDP
SETZM UNTNUM##
LKL9: $CALL DEVUNT##
SKIPGE DUPUSE##(I1) ;THIS DUP IN USE?
JRST LKL10 ;NO
MOVEI DUPDUP##(I1)
MOVEM DL1111+PRMPTR ;Set duplex
MOVEI LNTYP##(I1)
MOVEM DL1112+PRMPTR ;Set protocol
MOVE CTLNUM## ;Compute KMC CSR address
LSH 3
ADDI 160540
MOVEM @DL2650+PRMPTR ;Set controller register
HRRZ I1 ;Compute DUP CSR address
LSH 3
ADDI 160300
MOVEM @DL2651+PRMPTR ;Set unit register
MOVE CTLNUM## ;Compute KMC vector address
LSH 3
ADDI 540
MOVEM @DL2655+PRMPTR ;Set interrupt vector
MOVEI ^D5
MOVEM @DL2660+PRMPTR ;Set interrupt priority
MOVEI DUPRAT(I1)
MOVEM DLS0+PRMPTR ;Set baud rate
MOVE LNTYP(I1)
MOVEI T4,LKKDD
CAIN ^D5
MOVEI T4,LKKDX
$CALL LLPRM
LKL10: AOS UNTNUM##
SOJG P2,LKL9 ;BACK FOR NEXT DUP WITHIN KDP
LKL11: AOS CTLNUM##
SOJG P1,LKL8 ;BACK FOR NEXT KDP
LKL12: $RETT
LKDTE: EXP DL1100,DL2650,DL2655,DL2660,DL2670
EXP 0
LKDMX: EXP DL1100,DL1105,DL1110,DL1111,DL1112,DL1113,DL1120,DL1121
EXP DL2650,DL2655,DL2660
EXP 0
LKKDD: EXP DL1100,DL1110,DL1111,DL1112,DL1113,DL1120,DL1121
EXP DL2650,DL2651,DL2655,DL2660,DLS0
EXP 0
LKKDX: EXP DL1100,DL1110,DL1111,DL1112,DL1113,XL1121,XL1130,XL1131
EXP XL1132,DL2650,DL2651,DL2655,DL2660,DLS0
EXP 0
LLPRM: MOVEI [ITEXT(^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/)]
SKIPGE UNTNUM##
MOVEI [ITEXT(^T/DEVTXT/-^D/CTLNUM/)]
MOVEM DL1100+PRMPTR
$TEXT ,<^M^J Line = ^I/@DL1100+PRMPTR/^M^J>
PJRST LISLD
SUBTTL List Logging Processors
LISLF: $TEXT ,<^M^J Logging = File^M^J>
MOVEI T4,7
SETZB I1,TF
LSLF1: SKIPN T1,GBLFLT##(I1) ; Get next class mask
JRST LSLF6 ; (if any are on).
TXON TF,1
$TEXT ,< Sink = (host)>
$TEXT ,< Events = ^D/I1/.^A>
JUMPL T1,[$TEXT ,<*> ; All types.
JRST LSLF6]
SETZB T2,T3
LSLF2: HRRZ S1,T3 ; Find next bit on
LSHC T1,-1 ; by shifting it from T1
SKIPL T2 ; to T2.
AOJA T3,LSLF2
LSLF3: HRRZ S2,T3 ; Find next bit off
LSHC T1,-1 ; by shifting it from T1
SKIPG T2 ; to T2.
AOJA T3,LSLF3
TXOE T3,1000000
$TEXT ,<,^A>
CAMN S1,S2 ; Single flag
$TEXT ,<^D/S1/^A>
CAME S1,S2 ; or range.
$TEXT ,<^D/S1/-^D/S2/^A>
ADDI T3,2 ; Account for test bits
JUMPN T1,LSLF2 ; and go on if more.
$TEXT ,<>
LSLF6: AOS I1 ; On to next class.
SOJG T4,LSLF1
$RETT
SUBTTL List Module MCB-Executive Processors
EXT <CCBNUM,RDBLEN>
LISMC: SKIPN PRVLDG## ; Don't list MCB-Exec if not
$RETT ; privileged.
$CALL SETDFL## ;Make sure defaults are set
$TEXT ,<^M^J Module = MCB-Executive^M^J>
$TEXT ,< CCBs = ^D/CCBNUM/>
MOVE S1,RDBNUM
$TEXT ,< RDBs = ^D/S1/^A>
SKIPE S2,BUFDIF##
JRST [ SUB S1,S2
$TEXT ,<:^D/S1/^A>
JRST .+1]
$TEXT ,<^M^J RDB length = ^D/RDBLEN/>
$RETT
EXT <PRCNAM,PRCDRV,PRCUSE>
LISMP: $CALL SETDFL## ;Make sure defaults are set
$TEXT ,<^M^J Module = MCB-Executive^M^J>
$TEXT ,< Process = CEX, LLC>
SKIPL PRCMDT##
$TEXT ,< Process = MDT>
$TEXT ,< Process = NDT>
$TEXT ,< Process = INI, LLC>
$TEXT ,< Process = NMX, NM:, LLC>
$TEXT ,< Process = SC, LLC>
$TEXT ,< Process = SC1>
$TEXT ,< Process = SCX, NS:, LLC>
$TEXT ,< Process = NSP, LLC>
$TEXT ,< Process = NS1>
$TEXT ,< Process = NS2>
$TEXT ,< Process = XPT, LLC>
$TEXT ,< Process = XPE>
$TEXT ,< Process = TLI>
MOVE S1,NODTYP## ;if not dn200,
CAXE S1,NDN200## ;then
$TEXT ,< Process = TOP, LLC>
MOVE S1,NODTYP## ;if not x25
CAIN S1,NX25## ;then skip
JRST [ $TEXT ,< Process = GAT>
$TEXT ,< Process = GAN>
$TEXT ,< Process = PLP>
$TEXT ,< Process = PLE>
$TEXT ,< Process = PLN>
$TEXT ,< Process = FLN>
$TEXT ,< Process = FLP>
JRST .+1]
SETZ T1,
LMP1: CAMLE T1,PRCPTR##
JRST LMP2
$TEXT ,< Process = ^T/PRCNAM(T1)/^A>
SKIPE PRCDRV(T1)
$TEXT ,<, ^T/PRCDRV(T1)/^A>
SKIPL PRCUSE(T1)
$TEXT ,<, LLC^A>
$TEXT ,< >
AOJA T1,LMP1
LMP2: $RETT
SUBTTL List Module RSX-Executive Processors
LISR: $CALL P$KEYW## ;Get type of display
JUMPE S1,LISR ; and if this is it
PJRST 0(S1) ; then go to display routine.
EXT <RSTNAM>
LISRT: $TEXT ,<^M^J Module = RSX-Executive^M^J>
SKIPN NMLTYP##
$TEXT ,< Task = NML>
SKIPLE NMLTYP##
$TEXT ,< Task = NMS>
MOVE S1,NODTYP## ;if dn200,
CAXN S1,NDN200## ;then
$TEXT ,< Task = POSI, 3>
SETZB T1,T2
LRT1: CAMLE T1,RSTPTR##
JRST LRT2
$TEXT ,< Task = ^T/RSTNAM(T2)/>
ADDI T2,2
AOJA T1,LRT1
LRT2: $RETT
SUBTTL List Module X25-Protocol Processors
LISXPC: $CALL SETDFL## ;Make sure defaults are set
MOVE LP,QUABLK ; Get the qualifier
SKIPN LP ; Is there a qualfier?
JRST LISXP0 ; No
SKIPE T1,@PRMPTR(LP)
JRST LISXPD
LISXP0: $TEXT ,<^M^J Module = X25-Protocol^M^J>
MOVEI T4,LDXPC
PJRST LISLD
LDXPC: EXP XP1110,XP1140,XP1141,XP1150,XP1151,XP1152,XP1153,XP1154
EXP XP1160,XP1161,XP1162,XP1163,XPS0
EXP 0
LISXPD: AOSE T1
JRST [ $CALL FNDQUA
JUMPF [$SEMFAIL(DTE not defined)]
JRST .+1]
$TEXT ,<^M^J Module = X25-Protocol^M^J>
SETOM KNOCNT#
JUMPN T1,LISDTE
SETZB I1,I2 ; Start off at zero.
LISKD1: CAMN I1,@ECUR(LP) ; For each destination item
$RETT
SKIPE @EPTR(LP) ; Check if qualifier specified
$CALL LISDTE ; There was, so do specific qualifier.
ADD I2,EINC(LP)
AOJA I1,LISKD1
LISDTE: AOSE KNOCNT#
$TEXT ,<>
MOVEI T4,LDXPC1
CAIE LP,QUAGRP
PJRST LISLD
MOVEI T4,LDXPC2
$CALL LISLD
$SAVE <T1,T2,T3,T4>
SETZB T1,T2
SETZM T3
LSGRST: CAIN T1,NUMDUP
$RET
MOVE T4,T3
IMULI T4,NUMDUP
ADD T4,I1
SKIPN DTEADR(T2)
JRST LSGRNX
SKIPGE GRPNUM(T4)
JRST LSGR0
$TEXT ,< DTE = ^T/DTEADR(T2)/>
$TEXT ,< NUMBER = ^D/GRPNUM(T4)/>
LSGR0: AOJ T3,
LSGRNX: ADDI T2,4
AOJA T1,LSGRST
LDXPC1: EXP XP1100,XP1120,XP1130,XP1131
EXP 0
LDXPC2: EXP XP1101,XP1172
EXP 0
SUBTTL List Module X25-Server Processors
LISXSC: $CALL SETDFL## ;Make sure defaults are set
MOVE T1,NODTYP## ; If not
CAIE T1,NX25## ; an X.25 node
$RETT ; then this is all.
MOVEI LP,QUADST
SKIPE T1,@PRMPTR(LP)
JRST LISXSD
$TEXT ,<^M^J Module = X25-Server^M^J>
MOVEI T4,LDXSC
PJRST LISLD
LDXSC: EXP XSS0,XSS1,DNX2,DNX3,DNX4
EXP 0
LISXSD: AOSE T1
JRST [ $CALL FNDQUA
JUMPF [$SEMFAIL(Destination not defined)]
JRST .+1]
$TEXT ,<^M^J Module = X25-Server^M^J>
SETOM KNOCNT#
JUMPN T1,LISDST
SETZB I1,I2 ; Start off at zero.
LISKD3: CAMN I1,@ECUR(LP) ; For each destination item
$RETT
$CALL LISDST
ADD I2,EINC(LP)
AOJA I1,LISKD3
LISDST: AOSE KNOCNT#
$TEXT ,<>
MOVEI T4,LDD1
PJRST LISLD ; display destination parameters.
LDD1: EXP XS300,XS320,XS330,XS331,XS332,XS340,XS350
EXP XS351,XS352,XS353,XS354,XS355
EXP 0
END