Google
 

Trailing-Edge - PDP-10 Archives - BB-X116A-BB_1984 - ncptab.mac
There are 21 other files named ncptab.mac in the archive. Click here to see a list.
;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
;
;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

;                    COPYRIGHT (c) 1980, 1981, 1982
;                    DIGITAL EQUIPMENT CORPORATION
;                        Maynard, Massachusetts
;
;     This software is furnished under a license and may  be  used
;     and copied only in accordance with the terms of such license
;     and with the inclusion of the above copyright notice.   This
;     software  or any other copies thereof may not be provided or
;     otherwise made available to any other person.  No  title  to
;     and ownership of the software is hereby transferred.
;
;     The information  in  this  software  is  subject  to  change
;     without  notice  and should not be construed as a commitment
;     by DIGITAL EQUIPMENT CORPORATION.
;
;     DIGITAL assumes no responsibility for the use or reliability
;     of  its  software  on  equipment  which  is  not supplied by
;     DIGITAL.


;++
; 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 MACSYM	      ; System Wide Macro Definitions
	SEARCH GLXMAC	      ; GALAXY Universal Definitions
TOPS20	SEARCH MONSYM	      ; Monitor Universal Symbols
	SEARCH ORNMAC	      ; OPR/ORION Universal Definitions

	S1=:1
	S2=:2
	T1=:3
	T2=:4

	SUBTTL	Macro Definitions for Commonly Used Syntax

;
; MACROS:
;

; PRTVER (MAJ,MIN,EDT) - Print out a version number in listing

DEFINE PRTVER (MAJ,MIN,EDT,DOT<.>), <
	IF1 <
	PRINTX NCPTAB - Assembled using GLXMAC version: 'MAJ'DOT'MIN('EDT)>>

; NCPVER (VERSION,MINOR,EDIT,WHO) - Make NCP Version 

DEFINE	NCPVER (VER,MIN,EDT,WHO), <
	NCPVRS==:<BYTE(3)WHO(9)VER(6)MIN(18)EDT>>

; X.25 - Delineate X.25 features

IFNDEF	FTX25, <FTX25==1>     ; Make X.25 permanent

DEFINE	X.25 <IFN FTX25, >

; CKT$ID (next-pdb) - Parse canonical Circuit Id

DEFINE	CKT$ID (NEXT,LIST), <
	IFB <LIST>, <$FIELD (NEXT,<Circuit Id>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)>
	IFNB <LIST>, <$FIELD (NEXT,<Circuit Id>,<$FLAGS(CM%BRK),$BREAK(LITBRK),LIST>)>
	>		      ; End of CKT$ID Definition

; LINE$ID (next-pdb) - Parse canonical Line Id

DEFINE	LINE$ID (NEXT,LIST), <
	IFB <LIST>, <$FIELD (NEXT,<Line Id>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)>
	IFNB <LIST>, <$FIELD (NEXT,<Line Id>,<$FLAGS(CM%BRK),$BREAK(LITBRK),LIST>)>
	>		      ; End of LINE$ID Definition

; NOD$NAME (next-pdb) - 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),LIST>)>
	>		      ; End of NOD$NAME Definition

; NOD$NUMBER (next-pdb) - Parse canonical Node Number 

DEFINE	NOD$NUMBER (NEXT,LIST), <
	IFB <LIST>, <$NUMBER (NEXT,<^D10>,<Decimal Node Address>)>
	IFNB <LIST>, <$NUMBER (NEXT,<^D10>,<Decimal Node Address>,LIST)>
	>		      ; End of NOD$NUMBER Definition

; NOD$ID (next-pdb) - Parse canonical node identifier

DEFINE	NOD$ID (NEXT,LIST,%A), <
	$NUMBER (NEXT,<^D10>,<Decimal Node Address>,<$ALTERNATE(%A)>)
%A:	NOD$NAME (NEXT,LIST)
	IF2 <PURGE %A>	      ; Remove from symbol table
	>		      ; End of NOD$ID 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>,<$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

X.25 <			      ; Start X.25 conditions

; 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

>			      ; End X.25 conditional features

