Google
 

Trailing-Edge - PDP-10 Archives - CFS_TSU04_19910205_1of1 - update/decsrc/ncptab.mac
There are 21 other files named ncptab.mac in the archive. Click here to see a list.
; UPD ID= 344, SNARK:<6.1.NML>NCPTAB.MAC.28,  11-Oct-85 10:51:57 by MCCOLLUM
; Change VALKEY to PARKEY in CLEAR EXEC SERVICE NODE VERSION
;
; 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) 1976,1977,1978,1979,1980,1981,1982
;          BY DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.

;++
; 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
	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)
	VERSIN (NCP)

;Invoke the macros.
	NCPVRX (\NCPVER,\NCPMIN,\NCPEDT,\NCPWHO) ; Make & print version number
;$$	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

TOPS10	<
; 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
	>		      ; End of TOPS10 Conditional

TOPS20	<
; 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)>)>
IFNB <LIST>,<$NODNM (NEXT,<Node Name>,<$FLAGS(CM%NSF+CM%PO),$ALTERNATE(LIST)>)>
	>		      ; End of NOD$NAME Definition
	>		      ; End of TOPS20 Conditional

; 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>)>

	>		      ; 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

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

; 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'
					>

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:	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:	SKIPGE	CR.RES(S2)	; Name start with alphabetic 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	/MEM/	      ; 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
	PARKEY	(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
	VALKEY	(SET199,C$TDCT,^D1,DDCMP-CONTROL)
	VALKEY	(SET199,C$TDDM,^D4,DDCMP-DMC)
	VALKEY	(SET199,C$TDPT,^D0,DDCMP-POINT)
	VALKEY	(SET199,C$TDTR,^D2,DDCMP-TRIBUTARY)
      	VALKEY	(SET199,C$TX25,^D3,X25)
	$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
	VALKEY	(SET299,L$PMDD,^D1,DDCMP-CONTROL)
	VALKEY	(SET299,L$PDDD,^D4,DDCMP-DMC)
	VALKEY	(SET299,L$PPDD,^D0,DDCMP-POINT)
	VALKEY	(SET299,L$PTDD,^D2,DDCMP-TRIBUTARY)
      	VALKEY	(SET299,L$PLPB,^D5,LAPB)
	$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: