mirror of
https://github.com/PDP-10/stacken.git
synced 2026-03-06 19:11:04 +00:00
3677 lines
97 KiB
Plaintext
3677 lines
97 KiB
Plaintext
;DSKT:NCPTAB.MAC[10,6062,NML] 1985-10-10 15:42:28, Edit by APPELLOF
|
||
; Allow TOPS-10 to accept node names which start with digits
|
||
; (e.g. "2LATE") QAR 868334
|
||
;
|
||
;DSKT:NCPTAB.MAC[10,6062,NML] 1985-08-09 08:42:28, Edit by APPELLOF
|
||
; Change "DDCMP-POINT" etc. to "DDCMP POINT" etc. SPR 10-34758
|
||
;
|
||
; UPD ID= 330, SNARK:<6.1.NML>NCPTAB.MAC.27, 15-May-85 21:20:50 by MCCOLLUM
|
||
; Make "HARDWARE" in "CLEAR NODE x HARDWARE ADDRESS" a VALKEY
|
||
; Bump development number to match UPD ID.
|
||
;
|
||
; UPD ID= 328, SNARK:<6.1.NML>NCPTAB.MAC.26, 13-May-85 12:05:27 by MCCOLLUM
|
||
; Add SET EXECUTOR ADDRESS and SET EXECUTOR CIRCUIT commands.
|
||
;
|
||
; UPD ID= 327, SNARK:<6.1.NML>NCPTAB.MAC.25, 12-May-85 21:01:15 by MCCOLLUM
|
||
; Fix bug in NOD$NUMBER that broke NOD$ID
|
||
;
|
||
; UPD ID= 326, SNARK:<6.1.NML>NCPTAB.MAC.24, 10-May-85 15:42:38 by MCCOLLUM
|
||
; Add $ACTION routines to NOD$NUMBER to catch area and node numbers that
|
||
; are out of range.
|
||
;
|
||
; UPD ID= 318, SNARK:<6.1.NML>NCPTAB.MAC.23, 7-May-85 18:05:39 by GLINDELL
|
||
; Suppress CREF listing of CM%INV and CM%FW - already defined in MONSYM
|
||
;
|
||
; UPD ID= 312, SNARK:<6.1.NML>NCPTAB.MAC.22, 6-May-85 21:46:56 by GLINDELL
|
||
; Reinstate SHOW SIGNIFICANT but make the keyword invisible.
|
||
; While we are at it, make 'FENCE' invisible too.
|
||
;
|
||
; UPD ID= 311, SNARK:<6.1.NML>NCPTAB.MAC.21, 6-May-85 18:28:33 by MCCOLLUM
|
||
; Add CONSOLE LOAD FILE and CONSOLE SECONDARY LOADER to CLEAR NODE x.
|
||
;
|
||
; UPD ID= 310, SNARK:<6.1.NML>NCPTAB.MAC.20, 3-May-85 13:57:00 by MCCOLLUM
|
||
; Add a macro SETFIL to parse an arbitrary string containing valid network
|
||
; file name characters. Use this macro to parse file names that are allowed
|
||
; in the SET NODE commands (LOAD FILE, SECONDARY/TERTIARY LOADERS, etc.).
|
||
;
|
||
; NOTE: The correct action here is to use .CMFIL to read a parse-only file
|
||
; spec, but because of the peculiarities of OPR/NCPTAB this is not
|
||
; possible.
|
||
;
|
||
; UPD ID= 302, SNARK:<6.1.NML>NCPTAB.MAC.16, 29-Apr-85 13:42:09 by MCCOLLUM
|
||
; Remove SHOW SIGNIFICANT
|
||
;
|
||
; UPD ID= 301, SNARK:<6.1.NML>NCPTAB.MAC.15, 29-Apr-85 10:56:23 by MCCOLLUM
|
||
; Add ALL keyword to SET MODULE LOOPER/LOADER
|
||
;
|
||
; UPD ID= 293, SNARK:<6.1.NML>NCPTAB.MAC.14, 15-Mar-85 13:39:51 by MCCOLLUM
|
||
; Add BROADCAST ROUTING TIMER command to SET EXECUTOR.
|
||
;
|
||
; UPD ID= 251, SNARK:<6.1.NML>NCPTAB.MAC.13, 30-Jan-85 13:31:35 by HALPIN
|
||
; Fix bug in SET MODULE LOADER/LOOPER/CONFIGURATOR tables.
|
||
;
|
||
; UPD ID= 243, SNARK:<6.1.NML>NCPTAB.MAC.12, 23-Jan-85 12:09:17 by HALPIN
|
||
; Fix preceding edit. The Parameter Keyword table for CONSOLE SECONDARY
|
||
; LOADER and CONSOLE LOAD FILE was not in Alphabetic order.
|
||
;
|
||
; ******WARNING: ALL TABLES IN THIS FILE MUST BE IN ALPHABETIC ORDER****
|
||
;
|
||
; UPD ID= 242, SNARK:<6.1.NML>NCPTAB.MAC.11, 21-Jan-85 14:22:46 by HALPIN
|
||
; Change the BUFFER SIZE in-line help from <Memory Units> to <Bytes>.
|
||
; Add Keywords in the SET NODE tables for the CONSOLE SECONDARY LOADER
|
||
; and CONSOLE LOAD FILE.
|
||
; Rewrite the LOOP parsing tables correctly.
|
||
;
|
||
; UPD ID= 223, SNARK:<6.1.NML>NCPTAB.MAC.10, 17-Dec-84 14:00:34 by HALPIN
|
||
; Fix SHOW MODULE CONFIGURATOR commands to conform to LCG Network Management
|
||
; Spec.
|
||
;
|
||
; UPD ID= 221, SNARK:<6.1.NML>NCPTAB.MAC.9, 17-Dec-84 11:26:50 by HALPIN
|
||
; Fix SET MODULE CONFIGURATOR commands to conform to LCG Network Management
|
||
; Spec.
|
||
;
|
||
; UPD ID= 67, SNARK:<6.1.NML>NCPTAB.MAC.8, 31-Aug-84 11:18:22 by HALPIN
|
||
; More updates to parsing tables. Fix some LOGGING commands
|
||
;
|
||
; UPD ID= 55, SNARK:<6.1.NML>NCPTAB.MAC.7, 7-Jun-84 12:11:37 by HALPIN
|
||
; Ident 57
|
||
; Conditionalized NOD$NAME macro for TOPS10 & TOPS20. Conditionalized
|
||
; the CHKNAM Action routine for TOPS-10 Only.
|
||
;
|
||
; UPD ID= 54, SNARK:<6.1.NML>NCPTAB.MAC.6, 6-Jun-84 11:36:41 by HALPIN
|
||
; Ident 56
|
||
; Update tables to include all the new NCP commands from the
|
||
; LSG Phase IV DECnet Network Management Function Spec.
|
||
; And recover from the big merge.
|
||
;
|
||
; UPD ID= 45, SNARK:<6.1.NML>NCPTAB.MAC.5, 24-May-84 19:58:34 by GLINDELL
|
||
;More merge
|
||
; UPD ID= 26, SNARK:<6.1.NML>NCPTAB.MAC.4, 24-May-84 16:07:57 by GLINDELL
|
||
;DSKT:NCPTAB.MAC[10,6026,NML702] 10-Feb-84 11:08:21, Edit by DAVENPORT
|
||
;
|
||
; Change keyword names from $DNxxx to $KNxxx to avoid conflicts with
|
||
; DNET. UUO definitions from UUOSYM.R36.
|
||
;
|
||
;DSKC:NCPTAB.MAC[10,6026,NCPTAB] 19-Jan-84 14:47:10, Edit by DAVENPORT
|
||
;
|
||
; QAR #125739, 125740 - Change LITBRK break mask to make "?" a break
|
||
; character. This allows help to be typed for circuit-ids, line-ids,
|
||
; and several other fields. Add help message to NML-10s version of
|
||
; $IFILE, $OFILE, and $FILE parser macros.
|
||
;
|
||
;DSKC:NCPTAB.MAC[10,6026,NCPTAB] 10-Jan-84 11:22:33, Edit by DAVENPORT
|
||
;
|
||
; QAR # 125523 - Fix EVLIST parse macro to correctly default events to
|
||
; ".*" on a carriage return. Requires change to GLXSCN on TOPS-10 to
|
||
; implement defaulting of tokens.
|
||
;
|
||
;DSKC:NCPTAB.MAC[10,6026,NCPTAB] 15-Dec-83 12:55:40, Edit by DAVENPORT
|
||
;
|
||
; Make NOD$NAME macro only accept node names starting with an alphabetic
|
||
; character. To parse node addresses, use the NOD$NUMBER macro.
|
||
;
|
||
;DSKC:NCPTAB.MAC[10,5665,SOURCE,TOPS10] 20-Oct-83 22:36:38, Edit by GROSSMAN
|
||
;
|
||
; Take 5.1 release NCPCEX and NCPTAB and make them work for Tops-10.
|
||
; Conditionalize searching of MONSYM.
|
||
; Convert .DNxxx symbols to $DNxxx symbols to avoid conflict with UUOSYM
|
||
; symbols.
|
||
; Import definitions of FLDBn. symbols (which aren't defined by GLXMAC).
|
||
; Redefine NETOFI, and NETIFI to get around GLXSCN bugs.
|
||
; Edit=42
|
||
;
|
||
;PH4:<HALPIN>NCPTAB.MAC.9 12-Dec-83 17:41:57, Edit by HALPIN
|
||
; ident 51
|
||
; Moved NCPDEV & NCPMAN symbol definitions so OPR builds
|
||
; don't blow up
|
||
;
|
||
;PH4:<HALPIN>NCPTAB.MAC.6 30-Nov-83 13:50:40, Edit by HALPIN
|
||
; ident 50
|
||
; SET NODE node-id SERVICE NODE VERSION number
|
||
;
|
||
;<MCINTEE>NCPTAB.MAC.4, 21-Nov-83 12:43:03, Edit by MCINTEE
|
||
; ident 49
|
||
; Remove local symbols, as they blow up the build
|
||
;
|
||
;<MCINTEE>NCPTAB.MAC.9, 9-Nov-83 07:57:05, Edit by MCINTEE
|
||
; ident 48
|
||
; More version stuff
|
||
;
|
||
;<MCINTEE>NCPTAB.MAC.4, 3-Nov-83 13:58:56, Edit by MCINTEE
|
||
; ident 47
|
||
; Leave local symbols in. They are useful.
|
||
;
|
||
;<MCINTEE>NCPTAB.MAC.3, 1-Nov-83 10:50:07, Edit by MCINTEE
|
||
; ident 46
|
||
; Fix up version stuff
|
||
; Fix bug in NOD$NUMBER
|
||
;
|
||
;<MCINTEE.WORK>NCPTAB.MAC.2, 9-Aug-83 11:29:21, Edit by MCINTEE
|
||
;
|
||
; ident 45
|
||
; Allow x.y for node number
|
||
;
|
||
;<MCINTEE.WORK>NCPTAB.MAC.8, 7-Jul-83 12:46:23, Edit by MCINTEE
|
||
;
|
||
; ident 44
|
||
; SHOW ADJACENT NODE qualifier work
|
||
;
|
||
;<MCINTEE.WORK>NCPTAB.MAC.2, 30-Jun-83 15:19:27, Edit by MCINTEE
|
||
; ident 43
|
||
; more work on the new qualifiers
|
||
;
|
||
;<MCINTEE.WORK>NCPTAB.MAC.20, 30-Jun-83 08:42:28, Edit by MCINTEE
|
||
; ident 42
|
||
; Conflict in names for LOAD command and LOADER module
|
||
; Conflict in names for LOOP command and LOOPER module
|
||
;
|
||
;<MCINTEE.WORK>NCPTAB.MAC.18, 30-Jun-83 08:06:12, Edit by MCINTEE
|
||
;
|
||
; ident 41
|
||
; phase IV updates:
|
||
; add modules CONFIGURATOR, CONSOLE, LOADER, LOOPER
|
||
; add selector SIGNIFICANT
|
||
; add qualifiers ADJACENT NODE node-id, CIRCUIT circuit-id, KNOWN CIRCUITS
|
||
; add entities ADJACENT NODES & AREA
|
||
;
|
||
;<X25-UPDATE>NCPTAB.MAC.6, 21-Jun-83 08:42:18, Edit by MCINTEE
|
||
;
|
||
; ident 40
|
||
; X25 update - correction to SET/ZERO MODULE X25-SERVER.
|
||
; No qualifier for X25-SERVER.
|
||
;
|
||
;NET:<BRANDT.DEVELOPMENT>NCPTAB.MAC.1 13-Dec-82 14:39:55, Edit by BRANDT
|
||
;
|
||
; ident 39
|
||
; Make "SET MODULE X25-SERVER COUNTER TIMER ..." legal (at SET828)
|
||
; Make "ZERO MODULE X25-SERVER " legal (at ZER151)
|
||
;
|
||
;NET:<PECKHAM.DEVELOPMENT>NCPTAB.MAC.3 5-Dec-82 13:39:55, Edit by PECKHAM
|
||
;
|
||
; ident 38
|
||
; Make "CLEAR NODE name NAME" legal (at CLR900).
|
||
; Make "ZERO EXECUTOR COUNTERS" legal (at ZER100).
|
||
; Make "SHOW LOGGING SUMMARY <sink-node-options>" legal (at SHW510).
|
||
;
|
||
;NET:<PECKHAM.DEVELOPMENT>NCPTAB.MAC.2 29-Sep-82 17:50:21, Edit by PECKHAM
|
||
;
|
||
; ident 37
|
||
; Re-include the $DEFAULTs that were removed in #36.
|
||
;
|
||
;NET:<PECKHAM.DEVELOPMENT>NCPTAB.MAC.6 24-Sep-82 14:43:43, Edit by PECKHAM
|
||
;
|
||
; ident 36
|
||
; Fix SET318 keywords to NOT all go to SET319, but to proper prompts.
|
||
; Fix TEL140 keywords to NOT all go to TEL150, but to proper prompts.
|
||
; Elimate inappropriate $DEFAULTs.
|
||
; Set break set for CKT$ID and LINE$ID to LITBRK.
|
||
; Add invisible system specific parameter - SET/CLEAR NODE FENCE
|
||
;
|
||
;<PLATUKIS>NCPTAB.MAC.4 14-Jun-82 14:41:13, Edit by PLATUKIS
|
||
;
|
||
; ident 35
|
||
; change syntax construction of known qualifier keywords.
|
||
;
|
||
;NET:<BRANDT.DEVELOPMENT>NCPTAB.MAC.3 20-May-82 11:22:49, Edit by BRANDT
|
||
;
|
||
; Ident 34.
|
||
; Change DECSYSTEM-10-20 to DECSYSTEM-1020 to correspond to
|
||
; documentation.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.3 26-Mar-82 18:22:49, Edit by VOBA
|
||
;
|
||
; Ident 33.
|
||
; Fix ZERO command syntax not to assign any value to the COUNTERS parameter,
|
||
; treat it as a dummy keywords.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.66 25-Mar-82 18:09:01, Edit by VOBA
|
||
;
|
||
; Ident 32.
|
||
; Change the syntax of SHOW MODULE commands not to include default
|
||
; qualifier parameters if the user does not specify them.
|
||
; Change the syntax of MODULE commands not to use P$ALL for keyword ALL.
|
||
; Use a new variable X$ALL with value of 0, instead.
|
||
; Change the parsing of all CLEAR parameters to be value keyword. The
|
||
; CLEAR qualifier parameters remain regular parameters.
|
||
; Add (phantom) parameter NODE TYPE (2600) for CIRCUIT entity commands.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.3 16-Mar-82 08:48:44, Edit by VOBA
|
||
;
|
||
; Ident 31.
|
||
; Make the default information type of SHOW MODULE X25-ACCESS command be
|
||
; CHARACTERISTICS, since others do not have any meanings.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.7 15-Mar-82 16:02:30, Edit by VOBA
|
||
;
|
||
; Ident 30.
|
||
; Fix all parameter types of KNOWN qualifiers so that NCPCEX can recognize
|
||
; them.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.3 15-Mar-82 10:20:57, Edit by VOBA
|
||
;
|
||
; Ident 29.
|
||
; Fix SHOW LOGGING command to parse the EVENTS qualifier correctly.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.7 12-Mar-82 13:49:09, Edit by VOBA
|
||
;
|
||
; Ident 28.
|
||
; Rewrite the syntax of SHOW MODULE commands to include the qualifier
|
||
; parameters at end of commands.
|
||
; Remove all references to TO parameter in all SHOW commands.
|
||
;
|
||
;NET:<GROSSMAN.NML-SOURCES>NCPTAB.MAC.3 8-Mar-82 15:42:21, Edit by GROSSMAN
|
||
;
|
||
; Ident 27.
|
||
; Fix Tops-10 file break set so that dashes are now illegal...
|
||
;
|
||
;NET:<BRANDT.DEVELOPMENT>NCPTAB.MAC.2 5-Mar-82 12:10:00, Edit by BRANDT
|
||
;
|
||
; Ident 26.
|
||
; Disable alternate TO output_file for SHOW and LIST command.
|
||
;
|
||
;NET:<BRANDT.DEVELOPMENT>NCPTAB.MAC.2 4-Mar-82 17:01:00, Edit by BRANDT
|
||
;
|
||
; Ident 25.
|
||
; Merge NCPTAB.FTR into NCPTAB.MAC.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.2 4-Mar-82 16:55:00, Edit by VOBA
|
||
;
|
||
; Ident 24.
|
||
; Change SHOW syntax of MODULE entity to use macro PARKEY instead of NCPKEY.
|
||
;
|
||
;NET:<DECNET20-V3P1.BASELEVEL-2.SOURCES>NCPTAB.MAC.15 3-Mar-82 12:30:13, Edit by VOBA
|
||
;
|
||
; Ident 23.
|
||
; Change MODULE X25-ACCESS parameter numbers to reflect proposed change
|
||
; to the architecture specification.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.7 1-Mar-82 14:41:56, Edit by VOBA
|
||
;
|
||
; Ident 22.
|
||
; Change break mask HEXBRK to recognize hexadecimal digits in lower case.
|
||
;
|
||
;NET:<PECKHAM.DEVELOPMENT>NCPTAB.MAC.2 1-Mar-82 08:00:12, Edit by PECKHAM
|
||
;
|
||
; Change SHOW LOGGING entity to use VALKEY instead of NCPKEY to be consistent.
|
||
;
|
||
;NET:<GROSSMAN.NML-SOURCES>NCPTAB.MAC.3 25-Feb-82 20:26:33, Edit by GROSSMAN
|
||
;
|
||
; Add a line that got lost between KL1026 and here. (Its at T10BRK:)
|
||
;
|
||
;NET:<PECKHAM.DEVELOPMENT>NCPTAB.MAC.3 24-Feb-82 14:30:40, Edit by PECKHAM
|
||
; for VOBA
|
||
; Change help file extensions to .MEM
|
||
;
|
||
;NET:<PECKHAM.DEVELOPMENT>NCPTAB.MAC.2 24-Feb-82 10:01:09, Edit by PECKHAM
|
||
;
|
||
; PURGE variables FTJSYS, FTUUOS.
|
||
;
|
||
;NET:<GROSSMAN.NML-SOURCES>NCPTAB.MAC.3 24-Feb-82 08:44:13, Edit by GROSSMAN
|
||
;
|
||
; Redefine $FILE, $IFILE, $OFILE as $FIELD with a TOPS10 filespec break set.
|
||
; This will cause OPR to pass the (possibly illegal) filespec to NML as an
|
||
; ASCII string, instead of parsed SIXBIT tokens. This will save NML proper the
|
||
; trouble of converting that back into ASCII, and also avoid several GLXCMD
|
||
; bugs dealing with filespecs (Tops-10 only).
|
||
;
|
||
;NET:<PECKHAM.DEVELOPMENT>NCPTAB.MAC.3 19-Feb-82 14:31:36, Edit by PECKHAM
|
||
;
|
||
; Ident 21.
|
||
; Fix SINK qualifier requirements for SHOW LOGGING parameter parsing.
|
||
;
|
||
;NET:<VOBA.NML.DEVELOPMENT>NCPTAB.MAC.5 17-Feb-82 08:07:53, Edit by VOBA
|
||
;
|
||
; Ident 20.
|
||
; Add TOPS10 condition to the HELP file specification so TOPS-10 can parse
|
||
; HELP file name.
|
||
;
|
||
;NET:<VOBA.NML>NCPTAB.MAC.3 30-Jan-82 11:50:45, Edit by VOBA
|
||
;
|
||
; Ident 19.
|
||
; Remove references of .RETT in the NCPHLP action routine.
|
||
;
|
||
;NET:<VOBA.NML>NCPTAB.MAC.45 25-Jan-82 16:15:34, Edit by VOBA
|
||
;
|
||
; Ident 18.
|
||
; Fix syntax to parse event list. Fix syntax to parse SET & CLEAR LOGGING.
|
||
; Remove ABORT command from syntax table permanently.
|
||
; Change TELL command table not to include itself in the command.
|
||
;
|
||
;NET:<PECKHAM.DEVELOPMENT>NCPTAB.MAC.12 22-Jan-82 06:46:21, Edit by PECKHAM
|
||
;
|
||
; Ident 17.
|
||
; Remove ABORT command.
|
||
; Enable all X.25 parameters permanently.
|
||
; Add DMP parameters and clean up for NM V3.0.0
|
||
;
|
||
;NET:<GUNN.DEVELOPMENT>NCP3TB.MAC.6 18-Jan-82 18:18:46, Edit by GUNN
|
||
;
|
||
; Ident 16. (Decimal)
|
||
; Parse NODE IDENTIFICATION parameter and others as quoted strings
|
||
; instead of or in addition to fields.
|
||
;
|
||
;NET:<BRANDT.DEVELOP>NCP3TB.MAC.1 13-Jan-82 16:44:10, Edit by BRANDT
|
||
;
|
||
; Ident 15 (octal) (more or less!)
|
||
; Turn on "no-parse" bit for nodes.
|
||
; Update NCPVER to get in sync with Ident numbers.
|
||
;
|
||
;NET:<GUNN.DEVELOPMENT>NCP3TB.MAC.2 12-Jan-82 14:14:11, Edit by GUNN
|
||
;
|
||
; Update copyright date to 1982.
|
||
; Remove .TEXT directive.
|
||
; Fix DEBUG conditionals to check for value if DEBUG is defined.
|
||
;
|
||
;NET:<VOBA.NML>NCP3TB.MAC.122 11-Jan-82 10:01:17, Edit by VOBA
|
||
;
|
||
; Implement full NCP command syntax table.
|
||
;
|
||
;NET:<DECNET20-V3P1.BASELEVEL-2.TOPS20>NCP3TB.MAC.2 20-Aug-81 09:53:59, Edit by GUNN
|
||
;
|
||
; Put C$PMAX, C$PRCL, & C$MRCL under X.25 conditional.
|
||
;
|
||
;NET:<DECNET20-V3P1.NML>NCP3TB.MAC.2 8-Aug-81 16:49:28, Edit by GUNN
|
||
;
|
||
; Removed space " " from break mask of network file specification. Can't
|
||
; parse more than one parameter on a single command. Syntax of remote
|
||
; file spec changed to 'KL2102"OPERATOR;PASSWORD;ACCOUNT"::DIR:NAME.EXT'
|
||
; as a bypass.
|
||
;
|
||
;NET:<DECNET20-V3P1.NCP.SOURCES>NCP3TB.MAC.29 18-Jul-81 13:37:04, Edit by GUNN
|
||
;
|
||
; Added break mask for network style file specifications.
|
||
; Changed PRTVER macro to print out version in nice format.
|
||
; Fixed VALKEY and PARKEY macros to only print out warning only
|
||
; if symbol is being redefined with a different value.
|
||
;
|
||
;NET:<DECNET20-V3P1.NCP.SOURCES>NCP3TB.MAC.11 12-May-81 16:16:00, Edit by GUNN
|
||
;
|
||
; Change DUMP ADDRESS and DUMP COUNT to decimal radix input.
|
||
;
|
||
;NET:<DECNET20-V3P1.NCP.SOURCES>NCP3TB.MAC.10 11-May-81 17:21:01, Edit by GUNN
|
||
;
|
||
; Fix break mask for SERVICE PASSWORD.
|
||
;
|
||
;NET:<DECNET20-V3P1.NCP.SOURCES>NCP3TB.MAC.8 11-May-81 16:50:49, Edit by GUNN
|
||
;
|
||
; Make SUMMARY be default for SHOW commands.
|
||
;
|
||
;NET:<DECNET20-V3P1.NCP.SOURCES>NCP3TB.MAC.7 11-May-81 10:35:55, Edit by GUNN
|
||
;
|
||
; Changed SERVICE DEVICE table to reflect MOP V2.1 specification.
|
||
;
|
||
;NET:<DECNET20-V3P1.NCP.SOURCES>NCP3TB.MAC.6 9-Apr-81 10:44:03, Edit by GUNN
|
||
;
|
||
; Began change of LOAD command syntax to allow only one of either ADDRESS or
|
||
; NAME parameters for NODE entity option, left commented out.
|
||
; Removed UNIVERSAL TIME parameter, not settable by NCP.
|
||
; Made SERVICE PASSWORD field accept only hexadecimal digit characters.
|
||
;
|
||
;NET:<DECNET20-V3P1.BASELEVEL-2.SOURCES>NCP3TB.MAC.15 9-Feb-81 14:48:59, Edit by GUNN
|
||
;
|
||
; Changed all node address to be always be input in decimal.
|
||
;
|
||
|
||
; NCPTAB.MAC - NCP/OPR Command Parsing Tables NCP V3.0
|
||
|
||
|
||
DEBUG==0 ;***** - Build a debug version
|
||
FTX25==1 ;Assemble with X.25 features
|
||
.CLIST==0 ;Don't print keyword code assignments
|
||
; at beginning of listing
|
||
|
||
IFNDEF DEBUG, <TITLE NCPTAB - DECnet-10/20 NCP Command Definitions>
|
||
IFDEF DEBUG, <
|
||
IFN DEBUG, <TITLE NCP3TB - DECnet-10/20 NCP Command Definitions>
|
||
IFE DEBUG, <TITLE NCPTAB - DECnet-10/20 NCP Command Definitions>>
|
||
|
||
SALL ; Keep listing clean looking
|
||
|
||
;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 1976,1977,1978,1979,1980,1981,1982,1986.
|
||
;ALL RIGHTS RESERVED.
|
||
|
||
;++
|
||
; FACILITY: DECnet-10/20 V3.0 Network Control Program (NCP)
|
||
;
|
||
; FUNCTIONAL DESCRIPTION:
|
||
;
|
||
; This module provides the command parsing tables used by the
|
||
; GALAXY Operator Interface Program, OPR, on the DECsystem-10
|
||
; and DECSYSTEM-20 DECnet systems for Network Management commands.
|
||
;
|
||
; ENVIRONMENT: User mode as part of OPR GALAXY system with GLXLIB.
|
||
;
|
||
; AUTHOR: Dale C. Gunn, CREATION DATE: 13-JUN-80
|
||
;
|
||
; MODIFIED BY:
|
||
;
|
||
; Dale C. Gunn, 13-JUN-80: VERSION 03
|
||
; 01 - Create Version 3.0 source module from Version 2.0 Base Level
|
||
;
|
||
; Dale C. Gunn, 12-AUG-80: VERSION 03
|
||
; 02 - Update to reflect X.25 Network Management Spec of 26 JUN 80
|
||
; 03 - Miscellaneous corrections
|
||
; 04 - Change name of KEYTAB macro to NCPKEY to avoid conflict with
|
||
; the GALAXY macro or same name, and allow it to be called from
|
||
; within NCPKEY.
|
||
; 05 - Change keyword codes for node parameters be identical to the
|
||
; corresponding Network Management Architecture parameter number.
|
||
; 06 - Add PARKEY macro to define symbols for parameter numbers.
|
||
; 07 - Put X.25 specific commands and parameters under conditional.
|
||
;
|
||
; Dale C. Gunn, 24-OCT-80: VERSION 03
|
||
; 08 - Update to reflect X.25 Network Management Spec (V2.1) of 21 AUG 80
|
||
; 09 - Added default strings where appropriate
|
||
; 10 - Miscellaneous and various coding errors fixed
|
||
;
|
||
; Dale C. Gunn, 30-JAN-81: VERSION 03
|
||
; 11 - Add access control syntax to LOOP NODE command
|
||
; 12 - Add break mask to access control fields to allow
|
||
; all printing characters
|
||
; 13 - Changed parse of node address to decimal radix
|
||
;
|
||
;--
|
||
|
||
SUBTTL Declarations
|
||
|
||
;
|
||
; INCLUDE FILES:
|
||
;
|
||
|
||
SEARCH GLXMAC ; GALAXY Universal Definitions
|
||
SEARCH ORNMAC ; OPR/ORION Universal Definitions
|
||
|
||
PROLOG NCPTAB ; Init Galaxy macros and such
|
||
|
||
TOPS20 <SEARCH MONSYM> ; Monitor Universal Symbols
|
||
SEARCH MACSYM ; System Wide Macro Definitions
|
||
|
||
.BCOPY
|
||
COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1976,1986. ALL RIGHTS RESERVED.
|
||
\;END COPYRIGHT MACRO
|
||
.ECOPY
|
||
|
||
SUBTTL REGISTER DEFINITIONS
|
||
|
||
S1=:1
|
||
S2=:2
|
||
T1=:3
|
||
T2=:4
|
||
|
||
SUBTTL VERSION INFORMATION
|
||
|
||
|
||
NCPMAN==:^D39 ;Maintenance edit number
|
||
NCPDEV==:^D329 ;Development edit number (ident # in edit history)
|
||
NCPVER==:^D4 ;Major version number
|
||
NCPMIN==:^D0 ;Minor version number
|
||
NCPWHO==:^D0 ;Customer version number
|
||
|
||
; PRTVER (EDT) - print out GLXMAC version number in listing
|
||
DEFINE PRTVER (EDT), <
|
||
GLXNCP==:<EDT>
|
||
IF1 <
|
||
PRINTX NCPTAB - Assembled using GLXMAC version: 'EDT>>
|
||
|
||
; NCPVRX (VERSION,MINOR,EDIT,WHO) - Make NCP Version
|
||
; AND print it out in the listing.
|
||
DEFINE NCPVRX (MAJ,MIN,EDT,WHO), <
|
||
NCPVRS==:<BYTE(3)WHO(9)MAJ(6)MIN(18)EDT>
|
||
IF1 <
|
||
PRINTX NCPTAB - Assembling NCP version: 'MAJ'.'MIN('EDT)>>
|
||
|
||
;Tell the rest of GALAXY about the version number (Defines NCPEDT)
|
||
TOPS20< VERSIN (NCP)>
|
||
TOPS10< NCPEDT==<NCPDEV&777>*1000+<NCPMAN&777>>
|
||
|
||
;Invoke the macros.
|
||
NCPVRX (\NCPVER,\NCPMIN,\NCPEDT,\NCPWHO) ; Make & print version number
|
||
TOPS10< PRTVER (\GLXVER,\GLXMIN,\GLXEDT,\GLXWHO)>; Print GLXMAC version in listing
|
||
|
||
SUBTTL Macro Definitions for Commonly Used Syntax
|
||
|
||
;
|
||
; MACROS:
|
||
;
|
||
|
||
; CKT$ID (next-pdb) - Parse canonical Circuit Id
|
||
|
||
DEFINE CKT$ID (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<Circuit Id>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<Circuit Id>,<$FLAGS(CM%BRK),$BREAK(LITBRK),LIST>)>
|
||
> ; End of CKT$ID Definition
|
||
|
||
; LINE$ID (next-pdb) - Parse canonical Line Id
|
||
|
||
DEFINE LINE$ID (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<Line Id>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<Line Id>,<$FLAGS(CM%BRK),$BREAK(LITBRK),LIST>)>
|
||
> ; End of LINE$ID Definition
|
||
|
||
; NOD$NAME (next-pdb, alternate-pdb) - Parse canonical Node Name
|
||
|
||
DEFINE NOD$NAME (NEXT,LIST), <
|
||
IFB <LIST>,<$NODNM (NEXT,<Node Name>,<$FLAGS(CM%NSF+CM%PO),$ACTION(CHKNAM)>)>
|
||
IFNB <LIST>,<$NODNM (NEXT,<Node Name>,<$FLAGS(CM%NSF+CM%PO),$ACTION(CHKNAM),LIST>)>
|
||
> ; End of NOD$NAME Definition
|
||
|
||
; NOD$NUMBER (next-pdb, alternate-pdb, next-pdb-default)
|
||
; Parse canonical node number
|
||
; **NOTE** ALTPDB is the address of the alternate PDB, not the $ALTERNATE macro
|
||
|
||
DEFINE NOD$NUMBER (NEXT,ALTPDB,NDEFLT,%A,%B), <
|
||
|
||
IFNB <ALTPDB>,<
|
||
$NUMBER (%A,<^D10>,<Area Number or Decimal Node Address>,<$ACTION(CHKANM),$ALTERNATE(ALTPDB)>)
|
||
>;;END OF IFNB ALTPDB
|
||
|
||
IFB <ALTPDB>,<
|
||
$NUMBER (%A,<^D10>,<Area Number or Decimal Node Address>,<$ACTION(CHKANM)>)
|
||
>;;END OF IFB ALTPDB
|
||
|
||
IFNB <NDEFLT>,<
|
||
%A: $TOKEN (%B,<.>,<$DEFAULT(NDEFLT),$ALTERNATE(NEXT),$ACTION(CHKARN)>)
|
||
>;;END OF IFNB NDEFLT
|
||
|
||
IFB <NDEFLT>,<
|
||
%A: $TOKEN (%B,<.>,<$ALTERNATE(NEXT),$ACTION(CHKARN)>)
|
||
>;;END OF IFB NDEFLT
|
||
|
||
%B: $NUMBER (NEXT,<^D10>,<Decimal Node Address>,$ACTION(CHKNNM))
|
||
IF2 <PURGE %A,%B> ; Remove from symbol table
|
||
> ; End of NOD$NUMBER Definition
|
||
|
||
; NOD$ID (next-pdb, alternate-pdb, next-pdb-default)
|
||
; Parse canonical node identifier
|
||
|
||
DEFINE NOD$ID (NEXT,LIST,NDEFLT,%A), <
|
||
NOD$NUMBER (NEXT,%A,NDEFLT)
|
||
%A: NOD$NAME (NEXT,LIST)
|
||
IF2 <PURGE %A> ; Remove from symbol table
|
||
> ; End of NOD$ID Definition
|
||
|
||
; NI$ADDRESS (next-pdb) - Parse NI address
|
||
|
||
DEFINE NI$ADDRESS (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<NI address>,<$FLAGS(CM%BRK),$BREAK(ETHBRK)>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<NI address>,<$FLAGS(CM%BRK),$BREAK(ETHBRK),LIST>)>
|
||
> ; End of NI$ADDRESS Definition
|
||
|
||
; SVC$PASSWORD (next-pdb) - Parse canonical service password
|
||
|
||
DEFINE SVC$PASSWORD (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<Hexadecimal Boot Password>,<$FLAGS(CM%BRK),$BREAK(HEXBRK)>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<Hexadecimal Boot Password>,<$FLAGS(CM%BRK),$BREAK(HEXBRK),LIST>)>
|
||
> ; End of SVC$PASSWORD Definition
|
||
|
||
; EVLIST (next-pdb) - Parse event list
|
||
|
||
DEFINE EVLIST (NEXT,%A,%B,%C,%D,%E,%F,%G), <
|
||
$DIGIT (%A,<^D10>,<Event Class>)
|
||
%A: $TOKEN (%B,<.>,<$DEFAULT(<.>)>)
|
||
%B: $DIGIT (%C,<^D10>,<Event Type>,<$DEFAULT(<*>),$ALTERNATE(%G)>)
|
||
%C: $TOKEN (%D,<->,<$HELP(<"-" To Specify Type Range>),$ALTERNATE(%E)>)
|
||
%D: $DIGIT (%E,<^D10>,<Ending Type Range>)
|
||
%E: $COMMA (%F,<$HELP(<"," To Specify Additional Type>),$ALTERNATE(NEXT)>)
|
||
%F: $DIGIT (%C,<^D10>,<Event Type>)
|
||
%G: $TOKEN (NEXT,<*>,<$HELP(<"*" To Specify All Types Of This Class>)>)
|
||
IF2 <PURGE %A,%B,%C,%D,%E,%F,%G>
|
||
> ; End of EVLIST Definition
|
||
|
||
; CHANNELS (next-pdb) - Parse list of channels
|
||
|
||
DEFINE CHANNELS (NEXT,%A,%B,%C,%D), <
|
||
%A: $DIGIT (%B,<^D10>,<List Of Channel Ranges "n-m" or Single Channels>)
|
||
%B: $TOKEN (%C,<->,<$HELP(<"-" To Specify Channel Range>),$ALTERNATE(%D)>)
|
||
%C: $NUMBER (%D,<^D10>,<Ending Channel Range>)
|
||
%D: $COMMA (%A,<$HELP(<"," To Specify Additional Channel>),$ALTERNATE(NEXT)>)
|
||
IF2 <PURGE %A,%B,%C,%D>
|
||
> ; End of CHANNELS Definition
|
||
|
||
; OBJECT$ID (next-pdb) - Parse object name/number identification
|
||
|
||
DEFINE OBJECT$ID (NEXT,%A,%B), <
|
||
$NUMBER (NEXT,<^D10>,<Object Identifier Number>,<$ALTERNATE(%A)>)
|
||
%A: $QUOTE (NEXT,<Quoted Numeric Object Identifier Name>,<$ALTERNATE(%B)>)
|
||
%B: $FIELD (NEXT,<Object Identifier Name>)
|
||
IF2 <PURGE %A,%B,%C>
|
||
> ; End of OBJECT$ID Definition
|
||
|
||
; NET$NAME (next-pdb) - Parse canonical network name
|
||
|
||
DEFINE NET$NAME (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<Network Name>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<Network Name>,LIST)>
|
||
> ; End of NET$NAME Definition
|
||
|
||
; DTE$ADR (next-pdb) - Parse canonical DTE address
|
||
|
||
DEFINE DTE$ADR (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<Decimal DTE Address>,<$FLAGS(CM%BRK),$BREAK(DECBRK)>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<Decimal DTE Address>,<$FLAGS(CM%BRK),$BREAK(DECBRK)>,LIST)>
|
||
> ; End of DTE$ADR Definition
|
||
|
||
; CALL$NUMBER (next-pdb) - Parse canonical X25 DTE address
|
||
|
||
DEFINE CALL$NUMBER (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<Full Remote DTE Address>,<$FLAGS(CM%BRK),$BREAK(CALBRK)>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<Full Remote DTE Address>,<$FLAGS(CM%BRK),$BREAK(CALBRK)>,LIST)>
|
||
> ; End of CALL$NUMBER Definition
|
||
|
||
; DEST$NAME (next-pdb) - Parse canonical X25 destination name
|
||
|
||
DEFINE DEST$NAME (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<Destination Name String>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<Destination Name String>,LIST)>
|
||
> ; End of DEST$NAME Definition
|
||
|
||
; SUB$ADDR (next-pdb) - Parse canonical X25 subaddress range
|
||
|
||
DEFINE SUB$ADDR (NEXT,%A,%B), <
|
||
$DIGIT (%A,<^D10>,<Subaddress Range "n-m">)
|
||
%A: $TOKEN (%B,<->,<$HELP(<"-" To Specify Subaddress Range>),$DEFAULT(<->)>)
|
||
%B: $NUMBER (NEXT,<^D10>,<Ending Subaddress>)
|
||
IF2 <PURGE %A,%B> ; Remove from symbol table
|
||
> ; End of SUB$ADDR Definition
|
||
|
||
|
||
; DEV$ID (next-pdb) - Parse canonical device identifier
|
||
|
||
DEFINE DEV$ID (NEXT,LIST), <
|
||
IFB <LIST>, <$FIELD (NEXT,<Device Specification "ddd-c-u">)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<Device Specification "ddd-c-u">,LIST)>
|
||
> ; End of DEV$ID Definition
|
||
|
||
; STR$ID (NEXT,LIST) - Parse standard transparent string argument
|
||
|
||
DEFINE STR$ID (NEXT,HELP,%A), <
|
||
IFB <HELP>,<$QUOTE (NEXT,<Quoted or Unquoted String>,<$ALTERNATE(%A)>)>
|
||
IFNB <HELP>,<$QUOTE (NEXT,<Quoted or Unquoted HELP>,<$ALTERNATE(%A)>)>
|
||
%A: $FIELD (NEXT,,<$FLAGS(CM%SDH)>)
|
||
IF2 <PURGE %A>>
|
||
|
||
; DEV$TYPE (NEXT,LIST) - Parse service device type
|
||
|
||
DEFINE DEV$TYPE (NEXT,%A), <
|
||
IFB <LIST>, <$KEYDSP (%A)>
|
||
IFNB <LIST>, <$KEYDSP (%A,LIST)>
|
||
%A: $STAB
|
||
VALKEY (NEXT,N$TCI,^D7,CI)
|
||
VALKEY (NEXT,N$TCNA,^D3,CNA)
|
||
VALKEY (NEXT,N$TDA,^D8,DA)
|
||
VALKEY (NEXT,N$TDL,^D4,DL)
|
||
VALKEY (NEXT,N$TDLV,^D16,DLV)
|
||
VALKEY (NEXT,N$TDMC,^D12,DMC)
|
||
VALKEY (NEXT,N$TDMF,^D38,DMF)
|
||
VALKEY (NEXT,N$TDMP,^D18,DMP)
|
||
VALKEY (NEXT,N$TDMR,^D32,DMR)
|
||
VALKEY (NEXT,N$TDMV,^D34,DMV)
|
||
VALKEY (NEXT,N$TDN,^D14,DN)
|
||
VALKEY (NEXT,N$TDP,^D0,DP)
|
||
VALKEY (NEXT,N$TDPV,^D36,DPV)
|
||
VALKEY (NEXT,N$TDQ,^D6,DQ)
|
||
VALKEY (NEXT,N$TDTE,^D20,DTE)
|
||
VALKEY (NEXT,N$TDU,^D2,DU)
|
||
VALKEY (NEXT,N$TDUP,^D10,DUP)
|
||
VALKEY (NEXT,N$TDV,^D22,DV)
|
||
VALKEY (NEXT,N$TDZ,^D24,DZ)
|
||
VALKEY (NEXT,N$TKDP,^D28,KDP)
|
||
VALKEY (NEXT,N$TKDZ,^D30,KDZ)
|
||
VALKEY (NEXT,N$TKL,^D32,KL)
|
||
VALKEY (NEXT,N$TKMY,^D42,KMY)
|
||
VALKEY (NEXT,N$TKMX,^D44,KMX)
|
||
VALKEY (NEXT,N$TNI,^D15,NI)
|
||
VALKEY (NEXT,N$TPCL,^D9,PCL)
|
||
VALKEY (NEXT,N$TQNA,^D5,QNA)
|
||
VALKEY (NEXT,N$TUNA,^D1,UNA)
|
||
$ETAB
|
||
IF2 <PURGE %A>
|
||
> ; End of DEV$TYPE Definition
|
||
|
||
; PRTVAL (SYM,CODE,KEY) - Print out symbols, values, and keywords
|
||
|
||
DEFINE PRTVAL (SYM,CODE,KEY), <
|
||
PRINTX 'SYM = 'CODE ('KEY)>
|
||
|
||
; WARNING (SYM,CODE) - Print out warning for duplicated symbols with different
|
||
; values
|
||
|
||
DEFINE WARNING (SYM,VAL,CODE), <
|
||
IFDIF <'VAL><'CODE>, <
|
||
PRINTX WARNING - 'SYM has been defined as 'VAL, now as 'CODE>>
|
||
|
||
; NCPKEY (next-pdb,keyword,symbol-suffix [,flags]) - Make keyword table entry
|
||
; for an NCP command and define a symbol to represent the keyword value
|
||
|
||
..Z==0
|
||
IF2 <PURGE ..Z>
|
||
|
||
DEFINE NCPKEY (NXT,CODE,KEY,FLAGS), <
|
||
IFNDEF $KN'CODE,<
|
||
..Z==..Z+1 ; Bump keyword code counter
|
||
$KN'CODE==:..Z> ; Assign value to global symbol
|
||
IFN .CLIST, <PRINTX <$KN'CODE = 'KEY>>
|
||
IFB <FLAGS>, <DSPTAB (NXT,$KN'CODE,KEY)>
|
||
IFNB <FLAGS>, <DSPTAB (NXT,$KN'CODE,KEY,FLAGS)>
|
||
> ; End of NCPKEY Macro Definition
|
||
|
||
; PARKEY (next-pdb,symbol,value,keyword [,flags]) - Make keyword table entry
|
||
; for an NML parameter and define a symbol to represent
|
||
; the keyword value
|
||
|
||
DEFINE PARKEY (NXT,SYM,CODE,KEY,FLAGS), <
|
||
IF1 <IFNB <CODE>, <
|
||
IFN .CLIST, <PRTVAL (SYM,\<CODE>,KEY)>
|
||
IFDEF SYM, <WARNING ('SYM,\<SYM>,\<CODE>)>
|
||
IFNDEF SYM, <SYM==:CODE>>>
|
||
IFB <FLAGS>, <DSPTAB (NXT,SYM,KEY)>
|
||
IFNB <FLAGS>, <DSPTAB (NXT,SYM,KEY,FLAGS)>
|
||
> ; End of PARKEY Macro Definition
|
||
|
||
; VALKEY (next-pdb,symbol,value,keyword [,flags]) - Make keyword table entry
|
||
; for an NML keyword code value and define a symbol to represent
|
||
; the keyword value
|
||
|
||
DEFINE VALKEY (NXT,SYM,CODE,KEY,FLAGS), <
|
||
IF1 <IFNB <CODE>, <
|
||
IFN .CLIST, <PRTVAL (SYM,\<VAL$KY!CODE>,KEY)>
|
||
IFDEF SYM, <WARNING ('SYM,\<SYM>,\<CODE>)>
|
||
IFNDEF SYM, <SYM==CODE>>>
|
||
IFB <FLAGS>, <DSPTAB (NXT,<VAL$KY!SYM>,KEY)> ; Indicate parameter value
|
||
IFNB <FLAGS>, <DSPTAB (NXT,<VAL$KY!SYM>,KEY,FLAGS)>
|
||
> ; End of VALKEY macro definition
|
||
|
||
|
||
; KNWKEY (next-pdb,symbol,value,keyword [,flags]) - Make keyword table entry
|
||
; for an NML known qualifier keyword code and define a symbol to
|
||
; represent the keyword value
|
||
|
||
DEFINE KNWKEY (NXT,SYM,CODE,KEY,FLAGS), <
|
||
IF1 <IFNB <CODE>, <
|
||
IFN .CLIST, <PRTVAL (SYM,\<KNW$KY!CODE>,KEY)>
|
||
IFDEF SYM, <WARNING ('SYM,\<SYM>,\<CODE>)>
|
||
IFNDEF SYM, <SYM==CODE>>>
|
||
IFB <FLAGS>, <DSPTAB (NXT,<KNW$KY!SYM>,KEY)>
|
||
IFNB <FLAGS>, <DSPTAB (NXT,<KNW$KY!SYM>,KEY,FLAGS)>
|
||
> ; End of KNWKEY macro definition
|
||
|
||
|
||
; The following redefinitions are done so that a Tops-10 file spec can be
|
||
; passed to NML as an ASCII string.
|
||
|
||
TOPS10 <
|
||
|
||
;DEFINE STANDARD BREAK MASKS (NORMALLY COMES FROM MONSYM)
|
||
|
||
BRINI. ;INITIALIZE BREAK MASK FOR STANDARD FIELD
|
||
BRKCH. (0,37) ;ALL CONTROL CHARACTERS
|
||
BRKCH. (40,54) ;SPACE THROUGH COMMA
|
||
BRKCH. (56,57) ;DOT AND SLASH
|
||
BRKCH. (72,77) ;COLON THROUGH QUESTION MARK
|
||
BRKCH. (100) ;ATSIGN
|
||
BRKCH. (133,140) ;OPEN BRACKET THROUGH ACCENT GRAVE
|
||
BRKCH. (173,177) ;CLOSE BRACKET THROUGH TILDE
|
||
|
||
FLDB0.==W0. ;STANDARD FIELD BREAK MASK
|
||
FLDB1.==W1.
|
||
FLDB2.==W2.
|
||
FLDB3.==W3.
|
||
|
||
;KEYWORD BREAK SET. SAME AS STANDARD FIELD FOR NOW
|
||
|
||
KEYB0.==FLDB0.
|
||
KEYB1.==FLDB1.
|
||
KEYB2.==FLDB2.
|
||
KEYB3.==FLDB3.
|
||
|
||
;T10BRK: BRMSK. (FLDB0.,<FLDB1.&<^-<1_^D33!1_^D23>>>,FLDB2.,FLDB3.,<:.[]>)
|
||
T10BRK: BRMSK. (FLDB0.,FLDB1.,FLDB2.,FLDB3.,<:.[],>,-)
|
||
|
||
IF1, < DEFINE $IFILE (NXT,HELP<input filespec>,ARGLST) <
|
||
$FIELD (<NXT>,<HELP>,<$BREAK (T10BRK),ARGLST>)>
|
||
|
||
DEFINE $OFILE (NXT,HELP<output filespec>,ARGLST) <
|
||
$FIELD (<NXT>,<HELP>,<$BREAK (T10BRK),ARGLST>)>
|
||
|
||
DEFINE $FILE (NXT,HELP<filespec>,ARGLST) <
|
||
$FIELD (<NXT>,<HELP>,<$BREAK (T10BRK),ARGLST>)>
|
||
|
||
DEFINE NETOFI (NXT),<$OFILE(NXT)>
|
||
DEFINE NETIFI (NXT),<$IFILE(NXT)>
|
||
|
||
> ; End of IF1
|
||
> ; End of TOPS10
|
||
|
||
|
||
; NETIFI (next-pdb) - Parse network input file name with optional data in
|
||
; the format of node"user account password"::input-file-spec
|
||
|
||
TOPS20 <
|
||
DEFINE NETIFI (NEXT,%A,%B,%C,%D,%E,%F), <
|
||
$IFILE (NEXT,<Local Input File Name>,<$ALTERNATE(%A)>)
|
||
%A: $NODNM (%E,<Remote File Name>,<$FLAGS(CM%PO),$ALTERNATE(%B)>)
|
||
%B: $FIELD (%C,<>,<$FLAGS(CM%SDH+CM%BRK),$BREAK(NODBRK)>)
|
||
%C: $QUOTE (%D,<Optional "user password [account]">,<$ALTERNATE(%D)>)
|
||
%D: $TOKEN (%E,<::>,<$DEFAULT(<::>),$HELP(<"::" To Terminate Node Name>)>)
|
||
%E: $IFILE (NEXT,<Remote File Name>,<$ALTERNATE(%F)>)
|
||
%F: $FIELD (NEXT,<>,<$FLAGS(CM%SDH+CM%BRK),$BREAK(LITBRK)>)
|
||
IF2 <PURGE %A,%B,%C,%D,%E,%F>
|
||
> ; End of NETIFI macro definition
|
||
|
||
; NETOFI (next-pdb) - Parse network output file name with optional data in
|
||
; the format of node"user account password"::output-file-spec
|
||
|
||
DEFINE NETOFI (NEXT,%A,%B,%C,%D,%E,%F), <
|
||
$NODNM (%D,<Remote File Name>,<$FLAGS(CM%PO),$ALTERNATE(%A)>)
|
||
%A: $FIELD (%B,<>,<$FLAGS(CM%SDH+CM%BRK),$BREAK(NODBRK),$ALTERNATE(%F)>)
|
||
%B: $QUOTE (%C,<Optional "user password [account]">,<$ALTERNATE(%C)>)
|
||
%C: $TOKEN (%D,<::>,<$DEFAULT(<::>),$HELP(<"::" To Terminate Node Name>)>)
|
||
%D: $OFILE (NEXT,<Remote File Name>,<$ALTERNATE(%E)>)
|
||
%E: $FIELD (NEXT,<>,<$FLAGS(CM%SDH+CM%BRK),$BREAK(LITBRK)>)
|
||
%F: $OFILE (NEXT,<Local Output File Name>)
|
||
IF2 <PURGE %A,%B,%C,%D,%E,%F>
|
||
> ; End of NETOFI macro definition
|
||
>; END TOPS20
|
||
|
||
; SETFIL (next-pdb) - Parse field for SET FILE commands
|
||
|
||
DEFINE SETFIL(NEXT), <
|
||
IFB <LIST>, <$FIELD (NEXT,<File name>,<$FLAGS(CM%BRK),$BREAK(SETBRK)>)>
|
||
IFNB <LIST>, <$FIELD (NEXT,<File name>,<$FLAGS(CM%BRK),$BREAK(SETBRK),LIST>)>
|
||
> ; End of SETFIL Definition
|
||
|
||
SUBTTL Local Symbols
|
||
|
||
;
|
||
; EQUATED SYMBOLS:
|
||
;
|
||
|
||
VAL$KY==:1B18 ; Flag to indicate keyword is a parameter value
|
||
KNW$KY==:1B19 ; Flag to indicate keyword is a qualifier
|
||
|
||
IFNDEF FTX25, <FTX25==0> ; Default to exclude MODULE X25 commands
|
||
IFNDEF .CLIST, <.CLIST==0> ; Default to prevent printing keyword symbol
|
||
; assignments at front of listing
|
||
|
||
;
|
||
; GLOBAL SYMBOLS:
|
||
;
|
||
|
||
IF2 <ASUPPRESS>
|
||
|
||
|
||
DEFINE PRTEDT (MAN,DEV) <
|
||
PRINTX NCP MAINTENANCE EDIT NUMBER 'MAN'
|
||
PRINTX NCP DEVELOPMENT EDIT NUMBER 'DEV'
|
||
>
|
||
|
||
TOPS20 <IF2 <PRTEDT (\NCPMAN,\NCPDEV)>>
|
||
|
||
|
||
IFDEF DEBUG, <
|
||
IFN DEBUG, <INTERN NCP3TB>
|
||
IFE DEBUG, <INTERN NCPTAB>>
|
||
IFNDEF DEBUG, <INTERN NCPTAB>
|
||
|
||
SUBTTL Local Storage
|
||
|
||
;
|
||
; OWN STORAGE:
|
||
;
|
||
|
||
; OPRPAR Argument Block
|
||
|
||
IFDEF DEBUG, <
|
||
IFN DEBUG, <NCP3TB:>
|
||
IFE DEBUG, <NCPTAB:>>
|
||
IFNDEF DEBUG, <NCPTAB:> ; Externally referenced by OPR
|
||
EXP 2 ; Length
|
||
EXP ININCP ; Address of $INIT PDB
|
||
EXP NCPFDB ; Address of Top Level $KEY PDB
|
||
NCPGVN: TOPS10 <EXP GLXEDT> ; Version of GLXMAC
|
||
TOPS20 <EXP GMCEDT> ; Version number of GLXMAC
|
||
NCPVRN: EXP NCPVRS ; Version number of NCP
|
||
|
||
|
||
;
|
||
; Common Break Mask Tables
|
||
;
|
||
|
||
ETHBRK: BRMSK. (-1,-1,-1,-1,0123456789ABCDEFabcdef-) ; Hexadecimal field
|
||
HEXBRK: BRMSK. (-1,-1,-1,-1,0123456789ABCDEFabcdef) ; Hexadecimal field
|
||
DECBRK: BRMSK. (-1,-1,-1,-1,0123456789) ; Decimal field
|
||
CALBRK: BRMSK. (-1,-1,-1,-1,<*0123456789>) ; Call number field
|
||
NODBRK: BRMSK. (FLDB0.,FLDB1.,FLDB2.,FLDB3.,<_>,<->) ; Node name field
|
||
DOTBRK: BRMSK. (KEYB0.,KEYB1.,KEYB2.,KEYB3.,<.>) ; Keyword w/o dot as a break character
|
||
SETBRK: BRMSK. (FLDB0.,<FLDB1.&<^-<1_^D33!1_^D23>>>,FLDB2.,FLDB3.,[ ]<>:-._) ;Break mask for SETFIL
|
||
|
||
; Mask for all printing characters. NOTE: Special handling is required for
|
||
; double quote (") and comma (,) characters. Two bits which were shifted left
|
||
; 33 and 23 positions in the second field are set to indicate (") and (,),
|
||
; respectively.
|
||
; BRMSK. calls UNBRK. with double quote as a delimiter which prevents use of
|
||
; that character in the string argument to this macro. Since both sets of
|
||
; quoting characters are used in the string comma must be specially handled
|
||
; lest it would be interpreted as an argument delimeter.
|
||
|
||
LITBRK: BRMSK. (FLDB0.,<FLDB1.&<^-<1_^D33!1_^D23>>>,FLDB2.,FLDB3.,!#$%&'()*+-./:;<=>@[\]^_`{|}~)
|
||
SUBTTL Parser Action Routines
|
||
|
||
|
||
; $ACTION routine used to check for a valid node name returned
|
||
; by the $NODNM parse macro. It filters out node addresses.
|
||
;******TOPS-10 ONLY*******
|
||
|
||
TOPS10 <
|
||
CHKNAM: MOVE 0,CR.RES(S2) ; Get node name.
|
||
TLNE 0,770000 ; Is there a leading character?
|
||
PJRST [SETO 0, ; Yes, return TRUE
|
||
POPJ P,] ; ...
|
||
MOVEI S2,[ASCIZ /Node name must start with an alphabetic character/]
|
||
SETZ 0, ; Return FALSE with error message in S2
|
||
POPJ P, ; ...
|
||
> ; End of TOPS-10 Conditional
|
||
|
||
; $ACTION routine to check for a valid node number for the NOD$NUMBER
|
||
; macro. Note that at this time we don't know if this is an area number or
|
||
; a node number. We'll check to see that it's a valid node number now and
|
||
; if it turns out to be an area number, we'll catch it in CHKARN.
|
||
;
|
||
CHKANM: SKIPL T1,CR.RES(S2) ; Get number and check range
|
||
CAIL T1,^D1024 ; must be between 0 and 1023 inclusive
|
||
JRST [ MOVEI S2,[ASCIZ/Area or node number out of range/] ; Error text
|
||
SETZ 0, ; Flag error
|
||
POPJ P, ] ; And return false
|
||
MOVEM T1,AREANM ; Save in case it was area number
|
||
POPJ P, ; Return
|
||
AREANM: BLOCK 1
|
||
|
||
; $ACTION routine to verify that the area number we got in CHKANM is valid.
|
||
; We have already checked to see if it is between 0 and 1023. Now we will
|
||
; verify that it was between 0 and 63.
|
||
;
|
||
CHKARN: MOVE T1,AREANM ; Get area number from CHKANM
|
||
CAIGE T1,^D64 ; And check range (0-63 is valid)
|
||
POPJ P, ; OK. Return
|
||
MOVEI S2,[ASCIZ/Area number out of range/] ; Error text
|
||
SETZ 0, ; Flag error
|
||
POPJ P, ; Return false
|
||
|
||
; $ACTION routine to verify that the node number in "area.node" is valid.
|
||
; We already know that the area number, if typed was valid.
|
||
;
|
||
CHKNNM: SKIPL T1,CR.RES(S2) ; Get number and check range
|
||
CAIL T1,^D1024 ; must be between 0 and 1023 inclusive
|
||
JRST [ MOVEI S2,[ASCIZ/Node number out of range/] ; Error text
|
||
SETZ 0, ; Flag error
|
||
POPJ P, ] ; And return false
|
||
POPJ P, ; OK. Return true
|
||
|
||
SUBTTL Main NCP Command Tables
|
||
|
||
ININCP::$INIT (NCPFDB) ; NCP Command Prompt Initialization
|
||
|
||
NCPFDB: $KEYDSP (NCPTBL)
|
||
|
||
NCPTBL: $STAB ; NCP Command Keyword Table
|
||
NCPKEY (CANFDB,CAN,CANCEL)
|
||
NCPKEY (CLRFDB,CLR,CLEAR)
|
||
NCPKEY (SETFDB,DEF,DEFINE)
|
||
NCPKEY (DMPFDB,DMP,DUMP)
|
||
NCPKEY (HLPFDB,HLP,HELP)
|
||
NCPKEY (SHWFDB,LST,LIST)
|
||
NCPKEY (LODFDB,LOD,LOAD)
|
||
NCPKEY (LOPFDB,LOP,LOOP)
|
||
NCPKEY (CLRFDB,PUR,PURGE)
|
||
NCPKEY (SETFDB,SET,SET)
|
||
NCPKEY (SHWFDB,SHW,SHOW)
|
||
NCPKEY (TELFDB,TEL,TELL)
|
||
NCPKEY (TRGFDB,TRG,TRIGGER)
|
||
NCPKEY (ZERFDB,ZRO,ZERO)
|
||
$ETAB
|
||
|
||
SUBTTL Tables that appear out of ordinary sequence
|
||
;The reason for such things is to get the $KNxxx constants defined in
|
||
;the NCPKEY macro to be consecutive.
|
||
|
||
;Module ids
|
||
SHW201:$STAB ; MODULE module-id keyword table
|
||
NCPKEY (SHW270,CFG,CONFIGURATOR)
|
||
NCPKEY (SHW280,CSL,CONSOLE)
|
||
NCPKEY (SHW290,LDR,LOADER)
|
||
NCPKEY (SHW290,LPR,LOOPER)
|
||
NCPKEY (SHW210,XAC,X25-ACCESS)
|
||
NCPKEY (SHW220,XPR,X25-PROTOCOL)
|
||
NCPKEY (SHW260,XSV,X25-SERVER)
|
||
$ETAB
|
||
|
||
SUBTTL HELP Command
|
||
|
||
ND CR.ADR,4 ; Address of current argument
|
||
|
||
HLPFDB: $NOISE (HLP100,<with>)
|
||
|
||
HLP100: $CTEXT (,<command>,<$ACTION(NCPHLP),$DEFAULT(HELP)>)
|
||
|
||
NCPHLP::MOVE T1,CR.ADR(S2) ; Get the data
|
||
HRROI T1,ARG.DA(T1) ; Point to the string
|
||
$CALL SETOUT## ; Setup proper $TEXT defaults
|
||
MOVEI S1,HELPFS ; Point to help file
|
||
MOVE S2,T1 ; Point to string
|
||
$CALL P$HELP##
|
||
$CALL SNDOUT## ; Send the output
|
||
$CALL P$NPRO## ; Mark no processing
|
||
SETO 0,
|
||
POPJ 17,0 ; Return TRUE
|
||
|
||
HELPFS: XWD HSIZ,0 ; File descriptor of help file for NCP
|
||
|
||
TOPS10< SIXBIT /HLP/ ; Directory
|
||
SIXBIT /NCP/ ; File name
|
||
SIXBIT /HLP/ ; Extension
|
||
EXP 0> ; PPN
|
||
|
||
TOPS20< ASCIZ /HLP:NCP.MEM/>
|
||
|
||
HSIZ==.-HELPFS
|
||
|
||
SUBTTL ABORT/CANCEL Command
|
||
|
||
CANFDB: $KEYDSP (CAN100,<$DEFAULT(QUEUE)>)
|
||
|
||
CAN100: $STAB ; ABORT/CANCEL Command Entity Keyword Table
|
||
NCPKEY (CAN200,QUE,QUEUE)
|
||
$ETAB
|
||
|
||
CAN200: $KEYDSP (CAN300,<$DEFAULT(REQUEST)>)
|
||
|
||
CAN300: $STAB ; QUEUE Entity Parameter Keyword Table
|
||
NCPKEY (CAN400,REQ,REQUEST)
|
||
$ETAB
|
||
|
||
CAN400: $NUMBER (NCPCFM,^D10,<Request Id Number>) ; NCP Request Number
|
||
|
||
SUBTTL CLEAR and PURGE Commands
|
||
|
||
CLRFDB: $KEYDSP (CLR100)
|
||
|
||
CLR100: $STAB ; CLEAR Command Entity Keyword Table
|
||
NCPKEY (CLR300,CKT,CIRCUIT)
|
||
NCPKEY (CLR500,XTR,EXECUTOR)
|
||
NCPKEY (CLR600,KNW,KNOWN)
|
||
NCPKEY (CLR400,LIN,LINE)
|
||
NCPKEY (CLR700,LGG,LOGGING)
|
||
NCPKEY (CLR800,MDL,MODULE)
|
||
NCPKEY (CLR900,NOD,NODE)
|
||
$ETAB
|
||
|
||
SUBTTL CLEAR/PURGE CIRCUIT Command
|
||
|
||
CLR300: CKT$ID (CLR305) ; CIRCUIT ckt-id
|
||
|
||
CLR305: $KEYDSP (CLR990,<$ALTERNATE(CLR310)>)
|
||
|
||
CLR310: $KEYDSP (CLR320,<$ALTERNATE(CLR360)>)
|
||
|
||
CLR320: $STAB ; CIRCUIT Parameter Keyword Table
|
||
PARKEY (CLR350,C$PACT,^D1150,ACTIVE)
|
||
PARKEY (CLR325,C$PBAB,^D1141,BABBLE)
|
||
PARKEY (CLR325,C$PCTR,^D0110,COUNTER)
|
||
PARKEY (CLR354,C$PDEA,^D1156,DEAD)
|
||
PARKEY (CLR352,C$PDYI,^D1155,DYING)
|
||
PARKEY (CLR352,C$PINA,^D1152,INACTIVE)
|
||
PARKEY (CLR335,C$PMAX,^D0000,MAXIMUM)
|
||
VALKEY (CLR399,C$POWR,^D1100,OWNER)
|
||
PARKEY (CLR325,C$PRCL,^D0921,RECALL)
|
||
PARKEY (CLR325,C$PTRA,^D1142,TRANSMIT)
|
||
$ETAB
|
||
|
||
CLR325: $KEYDSP (CLR330,<$DEFAULT(TIMER)>)
|
||
|
||
CLR330: $STAB ; COUNTER/RECALL TIMER
|
||
VALKEY (CLR399,C$PTMR,^D0,TIMER)
|
||
$ETAB
|
||
|
||
CLR335: $KEYDSP (CLR336,<$DEFAULT(RECALLS)>)
|
||
|
||
CLR336: $STAB
|
||
VALKEY (CLR399,C$MBUF,^D1145,BUFFERS)
|
||
VALKEY (CLR399,C$MRCL,^D0920,RECALLS)
|
||
VALKEY (CLR399,C$MTRA,^D1146,TRANSMITS)
|
||
$ETAB
|
||
|
||
CLR350: $KEYDSP (CLR351)
|
||
|
||
CLR351: $STAB ; ACTIVE Keyword Table
|
||
VALKEY (CLR399,C$SBAS,^D0,BASE)
|
||
VALKEY (CLR399,C$SINC,^D1,INCREMENT)
|
||
$ETAB
|
||
|
||
CLR352: $KEYDSP (CLR353)
|
||
|
||
CLR353: $STAB ; INACTIVE, DYING Keyword Table
|
||
VALKEY (CLR399,C$SBAS,^D0,BASE)
|
||
VALKEY (CLR399,C$SINC,^D1,INCREMENT)
|
||
VALKEY (CLR399,C$STHR,^D2,THRESHOLD)
|
||
$ETAB
|
||
|
||
CLR354: $KEYDSP (CLR355)
|
||
|
||
CLR355: $STAB ; DEAD Keyword Table
|
||
VALKEY (CLR399,C$STHR,^D2,THRESHOLD)
|
||
$ETAB
|
||
|
||
CLR360: $KEYDSP (CLR361,<$FLAGS(CM%SDH)>)
|
||
|
||
CLR361: $STAB
|
||
PARKEY (CLR362,C$PNOD,^D2600,NODE)
|
||
$ETAB
|
||
|
||
CLR362: $KEYDSP (CLR363,<$FLAGS(CM%SDH)>)
|
||
|
||
CLR363: $STAB
|
||
VALKEY (CLR399,C$NTYP,^D0,TYPE)
|
||
$ETAB
|
||
|
||
CLR399: $CRLF (<$ALTERNATE(CLR310)>)
|
||
|
||
SUBTTL CLEAR/PURGE LINE Command
|
||
|
||
CLR400: LINE$ID (CLR405) ; LINE Line-id
|
||
|
||
CLR405: $KEYDSP (CLR990,<$ALTERNATE(CLR410)>)
|
||
|
||
CLR410: $KEYDSP (CLR420)
|
||
|
||
CLR420: $STAB ; LINE Parameter Keyword Table
|
||
PARKEY (CLR425,L$PCTR,^D0110,COUNTER)
|
||
PARKEY (CLR425,L$PDEA,^D1151,DEAD)
|
||
PARKEY (CLR425,L$PDEL,^D1152,DELAY)
|
||
PARKEY (CLR425,L$PHBK,^D1122,HOLDBACK)
|
||
PARKEY (CLR435,L$PMAX,^D0000,MAXIMUM)
|
||
PARKEY (CLR425,L$PSCH,^D1150,SCHEDULING)
|
||
PARKEY (CLR425,L$PSTR,^D1154,STREAM)
|
||
$ETAB
|
||
|
||
CLR425: $KEYDSP (CLR430,<$DEFAULT(TIMER)>)
|
||
|
||
CLR430: $STAB
|
||
VALKEY (CLR499,L$PTMR,^D0,TIMER)
|
||
$ETAB
|
||
|
||
|
||
CLR435: $KEYDSP (CLR436,<$DEFAULT(RETRANSMITS)>)
|
||
|
||
CLR436: $STAB
|
||
VALKEY (CLR499,L$MRTR,^D1131,RETRANSMITS)
|
||
$ETAB
|
||
|
||
CLR499: $CRLF (<$ALTERNATE(CLR410)>)
|
||
|
||
SUBTTL CLEAR/PURGE EXECUTOR Command
|
||
|
||
CLR500: $KEYDSP (CLR510,<$ALTERNATE(CLR910),$DEFAULT(NODE)>)
|
||
|
||
CLR510: $STAB ; EXECUTOR Keyword Table
|
||
PARKEY (NCPCFM,N$XNOD,^D2501,NODE) ; Dummy parameter value for our use
|
||
$ETAB
|
||
|
||
SUBTTL CLEAR/PURGE KNOWN Command
|
||
|
||
CLR600: $KEYDSP (CLR610)
|
||
|
||
CLR610: $STAB ; KNOWN Entities Keyword Table
|
||
NCPKEY (CLR305,CKT,CIRCUITS)
|
||
NCPKEY (CLR405,LIN,LINES)
|
||
NCPKEY (CLR720,LGG,LOGGING)
|
||
NCPKEY (CLR906,NOD,NODES)
|
||
$ETAB
|
||
|
||
SUBTTL CLEAR/PURGE LOGGING Command
|
||
|
||
CLR700: $KEYDSP (CLR710)
|
||
|
||
CLR710: $STAB ; LOGGING sink-type Keyword Table
|
||
VALKEY (CLR720,E$SCSL,^D1,CONSOLE)
|
||
VALKEY (CLR720,E$SFIL,^D2,FILE)
|
||
VALKEY (CLR720,E$SMTR,^D3,MONITOR)
|
||
$ETAB
|
||
|
||
CLR720: $KEYDSP (CLR730)
|
||
|
||
CLR725: $KEYDSP (CLR730,<$ALTERNATE(NCPCFM)>)
|
||
|
||
CLR730: $STAB ; LOGGING Entities Keyword Table
|
||
PARKEY (CLR735,E$PEVT,^D201,EVENT)
|
||
PARKEY (CLR740,E$PKNW,^D201,KNOWN)
|
||
VALKEY (CLR725,E$PNAM,^D100,NAME)
|
||
$ETAB
|
||
|
||
CLR735: EVLIST (CLR750) ; EVENT event-list
|
||
|
||
CLR740: $KEYDSP (CLR745,<$DEFAULT(EVENTS)>)
|
||
|
||
CLR745: $STAB ; KNOWN keyword parameter table
|
||
KNWKEY (CLR750,E$KEVT,^D0,EVENTS)
|
||
$ETAB
|
||
|
||
CLR750: $KEYDSP (CLR755,<$ALTERNATE(CLR775)>)
|
||
|
||
CLR755: $STAB ; Optional source-qual keyword table
|
||
PARKEY (CLR756,E$QCKT,^D3,CIRCUIT)
|
||
PARKEY (CLR757,E$QLIN,^D1,LINE)
|
||
PARKEY (CLR759,E$QMOD,^D4,MODULE)
|
||
PARKEY (CLR758,E$QNOD,^D0,NODE)
|
||
$ETAB
|
||
|
||
CLR756: CKT$ID (CLR775) ; CIRCUIT ckt-id
|
||
|
||
CLR757: LINE$ID (CLR775) ; LINE line-id
|
||
|
||
CLR758: NOD$ID (CLR775) ; NODE node-id
|
||
|
||
|
||
CLR759: $KEYDSP (CLR760)
|
||
|
||
CLR760: $STAB ; MODULE module-id Keyword Table
|
||
NCPKEY (CLR775,XAC,X25-ACCESS)
|
||
NCPKEY (CLR775,XPR,X25-PROTOCOL)
|
||
NCPKEY (CLR775,XSV,X25-SERVER)
|
||
$ETAB
|
||
|
||
|
||
CLR775: $KEYDSP (CLR780,<$ALTERNATE(CLR725)>)
|
||
|
||
CLR780: $STAB ; Optional sink-node Keyword Table
|
||
PARKEY (CLR785,E$PSNK,^D200,SINK)
|
||
$ETAB
|
||
|
||
CLR785: $KEYDSP (CLR790,<$DEFAULT(EXECUTOR)>)
|
||
|
||
CLR790: $STAB ; SINK Keyword Table
|
||
VALKEY (CLR725,E$SXTR,^D0,EXECUTOR)
|
||
PARKEY (CLR795,E$SNOD,^D0,NODE)
|
||
$ETAB
|
||
|
||
CLR795: NOD$ID (CLR725) ; SINK NODE node-id
|
||
|
||
SUBTTL CLEAR/PURGE MODULE Commands
|
||
|
||
|
||
CLR800: $KEYDSP (CLR805)
|
||
|
||
CLR805: $STAB ; MODULE module-id Keyword Table
|
||
NCPKEY (CLR810,XAC,X25-ACCESS)
|
||
NCPKEY (CLR840,XPR,X25-PROTOCOL)
|
||
NCPKEY (CLR870,XSV,X25-SERVER)
|
||
$ETAB
|
||
|
||
|
||
SUBTTL CLEAR/PURGE MODULE X25-ACCESS Commands
|
||
|
||
|
||
CLR810: $KEYDSP (CLR812,<$ALTERNATE(CLR814)>)
|
||
|
||
CLR811: $KEYDSP (CLR812,<$ALTERNATE(CLR816)>)
|
||
|
||
CLR812: $STAB ; X25-ACCESS Module Parameter Keyword Table
|
||
VALKEY (CLR811,X$AACT,^D332,ACCOUNT)
|
||
VALKEY (CLR811,X$APWD,^D331,PASSWORD)
|
||
VALKEY (CLR811,X$AUSR,^D330,USER)
|
||
$ETAB
|
||
|
||
CLR814: $KEYDSP (CLR815)
|
||
|
||
CLR815: $STAB
|
||
PARKEY (CLR816,X$ALL,^D000,ALL)
|
||
$ETAB
|
||
|
||
CLR816: $KEYDSP (CLR817,<$ALTERNATE(NCPCFM)>)
|
||
|
||
CLR817: $STAB ; Network Qualifier Table for other parameters
|
||
PARKEY (CLR818,X$AKNW,^D1110,KNOWN)
|
||
PARKEY (CLR820,X$ANWK,^D1110,NETWORK)
|
||
$ETAB
|
||
|
||
CLR818: $KEYDSP (CLR819,<$DEFAULT(NETWORKS)>)
|
||
|
||
CLR819: $STAB
|
||
KNWKEY (NCPCFM,X$KNWK,^D0000,NETWORKS)
|
||
$ETAB
|
||
|
||
CLR820: NET$NAME (NCPCFM)
|
||
|
||
|
||
SUBTTL CLEAR/PURGE MODULE X25-PROTOCOL Commands
|
||
|
||
|
||
CLR840: $KEYDSP (CLR842,<$ALTERNATE(CLR848)>)
|
||
|
||
CLR841: $CRLF (<$ALTERNATE(CLR86G)>)
|
||
|
||
CLR842: $STAB ; MODULE X25-PROTOCOL regular parameter table
|
||
PARKEY (CLR844,X$PCLL,^D1160,CALL)
|
||
PARKEY (CLR844,X$PCLR,^D1161,CLEAR)
|
||
PARKEY (CLR846,X$PMAX,^D0000,MAXIMUM)
|
||
PARKEY (CLR844,X$PRST,^D1162,RESET)
|
||
PARKEY (CLR844,X$PRTT,^D1163,RESTART)
|
||
$ETAB
|
||
|
||
CLR844: $KEYDSP (CLR845,<$DEFAULT(TIMER)>)
|
||
|
||
CLR845: $STAB ; CALL/CLEAR/RESET/RESTART TIMER
|
||
VALKEY (CLR841,X$PTMR,^D0,TIMER)
|
||
$ETAB
|
||
|
||
CLR846: $KEYDSP (CLR847)
|
||
|
||
CLR847: $STAB ; MAXIMUM parameter table
|
||
VALKEY (CLR841,X$MCLR,^D1152,CLEARS)
|
||
VALKEY (CLR841,X$MRES,^D1153,RESETS)
|
||
VALKEY (CLR841,X$MRST,^D1154,RESTARTS)
|
||
$ETAB
|
||
|
||
CLR848: $KEYDSP (CLR849,<$ALTERNATE(CLR854)>)
|
||
|
||
CLR849: $STAB ; DTE options table
|
||
PARKEY (CLR850,X$PCTR,^D0100,COUNTER)
|
||
PARKEY (CLR852,X$PLIN,^D1120,LINE)
|
||
$ETAB
|
||
|
||
CLR850: $KEYDSP (CLR851,<$DEFAULT(TIMER)>)
|
||
|
||
CLR851: $STAB
|
||
VALKEY (CLR853,X$PTMR,^D0,TIMER)
|
||
$ETAB
|
||
|
||
CLR852: LINE$ID (CLR853)
|
||
|
||
CLR853: $KEYDSP (CLR849,<$ALTERNATE(CLR864)>)
|
||
|
||
CLR854: $KEYDSP (CLR855,<$ALTERNATE(CLR862)>)
|
||
|
||
CLR855: $STAB ; GROUP qualifier parameter
|
||
PARKEY (CLR856,X$PGRP,^D1101,GROUP)
|
||
$ETAB
|
||
|
||
CLR856: $FIELD (CLR858,<Group Name>)
|
||
|
||
CLR858: $KEYDSP (CLR859)
|
||
|
||
CLR859: $STAB ; GROUP options parameter table
|
||
PARKEY (CLR860,X$GDTE,^D1170,DTE)
|
||
VALKEY (CLR861,X$GTYP,^D1172,TYPE)
|
||
$ETAB
|
||
|
||
CLR860: DTE$ADR (CLR861)
|
||
|
||
CLR861: $KEYDSP (CLR859,<$ALTERNATE(NCPCFM)>)
|
||
|
||
CLR862: $KEYDSP (CLR863)
|
||
|
||
CLR863: $STAB
|
||
PARKEY (CLR86A,X$ALL,^D0000,ALL)
|
||
$ETAB
|
||
|
||
CLR864: $KEYDSP (CLR866,<$ALTERNATE(NCPCFM)>)
|
||
|
||
CLR866: $STAB ; DTE qualifier table
|
||
PARKEY (CLR867,X$PDTE,^D1100,DTE)
|
||
PARKEY (CLR868,X$PKNW,^D1100,KNOWN)
|
||
$ETAB
|
||
|
||
CLR867: DTE$ADR (NCPCFM)
|
||
|
||
CLR868: $KEYDSP (CLR869,<$DEFAULT(DTES)>)
|
||
|
||
CLR869: $STAB
|
||
KNWKEY (NCPCFM,X$KDTE,^D0000,DTES)
|
||
$ETAB
|
||
|
||
CLR86A: $KEYDSP (CLR86B,<$ALTERNATE(NCPCFM)>)
|
||
|
||
CLR86B: $STAB ; DTE and GROUP qualifier table
|
||
PARKEY (CLR867,X$PDTE,^D1100,DTE)
|
||
PARKEY (CLR86C,X$PGRP,^D1101,GROUP)
|
||
PARKEY (CLR86E,X$PKNW,^D1100,KNOWN)
|
||
$ETAB
|
||
|
||
CLR86C: $FIELD (NCPCFM,<Group Name>)
|
||
|
||
CLR86E: $KEYDSP (CLR86F)
|
||
|
||
CLR86F: $STAB ; KNOWN qualifiers table
|
||
KNWKEY (NCPCFM,X$KDTE,^D0,DTES)
|
||
KNWKEY (NCPCFM,X$KGRP,^D1,GROUPS)
|
||
$ETAB
|
||
|
||
CLR86G: $KEYDSP (CLR842,<$ALTERNATE(CLR86H)>)
|
||
|
||
CLR86H: $KEYDSP (CLR849,<$ALTERNATE(CLR86I)>)
|
||
|
||
CLR86I: $KEYDSP (CLR855)
|
||
|
||
|
||
SUBTTL CLEAR/PURGE MODULE X25-SERVER Commands
|
||
|
||
|
||
CLR870: $KEYDSP (CLR871,<$ALTERNATE(CLR874)>)
|
||
|
||
CLR871: $STAB
|
||
VALKEY (CLR878,X$SACT,^D332,ACCOUNT)
|
||
PARKEY (CLR872,X$SCLL,^D000,CALL)
|
||
VALKEY (CLR878,X$SGRP,^D353,GROUP)
|
||
VALKEY (CLR878,X$SNBR,^D354,NUMBER)
|
||
VALKEY (CLR878,X$SPWD,^D331,PASSWORD)
|
||
VALKEY (CLR878,X$SPRI,^D350,PRIORITY)
|
||
VALKEY (CLR878,X$SSUB,^D355,SUBADDRESSES)
|
||
VALKEY (CLR878,X$SUSR,^D330,USER)
|
||
$ETAB
|
||
|
||
CLR872: $KEYDSP (CLR873)
|
||
|
||
CLR873: $STAB ; CALL MASK/VALUE parameters table
|
||
VALKEY (CLR878,X$CMSK,^D351,MASK)
|
||
VALKEY (CLR878,X$CVAL,^D352,VALUE)
|
||
$ETAB
|
||
|
||
CLR874: $KEYDSP (CLR875,<$ALTERNATE(CLR880)>)
|
||
|
||
CLR875: $STAB
|
||
PARKEY (CLR876,X$SCTR,^D100,COUNTER)
|
||
$ETAB
|
||
|
||
CLR876: $KEYDSP (CLR877,<$DEFAULT(TIMER)>)
|
||
|
||
CLR877: $STAB ; COUNTER TIMER parameter
|
||
VALKEY (CLR87A,X$STMR,^D0,TIMER)
|
||
$ETAB
|
||
|
||
CLR878: $KEYDSP (CLR871,<$ALTERNATE(CLR879)>)
|
||
|
||
CLR879: $KEYDSP (CLR875,<$ALTERNATE(CLR882)>)
|
||
|
||
CLR87A: $KEYDSP (CLR87B,<$ALTERNATE(NCPCFM)>)
|
||
|
||
CLR87B: $STAB
|
||
VALKEY (CLR87E,X$SACT,^D332,ACCOUNT)
|
||
PARKEY (CLR87C,X$SCLL,^D000,CALL)
|
||
VALKEY (CLR87E,X$SGRP,^D353,GROUP)
|
||
VALKEY (CLR87E,X$SNBR,^D354,NUMBER)
|
||
VALKEY (CLR87E,X$SPWD,^D331,PASSWORD)
|
||
VALKEY (CLR87E,X$SPRI,^D350,PRIORITY)
|
||
VALKEY (CLR87E,X$SSUB,^D355,SUBADDRESSES)
|
||
VALKEY (CLR87E,X$SUSR,^D330,USER)
|
||
$ETAB
|
||
|
||
CLR87C: $KEYDSP (CLR87D)
|
||
|
||
CLR87D: $STAB ; CALL MASK/VALUE parameters table
|
||
VALKEY (CLR87E,X$CMSK,^D351,MASK)
|
||
VALKEY (CLR87E,X$CVAL,^D352,VALUE)
|
||
$ETAB
|
||
|
||
CLR87E: $KEYDSP (CLR87B,<$ALTERNATE(CLR882)>)
|
||
|
||
CLR880: $KEYDSP (CLR881)
|
||
|
||
CLR881: $STAB ; ALL parameter table
|
||
PARKEY (CLR882,X$ALL,^D000,ALL)
|
||
$ETAB
|
||
|
||
CLR882: $KEYDSP (CLR883,<$ALTERNATE(NCPCFM)>)
|
||
|
||
CLR883: $STAB ; DESTINATION qualifier parameters table
|
||
PARKEY (CLR884,X$SDST,^D300,DESTINATION)
|
||
PARKEY (CLR886,X$SKNW,^D300,KNOWN)
|
||
$ETAB
|
||
|
||
CLR884: DEST$NAME (NCPCFM)
|
||
|
||
CLR886: $KEYDSP (CLR887,<$DEFAULT(DESTINATIONS)>)
|
||
|
||
CLR887: $STAB
|
||
KNWKEY (NCPCFM,X$KDST,^D000,DESTINATIONS)
|
||
$ETAB
|
||
|
||
|
||
SUBTTL CLEAR/PURGE NODE Command
|
||
|
||
CLR900: NOD$NUMBER (CLR906,CLR901,<ALL>) ; NODE node-address
|
||
|
||
CLR901: NOD$NAME (CLR904) ; NODE node-name
|
||
|
||
CLR904: $KEYDSP (CLR905,<$ALTERNATE(CLR906),$DEFAULT(CIRCUIT)>)
|
||
|
||
CLR905: $STAB
|
||
VALKEY (NCPCFM,N$PCKT,^D501,CIRCUIT)
|
||
$ETAB
|
||
|
||
CLR906: $KEYDSP (CLR990,<$ALTERNATE(CLR910),$DEFAULT(ALL)>)
|
||
|
||
CLR910: $KEYDSP (CLR915,<$ALTERNATE(CLR916)>)
|
||
|
||
CLR915: $STAB ; NODE Parameter Keyword Table
|
||
PARKEY (CLR9C0,N$PCON,^D000,CONSOLE)
|
||
PARKEY (CLR920,N$PCTR,^D160,COUNTER)
|
||
VALKEY (CLR999,N$PCPU,^D113,CPU)
|
||
PARKEY (CLR9A0,N$PDIA,^D123,DIAGNOSTIC)
|
||
PARKEY (CLR925,N$PDMP,^D000,DUMP)
|
||
VALKEY (CLR9B0,N$PHRD,^D114,HARDWARE)
|
||
VALKEY (CLR999,N$PHST,^D141,HOST)
|
||
VALKEY (CLR999,N$PIDN,^D100,IDENTIFICATION)
|
||
PARKEY (CLR920,N$PICG,^D510,INCOMING)
|
||
PARKEY (CLR930,N$PLOD,^D120,LOAD)
|
||
VALKEY (NCPCFM,N$PNAM,^D500,NAME)
|
||
PARKEY (CLR920,N$POTG,^D511,OUTGOING)
|
||
PARKEY (CLR935,N$PSDY,^D000,SECONDARY)
|
||
PARKEY (CLR940,N$PSVC,^D000,SERVICE)
|
||
PARKEY (CLR945,N$PSWR,^D000,SOFTWARE)
|
||
PARKEY (CLR950,N$PTRT,^D000,TERTIARY)
|
||
$ETAB
|
||
|
||
CLR916: $KEYDSP (CLR917,<$FLAGS(CM%SDH)>)
|
||
|
||
CLR917: $STAB ; FENCE (in house command)
|
||
PARKEY (CLR999,N$PFEN,^D2500,FENCE,CM%INV)
|
||
$ETAB
|
||
|
||
CLR920: $KEYDSP (CLR921,<$DEFAULT(TIMER)>)
|
||
|
||
CLR921: $STAB
|
||
VALKEY (CLR999,N$PTMR,^D0,TIMER)
|
||
$ETAB
|
||
|
||
CLR925: $KEYDSP (CLR926)
|
||
|
||
CLR926: $STAB ; DUMP parameter table
|
||
VALKEY (CLR999,N$DADR,^D135,ADDRESS)
|
||
VALKEY (CLR999,N$DCNT,^D136,COUNT)
|
||
VALKEY (CLR999,N$DFIL,^D130,FILE)
|
||
$ETAB
|
||
|
||
CLR930: $KEYDSP (CLR931,<$DEFAULT(FILE)>)
|
||
|
||
CLR931: $STAB ; LOAD parameter table
|
||
VALKEY (CLR999,N$LFIL,^D0,FILE)
|
||
$ETAB
|
||
|
||
CLR935: $KEYDSP (CLR936)
|
||
|
||
CLR936: $STAB ; SECONDARY parameter table
|
||
VALKEY (CLR999,N$SDPR,^D131,DUMPER)
|
||
VALKEY (CLR999,N$SLDR,^D121,LOADER)
|
||
$ETAB
|
||
|
||
CLR940: $KEYDSP (CLR941)
|
||
|
||
CLR941: $STAB ; SERVICE parameter table
|
||
VALKEY (CLR999,N$SCKT,^D110,CIRCUIT)
|
||
VALKEY (CLR999,N$SDVC,^D112,DEVICE)
|
||
VALKEY (CLR942,N$SNOD,^D115,NODE)
|
||
VALKEY (CLR999,N$SPWD,^D111,PASSWORD)
|
||
$ETAB
|
||
|
||
CLR942: $KEYDSP (CLR943,$DEFAULT<VERSION>)
|
||
|
||
CLR943: $STAB
|
||
VALKEY (CLR999,N$NVER,^D000,VERSION)
|
||
$ETAB
|
||
|
||
CLR945: $KEYDSP (CLR946)
|
||
|
||
CLR946: $STAB ; SOFTWARE parameter table
|
||
VALKEY (CLR999,N$SIDN,^D126,IDENTIFICATION)
|
||
VALKEY (CLR999,N$STYP,^D125,TYPE)
|
||
$ETAB
|
||
|
||
CLR950: $KEYDSP (CLR951,<$DEFAULT(LOADER)>)
|
||
|
||
CLR951: $STAB ; TERTIARY device table
|
||
VALKEY (CLR999,N$TLDR,^D122,LOADER)
|
||
$ETAB
|
||
|
||
CLR990: $STAB ; ALL Keyword Dispatch Table
|
||
PARKEY (NCPCFM,P$ALL,,ALL)
|
||
$ETAB
|
||
|
||
CLR999: $CRLF (<$ALTERNATE(CLR910)>)
|
||
|
||
;CLEAR NODE x DIAGNOSTIC
|
||
CLR9A0: $KEYDSP (CLR9A1,<$DEFAULT(FILE)>)
|
||
|
||
CLR9A1: $STAB
|
||
PARKEY (NCPCFM,N$PDI1,^D0,FILE)
|
||
$ETAB
|
||
|
||
;CLEAR NODE x HARDWARE
|
||
CLR9B0: $KEYDSP (CLR9B1,<$DEFAULT(ADDRESS)>)
|
||
|
||
CLR9B1: $STAB
|
||
PARKEY (NCPCFM,N$PHR1,^D0,ADDRESS)
|
||
$ETAB
|
||
|
||
;CLEAR NODE x CONSOLE
|
||
CLR9C0: $KEYDSP (CLR9C1)
|
||
|
||
CLR9C1: $STAB
|
||
PARKEY (CLR9C4,N$CLOD,^D000,LOAD)
|
||
PARKEY (CLR9C2,N$CSEC,^D000,SECONDARY)
|
||
$ETAB
|
||
|
||
CLR9C2: $KEYDSP (CLR9C3,<$DEFAULT(LOADER)>)
|
||
|
||
CLR9C3: $STAB
|
||
VALKEY (NCPCFM,N$CSLD,^D2511,LOADER)
|
||
$ETAB
|
||
|
||
CLR9C4: $KEYDSP (CLR9C5,<$DEFAULT(FILE)>)
|
||
|
||
CLR9C5: $STAB
|
||
VALKEY (NCPCFM,N$NLDF,^D2512,FILE)
|
||
$ETAB
|
||
|
||
SUBTTL DUMP Command
|
||
|
||
DMPFDB: $KEYDSP (DMP100)
|
||
|
||
DMP100: $STAB ; DUMP Command Entity Keyword Table
|
||
NCPKEY (DMP200,NOD,NODE)
|
||
NCPKEY (DMP300,VIA,VIA)
|
||
$ETAB
|
||
|
||
DMP200: NOD$ID (DMP210) ; Node name or number
|
||
|
||
DMP210: $KEYDSP (DMP220,<$ALTERNATE(NCPCFM)>)
|
||
|
||
DMP220: $STAB ; Optional DUMP Keyword Table
|
||
PARKEY (DMP230,N$PDMP,^D000,DUMP)
|
||
PARKEY (DMP250,N$SPWD,,PASSWORD)
|
||
PARKEY (DMP260,N$LPHY,,PHYSICAL)
|
||
PARKEY (DMP238,N$SDPR,,SECONDARY)
|
||
PARKEY (DMP244,N$PSVC,,SERVICE)
|
||
PARKEY (DMP252,N$DFIL,,TO)
|
||
PARKEY (DMP254,N$SCKT,,VIA)
|
||
$ETAB
|
||
|
||
DMP230: $KEYDSP (DMP232)
|
||
|
||
DMP232: $STAB
|
||
PARKEY (DMP234,N$DADR,^D135,ADDRESS)
|
||
PARKEY (DMP236,N$DCNT,^D136,COUNT)
|
||
$ETAB
|
||
|
||
DMP234: $NUMBER (DMP210,<^D8>,<Octal Beginning Dump Address>)
|
||
|
||
DMP236: $NUMBER (DMP210,<^D10>,<Number of Words to Dump>)
|
||
|
||
DMP238: $KEYDSP (DMP240,<$ALTERNATE(DMP242),$DEFAULT(DUMPER)>)
|
||
|
||
DMP240: $STAB ; SECONDARY device table
|
||
PARKEY (DMP242,N$PSDY,,DUMPER)
|
||
$ETAB
|
||
|
||
DMP242: NETIFI (DMP210) ; SECONDARY DUMPER
|
||
|
||
DMP244: $KEYDSP (DMP246)
|
||
|
||
DMP246: $STAB ; SERVICE keyword dispatch table
|
||
PARKEY (DMP248,N$SDVC,,DEVICE)
|
||
PARKEY (DMP250,N$SPWD,,PASSWORD)
|
||
$ETAB
|
||
|
||
DMP248: LALL
|
||
DEV$TYPE (DMP210) ; SERVICE DEVICE dev-id
|
||
SALL
|
||
|
||
DMP250: SVC$PASSWORD (DMP210)
|
||
|
||
DMP252: NETOFI (DMP210) ; DUMP TO output file
|
||
|
||
DMP254: CKT$ID (DMP210) ; DUMP NODE node-id VIA ckt-id
|
||
|
||
DMP260: $KEYDSP (DMP261,<$DEFAULT(ADDRESS)>)
|
||
|
||
DMP261: $STAB
|
||
PARKEY (DMP262,N$LPHA,,ADDRESS)
|
||
$ETAB
|
||
|
||
DMP262: NI$ADDRESS (DMP210)
|
||
|
||
DMP300: CKT$ID (DMP310) ; DUMP VIA ckt-id
|
||
|
||
DMP310: $KEYDSP (DMP320,<$ALTERNATE(NCPCFM)>)
|
||
|
||
DMP320: $STAB ; Optional DUMP Keyword Table
|
||
PARKEY (DMP230,N$PDMP,^D000,DUMP)
|
||
PARKEY (DMP250,N$SPWD,,PASSWORD)
|
||
PARKEY (DMP260,N$LPHY,,PHYSICAL)
|
||
PARKEY (DMP238,N$SDPR,,SECONDARY)
|
||
PARKEY (DMP244,N$PSVC,,SERVICE)
|
||
PARKEY (DMP252,N$DFIL,,TO)
|
||
$ETAB
|
||
|
||
SUBTTL LOAD Command
|
||
|
||
LODFDB: $KEYDSP (LOD100)
|
||
|
||
LOD100: $STAB ; LOAD Command Entity Keyword Table
|
||
NCPKEY (LOD200,NOD,NODE)
|
||
NCPKEY (LOD300,VIA,VIA)
|
||
$ETAB
|
||
|
||
LOD200: NOD$ID (LOD210) ; Node Name or Number
|
||
|
||
LOD210: $KEYDSP (LOD220,<$ALTERNATE(NCPCFM)>)
|
||
|
||
LOD220: $STAB ; LOAD Optional Keyword Table
|
||
PARKEY (LOD230,N$PADR,,ADDRESS)
|
||
PARKEY (LOD231,N$PCPU,^D113,CPU)
|
||
PARKEY (LOD270,N$PLOD,,FROM)
|
||
PARKEY (LOD234,N$PHST,^D141,HOST)
|
||
PARKEY (LOD235,N$PNAM,^D500,NAME)
|
||
PARKEY (LOD242,N$SPWD,,PASSWORD)
|
||
PARKEY (LOD280,N$LPHY,,PHYSICAL)
|
||
PARKEY (LOD236,N$SLDR,,SECONDARY)
|
||
PARKEY (LOD239,N$PSVC,,SERVICE)
|
||
PARKEY (LOD243,N$PSWR,,SOFTWARE)
|
||
PARKEY (LOD256,N$TLDR,,TERTIARY)
|
||
PARKEY (LOD262,N$SCKT,,VIA)
|
||
$ETAB
|
||
|
||
LOD230: NOD$NUMBER (LOD210) ; ADDRESS node-address
|
||
|
||
LOD231: $KEYDSP (LOD232)
|
||
|
||
LOD232: $STAB ; CPU-type Keyword Table
|
||
VALKEY (LOD210,N$D10,,DECSYSTEM-1020)
|
||
VALKEY (LOD210,N$P11,,PDP-11)
|
||
VALKEY (LOD210,N$P08,,PDP-8)
|
||
VALKEY (LOD210,N$VAX,,VAX-11)
|
||
$ETAB
|
||
|
||
LOD234: NOD$ID (LOD210) ; HOST node-id
|
||
|
||
LOD235: NOD$NAME (LOD210) ; NAME node-name
|
||
|
||
LOD236: $KEYDSP (LOD237,<$ALTERNATE(LOD270),$DEFAULT(LOADER)>)
|
||
|
||
LOD237: $STAB
|
||
PARKEY (LOD270,N$PSDY,,LOADER)
|
||
$ETAB
|
||
|
||
LOD239: $KEYDSP (LOD240)
|
||
|
||
LOD240: $STAB ; SERVICE Keyword Table
|
||
PARKEY (LOD241,N$SDVC,,DEVICE)
|
||
PARKEY (LOD24A,N$SNOD,,NODE)
|
||
PARKEY (LOD242,N$SPWD,,PASSWORD)
|
||
$ETAB
|
||
|
||
LOD241: DEV$TYPE (LOD210) ; SERVICE DEVICE dev-id
|
||
|
||
LOD24A: $KEYDSP (LOD24B,$DEFAULT<VERSION>)
|
||
|
||
LOD24B: $STAB
|
||
PARKEY (LOD24C,N$NVER,,VERSION)
|
||
$ETAB
|
||
|
||
LOD24C: $NUMBER (LOD210,<^D10>)
|
||
|
||
LOD242: SVC$PASSWORD (LOD210) ; [SERVICE] PASSWORD password
|
||
|
||
LOD243: $KEYDSP (LOD244)
|
||
|
||
LOD244: $STAB ; SOFTWARE Keyword Dispatch
|
||
PARKEY (LOD245,N$SIDN,,IDENTIFICATION)
|
||
PARKEY (LOD248,N$STYP,,TYPE)
|
||
$ETAB
|
||
|
||
LOD245: STR$ID (LOD210,<Software Identification>)
|
||
|
||
LOD248: $KEYDSP (LOD250)
|
||
|
||
LOD250: $STAB ; SOFTWARE TYPE Keyword Dispatch
|
||
VALKEY (LOD210,N$SSLD,,SECONDARY-LOADER)
|
||
VALKEY (LOD210,N$SSYS,,SYSTEM)
|
||
VALKEY (LOD210,N$STLD,,TERTIARY-LOADER)
|
||
$ETAB
|
||
|
||
LOD256: $KEYDSP (LOD258,<$ALTERNATE(LOD270),$DEFAULT(LOADER)>)
|
||
|
||
LOD258: $STAB
|
||
PARKEY (LOD270,N$PTRT,,LOADER) ; TERTIARY LOADER
|
||
$ETAB
|
||
|
||
LOD262: CKT$ID (LOD210) ; LOAD NODE node-id VIA ckt-id
|
||
|
||
LOD270: NETIFI (LOD210) ; TERTIARY LOADER file-id
|
||
|
||
LOD280: $KEYDSP (LOD281,<$DEFAULT(ADDRESS)>)
|
||
|
||
LOD281: $STAB
|
||
PARKEY (LOD282,N$LPHA,,ADDRESS)
|
||
$ETAB
|
||
|
||
LOD282: NI$ADDRESS (LOD210)
|
||
|
||
LOD300: CKT$ID (LOD310) ; LOAD VIA ckt-id
|
||
|
||
LOD310: $KEYDSP (LOD320,<$ALTERNATE(NCPCFM)>)
|
||
|
||
LOD320: $STAB ; VIA Optional Keyword Table
|
||
PARKEY (LOD230,N$PADR,,ADDRESS)
|
||
PARKEY (LOD231,N$PCPU,^D113,CPU)
|
||
PARKEY (LOD270,N$PLOD,,FROM)
|
||
PARKEY (LOD234,N$PHST,^D141,HOST)
|
||
PARKEY (LOD235,N$PNAM,^D500,NAME)
|
||
PARKEY (LOD242,N$SPWD,,PASSWORD)
|
||
PARKEY (LOD280,N$LPHY,,PHYSICAL)
|
||
PARKEY (LOD236,N$SLDR,,SECONDARY)
|
||
PARKEY (LOD239,N$PSVC,,SERVICE)
|
||
PARKEY (LOD243,N$PSWR,,SOFTWARE)
|
||
PARKEY (LOD256,N$TLDR,,TERTIARY)
|
||
$ETAB
|
||
|
||
SUBTTL LOOP Command
|
||
|
||
LOPFDB: $KEYDSP (LOP100)
|
||
|
||
LOP100: $STAB ; LOOP Command Entity Keyword Table
|
||
NCPKEY (LOP110,CKT,CIRCUIT)
|
||
NCPKEY (LOP200,XTR,EXECUTOR)
|
||
NCPKEY (LOP300,LIN,LINE)
|
||
NCPKEY (LOP400,NOD,NODE)
|
||
$ETAB
|
||
|
||
LOP110: CKT$ID (LOP120)
|
||
|
||
LOP120: $KEYDSP (LOP121,<$ALTERNATE(LOP310)>)
|
||
|
||
LOP121: $STAB
|
||
PARKEY (LOP130,N$LASS,^D000,ASSISTANT)
|
||
PARKEY (LOP140,N$LHLP,^D154,HELP)
|
||
PARKEY (LOP150,N$LNOD,^D155,NODE)
|
||
PARKEY (LOP160,N$LPHY,^D10,PHYSICAL)
|
||
$ETAB
|
||
|
||
LOP130: $KEYDSP (LOP131)
|
||
|
||
LOP131: $STAB ;ASSISTANT keyword table
|
||
PARKEY (LOP132,N$ANOD,^D156,NODE)
|
||
PARKEY (LOP135,N$APHY,^D153,PHYSICAL)
|
||
$ETAB
|
||
|
||
LOP132: NOD$ID (LOP310)
|
||
|
||
LOP135: $KEYDSP (LOP136,$DEFAULT<ADDRESS>)
|
||
|
||
LOP136: $STAB
|
||
PARKEY (LOP137,N$LAPA,^D000,ADDRESS)
|
||
$ETAB
|
||
|
||
LOP137: NI$ADDRESS (LOP310)
|
||
|
||
LOP140: $KEYDSP (LOP145)
|
||
|
||
LOP145: $STAB ;HELP option keyword table
|
||
VALKEY (LOP310,N$HFUL,^D2,FULL)
|
||
VALKEY (LOP310,N$HTRA,^D2,TRANSMIT)
|
||
$ETAB
|
||
|
||
LOP150: NOD$ID (LOP310)
|
||
|
||
LOP160: $KEYDSP (LOP161,$DEFAULT<ADDRESS>)
|
||
|
||
LOP161: $STAB
|
||
PARKEY (LOP162,N$LPHA,^D000,ADDRESS)
|
||
$ETAB
|
||
|
||
LOP162: NI$ADDRESS (LOP310)
|
||
|
||
|
||
LOP200: $KEYDSP (LOP210,<$ALTERNATE(LOP310)>)
|
||
|
||
LOP210: $STAB ; ACCESS control Keyword Table
|
||
PARKEY (LOP220,N$XACT,,ACCOUNT)
|
||
PARKEY (LOP230,N$XPWD,,PASSWORD)
|
||
PARKEY (LOP240,N$XUSR,,USER)
|
||
$ETAB
|
||
|
||
LOP220: $FIELD (LOP200,<Account String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
LOP230: $FIELD (LOP200,<Access Password String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
LOP240: $FIELD (LOP200,<User Name>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
LOP300: LINE$ID (LOP310)
|
||
|
||
LOP310: $KEYDSP (LOP320,<$ALTERNATE(NCPCFM)>)
|
||
|
||
LOP320: $STAB
|
||
PARKEY (LOP330,N$LDRC,^D150,COUNT)
|
||
PARKEY (LOP340,N$LLTH,^D151,LENGTH)
|
||
PARKEY (LOP350,N$LWTH,^D152,WITH)
|
||
$ETAB
|
||
|
||
LOP330: $NUMBER (LOP310,<^D10>) ; COUNT count
|
||
|
||
LOP340: $NUMBER (LOP310,<^D10>) ; LENGTH length
|
||
|
||
LOP350: $KEYDSP (LOP351)
|
||
|
||
LOP351: $STAB ; WITH Option Keyword Table
|
||
VALKEY (LOP310,N$WMXD,^D2,MIXED)
|
||
VALKEY (LOP310,N$WONE,^D1,ONES)
|
||
VALKEY (LOP310,N$WZRO,^D0,ZEROES)
|
||
$ETAB
|
||
|
||
|
||
LOP400: NOD$ID (LOP200)
|
||
|
||
SUBTTL SHOW and LIST Commands
|
||
|
||
SHWFDB: $KEYDSP (SHW100)
|
||
|
||
SHW100: $STAB
|
||
NCPKEY (SHW110,ATV,ACTIVE)
|
||
NCPKEY (SHW410,ADJ,ADJACENT)
|
||
NCPKEY (SHW112,ARE,AREA)
|
||
NCPKEY (SHW130,CKT,CIRCUIT)
|
||
NCPKEY (SHW192,XTR,EXECUTOR)
|
||
NCPKEY (SHW110,KNW,KNOWN)
|
||
NCPKEY (SHW140,LIN,LINE)
|
||
NCPKEY (SHW170,LGG,LOGGING)
|
||
NCPKEY (SHW190,LOP,LOOP)
|
||
NCPKEY (SHW200,MDL,MODULE)
|
||
NCPKEY (SHW400,NOD,NODE)
|
||
NCPKEY (NCPCFM,QUE,QUEUE)
|
||
NCPKEY (SHW420,SIG,SIGNIFICANT,CM%INV) ;Make invisible
|
||
$ETAB
|
||
|
||
SHW110: $KEYDSP (SHW111)
|
||
|
||
SHW111: $STAB ; ACTIVE/KNOWN Entities Keyword Table
|
||
NCPKEY (SHW192,ARE,AREAS)
|
||
NCPKEY (SHW422,CKT,CIRCUITS)
|
||
NCPKEY (SHW192,LIN,LINES)
|
||
NCPKEY (SHW500,LGG,LOGGING)
|
||
NCPKEY (SHW192,MDL,MODULES)
|
||
NCPKEY (SHW192,NOD,NODES)
|
||
$ETAB
|
||
|
||
SHW112: $NUMBER (SHW192,<^D10>,<Area number>) ; AREA area-id
|
||
|
||
SHW130: CKT$ID (SHW422) ; CIRCUIT ckt-id
|
||
|
||
SHW140: LINE$ID (SHW192) ; LINE line-id
|
||
|
||
SHW170: $KEYDSP (SHW180)
|
||
|
||
SHW180: $STAB ; LOGGING sink-type keyword table
|
||
VALKEY (SHW500,E$SCSL,^D1,CONSOLE)
|
||
VALKEY (SHW500,E$SFIL,^D2,FILE)
|
||
VALKEY (SHW500,E$SMTR,^D3,MONITOR)
|
||
$ETAB
|
||
|
||
SHW190: $KEYDSP (SHW191,<$DEFAULT(NODES)>)
|
||
|
||
SHW191: $STAB ; LOOP entities keyword table
|
||
NCPKEY (SHW192,NOD,NODES)
|
||
$ETAB
|
||
|
||
SHW192: $KEYDSP (SHW193,<$DEFAULT(SUMMARY)>)
|
||
|
||
SHW193: $STAB ; SHOW Parameter Keyword Table
|
||
NCPKEY (NCPCFM,CHR,CHARACTERISTICS)
|
||
NCPKEY (NCPCFM,CTR,COUNTERS)
|
||
NCPKEY (NCPCFM,STS,STATUS)
|
||
NCPKEY (NCPCFM,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
|
||
SHW200: $KEYDSP (SHW201)
|
||
|
||
;The following table has been moved to the beginning so that
|
||
;$KNxxx for module ids will be consecutive.
|
||
;SHW201:$STAB ; MODULE module-id keyword table
|
||
; NCPKEY (SHW270,CFG,CONFIGURATOR)
|
||
; NCPKEY (SHW280,CSL,CONSOLE)
|
||
; NCPKEY (SHW290,LDR,LOADER)
|
||
; NCPKEY (SHW290,LPR,LOOPER)
|
||
; NCPKEY (SHW210,XAC,X25-ACCESS)
|
||
; NCPKEY (SHW220,XPR,X25-PROTOCOL)
|
||
; NCPKEY (SHW260,XSV,X25-SERVER)
|
||
; $ETAB
|
||
|
||
SUBTTL SHOW/LIST MODULE X25-ACCESS Commands
|
||
SHW210: $KEYDSP (SHW211,<$DEFAULT(CHARACTERISTICS)>)
|
||
|
||
SHW211: $STAB ; SHOW MODULE X25-ACCESS selector table
|
||
NCPKEY (SHW212,CHR,CHARACTERISTICS)
|
||
NCPKEY (SHW212,CTR,COUNTERS)
|
||
NCPKEY (SHW212,STS,STATUS)
|
||
NCPKEY (SHW212,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SHW212: $KEYDSP (SHW213,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SHW213: $STAB ; SHOW MODULE X25-ACCESS network qualifier
|
||
PARKEY (SHW214,X$AKNW,^D1110,KNOWN)
|
||
PARKEY (SHW216,X$ANWK,^D1110,NETWORK)
|
||
$ETAB
|
||
|
||
SHW214: $KEYDSP (SHW215,<$DEFAULT(NETWORKS)>)
|
||
|
||
SHW215: $STAB
|
||
KNWKEY (NCPCFM,X$KNWK,^D0000,NETWORKS)
|
||
$ETAB
|
||
|
||
SHW216: NET$NAME (NCPCFM) ; NETWORK network-name
|
||
|
||
SUBTTL SHOW/LIST MODULE X25-PROTOCOL Commands
|
||
SHW220: $KEYDSP (SHW221,<$DEFAULT(SUMMARY)>)
|
||
|
||
SHW221: $STAB ; SHOW MODULE X25-PROTOCOL selector table
|
||
NCPKEY (SHW222,CHR,CHARACTERISTICS)
|
||
NCPKEY (SHW222,CTR,COUNTERS)
|
||
NCPKEY (SHW222,STS,STATUS)
|
||
NCPKEY (SHW222,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SHW222: $KEYDSP (SHW223,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SHW223: $STAB ; X25-PROTOCOL Qualifier Table
|
||
PARKEY (SHW224,X$PDTE,^D1100,DTE)
|
||
PARKEY (SHW230,X$PGRP,^D1101,GROUP)
|
||
PARKEY (SHW240,X$PKNW,^D1100,KNOWN)
|
||
$ETAB
|
||
|
||
SHW224: DTE$ADR (NCPCFM) ; DTE dte-address
|
||
|
||
SHW230: $FIELD (NCPCFM,<Group Name>) ; GROUP group-name
|
||
|
||
SHW240: $KEYDSP (SHW241)
|
||
|
||
SHW241: $STAB
|
||
KNWKEY (NCPCFM,X$KDTE,^D0000,DTES)
|
||
KNWKEY (NCPCFM,X$KGRP,^D0001,GROUPS)
|
||
$ETAB
|
||
|
||
SUBTTL SHOW/LIST MODULE X25-SERVER Commands
|
||
SHW260: $KEYDSP (SHW261,<$DEFAULT(SUMMARY)>)
|
||
|
||
SHW261: $STAB ; SHOW MODULE X25-SERVER selector table
|
||
NCPKEY (SHW262,CHR,CHARACTERISTICS)
|
||
NCPKEY (NCPCFM,CTR,COUNTERS)
|
||
NCPKEY (SHW262,STS,STATUS)
|
||
NCPKEY (SHW262,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SHW262: $KEYDSP (SHW263,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SHW263: $STAB ; SHOW MODULE X25-SERVER destination qualifier
|
||
PARKEY (SHW264,X$SDST,^D300,DESTINATION)
|
||
PARKEY (SHW266,X$SKNW,^D300,KNOWN)
|
||
$ETAB
|
||
|
||
SHW264: DEST$NAME (NCPCFM) ; DESTINATION dest-name
|
||
|
||
SHW266: $KEYDSP (SHW267,<$DEFAULT(DESTINATIONS)>)
|
||
|
||
SHW267: $STAB
|
||
KNWKEY (NCPCFM,X$KDST,^D000,DESTINATIONS)
|
||
$ETAB
|
||
|
||
|
||
SUBTTL SHOW/LIST MODULE CONFIGURATOR Commands
|
||
|
||
SHW270: $KEYDSP (SHW271,<$ALTERNATE(SHW275)>)
|
||
|
||
SHW271: $STAB ; CONFIGURATOR qualifier table
|
||
PARKEY (SHW272,C$FCKT,^D100,CIRCUIT)
|
||
PARKEY (SHW273,C$FKNW,^D100,KNOWN)
|
||
$ETAB
|
||
|
||
SHW272: CKT$ID (SHW275) ; CIRCUIT circuit-id
|
||
|
||
SHW273: $KEYDSP (SHW274,<$DEFAULT(CIRCUITS)>)
|
||
|
||
SHW274: $STAB ; KNOWN CIRCUITS
|
||
KNWKEY (SHW275,C$FKNC,^D0,CIRCUITS)
|
||
$ETAB
|
||
|
||
SHW275: $KEYDSP (SHW276,<$DEFAULT(SUMMARY)>)
|
||
|
||
SHW276: $STAB ; SHOW MODULE CONFIGURATOR selector table
|
||
NCPKEY (NCPCFM,STS,STATUS)
|
||
NCPKEY (NCPCFM,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SUBTTL SHOW/LIST MODULE CONSOLE Commands
|
||
SHW280: $KEYDSP (SHW281)
|
||
|
||
SHW281: $STAB ; SHOW/LIST MODULE CONSOLE selector table
|
||
NCPKEY (NCPCFM,CHR,CHARACTERISTICS)
|
||
NCPKEY (NCPCFM,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SUBTTL SHOW/LIST MODULE LOADER/LOOPER Commands
|
||
SHW290: $KEYDSP (SHW291)
|
||
|
||
SHW291: $STAB ; SHOW/LIST MODULE LOADER/LOOPER selector table
|
||
NCPKEY (NCPCFM,STS,STATUS)
|
||
NCPKEY (NCPCFM,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SHW400: NOD$ID (SHW192,,<SUMMARY>)
|
||
|
||
SHW410: $KEYDSP (SHW411,$DEFAULT(NODES)) ; ADJACENT NODES
|
||
|
||
SHW411: $STAB
|
||
NCPKEY (SHW412,NOD,NODES)
|
||
$ETAB
|
||
|
||
SHW412: $KEYDSP (SHW413,<$DEFAULT(SUMMARY)>)
|
||
|
||
SHW413: $STAB ; SHOW ADJACENT NODE node-id Keyword Table
|
||
NCPKEY (SHW414,CHR,CHARACTERISTICS)
|
||
NCPKEY (SHW414,CTR,COUNTERS)
|
||
NCPKEY (SHW414,STS,STATUS)
|
||
NCPKEY (SHW414,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SHW414: $KEYDSP (SHW415,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SHW415: $STAB ; SHOW ADJACENT NODES qualifier table
|
||
PARKEY (SHW416,A$NCKT,^D822,CIRCUIT)
|
||
PARKEY (SHW417,A$NKNW,^D822,KNOWN)
|
||
$ETAB
|
||
|
||
SHW416: CKT$ID (NCPCFM)
|
||
|
||
SHW417: $KEYDSP (SHW418,<$DEFAULT (CIRCUITS)>)
|
||
|
||
SHW418: $STAB
|
||
KNWKEY (NCPCFM,A$NKNC,^D0,CIRCUITS)
|
||
$ETAB
|
||
|
||
SHW420: $KEYDSP (SHW421) ; SHOW SIGNIFICANT selector table
|
||
|
||
SHW421: $STAB
|
||
NCPKEY (SHW422,CKT,CIRCUITS)
|
||
NCPKEY (SHW192,LIN,LINES)
|
||
NCPKEY (SHW192,MDL,MODULES)
|
||
NCPKEY (SHW192,NOD,NODES)
|
||
$ETAB
|
||
|
||
SHW422: $KEYDSP (SHW423,<$DEFAULT(SUMMARY)>)
|
||
|
||
SHW423: $STAB ; CIRCUITS selector table
|
||
NCPKEY (SHW424,CHR,CHARACTERISTICS)
|
||
NCPKEY (SHW424,CTR,COUNTERS)
|
||
NCPKEY (SHW424,STS,STATUS)
|
||
NCPKEY (SHW424,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SHW424: $KEYDSP (SHW425,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SHW425: $STAB ; CIRCUITS qualifier table
|
||
PARKEY (SHW426,C$CADJ,^D800,ADJACENT)
|
||
$ETAB
|
||
|
||
SHW426: $KEYDSP (SHW427,<$DEFAULT(NODE)>)
|
||
|
||
SHW427: $STAB
|
||
PARKEY (SHW428,C$CNOD,^D0,NODE)
|
||
$ETAB
|
||
|
||
SHW428: NOD$ID (NCPCFM)
|
||
|
||
SUBTTL SHOW LOGGING SINK sink-type Commands
|
||
|
||
SHW500: $KEYDSP (SHW510,<$DEFAULT(SUMMARY)>)
|
||
|
||
SHW510: $STAB ; LOGGING entities keyword table
|
||
NCPKEY (SHW530,CHR,CHARACTERISTICS)
|
||
NCPKEY (SHW530,EVT,EVENTS)
|
||
NCPKEY (SHW530,STS,STATUS)
|
||
NCPKEY (SHW530,SUM,SUMMARY)
|
||
$ETAB
|
||
|
||
SHW530: $KEYDSP (SHW540,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SHW540: $STAB ; Qualifier Keyword Table
|
||
PARKEY (SHW550,E$SKNW,^D200,KNOWN)
|
||
PARKEY (SHW570,E$PSNK,^D200,SINK)
|
||
$ETAB
|
||
|
||
SHW550: $KEYDSP (SHW560,<$DEFAULT(SINKS)>)
|
||
|
||
SHW560: $STAB ; KNOWN Qualifier Keyword Table
|
||
KNWKEY (NCPCFM,E$SSNK,^D000,SINKS)
|
||
$ETAB
|
||
|
||
SHW570: $KEYDSP (SHW580,<$DEFAULT(NODE)>)
|
||
|
||
SHW580: $STAB ; SINK Qualifier Keyword Table
|
||
PARKEY (SHW590,E$SNOD,^D000,NODE)
|
||
$ETAB
|
||
|
||
SHW590: NOD$ID (NCPCFM) ; SINK NODE node-id
|
||
|
||
SUBTTL SET and DEFINE Commands
|
||
|
||
SETFDB: $KEYDSP (SET001)
|
||
|
||
SET001: $STAB
|
||
NCPKEY (SET100,CKT,CIRCUIT)
|
||
NCPKEY (SET300,XTR,EXECUTOR)
|
||
NCPKEY (SET400,KNW,KNOWN)
|
||
NCPKEY (SET200,LIN,LINE)
|
||
NCPKEY (SET500,LGG,LOGGING)
|
||
NCPKEY (SET600,MDL,MODULE)
|
||
NCPKEY (SET900,NOD,NODE)
|
||
$ETAB
|
||
|
||
SUBTTL SET/DEFINE CIRCUIT Command
|
||
|
||
SET100: CKT$ID (SET102) ; CIRCUIT ckt-id
|
||
|
||
SET102: $KEYDSP (SETX90,<$ALTERNATE(SET105)>)
|
||
|
||
SET105: $KEYDSP (SET107,<$ALTERNATE(SET190)>)
|
||
|
||
SET107: $STAB ; CIRCUIT Parameter Keyword Table
|
||
PARKEY (SET150,C$PACT,^D1150,ACTIVE)
|
||
PARKEY (SET147,C$PBAB,^D1141,BABBLE)
|
||
PARKEY (SET110,C$PBKG,^D0910,BLOCKING)
|
||
PARKEY (SET115,C$PCHN,^D1121,CHANNEL)
|
||
PARKEY (SET125,C$PCST,^D0900,COST)
|
||
PARKEY (SET130,C$PCTR,^D0110,COUNTER)
|
||
PARKEY (SET154,C$PDEA,^D1156,DEAD)
|
||
PARKEY (SET133,C$PDTE,^D1120,DTE)
|
||
PARKEY (SET152,C$PDYI,^D1155,DYING)
|
||
PARKEY (SET130,C$PHEL,^D0906,HELLO)
|
||
PARKEY (SET152,C$PINA,^D1152,INACTIVE)
|
||
PARKEY (SET120,C$PLIN,^D1110,LINE)
|
||
PARKEY (SET130,C$PLSN,^D0907,LISTEN)
|
||
PARKEY (SET135,C$PMAX,^D0000,MAXIMUM)
|
||
PARKEY (SET134,C$PNBR,^D0930,NUMBER)
|
||
PARKEY (SET160,C$POWR,^D1100,OWNER)
|
||
PARKEY (SET161,C$PPST,^D1010,POLLING)
|
||
PARKEY (SET130,C$PRCL,^D0921,RECALL)
|
||
PARKEY (SET19A,C$PRTP,^D0902,ROUTER)
|
||
PARKEY (SET110,C$PSVC,^D0100,SERVICE)
|
||
PARKEY (SET165,C$PSTT,^D0000,STATE)
|
||
PARKEY (SET147,C$PTRA,^D1142,TRANSMIT)
|
||
PARKEY (SET175,C$PTRB,^D1140,TRIBUTARY)
|
||
PARKEY (SET180,C$PTYP,^D1112,TYPE)
|
||
PARKEY (SET185,C$PUSG,^D1111,USAGE)
|
||
$ETAB
|
||
|
||
SET110: $KEYDSP (SET111)
|
||
|
||
SET111: $STAB ; BLOCKING/SERVICE Keyword Table
|
||
VALKEY (SET199,C$SDBD,^D1,DISABLED)
|
||
VALKEY (SET199,C$SEBD,^D0,ENABLED)
|
||
$ETAB
|
||
|
||
|
||
SET115: $NUMBER (SET199,<^D10>,<X25 Logical Channel Number>)
|
||
|
||
|
||
SET120: LINE$ID (SET199)
|
||
|
||
SET125: $NUMBER (SET199,<^D10>,<Routing Cost, 1 to 25 Decimal>)
|
||
|
||
SET130: $KEYDSP (SET131,<$DEFAULT(TIMER)>)
|
||
|
||
SET131: $STAB
|
||
PARKEY (SET132,C$STMR,^D0000,TIMER)
|
||
$ETAB
|
||
|
||
SET132: $NUMBER (SET199,<^D10>,<Seconds>)
|
||
|
||
|
||
SET133: DTE$ADR (SET199) ; DTE dte-address
|
||
|
||
SET134: CALL$NUMBER (SET199)
|
||
|
||
|
||
SET135: $KEYDSP (SET136)
|
||
|
||
SET136: $STAB ; MAXIMUM Keyword Table
|
||
PARKEY (SET140,C$MBUF,^D1145,BUFFERS)
|
||
PARKEY (SET137,C$MBLK,^D1122,DATA)
|
||
PARKEY (SET138,C$MRCL,^D0920,RECALLS)
|
||
PARKEY (SET14A,C$MROU,^D0901,ROUTERS)
|
||
PARKEY (SET143,C$MTRA,^D1146,TRANSMITS)
|
||
PARKEY (SET139,C$MWDW,^D1123,WINDOW)
|
||
$ETAB
|
||
|
||
|
||
SET137: $NUMBER (SET199,<^D10>,<Byte Count>)
|
||
|
||
SET138: $NUMBER (SET199,<^D10>,<Retry Count>)
|
||
|
||
SET139: $NUMBER (SET199,<^D10>,<Block Count>)
|
||
|
||
|
||
SET140: $KEYDSP (SET141,<$ALTERNATE(SET142)>)
|
||
|
||
SET141: $STAB ; MAXIMUM BUFFERS Keyword table
|
||
VALKEY (SET199,C$CBFU,^D255,UNLIMITED)
|
||
$ETAB
|
||
|
||
SET142: $NUMBER (SET199,<^D10>,<Receive Buffer Count>)
|
||
|
||
SET143: $NUMBER (SET199,<^D10>,<Data Message Count>)
|
||
|
||
SET147: $KEYDSP (SET148,<$DEFAULT(TIMER)>)
|
||
|
||
SET148: $STAB
|
||
PARKEY (SET149,C$CTMR,^D0000,TIMER)
|
||
$ETAB
|
||
|
||
SET149: $NUMBER (SET199,<^D10>,<Milliseconds>)
|
||
|
||
SET14A: $NUMBER (SET199,<^D10>)
|
||
|
||
SET150: $KEYDSP (SET151)
|
||
|
||
SET151: $STAB ; ACTIVE Keyword Table
|
||
PARKEY (SET157,C$SBAS,,BASE)
|
||
PARKEY (SET158,C$SINC,,INCREMENT)
|
||
$ETAB
|
||
|
||
SET152: $KEYDSP (SET153)
|
||
|
||
SET153: $STAB ; INACTIVE, DYING Keyword Table
|
||
PARKEY (SET157,C$SBAS,,BASE)
|
||
PARKEY (SET158,C$SINC,,INCREMENT)
|
||
PARKEY (SET159,C$STHR,,THRESHOLD)
|
||
$ETAB
|
||
|
||
SET154: $KEYDSP (SET155)
|
||
|
||
SET155: $STAB ; DEAD Keyword Table
|
||
PARKEY (SET159,C$STHR,,THRESHOLD)
|
||
$ETAB
|
||
|
||
SET157: $NUMBER (SET199,<^D10>,<Base Priority>)
|
||
|
||
SET158: $NUMBER (SET199,<^D10>,<Priority Increment>)
|
||
|
||
SET159: $NUMBER (SET199,<^D10>,<Priority Threshold>)
|
||
|
||
SET160: $FIELD (SET199,<Circuit Owner Identifier>)
|
||
|
||
SET161: $KEYDSP (SET162,<$DEFAULT(STATE)>)
|
||
|
||
SET162: $STAB ; POLLING Keyword Table
|
||
PARKEY (SET163,C$SPST,^D0000,STATE)
|
||
$ETAB
|
||
|
||
SET163: $KEYDSP (SET164)
|
||
|
||
SET164: $STAB ; POLLING STATE Keyword Table
|
||
VALKEY (SET199,C$SACT,^D1,ACTIVE)
|
||
VALKEY (SET199,C$SAUT,^D0,AUTOMATIC)
|
||
VALKEY (SET199,C$SDEA,^D4,DEAD)
|
||
VALKEY (SET199,C$SDYI,^D3,DYING)
|
||
VALKEY (SET199,C$SINA,^D2,INACTIVE)
|
||
$ETAB
|
||
|
||
SET165: $KEYDSP (SET166)
|
||
|
||
SET166: $STAB ; STATE Keyword Table
|
||
VALKEY (SET199,C$SOFF,^D1,OFF)
|
||
VALKEY (SET199,C$SON,^D0,ON)
|
||
VALKEY (SET199,C$SSVC,^D2,SERVICE)
|
||
$ETAB
|
||
|
||
|
||
SET170: SUB$ADDR (SET199)
|
||
|
||
|
||
SET175: $NUMBER (SET199,<^D10>,<Physical Tributary Address>)
|
||
|
||
SET180: $KEYDSP (SET181)
|
||
|
||
SET181: $STAB ; TYPE Keyword Table
|
||
PARKEY (SED181,C$TDDC,0,DDCMP)
|
||
VALKEY (SET199,C$TX25,^D3,X25)
|
||
$ETAB
|
||
|
||
SED181: $KEYDSP(SEE182)
|
||
|
||
SEE182: $STAB
|
||
VALKEY (SET199,C$TDCT,^D1,CONTROL)
|
||
VALKEY (SET199,C$TDDM,^D4,DMC)
|
||
VALKEY (SET199,C$TDPT,^D0,POINT)
|
||
VALKEY (SET199,C$TDTR,^D2,TRIBUTARY)
|
||
$ETAB
|
||
|
||
SET185: $KEYDSP (SET186)
|
||
|
||
SET186: $STAB ; USAGE Keyword Table
|
||
VALKEY (SET199,C$UICG,^D1,INCOMING)
|
||
VALKEY (SET199,C$UOTG,^D2,OUTGOING)
|
||
VALKEY (SET199,C$UPMT,^D0,PERMANENT)
|
||
$ETAB
|
||
|
||
SET190: $KEYDSP (SET191,<$FLAGS(CM%SDH)>)
|
||
|
||
SET191: $STAB ; NODE TYPE (in house command)
|
||
PARKEY (SET192,C$PNOD,^D2600,NODE)
|
||
$ETAB
|
||
|
||
SET192: $KEYDSP (SET193,<$DEFAULT(TYPE),$FLAGS(CM%SDH)>)
|
||
|
||
SET193: $STAB
|
||
PARKEY (SET194,C$NTYP,^D0000,TYPE)
|
||
$ETAB
|
||
|
||
SET194: $KEYDSP (SET195,<$FLAGS(CM%SDH)>)
|
||
|
||
SET195: $STAB
|
||
VALKEY (SET199,C$TPII,^D2,PHASE-II)
|
||
VALKEY (SET199,C$TRTG,^D0,ROUTING)
|
||
$ETAB
|
||
|
||
SET199: $CRLF (<$ALTERNATE(SET105)>) ; CIRCUIT parameters...
|
||
|
||
SET19A: $KEYDSP (SET19B,<$DEFAULT(PRIORITY)>)
|
||
|
||
SET19B: $STAB
|
||
PARKEY (SET19C,C$RPRI,^D0000,PRIORITY)
|
||
$ETAB
|
||
|
||
SET19C: $NUMBER (SET199,<^D10>)
|
||
|
||
SUBTTL SET/DEFINE LINE Command
|
||
|
||
SET200: LINE$ID (SET202) ; LINE Line-id
|
||
|
||
SET202: $KEYDSP (SETX90,<$ALTERNATE(SET205)>)
|
||
|
||
SET205: $KEYDSP (SET207)
|
||
|
||
SET207: $STAB ; LINE Parameter Keyword Table
|
||
PARKEY (SET210,L$PCLK,^D1113,CLOCK)
|
||
PARKEY (SET212,L$PCTL,^D1110,CONTROLLER)
|
||
PARKEY (SET250,L$PCTR,^D0110,COUNTER)
|
||
PARKEY (SET235,L$PDEA,^D1151,DEAD)
|
||
PARKEY (SET235,L$PDEL,^D1152,DELAY)
|
||
PARKEY (SET215,L$PDVC,^D1100,DEVICE)
|
||
PARKEY (SET220,L$PDPX,^D1111,DUPLEX)
|
||
PARKEY (SET250,L$PHBK,^D1122,HOLDBACK)
|
||
PARKEY (SET225,L$PMAX,^D0000,MAXIMUM)
|
||
PARKEY (SET230,L$PPRO,^D1112,PROTOCOL)
|
||
PARKEY (SET232,L$PREC,^D1105,RECEIVE)
|
||
PARKEY (SET235,L$PRTR,^D1121,RETRANSMIT)
|
||
PARKEY (SET235,L$PSCH,^D1150,SCHEDULING)
|
||
PARKEY (SET240,L$PSVC,^D0100,SERVICE)
|
||
PARKEY (SET245,L$PSTT,^D0000,STATE)
|
||
PARKEY (SET235,L$PSTR,^D1154,STREAM)
|
||
$ETAB
|
||
|
||
SET210: $KEYDSP (SET211)
|
||
|
||
SET211: $STAB ; CLOCK Keyword Table
|
||
VALKEY (SET299,L$CEXT,^D0,EXTERNAL)
|
||
VALKEY (SET299,L$CINT,^D1,INTERNAL)
|
||
$ETAB
|
||
|
||
SET212: $KEYDSP (SET213)
|
||
|
||
SET213: $STAB ; CONTROLLER Keyword Table
|
||
VALKEY (SET299,L$CLBK,^D1,LOOPBACK)
|
||
VALKEY (SET299,L$CNML,^D0,NORMAL)
|
||
$ETAB
|
||
|
||
SET215: DEV$ID (SET299)
|
||
|
||
SET220: $KEYDSP (SET221)
|
||
|
||
SET221: $STAB ; DUPLEX Keyword Table
|
||
VALKEY (SET299,L$DFLL,^D0,FULL)
|
||
VALKEY (SET299,L$DHLF,^D1,HALF)
|
||
$ETAB
|
||
|
||
|
||
SET225: $KEYDSP (SET226)
|
||
|
||
SET226: $STAB ; MAXIMUM Keyword Table
|
||
PARKEY (SET227,L$MBLK,^D1130,BLOCK)
|
||
PARKEY (SET228,L$MRTR,^D1131,RETRANSMITS)
|
||
PARKEY (SET229,L$MWDW,^D1132,WINDOW)
|
||
$ETAB
|
||
|
||
SET227: $NUMBER (SET299,<^D10>,<Byte Count>)
|
||
|
||
SET228: $NUMBER (SET299,<^D10>,<Block Count>)
|
||
|
||
SET229: $NUMBER (SET299,<^D10>,<Block Count>)
|
||
|
||
|
||
SET230: $KEYDSP (SET231)
|
||
|
||
SET231: $STAB ; PROTOCOL Keyword Table
|
||
PARKEY (SED231,L$PDDC,0,DDCMP)
|
||
VALKEY (SET299,L$PLPB,^D5,LAPB)
|
||
$ETAB
|
||
|
||
SED231: $KEYDSP(SEE231)
|
||
|
||
SEE231: $STAB
|
||
VALKEY (SET299,L$PMDD,^D1,CONTROL)
|
||
VALKEY (SET299,L$PDDD,^D4,DMC)
|
||
VALKEY (SET299,L$PPDD,^D0,POINT)
|
||
VALKEY (SET299,L$PTDD,^D2,TRIBUTARY)
|
||
$ETAB
|
||
|
||
SET232: $KEYDSP (SET233,<$DEFAULT(BUFFERS)>)
|
||
|
||
SET233: $STAB
|
||
PARKEY (SET234,L$CTMR,^D0000,BUFFERS)
|
||
$ETAB
|
||
|
||
SET234: $NUMBER (SET299,<^D10>,<Buffer count>)
|
||
|
||
SET235: $KEYDSP (SET236,<$DEFAULT(TIMER)>)
|
||
|
||
SET236: $STAB
|
||
PARKEY (SET238,L$CTMR,^D0000,TIMER)
|
||
$ETAB
|
||
|
||
SET238: $NUMBER (SET299,<^D10>,<Milliseconds>)
|
||
|
||
SET240: $KEYDSP (SET241)
|
||
|
||
SET241: $STAB ; SERVICE Keyword Table
|
||
VALKEY (SET299,L$SDBD,^D1,DISABLED)
|
||
VALKEY (SET299,L$SEBD,^D0,ENABLED)
|
||
PARKEY (SET238,L$STMR,<^D1120-L$PSVC>,TIMER)
|
||
$ETAB
|
||
|
||
SET245: $KEYDSP (SET246)
|
||
|
||
SET246: $STAB ; STATE Keyword Table
|
||
VALKEY (SET299,L$SOFF,^D1,OFF)
|
||
VALKEY (SET299,L$SON,^D0,ON)
|
||
VALKEY (SET299,L$SSVC,^D2,SERVICE)
|
||
$ETAB
|
||
|
||
SET250: $KEYDSP (SET251,<$DEFAULT(TIMER)>)
|
||
|
||
SET251: $STAB
|
||
PARKEY (SET252,L$RTMR,^D0000,TIMER)
|
||
$ETAB
|
||
|
||
SET252: $NUMBER (SET299,<^D10>,<Seconds>)
|
||
|
||
SET299: $CRLF (<$ALTERNATE(SET205)>)
|
||
|
||
SUBTTL SET/DEFINE EXECUTOR Command
|
||
|
||
SET300: $KEYDSP (SETX90,<$ALTERNATE(SET305)>)
|
||
|
||
SET305: $KEYDSP (SET310,<$ALTERNATE(SET306),$DEFAULT(NODE)>)
|
||
|
||
SET310: $STAB ; EXECUTOR Keyword Table
|
||
PARKEY (SET315,N$XNOD,,NODE) ; Dummy parameter value for our use
|
||
$ETAB
|
||
|
||
SET306: $KEYDSP (SETX92,<$ALTERNATE(SET903)>)
|
||
|
||
SET315: NOD$ID (SET317) ; Node id
|
||
|
||
SET317: $KEYDSP (SET318,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET318: $STAB ; Access Control Keyword Table
|
||
PARKEY (SET319,N$XACT,^D2502,ACCOUNT)
|
||
PARKEY (SET320,N$XPWD,^D2503,PASSWORD)
|
||
PARKEY (SET321,N$XUSR,^D2504,USER)
|
||
$ETAB
|
||
|
||
SET319: $FIELD (SET317,<Account String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
SET320: $FIELD (SET317,<Access Password String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
SET321: $FIELD (SET317,<User Name>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
SUBTTL SET/DEFINE KNOWN Command
|
||
|
||
SET400: $KEYDSP (SET410)
|
||
|
||
SET410: $STAB ; KNOWN Entities Keyword Table
|
||
NCPKEY (SET102,CKT,CIRCUITS)
|
||
NCPKEY (SET202,LIN,LINES)
|
||
NCPKEY (SET502,LGG,LOGGING)
|
||
NCPKEY (SET904,NOD,NODES)
|
||
$ETAB
|
||
|
||
SUBTTL SET/DEFINE LOGGING Command
|
||
|
||
SET500: $KEYDSP (SET501)
|
||
|
||
SET501: $STAB ; LOGGING sink-type Keyword Table
|
||
VALKEY (SET502,E$SCSL,^D1,CONSOLE)
|
||
VALKEY (SET502,E$SFIL,^D2,FILE)
|
||
VALKEY (SET502,E$SMTR,^D3,MONITOR)
|
||
$ETAB
|
||
|
||
SET502: $KEYDSP (SET506)
|
||
|
||
SET504: $KEYDSP (SET506,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET506: $STAB ; LOGGING parameter Keyword Table
|
||
PARKEY (NCPCFM,P$ALL,,ALL)
|
||
PARKEY (SET508,E$PEVT,^D201,EVENT)
|
||
PARKEY (SET510,E$PKNW,^D201,KNOWN)
|
||
PARKEY (SET560,E$PNAM,^D100,NAME)
|
||
PARKEY (SET570,E$PSTT,^D000,STATE)
|
||
$ETAB
|
||
|
||
SET508: EVLIST (SET520)
|
||
|
||
SET510: $KEYDSP (SET512,<$DEFAULT(EVENTS)>)
|
||
|
||
SET512: $STAB
|
||
KNWKEY (SET520,E$KEVT,^D0,EVENTS)
|
||
$ETAB
|
||
|
||
SET520: $KEYDSP (SET522,<$ALTERNATE(SET540)>)
|
||
|
||
SET522: $STAB ; Optional source-qual keyword table
|
||
PARKEY (SET53X,E$QARE,^D5,AREA)
|
||
PARKEY (SET524,E$QCKT,^D3,CIRCUIT)
|
||
PARKEY (SET526,E$QLIN,^D1,LINE)
|
||
PARKEY (SET528,E$QMDL,^D4,MODULE)
|
||
PARKEY (SET530,E$QNOD,^D0,NODE)
|
||
$ETAB
|
||
|
||
SET524: CKT$ID (SET540) ; CIRCUIT CKT-ID
|
||
|
||
SET526: LINE$ID (SET540) ; LINE line-id
|
||
|
||
|
||
SET528: $KEYDSP (SET529)
|
||
|
||
SET529: $STAB ; MODULE module-id Keyword Table
|
||
PARKEY (SET540,E$MCFG,\$KNCFG,CONFIGURATOR)
|
||
PARKEY (SET540,E$MCSL,\$KNCSL,CONSOLE)
|
||
PARKEY (SET540,E$MLOD,\$KNLDR,LOADER)
|
||
PARKEY (SET540,E$MLOP,\$KNLPR,LOOPER)
|
||
PARKEY (SET540,E$MXAC,\$KNXAC,X25-ACCESS)
|
||
PARKEY (SET540,E$MXPR,\$KNXPR,X25-PROTOCOL)
|
||
PARKEY (SET540,E$MXSV,\$KNXSV,X25-SERVER)
|
||
$ETAB
|
||
|
||
|
||
SET530: NOD$ID (SET540) ; NODE node-id
|
||
|
||
SET53X: $NUMBER (SET540,<^D10>,<AREA Number>)
|
||
|
||
SET540: $KEYDSP (SET542,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET542: $STAB ; Optional sink-node keyword table
|
||
PARKEY (SET544,E$PSNK,^D200,SINK)
|
||
$ETAB
|
||
|
||
SET544: $KEYDSP (SET546)
|
||
|
||
SET546: $STAB ; SINK Keyword Table
|
||
VALKEY (NCPCFM,E$SXTR,^D000,EXECUTOR)
|
||
PARKEY (SET548,E$SNOD,^D000,NODE)
|
||
$ETAB
|
||
|
||
SET548: NOD$ID (NCPCFM) ; SINK NODE node-id
|
||
|
||
SET560: $OFILE (NCPCFM,<Logging File Name>,<$ALTERNATE(SET562)>)
|
||
|
||
SET562: $DEV (NCPCFM,<$HELP(Console Device),$ALTERNATE(SET564)>)
|
||
|
||
SET564: $FIELD (NCPCFM,<Monitor Process Id>)
|
||
|
||
SET570: $KEYDSP (SET571)
|
||
|
||
SET571: $STAB
|
||
VALKEY (NCPCFM,E$SHLD,^D2,HOLD)
|
||
VALKEY (NCPCFM,E$SOFF,^D1,OFF)
|
||
VALKEY (NCPCFM,E$SON,^D0,ON)
|
||
$ETAB
|
||
|
||
SUBTTL SET/DEFINE MODULE Command
|
||
|
||
|
||
SET600: $KEYDSP (SET601)
|
||
|
||
SET601: $STAB ; MODULE module-id Keyword Table
|
||
NCPKEY (SET6C0,CFG,CONFIGURATOR)
|
||
NCPKEY (SET6A0,CSL,CONSOLE)
|
||
NCPKEY (SET6B0,LDR,LOADER)
|
||
NCPKEY (SET6B0,LPR,LOOPER)
|
||
NCPKEY (SET602,XAC,X25-ACCESS)
|
||
NCPKEY (SET630,XPR,X25-PROTOCOL)
|
||
NCPKEY (SET800,XSV,X25-SERVER)
|
||
$ETAB
|
||
|
||
|
||
SUBTTL SET/DEFINE MODULE X25-ACCESS Command
|
||
|
||
|
||
SET602: $KEYDSP (SET603,<$ALTERNATE(SET614)>)
|
||
|
||
SET603: $STAB ; MODULE X25-ACCESS parameter keyword table
|
||
PARKEY (SET604,X$AACT,^D332,ACCOUNT)
|
||
PARKEY (SET606,X$ANOD,^D320,NODE)
|
||
PARKEY (SET608,X$APWD,^D331,PASSWORD)
|
||
PARKEY (SET610,X$AUSR,^D330,USER)
|
||
$ETAB
|
||
|
||
SET604: $FIELD (SET612,<Account String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
SET606: NOD$ID (SET612)
|
||
|
||
SET608: $FIELD (SET612,<Access Password>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
SET610: $FIELD (SET612,<User Name>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
SET612: $KEYDSP (SET603,<$ALTERNATE(SET616)>)
|
||
|
||
SET614: $KEYDSP (SET615)
|
||
|
||
SET615: $STAB
|
||
PARKEY (SET616,X$ALL,^D000,ALL)
|
||
$ETAB
|
||
|
||
SET616: $KEYDSP (SET617,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET617: $STAB ; X25-ACCESS Network Qualifier Keyword Table
|
||
PARKEY (SET618,X$AKNW,^D1110,KNOWN)
|
||
PARKEY (SET620,X$ANWK,^D1110,NETWORK)
|
||
$ETAB
|
||
|
||
SET618: $KEYDSP (SET619,<$DEFAULT(NETWORKS)>)
|
||
|
||
SET619: $STAB
|
||
KNWKEY (NCPCFM,X$KNWK,^D0000,NETWORKS)
|
||
$ETAB
|
||
|
||
SET620: NET$NAME (NCPCFM)
|
||
|
||
|
||
SUBTTL SET/DEFINE MODULE X25-PROTOCOL Command
|
||
|
||
|
||
SET630: $KEYDSP (SET631,<$ALTERNATE(SET650)>)
|
||
|
||
SET631: $STAB
|
||
PARKEY (SET632,X$PCLL,^D1160,CALL)
|
||
PARKEY (SET632,X$PCLR,^D1161,CLEAR)
|
||
PARKEY (SET636,X$PDFT,^D0000,DEFAULT)
|
||
PARKEY (SET642,X$PMAX,^D0000,MAXIMUM)
|
||
PARKEY (SET646,X$PNWK,^D1110,NETWORK)
|
||
PARKEY (SET632,X$PRST,^D1162,RESET)
|
||
PARKEY (SET632,X$PRTT,^D1163,RESTART)
|
||
$ETAB
|
||
|
||
SET632: $KEYDSP (SET633,<$DEFAULT(TIMER)>)
|
||
|
||
SET633: $STAB
|
||
PARKEY (SET634,X$PTMR,^D0000,TIMER)
|
||
$ETAB
|
||
|
||
SET634: $NUMBER (SET648,<^D10>,<Seconds>)
|
||
|
||
SET636: $KEYDSP (SET637)
|
||
|
||
SET637: $STAB
|
||
PARKEY (SET638,X$DBLK,^D1140,DATA)
|
||
PARKEY (SET640,X$DWDW,^D1141,WINDOW)
|
||
$ETAB
|
||
|
||
SET638: $NUMBER (SET648,<^D10>,<Byte Count>)
|
||
|
||
SET640: $NUMBER (SET648,<^D10>,<Block Count>)
|
||
|
||
SET642: $KEYDSP (SET643)
|
||
|
||
SET643: $STAB ; MAXIMUM Parameter Table
|
||
PARKEY (SET644,X$MCLR,^D1152,CLEARS)
|
||
PARKEY (SET638,X$MBLK,^D1150,DATA)
|
||
PARKEY (SET644,X$MRES,^D1153,RESETS)
|
||
PARKEY (SET644,X$MRST,^D1154,RESTARTS)
|
||
PARKEY (SET640,X$MWDW,^D1151,WINDOW)
|
||
$ETAB
|
||
|
||
SET644: $NUMBER (SET648,<^D10>,<Retry Count>)
|
||
|
||
SET646: $FIELD (SET648,<Network Name>)
|
||
|
||
SET648: $KEYDSP (SET631,<$ALTERNATE(SET649)>)
|
||
|
||
SET649: $KEYDSP (SET651,<$ALTERNATE(SET64A)>)
|
||
|
||
SET64A: $KEYDSP (SET671,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET650: $KEYDSP (SET651,<$ALTERNATE(SET670)>)
|
||
|
||
SET651: $STAB
|
||
PARKEY (SET652,X$PCHN,^D1130,CHANNELS)
|
||
PARKEY (SET654,X$PCTR,^D0100,COUNTER)
|
||
PARKEY (SET658,X$PLIN,^D1120,LINE)
|
||
PARKEY (SET660,X$PSTT,^D0000,STATE)
|
||
$ETAB
|
||
|
||
SET652: CHANNELS (SET662)
|
||
|
||
SET654: $KEYDSP (SET655,<$DEFAULT(TIMER)>)
|
||
|
||
SET655: $STAB
|
||
PARKEY (SET656,X$PTMR,^D0000,TIMER)
|
||
$ETAB
|
||
|
||
SET656: $NUMBER (SET662,<^D10>,<Seconds>)
|
||
|
||
SET658: LINE$ID (SET662)
|
||
|
||
SET660: $KEYDSP (SET661)
|
||
|
||
SET661: $STAB
|
||
VALKEY (SET662,X$SOFF,^D1,OFF)
|
||
VALKEY (SET662,X$SON,^D0,ON)
|
||
VALKEY (SET662,X$SSHT,^D2,SHUT)
|
||
$ETAB
|
||
|
||
SET662: $KEYDSP (SET651,<$ALTERNATE(SET664)>)
|
||
|
||
SET664: $KEYDSP (SET665,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET665: $STAB ; DTE qualifier table
|
||
PARKEY (SET666,X$PDTE,^D1100,DTE)
|
||
PARKEY (SET668,X$PKNW,^D1100,KNOWN)
|
||
$ETAB
|
||
|
||
SET666: DTE$ADR (NCPCFM)
|
||
|
||
SET668: $KEYDSP (SET669,<$DEFAULT(DTES)>)
|
||
|
||
SET669: $STAB
|
||
KNWKEY (NCPCFM,X$KDTE,^D0000,DTES)
|
||
$ETAB
|
||
|
||
SET670: $KEYDSP (SET671,<$ALTERNATE(SET686)>)
|
||
|
||
SET671: $STAB
|
||
PARKEY (SET672,X$PGRP,^D1101,GROUP)
|
||
$ETAB
|
||
|
||
SET672: $FIELD (SET674,<Group Name>)
|
||
|
||
SET674: $KEYDSP (SET675,<$DEFAULT(DTE)>)
|
||
|
||
SET675: $STAB ; GROUP Option Table
|
||
PARKEY (SET676,X$GDTE,^D1170,DTE)
|
||
$ETAB
|
||
|
||
SET676: DTE$ADR (SET678)
|
||
|
||
SET678: $KEYDSP (SET679,<$DEFAULT(NUMBER)>)
|
||
|
||
SET679: $STAB
|
||
PARKEY (SET680,X$GNBR,^D1171,NUMBER)
|
||
$ETAB
|
||
|
||
SET680: $NUMBER (SET682,<^D10>,<Group Number 0-9999>)
|
||
|
||
SET682: $KEYDSP (SET683,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET683: $STAB
|
||
PARKEY (SET684,X$GTYP,^D1172,TYPE)
|
||
$ETAB
|
||
|
||
SET684: $KEYDSP (SET685,<$DEFAULT(BILATERAL)>)
|
||
|
||
SET685: $STAB
|
||
VALKEY (NCPCFM,X$BLTR,^D1,BILATERAL)
|
||
$ETAB
|
||
|
||
SET686: $KEYDSP (SET687)
|
||
|
||
SET687: $STAB
|
||
PARKEY (SET688,X$ALL,^D0000,ALL)
|
||
$ETAB
|
||
|
||
SET688: $KEYDSP (SET689)
|
||
|
||
SET689: $STAB
|
||
PARKEY (SET690,X$PDTE,^D1100,DTE)
|
||
PARKEY (SET692,X$PGRP,^D1101,GROUP)
|
||
PARKEY (SET694,X$PKNW,^D1100,KNOWN)
|
||
$ETAB
|
||
|
||
SET690: DTE$ADR (NCPCFM)
|
||
|
||
SET692: $FIELD (NCPCFM,<Group Name>)
|
||
|
||
SET694: $KEYDSP (SET695)
|
||
|
||
SET695: $STAB
|
||
KNWKEY (NCPCFM,X$KDTE,^D0000,DTES)
|
||
KNWKEY (NCPCFM,X$KGRP,^D0001,GROUPS)
|
||
$ETAB
|
||
|
||
SUBTTL SET/DEFINE MODULE CONSOLE Commands
|
||
SET6A0: $KEYDSP (SET6A1,<$DEFAULT(RESERVATION)>)
|
||
|
||
SET6A1: $STAB ; SET/DEFINE MODULE CONSOLE selector table
|
||
PARKEY (SET6A2,C$SRES,^D110,RESERVATION)
|
||
$ETAB
|
||
|
||
SET6A2: $KEYDSP (SET6A3,<$DEFAULT(TIMER)>)
|
||
|
||
SET6A3: $STAB ; RESERVATION TIMER
|
||
PARKEY (SET6A4,C$STIM,^D0,TIMER)
|
||
$ETAB
|
||
|
||
SET6A4: $NUMBER (NCPCFM,^D10)
|
||
|
||
|
||
SUBTTL SET/DEFINE LOADER & LOOPER Commands
|
||
SET6B0: $KEYDSP (SET6B1,<$ALTERNATE(SET6B2),$DEFAULT(ALL)>)
|
||
|
||
SET6B1: $STAB ; ALL Keyword Dispatch Table
|
||
PARKEY (NCPCFM,P$ALL,,ALL)
|
||
$ETAB
|
||
|
||
SET6B2: $KEYDSP (SET6B3,<$DEFAULT(ASSISTANCE)>)
|
||
|
||
SET6B3: $STAB
|
||
PARKEY (SET6C7,L$DASS,^D10,ASSISTANCE)
|
||
$ETAB
|
||
|
||
SUBTTL SET/DEFINE MODULE CONFIGURATOR Commands
|
||
SET6C0: $KEYDSP (SET6C1,<$ALTERNATE(SET6C5)>)
|
||
|
||
SET6C1: $STAB
|
||
PARKEY (SET6C2,M$CCIR,^D100,CIRCUIT)
|
||
PARKEY (SET6C3,M$CKCR,^D100,KNOWN)
|
||
$ETAB
|
||
|
||
SET6C2: CKT$ID (SET6C5)
|
||
|
||
SET6C3: $KEYDSP (SET6C4,<$DEFAULT(CIRCUITS)>)
|
||
|
||
SET6C4: $STAB
|
||
KNWKEY (SET6C5,M$CKKC,^D0,CIRCUITS)
|
||
$ETAB
|
||
|
||
SET6C5: $KEYDSP (SET6C6)
|
||
|
||
SET6C6: $STAB ; SET/DEFINE MODULE CONFIGURATOR selector table
|
||
PARKEY (NCPCFM,X$ALL,^D0000,ALL)
|
||
PARKEY (SET6C7,C$FSUR,^D110,SURVEILLANCE)
|
||
$ETAB
|
||
|
||
|
||
SET6C7: $KEYDSP (SET6C8)
|
||
|
||
SET6C8: $STAB ; SURVEILLANCE/ASSISTANCE control
|
||
VALKEY (NCPCFM,M$DISB,^D1,DISABLED)
|
||
VALKEY (NCPCFM,M$ENAB,^D0,ENABLED)
|
||
$ETAB
|
||
|
||
|
||
SUBTTL SET/DEFINE MODULE X25-SERVER Command
|
||
|
||
|
||
SET800: $KEYDSP (SET801,<$ALTERNATE(SET830)>)
|
||
|
||
SET801: $STAB ; MODULE X25-SERVER destination options table
|
||
PARKEY (SET802,X$SACT,^D332,ACCOUNT)
|
||
PARKEY (SET804,X$SCLL,^D000,CALL)
|
||
PARKEY (SET810,X$SGRP,^D353,GROUP)
|
||
PARKEY (SET812,X$SNOD,^D320,NODE)
|
||
PARKEY (SET814,X$SNBR,^D354,NUMBER)
|
||
PARKEY (SET816,X$SOBJ,^D340,OBJECT)
|
||
PARKEY (SET818,X$SPWD,^D331,PASSWORD)
|
||
PARKEY (SET820,X$SPRI,^D350,PRIORITY)
|
||
PARKEY (SET822,X$SSUB,^D355,SUBADDRESSES)
|
||
PARKEY (SET824,X$SUSR,^D330,USER)
|
||
$ETAB
|
||
|
||
SET802: $FIELD (SET826,<Account String>)
|
||
|
||
SET804: $KEYDSP (SET805)
|
||
|
||
SET805: $STAB ; CALL parameter table
|
||
PARKEY (SET806,X$CMSK,^D351,MASK)
|
||
PARKEY (SET808,X$CVAL,^D352,VALUE)
|
||
$ETAB
|
||
|
||
SET806: $FIELD (SET826,<Hexadecimal Mask>,<$FLAGS(CM%BRK),$BREAK(HEXBRK)>)
|
||
|
||
SET808: $FIELD (SET826,<Hexadecimal Data>,<$FLAGS(CM%BRK),$BREAK(HEXBRK)>)
|
||
|
||
SET810: $FIELD (SET826,<Group Name>)
|
||
|
||
SET812: NOD$ID (SET826)
|
||
|
||
SET814: CALL$NUMBER (SET826)
|
||
|
||
SET816: OBJECT$ID (SET826)
|
||
|
||
SET818: $FIELD (SET826,<Access Password>)
|
||
|
||
SET820: $NUMBER (SET826,<^D10>,<Priority Number 0-255>)
|
||
|
||
SET822: SUB$ADDR (SET826)
|
||
|
||
SET824: $FIELD (SET826,<User Name>)
|
||
|
||
SET826: $KEYDSP (SET801,<$ALTERNATE(SET850)>)
|
||
|
||
SET828: $KEYDSP (SET831,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET830: $KEYDSP (SET831,<$ALTERNATE(SET844)>)
|
||
|
||
SET831: $STAB ; MODULE X25-SERVER parameter table
|
||
PARKEY (SET832,X$SCTR,^D0100,COUNTER)
|
||
PARKEY (SET836,X$SMAX,^D0000,MAXIMUM)
|
||
$ETAB
|
||
|
||
SET832: $KEYDSP (SET833,<$DEFAULT(TIMER)>)
|
||
|
||
SET833: $STAB ; COUNTER TIMER parameter
|
||
PARKEY (SET834,X$PTMR,^D0000,TIMER)
|
||
$ETAB
|
||
|
||
SET834: $NUMBER (SET840,<^D10>,<Seconds>)
|
||
|
||
SET836: $KEYDSP (SET837,<$DEFAULT(CIRCUITS)>)
|
||
|
||
SET837: $STAB ; MAXIMUM CIRCUITS parameter
|
||
PARKEY (SET838,X$SCKT,^D0310,CIRCUITS)
|
||
$ETAB
|
||
|
||
SET838: $NUMBER (SET840,<^D10>,<Count>)
|
||
|
||
SET840: $KEYDSP (SET801,<$ALTERNATE(SET828)>)
|
||
|
||
SET844: $KEYDSP (SET845)
|
||
|
||
SET845: $STAB
|
||
PARKEY (SET850,X$ALL,^D0000,ALL)
|
||
$ETAB
|
||
|
||
SET850: $KEYDSP (SET851,<$ALTERNATE(NCPCFM)>)
|
||
|
||
SET851: $STAB
|
||
PARKEY (SET852,X$SDST,^D300,DESTINATION)
|
||
PARKEY (SET854,X$SKNW,^D300,KNOWN)
|
||
$ETAB
|
||
|
||
SET852: DEST$NAME (NCPCFM)
|
||
|
||
SET854: $KEYDSP (SET855,<$DEFAULT(DESTINATIONS)>)
|
||
|
||
SET855: $STAB
|
||
KNWKEY (NCPCFM,X$KDST,^D000,DESTINATIONS)
|
||
$ETAB
|
||
|
||
|
||
SUBTTL SET/ DEFINE NODE Command
|
||
|
||
SET900: NOD$NUMBER (SET904,SET901,<ALL>) ; NODE node-address
|
||
|
||
SET901: NOD$NAME (SET902) ; NODE node-name
|
||
|
||
SET902: $KEYDSP (SETX90,<$ALTERNATE(SET903),$DEFAULT(ALL)>)
|
||
|
||
SET903: $KEYDSP (SETX91,<$ALTERNATE(SET906)>)
|
||
|
||
SET904: $KEYDSP (SETX90,<$ALTERNATE(SET905),$DEFAULT(ALL)>)
|
||
|
||
SET905: $KEYDSP (SETX92,<$ALTERNATE(SET906),$DEFAULT(NAME)>)
|
||
|
||
SET906: $KEYDSP (SET907,<$ALTERNATE(SET908)>)
|
||
|
||
SET907: $STAB ; NODE Parameter Keyword Table
|
||
PARKEY (SET9Y0,N$PARE,^D928,AREA)
|
||
PARKEY (SET9T0,N$PBRD,^D912,BROADCAST)
|
||
PARKEY (SET915,N$PBFR,^D000,BUFFER)
|
||
PARKEY (SET9W0,N$PCON,^D000,CONSOLE)
|
||
PARKEY (SET910,N$PCTR,^D160,COUNTER)
|
||
PARKEY (SET920,N$PCPU,^D113,CPU)
|
||
PARKEY (SET925,N$PDLY,^D000,DELAY)
|
||
PARKEY (SET9Z0,N$PDIA,^D123,DIAGNOSTIC)
|
||
PARKEY (SET930,N$PDMP,^D000,DUMP)
|
||
PARKEY (SET9A0,N$PHRD,^D114,HARDWARE)
|
||
PARKEY (SET950,N$PHST,^D141,HOST)
|
||
PARKEY (SET955,N$PIDN,^D100,IDENTIFICATION)
|
||
PARKEY (SET910,N$PITY,^D722,INACTIVITY)
|
||
PARKEY (SET910,N$PICG,^D510,INCOMING)
|
||
PARKEY (SET960,N$PLOD,^D120,LOAD)
|
||
PARKEY (SET965,N$PMAX,^D000,MAXIMUM)
|
||
PARKEY (SET910,N$POTG,^D511,OUTGOING)
|
||
PARKEY (SET970,N$PRTR,^D723,RETRANSMIT)
|
||
PARKEY (SET910,N$PRTG,^D910,ROUTING)
|
||
PARKEY (SET975,N$PSDY,^D000,SECONDARY)
|
||
PARKEY (SET9B0,N$PSEG,^D932,SEGMENT)
|
||
PARKEY (SET980,N$PSVC,^D000,SERVICE)
|
||
PARKEY (SET985,N$PSWR,^D000,SOFTWARE)
|
||
PARKEY (SET990,N$PSTT,^D000,STATE)
|
||
PARKEY (SET993,N$PSUB,^D911,SUBADDRESSES)
|
||
PARKEY (SET995,N$PTRT,^D000,TERTIARY)
|
||
PARKEY (SETX05,N$PTYP,^D901,TYPE)
|
||
$ETAB
|
||
|
||
SET908: $KEYDSP (SET909,<$FLAGS(CM%SDH)>)
|
||
|
||
SET909: $STAB ; FENCE (in house command)
|
||
PARKEY (SETX93,N$PFEN,^D2500,FENCE,CM%INV)
|
||
$ETAB
|
||
|
||
SET910: $KEYDSP (SET911,<$DEFAULT(TIMER)>)
|
||
|
||
SET911: $STAB
|
||
PARKEY (SET912,N$PTMR,^D000,TIMER)
|
||
$ETAB
|
||
|
||
SET912: $NUMBER (SETX99,<^D10>,<Seconds>)
|
||
|
||
SET9T0: $KEYDSP (SET9T1,<$DEFAULT(ROUTING)>)
|
||
|
||
SET9T1: $STAB
|
||
PARKEY (SET910,N$PBRT,^D000,ROUTING)
|
||
$ETAB
|
||
|
||
SET915: $KEYDSP (SET916,<$DEFAULT(SIZE)>)
|
||
|
||
SET916: $STAB
|
||
PARKEY (SET918,N$BSIZ,^D931,SIZE)
|
||
$ETAB
|
||
|
||
SET918: $NUMBER (SETX99,<^D10>,<Bytes>)
|
||
|
||
SET920: $KEYDSP (SET921)
|
||
|
||
SET921: $STAB ; CPU-type keyword table
|
||
VALKEY (SETX99,N$D10,^D2,DECSYSTEM-1020)
|
||
VALKEY (SETX99,N$P11,^D1,PDP-11)
|
||
VALKEY (SETX99,N$P08,^D0,PDP-8)
|
||
VALKEY (SETX99,N$VAX,^D3,VAX-11)
|
||
$ETAB
|
||
|
||
SET925: $KEYDSP (SET926)
|
||
|
||
SET926: $STAB
|
||
PARKEY (SET928,N$DFTR,^D720,FACTOR)
|
||
PARKEY (SET928,N$DWHT,^D721,WEIGHT)
|
||
$ETAB
|
||
|
||
SET928: $NUMBER (SETX99,<^D10>)
|
||
|
||
SET930: $KEYDSP (SET931)
|
||
|
||
SET931: $STAB
|
||
PARKEY (SET935,N$DADR,^D135,ADDRESS)
|
||
PARKEY (SET940,N$DCNT,^D136,COUNT)
|
||
PARKEY (SET945,N$DFIL,^D130,FILE)
|
||
$ETAB
|
||
|
||
SET935: $NUMBER (SETX99,<^D8>,<Octal Beginning Dump Address>)
|
||
|
||
SET940: $NUMBER (SETX99,<^D10>,<Decimal Number of Words to Dump>)
|
||
|
||
SET945: SETFIL (SETX99)
|
||
|
||
SET950: NOD$ID (SETX99)
|
||
|
||
SET955: STR$ID (SETX99,<Executor Node Identification>)
|
||
|
||
SET960: $KEYDSP (SET961,<$DEFAULT(FILE)>)
|
||
|
||
SET961: $STAB
|
||
PARKEY (SET963,N$LFIL,^D000,FILE)
|
||
$ETAB
|
||
|
||
SET963: SETFIL (SETX99)
|
||
|
||
SET965: $KEYDSP (SET966)
|
||
|
||
SET966: $STAB
|
||
PARKEY (SET967,N$MADR,^D920,ADDRESS)
|
||
PARKEY (SET968,N$MARE,^D925,AREA)
|
||
PARKEY (SET969,N$MBRO,^D926,BROADCAST)
|
||
PARKEY (SET968,N$MBFR,^D930,BUFFERS)
|
||
PARKEY (SET968,N$MCKT,^D921,CIRCUITS)
|
||
PARKEY (SET968,N$MCST,^D922,COST)
|
||
PARKEY (SET968,N$MHPS,^D923,HOPS)
|
||
PARKEY (SET968,N$MLKS,^D710,LINKS)
|
||
PARKEY (SET968,N$MVST,^D924,VISITS)
|
||
$ETAB
|
||
|
||
SET967: NOD$NUMBER (SETX99)
|
||
|
||
SET968: $NUMBER (SETX99,<^D10>)
|
||
|
||
SET969: $KEYDSP (SET96A)
|
||
|
||
SET96A: $STAB
|
||
PARKEY (SET968,N$MBNR,^D0,NONROUTERS)
|
||
PARKEY (SET968,N$MBBR,^D1,ROUTERS)
|
||
$ETAB
|
||
|
||
SET970: $KEYDSP (SET971,<$DEFAULT(FACTOR)>)
|
||
|
||
SET971: $STAB
|
||
PARKEY (SET968,N$RFTR,^D000,FACTOR)
|
||
$ETAB
|
||
|
||
SET975: $KEYDSP (SET976)
|
||
|
||
SET976: $STAB
|
||
PARKEY (SET978,N$SDPR,^D131,DUMPER)
|
||
PARKEY (SET978,N$SLDR,^D121,LOADER)
|
||
$ETAB
|
||
|
||
SET978: SETFIL (SETX99)
|
||
|
||
SET980: $KEYDSP (SET981)
|
||
|
||
SET981: $STAB
|
||
PARKEY (SET982,N$SCKT,^D110,CIRCUIT)
|
||
PARKEY (SET983,N$SDVC,^D112,DEVICE)
|
||
PARKEY (SET98A,N$SNOD,^D115,NODE)
|
||
PARKEY (SET984,N$SPWD,^D111,PASSWORD)
|
||
$ETAB
|
||
|
||
SET982: CKT$ID (SETX99)
|
||
|
||
SET983: DEV$TYPE (SETX99)
|
||
|
||
SET98A: $KEYDSP (SET98B,<$DEFAULT(VERSION)>)
|
||
|
||
SET98B: $STAB
|
||
PARKEY (SET98C,N$NVER,^D000,VERSION)
|
||
$ETAB
|
||
|
||
SET98C: $NUMBER (SETX99,<^D10>)
|
||
|
||
SET984: SVC$PASSWORD (SETX99)
|
||
|
||
SET985: $KEYDSP (SET986)
|
||
|
||
SET986: $STAB
|
||
PARKEY (SET989,N$SIDN,^D126,IDENTIFICATION)
|
||
PARKEY (SET987,N$STYP,^D125,TYPE)
|
||
$ETAB
|
||
|
||
SET987: $KEYDSP (SET988)
|
||
|
||
SET988: $STAB
|
||
VALKEY (SETX99,N$SSLD,^D0,SECONDARY-LOADER)
|
||
VALKEY (SETX99,N$SSYS,^D2,SYSTEM)
|
||
VALKEY (SETX99,N$STLD,^D1,TERTIARY-LOADER)
|
||
$ETAB
|
||
|
||
SET989: STR$ID (SETX99,<Software Identification>)
|
||
|
||
SET990: $KEYDSP (SET991)
|
||
|
||
SET991: $STAB
|
||
VALKEY (SETX99,N$SOFF,^D1,OFF)
|
||
VALKEY (SETX99,N$SON,^D0,ON)
|
||
VALKEY (SETX99,N$SRTD,^D3,RESTRICTED)
|
||
VALKEY (SETX99,N$SSHT,^D2,SHUT)
|
||
$ETAB
|
||
|
||
|
||
SET993: SUB$ADDR (SETX99)
|
||
|
||
|
||
SET995: $KEYDSP (SET996,<$DEFAULT(LOADER)>)
|
||
|
||
SET996: $STAB
|
||
PARKEY (SET978,N$TLDR,^D122,LOADER)
|
||
$ETAB
|
||
|
||
SET9W0: $KEYDSP (SET9W1)
|
||
|
||
SET9W1: $STAB
|
||
PARKEY (SET9W4,N$CLOD,^D000,LOAD)
|
||
PARKEY (SET9W2,N$CSEC,^D000,SECONDARY)
|
||
$ETAB
|
||
|
||
SET9W2: $KEYDSP (SET9W3,<$DEFAULT(LOADER)>)
|
||
|
||
SET9W3: $STAB
|
||
PARKEY (SET978,N$CSLD,^D2511,LOADER)
|
||
$ETAB
|
||
|
||
SET9W4: $KEYDSP (SET9W5,<$DEFAULT(FILE)>)
|
||
|
||
SET9W5: $STAB
|
||
PARKEY (SET978,N$CLDF,^D2512,FILE)
|
||
$ETAB
|
||
|
||
SETX05: $KEYDSP (SETX06)
|
||
|
||
SETX06: $STAB
|
||
VALKEY (SETX99,N$TNAR,^D3,AREA-ROUTER)
|
||
VALKEY (SETX99,N$TNNR,^D1,NONROUTING-III)
|
||
VALKEY (SETX99,N$TNN4,^D5,NONROUTING-IV)
|
||
; VALKEY (SETX99,N$TPII,^D2,PHASE-II)
|
||
VALKEY (SETX99,N$TRTG,^D0,ROUTING-III)
|
||
VALKEY (SETX99,N$TRT4,^D4,ROUTING-IV)
|
||
$ETAB
|
||
|
||
SETX90: $STAB ; Clear VAL$KY so not confused with parameter
|
||
PARKEY (NCPCFM,P$ALL,VAL$KY^!777777,ALL) ; value keyword
|
||
$ETAB
|
||
|
||
SETX91: $STAB ; NODE ADDRESS Keyword Table
|
||
PARKEY (SETX93,N$PADR,^D0502,ADDRESS)
|
||
PARKEY (SETX94,N$PCKT,^D0501,CIRCUIT)
|
||
$ETAB
|
||
|
||
SETX92: $STAB ; NODE NAME Keyword Table
|
||
PARKEY (SETX95,N$PNAM,^D0500,NAME)
|
||
$ETAB
|
||
|
||
SETX93: NOD$NUMBER (NCPCFM)
|
||
|
||
SETX94: CKT$ID (NCPCFM)
|
||
|
||
SETX95: NOD$NAME (NCPCFM)
|
||
|
||
SETX99: $CRLF (<$ALTERNATE(SET906)>)
|
||
|
||
|
||
;SET NODE x AREA
|
||
SET9Y0: $KEYDSP (SET9Y1,<$DEFAULT(MAXIMUM)>)
|
||
|
||
SET9Y1: $STAB
|
||
PARKEY (SET9Y2,N$PAR1,^D0,MAXIMUM)
|
||
$ETAB
|
||
|
||
SET9Y2: $KEYDSP (SET9Y3)
|
||
|
||
SET9Y3: $STAB
|
||
PARKEY (SET9Y4,N$PARC,^D0,COST)
|
||
PARKEY (SET9Y4,N$PARH,^D1,HOPS)
|
||
$ETAB
|
||
|
||
SET9Y4: $NUMBER (SETX99,<^D10>)
|
||
|
||
;SET NODE x DIAGNOSTIC
|
||
SET9Z0: $KEYDSP (SET9Z1,<$DEFAULT(FILE)>)
|
||
|
||
SET9Z1: $STAB
|
||
PARKEY (SET9Z2,N$PDI1,^D0,FILE)
|
||
$ETAB
|
||
|
||
SET9Z2: SETFIL (SETX99)
|
||
|
||
;SET NODE x HARDWARE
|
||
SET9A0: $KEYDSP (SET9A1,<$DEFAULT(ADDRESS)>)
|
||
|
||
SET9A1: $STAB
|
||
PARKEY (SET9A2,N$PHR1,^D0,ADDRESS)
|
||
$ETAB
|
||
|
||
SET9A2: NI$ADDRESS (SETX99)
|
||
|
||
;SET NODE x SEGMENT
|
||
SET9B0: $KEYDSP (SET9B1,<$DEFAULT(BUFFER)>)
|
||
|
||
SET9B1: $STAB
|
||
PARKEY (SET9B2,N$PSE1,^D0,BUFFER)
|
||
$ETAB
|
||
|
||
SET9B2: $KEYDSP (SET9B3,<$DEFAULT(SIZE)>)
|
||
|
||
SET9B3: $STAB
|
||
PARKEY (SET9B4,N$PSE2,^D0,SIZE)
|
||
$ETAB
|
||
|
||
SET9B4: $NUMBER (SETX99,<^D10>,<Bytes>)
|
||
|
||
|
||
SUBTTL TELL Command Prefix
|
||
|
||
TELFDB: NOD$ID (TEL130) ; NODE node-id
|
||
|
||
TEL130: $KEYDSP (TEL140,<$ALTERNATE(TEL170)>)
|
||
|
||
TEL140: $STAB ; TELL access control keyword table
|
||
PARKEY (TEL150,N$XACT,,ACCOUNT)
|
||
PARKEY (TEL155,N$XPWD,,PASSWORD)
|
||
PARKEY (TEL160,N$XUSR,,USER)
|
||
$ETAB
|
||
|
||
TEL150: $FIELD (TEL130,<Account String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
TEL155: $FIELD (TEL130,<Password String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
TEL160: $FIELD (TEL130,<User Name>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)
|
||
|
||
TEL170: $KEYDSP (TEL172)
|
||
|
||
TEL172: $STAB ; NCP Command Keyword Table
|
||
NCPKEY (CANFDB,CAN,CANCEL)
|
||
NCPKEY (CLRFDB,CLR,CLEAR)
|
||
NCPKEY (SETFDB,DEF,DEFINE)
|
||
NCPKEY (DMPFDB,DMP,DUMP)
|
||
NCPKEY (HLPFDB,HLP,HELP)
|
||
NCPKEY (SHWFDB,LST,LIST)
|
||
NCPKEY (LODFDB,LOD,LOAD)
|
||
NCPKEY (LOPFDB,LOP,LOOP)
|
||
NCPKEY (CLRFDB,PUR,PURGE)
|
||
NCPKEY (SETFDB,SET,SET)
|
||
NCPKEY (SHWFDB,SHW,SHOW)
|
||
NCPKEY (TRGFDB,TRG,TRIGGER)
|
||
NCPKEY (ZERFDB,ZRO,ZERO)
|
||
$ETAB
|
||
|
||
SUBTTL TRIGGER Command
|
||
|
||
TRGFDB: $KEYDSP (TRG100)
|
||
|
||
TRG100: $STAB ; TRIGGER Command Entity Keyword Table
|
||
NCPKEY (TRG200,NOD,NODE)
|
||
NCPKEY (TRG300,VIA,VIA)
|
||
$ETAB
|
||
|
||
TRG200: NOD$ID (TRG210) ; Node name or number
|
||
|
||
TRG210: $KEYDSP (TRG220,<$ALTERNATE(NCPCFM)>)
|
||
|
||
TRG220: $STAB ; TRIGGER command entity parameter table
|
||
PARKEY (TRG230,N$SPWD,,PASSWORD)
|
||
PARKEY (TRG270,N$LPHY,,PHYSICAL)
|
||
PARKEY (TRG240,N$PSVC,,SERVICE)
|
||
PARKEY (TRG260,N$SCKT,,VIA)
|
||
$ETAB
|
||
|
||
TRG230: SVC$PASSWORD (TRG210)
|
||
|
||
TRG240: $KEYDSP (TRG250,<$DEFAULT(PASSWORD)>)
|
||
|
||
TRG250: $STAB
|
||
PARKEY (TRG230,N$SPWD,,PASSWORD)
|
||
$ETAB
|
||
|
||
TRG260: CKT$ID (NCPCFM) ; TRIGGER NODE node-id VIA ckt-id
|
||
|
||
TRG270: $KEYDSP (TRG271,<$DEFAULT(ADDRESS)>)
|
||
|
||
TRG271: $STAB
|
||
PARKEY (TRG272,N$LPHA,,ADDRESS)
|
||
$ETAB
|
||
|
||
TRG272: NI$ADDRESS (TRG210)
|
||
|
||
TRG300: CKT$ID (TRG310) ; TRIGGER VIA ckt-id
|
||
|
||
TRG310: $KEYDSP (TRG320,<$ALTERNATE(NCPCFM)>)
|
||
|
||
TRG320: $STAB
|
||
PARKEY (TRG330,N$SPWD,,PASSWORD)
|
||
PARKEY (TRG360,N$LPHA,,PHYSICAL)
|
||
PARKEY (TRG340,N$PSVC,,SERVICE)
|
||
$ETAB
|
||
|
||
TRG330: SVC$PASSWORD (TRG310)
|
||
|
||
TRG340: $KEYDSP (TRG350,<$DEFAULT(PASSWORD)>)
|
||
|
||
TRG350: $STAB
|
||
PARKEY (TRG330,N$SPWD,,PASSWORD)
|
||
$ETAB
|
||
|
||
TRG360: $KEYDSP (TRG361,<$DEFAULT(ADDRESS)>)
|
||
|
||
TRG361: $STAB
|
||
PARKEY (TRG362,N$LPHA,,ADDRESS)
|
||
$ETAB
|
||
|
||
TRG362: NI$ADDRESS (TRG310)
|
||
|
||
|
||
SUBTTL ZERO Command
|
||
|
||
ZERFDB: $KEYDSP (ZER100)
|
||
|
||
ZER100: $STAB ; ZERO Command Entity Keyword Table
|
||
NCPKEY (ZER110,CKT,CIRCUIT)
|
||
NCPKEY (ZER210,XTR,EXECUTOR)
|
||
NCPKEY (ZER130,KNW,KNOWN)
|
||
NCPKEY (ZER120,LIN,LINE)
|
||
NCPKEY (ZER150,MDL,MODULE)
|
||
NCPKEY (ZER170,NOD,NODE)
|
||
$ETAB
|
||
|
||
ZER110: CKT$ID (ZER210) ; CIRCUIT ckt-id
|
||
|
||
ZER120: LINE$ID (ZER210) ; LINE line-id
|
||
|
||
ZER130: $KEYDSP (ZER140)
|
||
|
||
ZER140: $STAB ; KNOWN Entities Keyword Table
|
||
NCPKEY (ZER210,CKT,CIRCUITS)
|
||
NCPKEY (ZER210,LIN,LINES)
|
||
NCPKEY (ZER210,MDL,MODULES)
|
||
NCPKEY (ZER210,NOD,NODES)
|
||
$ETAB
|
||
|
||
|
||
ZER150: $KEYDSP (ZER151)
|
||
|
||
ZER151: $STAB ; MODULE module-name keyword table
|
||
NCPKEY (ZER152,XPR,X25-PROTOCOL)
|
||
NCPKEY (ZER160,XSV,X25-SERVER)
|
||
$ETAB
|
||
|
||
ZER152: $KEYDSP (ZER153,<$DEFAULT(COUNTERS)>)
|
||
|
||
ZER153: $STAB
|
||
PARKEY (ZER154,Z$PCTR,^D0000,COUNTERS)
|
||
$ETAB
|
||
|
||
ZER154: $KEYDSP (ZER155,<$ALTERNATE(NCPCFM)>)
|
||
|
||
ZER155: $STAB
|
||
PARKEY (ZER156,X$PDTE,^D1100,DTE)
|
||
PARKEY (ZER158,X$PKNW,^D1100,KNOWN)
|
||
$ETAB
|
||
|
||
ZER156: DTE$ADR (NCPCFM)
|
||
|
||
ZER158: $KEYDSP (ZER159,<$DEFAULT(DTES)>)
|
||
|
||
ZER159: $STAB
|
||
KNWKEY (NCPCFM,X$KDTE,^D0000,DTES)
|
||
$ETAB
|
||
|
||
ZER160: $KEY (NCPCFM,ZER161,<$DEFAULT(COUNTERS)>)
|
||
|
||
ZER161: $STAB
|
||
PARKEY (,Z$PCTR,^D0000,COUNTERS)
|
||
$ETAB
|
||
|
||
|
||
ZER170: NOD$ID (ZER210,,<COUNTERS>) ; NODE node-id
|
||
|
||
ZER210: $KEYDSP (ZER211,$DEFAULT(COUNTERS))
|
||
|
||
ZER211: $STAB ; ZERO entity parameter keyword table
|
||
NCPKEY (NCPCFM,CTR,COUNTERS)
|
||
$ETAB
|
||
|
||
SUBTTL Common NCP Command Termination
|
||
|
||
NCPCFM: $CRLF ; End Command with CR/LF
|
||
|
||
SUBTTL Symbol Table Clean Up
|
||
|
||
XPUNGE ; Keep symbol table clean of local symbols
|
||
|
||
COMMENT # May or may not be needed depending on how
|
||
BLISS libraries are set up. #
|
||
|
||
PURGE CM%DPP ; PURGE symbols from universals
|
||
PURGE CM%FNC
|
||
PURGE CM%HPP
|
||
PURGE CM%IDA
|
||
PURGE CM%ITM
|
||
PURGE CM%NSF
|
||
PURGE CM%PO
|
||
PURGE CM%SDH
|
||
PURGE CM%BRK
|
||
PURGE FTJSYS
|
||
PURGE FTUUOS
|
||
|
||
PURGE .CMCFM
|
||
PURGE .CMCMA
|
||
PURGE .CMDEV
|
||
PURGE .CMFIL
|
||
PURGE .CMFLD
|
||
PURGE .CMIFI
|
||
PURGE .CMINI
|
||
PURGE .CMKEY
|
||
PURGE .CMNOD
|
||
PURGE .CMNOI
|
||
PURGE .CMNUM
|
||
PURGE .CMNUX
|
||
PURGE .CMOFI
|
||
PURGE .CMQST
|
||
PURGE .CMTAD
|
||
PURGE .CMTOK
|
||
PURGE .CMTXT
|
||
|
||
PURGE CM%INV
|
||
PURGE CM%FW
|
||
|
||
PURGE S1 ; Purge P$HELP related variables
|
||
PURGE S2
|
||
PURGE T1
|
||
PURGE T2
|
||
|
||
END ; End of NCPTAB.MAC
|
||
|
||
; Local Modes:
|
||
; Mode:MACRO
|
||
; Auto Save Mode:2
|
||
; Comment Column:30
|
||
; Comment Rounding:+1
|
||
; End:
|