; 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$TDA,^D8,DA)
	VALKEY (NEXT,N$TDL,^D4,DL)
	VALKEY (NEXT,N$TDLV,^D16,DLV)
	VALKEY (NEXT,N$TDMC,^D12,DMC)
	VALKEY (NEXT,N$TDMP,^D18,DMP)
	VALKEY (NEXT,N$TDMR,^D32,DMR)
	VALKEY (NEXT,N$TDN,^D14,DN)
	VALKEY (NEXT,N$TDP,^D0,DP)
	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)
	$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 $DN'CODE,<
		..Z==..Z+1    ; Bump keyword code counter
		$DN'CODE==:..Z>	; Assign value to global symbol
	IFN .CLIST, <PRINTX <$DN'CODE	= 'KEY>>
	IFB <FLAGS>, <DSPTAB (NXT,$DN'CODE,KEY)>
	IFNB <FLAGS>, <DSPTAB (NXT,$DN'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.

;T10BRK: BRMSK. (FLDB0.,<FLDB1.&<^-<1_^D33!1_^D23>>>,FLDB2.,FLDB3.,<:.[]>)
T10BRK:	BRMSK. (FLDB0.,FLDB1.,FLDB2.,FLDB3.,<:.[],>,-)

IF1, <	DEFINE	$IFILE (NXT,HELP,ARGLST) <
		$FIELD (<NXT>,<HELP>,<$BREAK (T10BRK),ARGLST>)>

	DEFINE	$OFILE (NXT,HELP,ARGLST) <
		$FIELD (<NXT>,<HELP>,<$BREAK (T10BRK),ARGLST>)>

	DEFINE	$FILE (NXT,HELP,ARGLST) <
		$FIELD (<NXT>,<HELP>,<$BREAK (T10BRK),ARGLST>)>

	>		      ; End of IF1
	DEFINE	NETOFI (NXT)<$OFILE(NXT)>
	DEFINE	NETIFI (NXT)<$IFILE(NXT)>
>			      ; End of TOPS10


; NETIFI (next-pdb) - Parse network input file name with optional data in
;	the format of node"user account password"::input-file-spec

TOPS20<
DEFINE	NETIFI (NEXT,%A,%B,%C,%D,%E,%F), <
	$IFILE (NEXT,<Local Input File Name>,<$ALTERNATE(%A)>)
%A:	$NODNM (%E,<Remote File Name>,<$FLAGS(CM%PO),$ALTERNATE(%B)>)
%B:	$FIELD (%C,<>,<$FLAGS(CM%SDH+CM%BRK),$BREAK(NODBRK)>)
%C:	$QUOTE (%D,<Optional "user password [account]">,<$ALTERNATE(%D)>)
%D:	$TOKEN (%E,<::>,<$DEFAULT(<::>),$HELP(<"::" To Terminate Node Name>)>)
%E:	$FILE (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:	$FILE (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
>
	SUBTTL	Local Symbols

;
; EQUATED SYMBOLS:
;

	GLXMAJ==:<GLXVRS&077700000000>_-^D24 ; Get major version number
	GLXMIN==:<GLXVRS&000077000000>_-^D18 ; Get minor version number
	GLXEDT==:<GLXVRS&000000777777> ; Get edit number

	PRTVER (\GLXMAJ,\GLXMIN,\GLXEDT) ; Print GALAXY version in listing
	NCPVER (^D3,0,^D39,0) ; Make our version number

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

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	GLXVRS	      ; Version number of GALAXY
NCPVRN:	EXP	NCPVRS	      ; Version number of NCP

	IF2	<PURGE GLXVRS>

;
; Common Break Mask Tables
;

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

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

	ND	CR.ADR,4      ; Address of current argument

HLPFDB:	$NOISE	(HLP100,<with>)

HLP100:	$CTEXT	(,<command>,<$ACTION(NCPHLP),$DEFAULT(HELP)>)

NCPHLP::MOVE	T1,CR.ADR(S2) ; Get the data
	HRROI	T1,ARG.DA(T1) ; Point to the string
	$CALL	SETOUT##      ; Setup proper $TEXT defaults
	MOVEI	S1,HELPFS     ; Point to help file
	MOVE	S2,T1	      ; Point to string
	$CALL	P$HELP##
	$CALL	SNDOUT##      ; Send the output
	$CALL	P$NPRO##      ; Mark no processing
	SETO	0,
	POPJ	17,0	      ; Return TRUE

HELPFS:	XWD	HSIZ,0	      ; File descriptor of help file for NCP

TOPS10<	SIXBIT	/HLP/	      ; Directory
	SIXBIT	/NCP/	      ; File name
	SIXBIT	/HLP/	      ; Extension
	EXP	0>	      ; PPN

TOPS20<	ASCIZ	/HLP:NCP.MEM/>

	HSIZ==.-HELPFS

	SUBTTL	ABORT/CANCEL Command

CANFDB:	$KEYDSP	(CAN100,<$DEFAULT(QUEUE)>)

CAN100:	$STAB		      ; ABORT/CANCEL Command Entity Keyword Table
	NCPKEY	(CAN200,QUE,QUEUE)
	$ETAB

CAN200:	$KEYDSP	(CAN300,<$DEFAULT(REQUEST)>)

CAN300:	$STAB		      ; QUEUE Entity Parameter Keyword Table
	NCPKEY	(CAN400,REQ,REQUEST)
	$ETAB

CAN400:	$NUMBER	(NCPCFM,^D10,<Request Id Number>) ; NCP Request Number

	SUBTTL	CLEAR and PURGE Commands

CLRFDB:	$KEYDSP	(CLR100)

CLR100:	$STAB		      ; CLEAR Command Entity Keyword Table
	NCPKEY	(CLR300,CKT,CIRCUIT)
	NCPKEY	(CLR500,XTR,EXECUTOR)
	NCPKEY	(CLR600,KNW,KNOWN)
	NCPKEY	(CLR400,LIN,LINE)
	NCPKEY	(CLR700,LGG,LOGGING)
X.25 <	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)
X.25 <	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)
X.25 <	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)
X.25 <	PARKEY	(CLR425,L$PHBK,^D1122,HOLDBACK)>
X.25 <	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

X.25 <			      ; Start X.25 conditions

CLR435:	$KEYDSP	(CLR436,<$DEFAULT(RETRANSMITS)>)

CLR436:	$STAB
	VALKEY	(CLR499,L$MRTR,^D1131,RETRANSMITS)
	$ETAB
>			      ; End X.25 conditions

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)
X.25 <	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

X.25 <			      ; Start X.25 conditions

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

>			      ; End X.25 conditions

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

X.25 <			      ; Start X.25 conditions

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

>			      ; End X.25 conditions

	SUBTTL	CLEAR/PURGE MODULE X25-ACCESS Commands

X.25 <			      ; Start X.25 conditions

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)

>			      ; End X.25 conditions

	SUBTTL	CLEAR/PURGE MODULE X25-PROTOCOL Commands

X.25 <			      ; Start X.25 conditions

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)

>			      ; End X.25 conditions

	SUBTTL	CLEAR/PURGE MODULE X25-SERVER Commands

X.25 <			      ; Start X.25 conditions

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

>			      ; End X.25 conditional features

	SUBTTL	CLEAR/PURGE NODE Command

CLR900:	NOD$NUMBER (CLR906,<$ALTERNATE(CLR901)>) ; 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)>)

CLR910:	$KEYDSP	(CLR915,<$ALTERNATE(CLR916)>)

CLR915:	$STAB		      ; NODE Parameter Keyword Table
	PARKEY	(CLR920,N$PCTR,^D160,COUNTER)
	VALKEY	(CLR999,N$PCPU,^D113,CPU)
	PARKEY	(CLR925,N$PDMP,^D000,DUMP)
	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)
	$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	(CLR999,N$SPWD,^D111,PASSWORD)
	$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)>)

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

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	(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	(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	(LOD242,N$SPWD,,PASSWORD)
	$ETAB

LOD241:	DEV$TYPE (LOD210)     ; SERVICE DEVICE dev-id

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

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	(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	(LOP200,CKT,CIRCUIT)
	NCPKEY	(LOP250,XTR,EXECUTOR)
	NCPKEY	(LOP300,LIN,LINE)
	NCPKEY	(LOP400,NOD,NODE)
	$ETAB

LOP200:	CKT$ID	(LOP410)

LOP250:	$KEYDSP	(LOP485,<$ALTERNATE(LOP410)>)

LOP300:	LINE$ID	(LOP410)

LOP400:	NOD$ID	(LOP480)

LOP410:	$KEYDSP	(LOP420,<$ALTERNATE(NCPCFM)>)

LOP420:	$STAB
	PARKEY	(LOP430,N$LDRC,^D150,COUNT)
	PARKEY	(LOP440,N$LLTH,^D151,LENGTH)
	PARKEY	(LOP460,N$LWTH,^D152,WITH)
	$ETAB

LOP430:	$NUMBER	(LOP410,<^D10>) ; COUNT count

LOP440:	$NUMBER	(LOP410,<^D10>) ; LENGTH length

LOP460:	$KEYDSP	(LOP470)

LOP470:	$STAB		      ; WITH Option Keyword Table
	VALKEY	(LOP410,N$WMXD,^D2,MIXED)
	VALKEY	(LOP410,N$WONE,^D1,ONES)	
	VALKEY	(LOP410,N$WZRO,^D0,ZEROES)
	$ETAB

LOP480:	$KEYDSP	(LOP485,<$ALTERNATE(LOP410)>)

LOP485:	$STAB		      ; ACCESS control Keyword Table
	PARKEY	(LOP490,N$XACT,,ACCOUNT)
	PARKEY	(LOP495,N$XPWD,,PASSWORD)
	PARKEY	(LOP500,N$XUSR,,USER)
	$ETAB

LOP490:	$FIELD	(LOP480,<Account String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)

LOP495:	$FIELD	(LOP480,<Access Password String>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)

LOP500:	$FIELD	(LOP480,<User Name>,<$FLAGS(CM%BRK),$BREAK(LITBRK)>)

	SUBTTL	SHOW and LIST Commands

SHWFDB:	$KEYDSP	(SHW100)

SHW100:	$STAB
	NCPKEY	(SHW110,ATV,ACTIVE)
	NCPKEY	(SHW130,CKT,CIRCUIT)
	NCPKEY	(SHW192,XTR,EXECUTOR)
	NCPKEY	(SHW110,KNW,KNOWN)
	NCPKEY	(SHW140,LIN,LINE)
	NCPKEY	(SHW170,LGG,LOGGING)
	NCPKEY	(SHW190,LOP,LOOP)
X.25 <	NCPKEY	(SHW200,MDL,MODULE)>
	NCPKEY	(SHW400,NOD,NODE)
	NCPKEY	(NCPCFM,QUE,QUEUE)
	$ETAB

SHW110:	$KEYDSP	(SHW111)

SHW111:	$STAB		      ; ACTIVE Entities Keyword Table
	NCPKEY	(SHW192,CKT,CIRCUITS)
	NCPKEY	(SHW192,LIN,LINES)
	NCPKEY	(SHW500,LGG,LOGGING)
X.25 <	NCPKEY	(SHW192,MDL,MODULES)>
	NCPKEY	(SHW192,NOD,NODES)
	$ETAB

SHW130:	CKT$ID	(SHW192)      ; 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

X.25 <			      ; Start X.25 conditions

SHW200:	$KEYDSP	(SHW201)

SHW201:	$STAB		      ; MODULE module-id keyword table
	NCPKEY	(SHW210,XAC,X25-ACCESS)
	NCPKEY	(SHW220,XPR,X25-PROTOCOL)
	NCPKEY	(SHW260,XSV,X25-SERVER)
	$ETAB

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

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

SHW260:	$KEYDSP	(SHW261,<$DEFAULT(SUMMARY)>)

SHW261:	$STAB		      ; SHOW MODULE X25-SERVER selector table
	NCPKEY	(SHW262,CHR,CHARACTERISTICS)
	NCPKEY	(SHW262,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

>			      ; End X.25 conditions

SHW400:	NOD$ID	(SHW192)      ; NODE node-id

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)
X.25 <	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)
X.25 <	PARKEY	(SET110,C$PBKG,^D0910,BLOCKING)>
X.25 <	PARKEY	(SET115,C$PCHN,^D1121,CHANNEL)>
	PARKEY	(SET125,C$PCST,^D0900,COST)
	PARKEY	(SET130,C$PCTR,^D0110,COUNTER)
	PARKEY	(SET154,C$PDEA,^D1156,DEAD)
X.25 <	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)
X.25 <	PARKEY	(SET135,C$PMAX,^D0000,MAXIMUM)>
X.25 <	PARKEY	(SET134,C$PNBR,^D0930,NUMBER)>
	PARKEY	(SET160,C$POWR,^D1100,OWNER)
	PARKEY	(SET161,C$PPST,^D1010,POLLING)
X.25 <	PARKEY	(SET130,C$PRCL,^D0921,RECALL)>
	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)
X.25 <	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

X.25 <			      ; Start X.25 conditions

SET115:	$NUMBER	(SET199,<^D10>,<X25 Logical Channel Number>)

>			      ; End X.25 conditions

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

X.25 <			      ; Start X.25 conditions

SET133:	DTE$ADR	(SET199)     ; DTE dte-address

SET134:	CALL$NUMBER (SET199)

>			      ; End X.25 conditions

SET135:	$KEYDSP	(SET136)

SET136:	$STAB		      ; MAXIMUM Keyword Table
	PARKEY	(SET140,C$MBUF,^D1145,BUFFERS)
X.25 <	PARKEY	(SET137,C$MBLK,^D1122,DATA)>
X.25 <	PARKEY	(SET138,C$MRCL,^D0920,RECALLS)>
	PARKEY	(SET143,C$MTRA,^D1146,TRANSMITS)
X.25 <	PARKEY	(SET139,C$MWDW,^D1123,WINDOW)>
	$ETAB

X.25 <			      ; Start X.25 conditions

SET137:	$NUMBER	(SET199,<^D10>,<Byte Count>)

SET138:	$NUMBER	(SET199,<^D10>,<Retry Count>)

SET139:	$NUMBER	(SET199,<^D10>,<Block Count>)

>			      ; End X.25 conditions

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

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

X.25 <			      ; Start X.25 conditions

SET170:	SUB$ADDR (SET199)

>			      ; End X.25 conditions

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)
X.25 <	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...

	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)
X.25 <	PARKEY	(SET250,L$PHBK,^D1122,HOLDBACK)>
X.25 <	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

X.25 <			      ; Start X.25 conditions

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

>			      ; End X.25 conditions

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)
X.25 <	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(SET905),$DEFAULT(NODE)>)

SET310:	$STAB		      ; EXECUTOR Keyword Table
	PARKEY	(SET315,N$XNOD,,NODE) ; Dummy parameter value for our use
	$ETAB

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	(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	(SET524,E$QCKT,^D3,CIRCUIT)
	PARKEY	(SET526,E$QLIN,^D1,LINE)
X.25 <	PARKEY	(SET528,E$QMDL,^D4,MODULE)>
	PARKEY	(SET530,E$QNOD,^D0,NODE)
	$ETAB

SET524:	CKT$ID	(SET504)      ; CIRCUIT CKT-ID

SET526:	LINE$ID	(SET504)      ; LINE line-id

X.25 <			      ; Start X.25 conditions

SET528:	$KEYDSP	(SET529)

SET529:	$STAB		      ; MODULE module-id Keyword Table
	PARKEY	(SET504,E$MXAC,\$DNXAC,X25-ACCESS)
	PARKEY	(SET504,E$MXPR,\$DNXPR,X25-PROTOCOL)
	PARKEY	(SET504,E$MXSV,\$DNXSV,X25-SERVER)
	$ETAB

>			      ; End X.25 conditions

SET530:	NOD$ID	(SET504)      ; NODE node-id

SET540:	$KEYDSP	(SET542,<$ALTERNATE(SET504)>)

SET542:	$STAB		      ; Optional sink-node keyword table
	PARKEY	(SET544,E$PSNK,^D200,SINK)
	$ETAB

SET544:	$KEYDSP	(SET546)

SET546:	$STAB		      ; SINK Keyword Table
	VALKEY	(SET504,E$SXTR,^D000,EXECUTOR)
	PARKEY	(SET548,E$SNOD,^D000,NODE)
	$ETAB

SET548:	NOD$ID	(SET504)      ; SINK NODE node-id

SET560:	$OFILE	(SET504,<Logging File Name>,<$ALTERNATE(SET562)>)

SET562:	$DEV	(SET504,<$HELP(Console Device),$ALTERNATE(SET564)>)

SET564:	$FIELD	(SET504,<Monitor Process Id>)

SET570:	$KEYDSP	(SET571)

SET571:	$STAB
	VALKEY	(SET504,E$SHLD,^D2,HOLD)
	VALKEY	(SET504,E$SOFF,^D1,OFF)
	VALKEY	(SET504,E$SON,^D0,ON)
	$ETAB

	SUBTTL	SET/DEFINE MODULE Command

X.25 <			      ; Start X.25 conditions

SET600: $KEYDSP	(SET601)

SET601: $STAB		      ; MODULE module-id Keyword Table
	NCPKEY	(SET602,XAC,X25-ACCESS)
	NCPKEY	(SET630,XPR,X25-PROTOCOL)
	NCPKEY	(SET800,XSV,X25-SERVER)
	$ETAB

>			      ; End X.25 conditions

	SUBTTL	SET/DEFINE MODULE X25-ACCESS Command

X.25 <			      ; Start X.25 conditions

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)

>			      ; End X.25 conditions

	SUBTTL	SET/DEFINE MODULE X25-PROTOCOL Command

X.25 <			      ; Start X.25 conditions

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

>			      ; End X.25 conditions

	SUBTTL	SET/DEFINE MODULE X25-SERVER Command

X.25 <			      ; Start X.25 conditions

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

>			      ; End X.25 conditional features

	SUBTTL	SET/DEFINE NODE Command

SET900:	NOD$NUMBER (SET904,<$ALTERNATE(SET901)>) ; 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	(SET915,N$PBFR,^D000,BUFFER)
	PARKEY	(SET910,N$PCTR,^D160,COUNTER)
	PARKEY	(SET920,N$PCPU,^D113,CPU)
	PARKEY	(SET925,N$PDLY,^D000,DELAY)
	PARKEY	(SET930,N$PDMP,^D000,DUMP)
	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	(SET980,N$PSVC,^D000,SERVICE)
	PARKEY	(SET985,N$PSWR,^D000,SOFTWARE)
	PARKEY	(SET990,N$PSTT,^D000,STATE)
X.25 <	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)
	$ETAB

SET910:	$KEYDSP	(SET911,<$DEFAULT(TIMER)>)

SET911:	$STAB
	PARKEY	(SET912,N$PTMR,^D000,TIMER)
	$ETAB

SET912:	$NUMBER	(SETX99,<^D10>,<Seconds>)

SET915:	$KEYDSP	(SET916,<$DEFAULT(SIZE)>)

SET916:	$STAB
	PARKEY	(SET918,N$BSIZ,^D931,SIZE)
	$ETAB

SET918:	$NUMBER	(SETX99,<^D10>,<Memory Units>)

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:	NETOFI	(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:	NETIFI	(SETX99)

SET965:	$KEYDSP	(SET966)

SET966:	$STAB
	PARKEY	(SET967,N$MADR,^D920,ADDRESS)
	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>)

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:	NETIFI	(SETX99)

SET980:	$KEYDSP	(SET981)

SET981:	$STAB
	PARKEY	(SET982,N$SCKT,^D110,CIRCUIT)
	PARKEY	(SET983,N$SDVC,^D112,DEVICE)
	PARKEY	(SET984,N$SPWD,^D111,PASSWORD)
	$ETAB

SET982:	CKT$ID	(SETX99)

SET983:	DEV$TYPE (SETX99)

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

X.25 <			      ; Start X.25 conditions

SET993:	SUB$ADDR (SETX99)

>			      ; End X.25 conditions

SET995:	$KEYDSP	(SET996,<$DEFAULT(LOADER)>)

SET996:	$STAB
	PARKEY	(SET978,N$TLDR,^D122,LOADER)
	$ETAB

SETX05:	$KEYDSP	(SETX06)

SETX06:	$STAB
	VALKEY	(SETX99,N$TNNR,^D1,NONROUTING)
	VALKEY	(SETX99,N$TPII,^D2,PHASE-II)
	VALKEY	(SETX99,N$TRTG,^D0,ROUTING)
	$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)>)

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

TRG300:	CKT$ID	(TRG310)      ; TRIGGER VIA ckt-id

TRG310:	$KEYDSP	(TRG320,<$ALTERNATE(NCPCFM)>)

TRG320:	$STAB
	PARKEY	(TRG330,N$SPWD,,PASSWORD)
	PARKEY	(TRG340,N$PSVC,,SERVICE)
	$ETAB

TRG330:	SVC$PASSWORD (TRG310)

TRG340:	$KEYDSP	(TRG350,<$DEFAULT(PASSWORD)>)

TRG350:	$STAB
	PARKEY	(TRG330,N$SPWD,,PASSWORD)
	$ETAB

	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)
X.25 <	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)
X.25 <	NCPKEY	(ZER210,MDL,MODULES)>
	NCPKEY	(ZER210,NOD,NODES)
	$ETAB

X.25 <			      ; Start X.25 conditions

ZER150:	$KEYDSP	(ZER151)

ZER151:	$STAB		      ; MODULE module-name keyword table
	NCPKEY	(ZER152,XPR,X25-PROTOCOL)
	NCPKEY	(ZER152,XPR,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

>			      ; End X.25 conditions

ZER170:	NOD$ID	(ZER210)      ; 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	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: