PDP-10 Archive: 10,7/netgen/ngnprs.mac from BB-X116C-BB

Trailing-Edge - PDP-10 Archives - BB-X116C-BB - 10,7/netgen/ngnprs.mac

There are 7 other files named ngnprs.mac in the archive. Click here to see a list.

;	TITLE	NGNPRS - NETGEN Parsing Tables and Support Routines
;		======

	SEARCH	NGNMAC

	INIGEN (NGNPRS)			; Initialize GLXLIB assembly options
;
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
;  OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
;COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1980,1981,1982,1985,1986.
;ALL RIGHTS RESERVED.
;
;
;MODULE NGNPRS
;
;	SUMMARY OF EDIT HISTORY - FOR FULL DETAILS SEE MODULE NETGEN.MAC
;
;	EDIT #		DATE
;	46.		24Oct82
;
; Version 4.1
;
;	3		06Dec82
;	4		08dec82
;      13               23Feb83
;      15               23Feb83
;      29.		13Jul84
;      30.		26Jul84
;      32.		17Oct84
;      34.		26Nov84
;      35.		06Jan85
;      38.		15Jul85
;

;
;   DEFINE Parse Blocks
;
	EXT	<ENTBLK,PRMBLK,QUABLK,KEYFLG>

DEFSKP==:777777
;
; EVLIST (next-pdb) - Parse event list
;
DEFINE	EVLIST (NEXT,%A,%B,%C,%D,%E,%F,%G), <
	$DIGIT (%A,<^D10>,<Event Class>,<$PREFILL(EVLST1),$ACTION(CHKNUM)>)
%A:	$TOKEN (%B,<.>,<$DEFAULT(<.>)>)
%B:	$DIGIT (%C,<^D10>,<Event Type>,<$PREFILL(EVLST1),$ALTERNATE(%G),$ACTION(CHKNUM)>)
%C:	$TOKEN (%D,<->,<$HELP(<"-" To Specify Type Range>),$ALTERNATE(%E)>)
%D:	$DIGIT (%E,<^D10>,<Ending Type Range>,<$PREFILL(EVLST2),$ACTION(CHKNUM)>)
%E:	$COMMA (%F,<$HELP(<"," To Specify Additional Type>),$ALTERNATE(NEXT)>)
%F:	$DIGIT (%C,<^D10>,<Event Type>,<$PREFILL(EVLST2),$ACTION(CHKNUM)>)
%G:	$TOKEN (NEXT,<*>,<$HELP(<"*" To Specify All Types Of This Class>)>)
	IF2 <PURGE %A,%B,%C,%D,%E,%F,%G>
	>		      ; End of EVLIST Definition

EVLST1:	MOVEI	^D511
	SKIPA
EVLST2:	MOVEI	^D31
	MOVEM	NUMMAX
	MOVEI	^D0
	MOVEM	NUMMIN
	$RETT
;
; 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
;
; 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.,!#$%&'()*+-./:;<=>?@[\]^_`{|}~)

;
; DEFINE	*	*	*	*	*	*	*
;
DEFPDB::$KEYDSP	(DEFTAB,$ACTION(ENT$BK))
DEFTAB:	$STAB
	DSPTAB	(DL0PDB,ENTCIR##,<Circuit>,KEYFLG)
	DSPTAB	(DF1PDB,ENTEXE##,<Executor>,KEYFLG)
	DSPTAB	(DFHPDB,KNOENT##,<Known>,KEYFLG)
	DSPTAB	(DL1PDB,ENTLIN##,<Line>,KEYFLG)
	DSPTAB	(DG3PDB,ENTLOG##,<Logging>,KEYFLG)
	DSPTAB	(DF5PDB,ENTMOD##,<Module>,KEYFLG)
	DSPTAB	(DG1PDB,ENTNOD##,<Node>,KEYFLG)
	DSPTAB	(DFVPDB,ENTPRO##,<Process>,KEYFLG)
	$ETAB

DL0PDB:	$FIELD	(DC1PDB,<<Circuit Id>>,<$ACTION(CHKFLD)>)

DL1PDB:	$FIELD	(DL2PDB,<<Line Id>>,<$ACTION(CHKFLD)>)

DG1PDB:	$NUMBER	(DG2PDB,^D10,<<Node Number, XXXXX to YYYYY>>,<$PREFILL(NODLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)

DFHPDB:	$KEYDSP	(DFHTAB,$ACTION(ENT$BK))
DFHTAB:	$STAB
	DSPTAB	(DFIPDB,ENTCIR##,<Circuits>,KEYFLG)
	DSPTAB	(DXIPDB,ENTLIN##,<Lines>,KEYFLG)
;	DSPTAB	(,ENTLOG##,<Logging>,KEYFLG)
;	DSPTAB	(,ENTMOD##,<Modules>,KEYFLG)
;	DSPTAB	(,ENTNOD##,<Nodes>,KEYFLG)
	$ETAB

DG3PDB:	$KEYDSP	(DG3TAB,$ACTION(ENT$BK))
DG3TAB:	$STAB
;	DSPTAB	(,LOGCON##,<Console>,KEYFLG)
	DSPTAB	(DG4PDB,LOGFIL##,<File>,KEYFLG)
;	DSPTAB	(,LOGMON##,<Monitor>,KEYFLG)
	$ETAB

DF5PDB:	$KEYDSP	(DF5TAB,$ACTION(ENT$BK))
DF5TAB:	$STAB
	DSPTAB	(DFJPDB,MODMCB##,<MCB-Executive>,KEYFLG)
	DSPTAB	(DFYPDB,MODRSX##,<RSX-Executive>,KEYFLG)
	DSPTAB	(DXMPDB,MODXPR##,<X25-Protocol>,KEYFLG)
	DSPTAB	(DXSPDB,MODXSR##,<X25-Server>,KEYFLG)
	$ETAB

DG2PDB:	$KEYDSP	(DG2TAB,$ACTION(PRM$BK))
DG2TAB:	$STAB
	DSPTAB	(DFCPDB,DNS14##,<Fence>,KEYFLG)
	$ETAB

DF1PDB:	$KEYDSP	(DF1TAB,$ACTION(PRM$BK))
DF1TAB:	$STAB
	DSPTAB	(DFCPDB,DN502##,<Address>,KEYFLG)
	DSPTAB	(DF9PDB,0,<Buffer>,KEYFLG)
	DSPTAB	(DFOPDB,DNS11##,<Circuit>,KEYFLG)
	DSPTAB	(DFAPDB,DN721##,<Delay>,KEYFLG)
	DSPTAB	(DFCPDB,DNS14##,<Fence>,KEYFLG)
	DSPTAB	(DFDPDB,DN100##,<Identification>,KEYFLG)
	DSPTAB	(DF2PDB,DN722##,<Inactivity>,KEYFLG)
	DSPTAB	(DF2PDB,DN510##,<Incoming>,KEYFLG)
	DSPTAB	(DF8PDB,0,<Management>,KEYFLG)
	DSPTAB	(DF3PDB,0,<Maximum>,KEYFLG)
	DSPTAB	(DFEPDB,DN500##,<Name>,KEYFLG)
	DSPTAB	(DFLPDB,0,<NSP>,KEYFLG)
	DSPTAB	(DFPPDB,DNS7##,<Open>,KEYFLG)
	DSPTAB	(DF2PDB,DN511##,<Outgoing>,KEYFLG)
	DSPTAB	(DFBPDB,DNS5##,<Receive>,KEYFLG)
	DSPTAB	(DF6PDB,DN723##,<Retransmit>,KEYFLG)
	DSPTAB	(DF2PDB,DN910##,<Routing>,KEYFLG)
	DSPTAB	(DFSPDB,DNS8##,<Segment>,KEYFLG)
	DSPTAB	(DFBPDB,DNS1##,<Transmit>,KEYFLG)
	$ETAB
DF2PDB:	$KEYDSP	(DF2TAB,<$ACTION(PRM$BK),$DEFAULT(Timer)>)
DF2TAB:	$STAB
	DSPTAB	(DFGPDB,DEFSKP,<Timer>,KEYFLG)
	$ETAB
DFSPDB:	$KEYDSP	(DFSTAB,<$ACTION(PRM$BK),$DEFAULT(Size)>)
DFSTAB:	$STAB
	DSPTAB	(NUMPDB,DEFSKP,<Size>,KEYFLG)
	$ETAB
DF3PDB:	$KEYDSP	(DF3TAB,$ACTION(PRM$BK))
DF3TAB:	$STAB
	DSPTAB	(DGCPDB,DN920##,<Address>,KEYFLG)
	DSPTAB	(NUMPDB,DN922##,<Cost>,KEYFLG)
	DSPTAB	(NUMPDB,DN923##,<Hops>,KEYFLG)
	DSPTAB	(NUMPDB,DN710##,<Links>,KEYFLG)
	DSPTAB	(DF4PDB,0,<Phase-II>,KEYFLG)
	DSPTAB	(DFPPDB,DNS9##,<Reserved>,KEYFLG)
	DSPTAB	(NUMPDB,DN924##,<Visits>,KEYFLG)
	$ETAB
DF4PDB:	$KEYDSP	(DF4TAB,<$ACTION(PRM$BK),$DEFAULT(Links)>)
DF4TAB:	$STAB
	DSPTAB	(NUMPDB,DNS0##,<Links>,KEYFLG)
	$ETAB
DFPPDB:	$KEYDSP	(DFPTAB,<$ACTION(PRM$BK),$DEFAULT(Ports)>)
DFPTAB:	$STAB
	DSPTAB	(NUMPDB,DEFSKP,<Ports>,KEYFLG)
	$ETAB
DF6PDB:	$KEYDSP	(DF6TAB,<$ACTION(PRM$BK),$DEFAULT(Factor)>)
DF6TAB:	$STAB
	DSPTAB	(NUMPDB,DEFSKP,<Factor>,KEYFLG)
	$ETAB
DF8PDB:	$KEYDSP	(DF8TAB,$ACTION(PRM$BK))
DF8TAB:	$STAB
	DSPTAB	(DFQPDB,DNS3##,<Account>,KEYFLG)
	DSPTAB	(DFNPDB,DNS4##,<Password>,KEYFLG)
	DSPTAB	(DFQPDB,DNS2##,<User>,KEYFLG)
	$ETAB
DF9PDB:	$KEYDSP	(DF9TAB,<$ACTION(PRM$BK),$DEFAULT(Size)>)
DF9TAB:	$STAB
	DSPTAB	(NUMPDB,DN931##,<Size>,KEYFLG)
	$ETAB
DFAPDB:	$KEYDSP	(DFATAB,$ACTION(PRM$BK))
DFATAB:	$STAB
	DSPTAB	(NUMPDB,DEFSKP,<Weight>,KEYFLG)
	$ETAB
DFBPDB:	$KEYDSP	(DFBTAB,<$ACTION(PRM$BK),$DEFAULT(Password)>)
DFBTAB:	$STAB
	DSPTAB	(DFNPDB,DEFSKP,<Password>,KEYFLG)
	$ETAB
DFIPDB:	$KEYDSP	(DFITAB,$ACTION(PRM$BK))
DFITAB:	$STAB
	DSPTAB	(DF2PDB,DKC906##,<Hello>,KEYFLG)
	DSPTAB	(DF2PDB,DKC907##,<Listen>,KEYFLG)
	$ETAB
DXIPDB:	$KEYDSP	(DXITAB,$ACTION(PRM$BK))
DXITAB:	$STAB
	DSPTAB	(DX7PDB,0,<Maximum>,KEYFLG)
	DSPTAB	(DTTPDB,XKL121##,<Retransmission>,KEYFLG)
	$ETAB
DFJPDB:	$KEYDSP	(DFJTAB,$ACTION(PRM$BK))
DFJTAB:	$STAB
	DSPTAB	(DFKPDB,DMS1##,<CCB>,KEYFLG)
	DSPTAB	(DFTPDB,DMS0##,<Process>,KEYFLG)
	DSPTAB	(DFKPDB,DMS2##,<RDB>,KEYFLG)
	$ETAB
DFKPDB:	$KEYDSP	(DFKTAB,$ACTION(PRM$BK))
DFKTAB:	$STAB
	DSPTAB	(NUMPDB,DEFSKP,<Number>,KEYFLG)
	$ETAB
DFLPDB:	$KEYDSP	(DFLTAB,$ACTION(PRM$BK))
DFLTAB:	$STAB
	DSPTAB	(DFOPDB,DNS12##,<Input>,KEYFLG)
	DSPTAB	(DFOPDB,DNS13##,<Output>,KEYFLG)
	$ETAB
DFOPDB:	$KEYDSP	(DFOTAB,$ACTION(PRM$BK))
DFOTAB:	$STAB
	DSPTAB	(DFMPDB,DEFSKP,<Buffer>,KEYFLG)
	$ETAB
DFMPDB:	$KEYDSP	(DFMTAB,$ACTION(PRM$BK))
DFMTAB:	$STAB
	DSPTAB	(NUMPDB,DEFSKP,<Quota>,KEYFLG)
	$ETAB

DG4PDB:	$KEYDSP	(DG4TAB,$ACTION(PRM$BK))
DG4TAB:	$STAB
	DSPTAB	(DG6PDB,LF201##,<Event>,KEYFLG)
;	DSPTAB	(DG5PDB,0,<Known>,KEYFLG)
	$ETAB

DG5PDB:	$KEYDSP	(DG5TAB,$ACTION(PRM$BK))
DG5TAB:	$STAB
	DSPTAB	(CRLF##,LF201##,<Events>,KEYFLG)
	$ETAB

DG6PDB:	EVLIST	(CRLF##)

DFUPDB:	$KEYDSP	(DFUTAB,$ALTERNATE(CRLF##))
DFUTAB:	$STAB
	DSPTAB	(CRLF##,0,<LLC>,KEYFLG)
;	DSPTAB	(,1,<RSX-driver>,KEYFLG)
	$ETAB
DFVPDB:	$KEYDSP	(DFVTAB,$ACTION(PRM$BK))
DFVTAB:	$STAB
	DSPTAB	(DFWPDB,0,<DMC>,KEYFLG)
	$ETAB
DFWPDB:	$KEYDSP	(DFWTAB,$ACTION(PRM$BK))
DFWTAB:	$STAB
	DSPTAB	(DFXPDB,0,<Transmit>,KEYFLG)
	$ETAB
DFXPDB:	$KEYDSP	(DFXTAB,$ACTION(PRM$BK))
DFXTAB:	$STAB
	DSPTAB	(NUMPDB,DPD1##,<Buffers>,KEYFLG)
	$ETAB
DFYPDB:	$KEYDSP	(DFYTAB,$ACTION(PRM$BK))
DFYTAB:	$STAB
	DSPTAB	(DG0PDB,DMS4##,<Driver>,KEYFLG)
	DSPTAB	(DFZPDB,DMS3##,<Task>,KEYFLG)
	$ETAB
DGCPDB:	$NUMBER	(CRLF##,^D10,<<Node Address, XXXXX to YYYYY>>,<$PREFILL(NUMLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)
DFCPDB:	$NUMBER	(CRLF##,^D10,<<Node Address, XXXXX to YYYYY>>,<$PREFILL(NODLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)
DFGPDB:	$NUMBER	(CRLF##,^D10,<<Timer value, 1 to 65535 seconds>>,<$ACTION(CHKNUM),$ERRTXT(Specify decimal number in range 1 to 65535)>)
DXCPDB:	$NUMBER	(CRLF##,^D10,<<Timer value, 1 to 255 seconds>>,<$ACTION(CHKNUM),$ERRTXT(Specify decimal number in range 1 to 255)>)
DRTPDB:	$NUMBER	(CRLF##,^D10,<<Timer value in milliseconds, XXXXX to YYYYY>>,<$PREFILL(NUMLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)
NUMPDB::$NUMBER	(CRLF##,^D10,<<Number, XXXXX to YYYYY>>,<$PREFILL(NUMLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)
DFNPDB:	$CTEXT	(CRLF##,<<Text, 1 to 8 characters>>,<$FLAGS(CM%BRK),$BREAK(LITBRK),$ACTION(CHKTXT)>)
DFQPDB:	$CTEXT	(CRLF##,<<Text, 1 to 16 characters>>,<$FLAGS(CM%BRK),$BREAK(LITBRK),$ACTION(CHKTXT)>)
DFDPDB:	$CTEXT	(CRLF##,<<Text, 1 to 32 characters>>,<$ACTION(CHKTXT)>)
DFEPDB:	$FIELD	(DFFPDB,<<Node Name, 1 to 6 alphanumeric characters>>,<$PREFILL(NODLIM),$ACTION(CHKNAM)>)
DFFPDB:	$CRLF	($ERRTXT (Specify 1 to 6 alphanumerics for the node name) )
DFRPDB:	$FIELD	(CRLF##,<<Process Name, 1 to 3 alphanumeric characters>>,<$ACTION(CHKNAM)>)
DFTPDB:	$FIELD	(DFUPDB,<<Process Name, 1 to 3 alphanumeric characters>>,<$ACTION(CHKNAM)>)
DFZPDB:	$FIELD	(CRLF##,<<Task Name, 1 to 6 alphanumeric characters>>,<$ACTION(CHKNAM)>)
DG0PDB:	$FIELD	(CRLF##,<<Driver Name, 1 to 2 alphanumeric characters>>,<$ACTION(CHKNAM)>)
DC1PDB:	$KEYDSP	(DC1TAB,$ACTION(PRM$BK))
DC1TAB:	$STAB
	DSPTAB	(NUMPDB,XC1121##,<Channel>,KEYFLG)
	DSPTAB	(NUMPDB,DC900##,<Cost>,KEYFLG)
	DSPTAB	(DC4PDB,XC1120##,<Dte>,KEYFLG)
	DSPTAB	(DC2PDB,0,<Maximum>,KEYFLG)
	DSPTAB	(DC3PDB,XC1112##,<Type>,KEYFLG)
	$ETAB	
DC2PDB:	$KEYDSP	(DC2TAB,$ACTION(PRM$BK))
DC2TAB:	$STAB	
	DSPTAB	(NUMPDB,XC1122##,<Data>,KEYFLG)
	DSPTAB	(NUMPDB,XC1123##,<Window>,KEYFLG)
	$ETAB
DC3PDB:	$KEY	(CRLF##,DC3TAB,<$DEFAULT(X25)>)
DC3TAB:	$STAB
	KEYTAB	(^D5,<X25>)
	$ETAB

DL2PDB:	$KEYDSP	(DL2TAB,$ACTION(PRM$BK))
DL2TAB:	$STAB
	DSPTAB	(DL3PDB,0,<Baud>,KEYFLG)
	DSPTAB	(DL5PDB,DL1111##,<Duplex>,KEYFLG)
	$ETAB
DL3PDB:	$KEYDSP	(DL3TAB,<$DEFAULT(Rate),$ACTION(PRM$BK)>)
DL3TAB:	$STAB
	DSPTAB	(DL4PDB,DLS0##,<Rate>,KEYFLG)
	$ETAB
DL4PDB:	$KEY	(CRLF##,DL4TAB)
DL4TAB:	$STAB
	KEYTAB	(BD.12,<1200>)
	KEYTAB	(BD.18,<1800>)
	KEYTAB	(BD.192,<19200>)
	KEYTAB	(BD.24,<2400>)
	KEYTAB	(BD.36,<3600>)
	KEYTAB	(BD.48,<4800>)
	KEYTAB	(BD.72,<7200>)
	KEYTAB	(BD.96,<9600>)
	$ETAB
DL5PDB:	$KEY	(CRLF##,DL5TAB)
DL5TAB:	$STAB
	KEYTAB	(^D0,<Full>,KEYFLG)
	KEYTAB	(^D1,<Half>,KEYFLG)
	$ETAB

DX4PDB:	$FIELD	(CRLF##,<<Text, Network name>>,<$ACTION(CHKNAM)>)

DXMPDB:	$KEYDSP (DXMTAB,<$ALTERNATE(DXGPDB),$ACTION(PRM$BK)>)
DXMTAB:	$STAB
	DSPTAB	(DX1PDB,XP1160##,<Call>,KEYFLG)
;	DSPTAB	(,XP1130##,<Channels>,KEYFLG)
	DSPTAB	(DX1PDB,XP1161##,<Clear>,KEYFLG)
	DSPTAB	(DX2PDB,0,<Default>,KEYFLG)
;	DSPTAB	(,0,<Line>,KEYFLG)
	DSPTAB	(DX3PDB,0,<Maximum>,KEYFLG)
	DSPTAB	(DX4PDB,XP1110##,<Network>,KEYFLG)
	DSPTAB	(DX1PDB,XP1162##,<Reset>,KEYFLG)
	DSPTAB	(DX1PDB,XP1163##,<Restart>,KEYFLG)
	$ETAB
DX1PDB:	$KEYDSP (DX1TAB,<$DEFAULT(Timer),$ACTION(PRM$BK)>)
DX1TAB:	$STAB
	DSPTAB	(DXCPDB,DEFSKP,<Timer>,KEYFLG)
	$ETAB
DX2PDB:	$KEYDSP	(DX2TAB,$ACTION(PRM$BK))
DX2TAB:	$STAB
	DSPTAB	(NUMPDB,XP1140##,<Data>,KEYFLG)
	DSPTAB	(NUMPDB,XP1141##,<Window>,KEYFLG)
	$ETAB
DX3PDB:	$KEYDSP	(DX3TAB,$ACTION(PRM$BK))
DX3TAB:	$STAB
	DSPTAB	(NUMPDB,XP1131##,<Channels>,KEYFLG)
	DSPTAB	(NUMPDB,XP1152##,<Clears>,KEYFLG)
	DSPTAB	(NUMPDB,XP1150##,<Data>,KEYFLG)
	DSPTAB	(NUMPDB,XPS0##,<Groups>,KEYFLG)
	DSPTAB	(NUMPDB,XP1153##,<Resets>,KEYFLG)
	DSPTAB	(NUMPDB,XP1154##,<Restarts>,KEYFLG)
	DSPTAB	(NUMPDB,XP1151##,<Window>,KEYFLG)
	$ETAB

DXSPDB:	$KEYDSP (DXSTAB,$ACTION(PRM$BK))
DXSTAB: $STAB
	DSPTAB	(DX8PDB,0,<Access>,KEYFLG)
	DSPTAB	(DD9PDB,XS332##,<Account>,KEYFLG)
	DSPTAB	(DD2PDB,0,<Call>,KEYFLG)
	DSPTAB	(DD9PDB,XS353##,<Group>,KEYFLG)
	DSPTAB  (DXDPDB,0,<Maximum>,KEYFLG)
	DSPTAB	(DD3PDB,XS320##,<Node>,KEYFLG)
	DSPTAB	(DD4PDB,XS354##,<Number>,KEYFLG)
	DSPTAB	(DD5PDB,XS340##,<Object>,KEYFLG)
	DSPTAB	(DD9PDB,XS331##,<Password>,KEYFLG)
	DSPTAB	(DD7PDB,XS350##,<Priority>,KEYFLG)
	DSPTAB	(DD8PDB,XS355##,<Subaddresses>,KEYFLG)
	DSPTAB	(DD9PDB,XS330##,<User>,KEYFLG)
	$ETAB

DD9PDB:	$FIELD	(DDNPDB,<<Text, 1 to 16 characters>>,<$ACTION(CHKNAM)>)
DD4PDB:	$FIELD	(DDNPDB,<Full Remote DTE Address>,<$FLAGS(CM%BRK),$BREAK(CALBRK),$ACTION(CHKFLD)>)
DD5PDB:	$NUMBER	(DDNPDB,^d10,<<Number, XXXXX to YYYYY>>,<$PREFILL(OBJLIM),$ALTERNATE(DXXPDB),$ACTION(CHKNUM)>)
DXXPDB:	$FIELD	(DDNPDB,<<Object name >>,<$PREFILL(OBJLIM),$ACTION(CHKNAM)>)
DD3PDB:	$NUMBER	(DDNPDB,^D10,<<Number, XXXXX to YYYYY>>,<$PREFILL(NODLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)
DZZPDB:	$FIELD	(DDNPDB,<<Node name, 1 to 6 alphanumeric characters>>,<$PREFILL(NODLIM),$ACTION(CHKNAM)>)
DD7PDB:	$NUMBER	(DDNPDB,^D10,<<Number, 0 to 255>>,<$ACTION(CHKNUM)>)
DD8PDB:	$DIGIT	(DDPPDB,^D10,<<Number, XXXXX to YYYYY>>,<$PREFILL(NUMLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)
DDPPDB:	$TOKEN	(DDQPDB,<->,$ALTERNATE(DDNPDB))
DDQPDB:	$DIGIT	(DDNPDB,^D10,<<Number, XXXXX to YYYYY>>,<$PREFILL(NUMLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)
DS1PDB: $FIELD	(DDNPDB,<Hexadecimal Mask>,<$FLAGS(CM%BRK),$BREAK(HEXBRK),$ACTION(CHKHEX)>)
DS2PDB: $FIELD	(DDNPDB,<Hexadecimal Data>,<$FLAGS(CM%BRK),$BREAK(HEXBRK),$ACTION(CHKHEX)>)

DD2PDB:	$KEYDSP	(DD2TAB,$ACTION(PRM$BK))
DD2TAB:	$STAB
	DSPTAB	(DS1PDB,XS351##,<Mask>,KEYFLG)
	DSPTAB	(DS2PDB,XS352##,<Value>,KEYFLG)
	$ETAB
DXDPDB: $KEYDSP (DXDTAB,$ACTION(PRM$BK))
DXDTAB: $STAB
	DSPTAB (NUMPDB,XSS1##,<Circuits>,KEYFLG)
        DSPTAB (NUMPDB,XSS0##,<Destinations>,KEYFLG)
	$ETAB
;
;	DESTINATION qualifier
;
DDNPDB:	$KEYDSP	(DDNTAB,<$ALTERNATE(CRLF##),$ACTION(QUA$BK)>)
DDNTAB:	$STAB
	DSPTAB	(DD1PDB,QUADST##,<Destination>,KEYFLG)
	DSPTAB	(DDOPDB,KNOQUA##,<Known>,KEYFLG)
	$ETAB
DDOPDB:	$KEYDSP	(DDOTAB,<$DEFAULT(Destinations),$ACTION(QUA$BK)>)
DDOTAB:	$STAB
	DSPTAB	(CRLF##,QUADST##,<Destinations>,KEYFLG)
	$ETAB
DD1PDB:	$FIELD	(CRLF##,<<Destination Name String>>,<$ACTION(CHKNAM)>)

DX7PDB:	$KEYDSP	(DX7TAB,$ACTION(PRM$BK))
DX7TAB:	$STAB
	DSPTAB	(NUMPDB,XKL131##,<Retransmits>,KEYFLG)
	DSPTAB	(NUMPDB,XKL132##,<Window>,KEYFLG)
	$ETAB	
DX8PDB:	$KEYDSP	(DX8TAB,$ACTION(PRM$BK))
DX8TAB:	$STAB
	DSPTAB	(DFQPDB,DNX3##,<Account>,KEYFLG)
	DSPTAB	(DFQPDB,DNX4##,<Password>,KEYFLG)
	DSPTAB	(DFQPDB,DNX2##,<User>,KEYFLG)
	$ETAB
;
;	DTE qualifier
;***** $ALTERNATE (LSEPDB)
;
DXAPDB:	$KEYDSP	(DXATAB,<$ALTERNATE(CRLF##),$ACTION(QUA$BK)>)
DXATAB:	$STAB
	DSPTAB	(DC4PDB,QUADTE##,<Dte>,KEYFLG)
	DSPTAB	(PXG1PB,QUAGRP##,<Group>,KEYFLG)
	DSPTAB	(DXBPDB,KNOQUA##,<Known>,KEYFLG)
	$ETAB
DXBPDB:	$KEYDSP	(DXBTAB,$ACTION(QUA$BK))
DXBTAB:	$STAB
	DSPTAB	(CRLF##,QUADTE##,<Dtes>,KEYFLG)
	DSPTAB	(CRLF##,QUAGRP##,<Groups>,KEYFLG)
	$ETAB
DC4PDB:	$FIELD	(CRLF##,<<Decimal DTE Address>>,<$FLAGS(CM%BRK),$BREAK(DECBRK),$ACTION(CHKFLD)>)
;
DTTPDB:	$KEYDSP	(DTTTAB,<$DEFAULT(Timer),$ACTION(PRM$BK)>)
DTTTAB:	$STAB
	DSPTAB	(DRTPDB,DEFSKP,<Timer>,KEYFLG)
	$ETAB
DXGPDB: $KEYDSP (DXGTAB, $ACTION(QUA$BK))
DXGTAB: $STAB
	DSPTAB 	(DXG0PB, QUAGRP##,<Group>,KEYFLG)
	$ETAB
DXG0PB:	$FIELD	(DXG1PB,<<Group Name>>,<$ACTION(CHKNAM)>)
DXG1PB:	$KEYDSP (DXG1TB,$ACTION(PRM$BK))
DXG1TB:	$STAB
	DSPTAB	(DXG2PD,XP1170##,<DTE>,KEYFLG)
	$ETAB
DXG2PD:	$FIELD	(DXG3PD,<<Dte Address>>,<$FLAGS(CM%BRK),$BREAK(CALBRK),$ACTION(CHKFLD)>)
DXG3PD:	$KEYDSP	(DXG3TB,$ACTION(PRM$BK))
DXG3TB:	$STAB
	DSPTAB	(DXG4PB,XP1171##,<NUMBER>,KEYFLG)
	$ETAB
DXG4PB: $NUMBER (DXG5PB,^D10,<<Group Number, 1-9999>>,<$ACTION(CHKNUM),$ERRTXT(Specify decimal number in range 1-9999)>)
DXG5PB:	$KEYDSP	(DXG5TB,<$ALTERNATE(CRLF##),$ACTION(PRM$BK)>)
DXG5TB:	$STAB
	DSPTAB	(DXG6PB,XP1172##,<TYPE>,KEYFLG)
	$ETAB
DXG6PB:	$KEY	(CRLF##,DXG6TB,$DEFAULT(BILATERAL))
DXG6TB:	$STAB
	KEYTAB	(^D5,<BILATERAL>)
	$ETAB

;
; PURGE	*	*	*	*	*	*	*
;
PURPDB::$KEYDSP	(PURTAB,$ACTION(ENT$BK))
PURTAB:	$STAB
	DSPTAB	(PXNPDB,ENTCIR##,<Circuit>,KEYFLG)
	DSPTAB	(PU1PDB,ENTEXE##,<Executor>,KEYFLG)
	DSPTAB	(PXLPDB,KNOENT##,<Known>,KEYFLG)
;	DSPTAB	(,ENTLIN##,<Line>,KEYFLG)
	DSPTAB	(PV3PDB,ENTLOG##,<Logging>,KEYFLG)
	DSPTAB	(PU4PDB,ENTMOD##,<Module>,KEYFLG)
	DSPTAB	(PU9PDB,ENTNOD##,<Node>,KEYFLG)
	$ETAB

PV3PDB:	$KEYDSP	(PV3TAB,$ACTION(ENT$BK))
PV3TAB:	$STAB
;	DSPTAB	(,LOGCON##,<Console>,KEYFLG)
	DSPTAB	(DG4PDB,LOGFIL##,<File>,KEYFLG)
;	DSPTAB	(,LOGMON##,<Monitor>,KEYFLG)
	$ETAB

PXLPDB:	$KEYDSP	(PXLTAB,$ACTION(ENT$BK))
PXLTAB:	$STAB
	DSPTAB	(PXIPDB,ENTLIN##,<Lines>,KEYFLG) 
	$ETAB

PXNPDB:	$FIELD	(PC1PDB,<<Circuit Id>>,<$ACTION(CHKFLD)>)
PU4PDB:	$KEYDSP	(PU4TAB,$ACTION(ENT$BK))
PU4TAB:	$STAB
	DSPTAB	(PU7PDB,MODMCB##,<MCB-Executive>,KEYFLG)
	DSPTAB	(PU8PDB,MODRSX##,<RSX-Executive>,KEYFLG)
	DSPTAB	(PXMPDB,MODXPR##,<X25-Protocol>,KEYFLG)
	DSPTAB	(PXSPDB,MODXSR##,<X25-Server>,KEYFLG)
	$ETAB
PU9PDB:	$NUMBER	(PU1PDB,^D10,<<Node Number, XXXXX to YYYYY>>,<$PREFILL(NODLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)

PU1PDB:	$KEYDSP	(PU1TAB,$ACTION(PRM$BK))
PU1TAB:	$STAB
	DSPTAB	(CRLF##,DNS14##,<Fence>,KEYFLG)
	DSPTAB	(CRLF##,DN100##,<Identification>,KEYFLG)
	DSPTAB	(PU2PDB,DN510##,<Incoming>,KEYFLG)
	DSPTAB	(PU6PDB,0,<Management>,KEYFLG)
	DSPTAB	(PU2PDB,DN511##,<Outgoing>,KEYFLG)
	DSPTAB	(PU5PDB,DNS5##,<Receive>,KEYFLG)
	DSPTAB	(PU5PDB,DNS1##,<Transmit>,KEYFLG)
	$ETAB
PU2PDB:	$KEYDSP	(PU2TAB,<$ACTION(PRM$BK),$DEFAULT(Timer)>)
PU2TAB:	$STAB
	DSPTAB	(CRLF##,DEFSKP,<Timer>,KEYFLG)
	$ETAB
PU5PDB:	$KEYDSP	(PU5TAB,<$DEFAULT(Password),$ACTION(PRM$BK)>)
PU5TAB:	$STAB
	DSPTAB	(CRLF##,DEFSKP,<Password>,KEYFLG)
	$ETAB
PU6PDB:	$KEYDSP	(PU6TAB,$ACTION(PRM$BK))
PU6TAB:	$STAB
	DSPTAB	(CRLF##,DNS3##,<Account>,KEYFLG)
	DSPTAB	(CRLF##,DNS4##,<Password>,KEYFLG)
	DSPTAB	(CRLF##,DNS2##,<User>,KEYFLG)
	$ETAB

PU7PDB:	$KEYDSP	(PU7TAB,$ACTION(PRM$BK))
PU7TAB:	$STAB
	DSPTAB	(DFRPDB,DMS0##,<Process>,KEYFLG)
	$ETAB
PU8PDB:	$KEYDSP	(PU8TAB,$ACTION(PRM$BK))
PU8TAB:	$STAB
	DSPTAB	(DG0PDB,DMS4##,<Driver>,KEYFLG)
	DSPTAB	(DFZPDB,DMS3##,<Task>,KEYFLG)
	$ETAB
PXIPDB:	$KEYDSP	(PXITAB,$ACTION(PRM$BK))
PXITAB:	$STAB
	DSPTAB	(PX7PDB,0,<Maximum>,KEYFLG)
	DSPTAB	(PU2PDB,XKL121##,<Retransmission>,KEYFLG)
	$ETAB

PX7PDB:	$KEYDSP	(PX7TAB,$ACTION(PRM$BK))
PX7TAB:	$STAB
	DSPTAB	(CRLF##,XKL131##,<Retransmits>,KEYFLG)
	DSPTAB	(CRLF##,XKL132##,<Window>,KEYFLG)
	$ETAB	

PXMPDB:	$KEYDSP (PXMTAB,<$ALTERNATE(PXGPDB),$ACTION(PRM$BK)>)
PXMTAB:	$STAB
	DSPTAB	(PU2PDB,XP1160##,<Call>,KEYFLG)
	DSPTAB	(PU2PDB,XP1161##,<Clear>,KEYFLG)
	DSPTAB	(PX3PDB,0,<Maximum>,KEYFLG)
	DSPTAB	(PU2PDB,XP1162##,<Reset>,KEYFLG)
	DSPTAB	(PU2PDB,XP1163##,<Restart>,KEYFLG)
	$ETAB

PX3PDB:	$KEYDSP	(PX3TAB,$ACTION(PRM$BK))
PX3TAB:	$STAB
	DSPTAB	(CRLF##,XP1152##,<Clears>,KEYFLG)
	DSPTAB	(CRLF##,XP1153##,<Resets>,KEYFLG)
	DSPTAB	(CRLF##,XP1154##,<Restarts>,KEYFLG)
	$ETAB

PXSPDB:	$KEYDSP (PXSTAB,<$ALTERNATE(PXTPDB),$ACTION(PRM$BK)>)
PXSTAB: $STAB
	DSPTAB	(DDNPDB,XS300##,<All>,KEYFLG)
	$ETAB

PXTPDB:	$KEYDSP (PXTTAB,$ACTION(PRM$BK))
PXTTAB: $STAB
	DSPTAB	(PX8PDB,0,<Access>,KEYFLG)
	DSPTAB	(DDNPDB,XS332##,<Account>,KEYFLG)
	DSPTAB	(PP2PDB,0,<Call>,KEYFLG)
	DSPTAB	(DDNPDB,XS353##,<Group>,KEYFLG)
	DSPTAB	(DDNPDB,XS354##,<Number>,KEYFLG)
	DSPTAB	(DDNPDB,XS331##,<Password>,KEYFLG)
	DSPTAB	(DDNPDB,XS350##,<Priority>,KEYFLG)
	DSPTAB	(DDNPDB,XS355##,<Subaddresses>,KEYFLG)
	DSPTAB	(DDNPDB,XS330##,<User>,KEYFLG)
	$ETAB

PX8PDB:	$KEYDSP	(PX8TAB,$ACTION(PRM$BK))
PX8TAB:	$STAB
	DSPTAB	(CRLF##,DNX3##,<Account>,KEYFLG)
	DSPTAB	(CRLF##,DNX4##,<Password>,KEYFLG)
	DSPTAB	(CRLF##,DNX2##,<User>,KEYFLG)
	$ETAB	

PP2PDB:	$KEYDSP	(PP2TAB,$ACTION(PRM$BK))
PP2TAB:	$STAB
	DSPTAB	(DDNPDB,XS351##,<Mask>,KEYFLG)
	DSPTAB	(DDNPDB,XS352##,<Value>,KEYFLG)
	$ETAB

PC1PDB:	$KEYDSP	(PC1TAB,$ACTION(PRM$BK))
PC1TAB:	$STAB
	DSPTAB	(CRLF##,XC1121##,<Channel>,KEYFLG)
	DSPTAB	(CRLF##,XC1120##,<Dte>,KEYFLG)
	DSPTAB	(PC2PDB,0,<Maximum>,KEYFLG)
	DSPTAB	(PC3PDB,XC1112##,<Type>,KEYFLG)
	$ETAB	

PC2PDB:	$KEYDSP	(PC2TAB,$ACTION(PRM$BK))
PC2TAB:	$STAB	
	DSPTAB	(CRLF##,XC1122##,<Data>,KEYFLG)
	DSPTAB	(CRLF##,XC1123##,<Window>,KEYFLG)
	$ETAB
PC3PDB:	$KEY	(CRLF##,PC3TAB,$DEFAULT(X25))
PC3TAB:	$STAB
	KEYTAB	(^D5,<X25>)
	$ETAB
PXGPDB: $KEYDSP (PXGTAB,<$ALTERNATE(PXG4PB),$ACTION(PRM$BK)>)
PXGTAB: $STAB
	DSPTAB 	(PXG0PB,XP1101##,<All>,KEYFLG)
	$ETAB
PXG0PB:	$KEYDSP (PXG0TB, $ACTION(QUA$BK))
PXG0TB: $STAB
	DSPTAB	(PXG1PB, QUAGRP##,<Group>,KEYFLG)
	DSPTAB	(PXG2PB, KNOQUA##,<Known>,KEYFLG)
	$ETAB
PXG1PB:	$FIELD	(CRLF##,<<Group Name>>,<$ACTION(CHKNAM)>)
PXG2PB: $KEYDSP (PXG2TB,$ACTION(QUA$BK))
PXG2TB: $STAB
	DSPTAB (CRLF##,QUAGRP##,<Groups>,KEYFLG)
	$ETAB
PXG3PB: $KEYDSP (PXG3TB, $ACTION(PRM$BK))
PXG3TB:	$STAB
	DSPTAB	(CRLF##,XP1170##,<DTE>,KEYFLG)
	DSPTAB	(CRLF##,XP1172##,<Type>,KEYFLG)
	$ETAB
PXG4PB:	$KEYDSP	(PXG4TB,$ACTION(QUA$BK))
PXG4TB:	$STAB
	DSPTAB	(PXG5PD,QUAGRP##,<Group>,KEYFLG)
	$ETAB
PXG5PD:	$FIELD	(PXG6PD,<<Group Name>>,<$ACTION(CHKNAM)>)
PXG6PD:	$KEYDSP	(PXG6TB,$ACTION(PRM$BK))
PXG6TB:	$STAB
	DSPTAB	(CRLF##,XP1172##,<Type>,KEYFLG)
	$ETAB	
;
; LIST	*	*	*	*	*	*	*	*
;
LISPDB::$KEYDSP	(LISTAB,$ACTION(ENT$BK))
LISTAB:	$STAB
;	DSPTAB	(,ENTCIR##,<Circuit>,KEYFLG)
	DSPTAB	(LS3PDB,ENTEXE##,<Executor>,KEYFLG)
	DSPTAB	(LS2PDB,KNOENT##,<Known>,KEYFLG)
;	DSPTAB	(,ENTLIN##,<Line>,KEYFLG)
	DSPTAB	(LS9PDB,ENTLOG##,<Logging>,KEYFLG)
	DSPTAB	(LS4PDB,ENTMOD##,<Module>,KEYFLG)
	DSPTAB	(LS1PDB,ENTNOD##,<Node>,KEYFLG)
	$ETAB

LS1PDB:	$NUMBER	(LS3PDB,^D10,<<Node Number, XXXXX to YYYYY>>,<$PREFILL(NODLIM),$ACTION(CHKNUM),$ERROR(NUMERR)>)

LS2PDB:	$KEYDSP	(LS2TAB,$ACTION(ENT$BK))
LS2TAB:	$STAB
	DSPTAB	(LS3PDB,ENTCIR##,<Circuits>,KEYFLG)
	DSPTAB	(LS3PDB,ENTLIN##,<Lines>,KEYFLG)
;	DSPTAB	(,ENTLOG##,<Logging>,KEYFLG)
	DSPTAB	(LS3PDB,KNOMOD##,<Modules>,KEYFLG)
	DSPTAB	(LS3PDB,ENTNOD##,<Nodes>,KEYFLG)
	$ETAB

LS3PDB:	$KEY	(CRLF##,LS3TAB,<$DEFAULT(Characteristics)>)
LS3TAB:	$STAB
	KEYTAB	(0,<Characteristics>)
	$ETAB

LS4PDB:	$KEYDSP	(LS4TAB,$ACTION(ENT$BK))
LS4TAB:	$STAB
	DSPTAB	(LS5PDB,MODMCB##,<MCB-Executive>,KEYFLG)
	DSPTAB	(LS7PDB,MODRSX##,<RSX-Executive>,KEYFLG)
	DSPTAB	(LSEPDB,MODXPR##,<X25-Protocol>,KEYFLG)
	DSPTAB	(LSDPDB,MODXSR##,<X25-Server>,KEYFLG)
	$ETAB

LS5PDB:	$KEYDSP	(LS5TAB,<$DEFAULT(Characteristics)>)
LS5TAB:	$STAB
	DSPTAB	(CRLF##,0,<Characteristics>,KEYFLG)
	DSPTAB	(LS6PDB,KNOQUA##,<Known>,KEYFLG)
	$ETAB

LS6PDB:	$KEYDSP	(LS6TAB,<$DEFAULT(Processes)>)
LS6TAB:	$STAB
	DSPTAB	(CRLF##,QUAPRO##,<Processes>,KEYFLG)
	$ETAB

LS7PDB:	$KEYDSP	(LS7TAB)
LS7TAB:	$STAB
	DSPTAB	(LS8PDB,KNOQUA##,<Known>,KEYFLG)
	$ETAB

LS8PDB:	$KEYDSP	(LS8TAB,<$DEFAULT(Tasks)>)
LS8TAB:	$STAB
	DSPTAB	(CRLF##,QUATAS##,<Tasks>,KEYFLG)
	$ETAB

LS9PDB:	$KEYDSP	(LS9TAB,$ACTION(ENT$BK))
LS9TAB:	$STAB
;	DSPTAB	(,LOGCON##,<Console>,KEYFLG)
	DSPTAB	(LSAPDB,LOGFIL##,<File>,KEYFLG)
;	DSPTAB	(,LOGMON##,<Monitor>,KEYFLG)
	$ETAB

LSAPDB:	$KEYDSP	(LSATAB,<$DEFAULT(Events)>)
LSATAB:	$STAB
	DSPTAB	(CRLF##,0,<Events>,KEYFLG)
	$ETAB
;***** $ALTERNATE (DDNPDB)
LSDPDB:	$KEYDSP	(LSDTAB,<$DEFAULT(Characteristics)>)
LSDTAB:	$STAB
	DSPTAB	(DDNPDB,0,<Characteristics>,KEYFLG)
	$ETAB
;****** $ALTERNATE (DXAPDB)
LSEPDB:	$KEYDSP	(LSETAB,<$DEFAULT(Characteristics)>)
LSETAB:	$STAB
	DSPTAB	(DXAPDB,0,<Characteristics>,KEYFLG)
	$ETAB

;
;   Parsing utilities
;
NUMMIN::BLOCK	1			;Number Low limit
NUMMAX::BLOCK	1			;Number High limit
;
; $ACTION routine aids
;

A$KEYW::MOVE	S1,CR.COD(S2)		;Keyword.
	CAIE	S1,.CMKEY
	 $RETF
	HRRZ	S1,@CR.RES(S2)		;Get TBLUK block
	HLRZ	S1,0(S1)		;to pick up data.
	$RETT

A$NUM::	MOVE	S1,CR.RES(S2)		;Get number.
	MOVE	CR.COD(S2)		;Number.
	CAIE	.CMNUM
	 CAIN	.CMNUX
	  $RETT
	$RETF

A$FLD::	MOVE	S1,CR.COD(S2)		;Field.
	CAIE	S1,.CMFLD
	 $RETF
	MOVE	S1,CR.FLG(S2)		;Get pointer to text
	MOVE	S1,.CMABP(S1)		;in atom buffer.
	$RETT

A$TEXT::MOVE	S1,CR.COD(S2)		;Text.
	CAIE	S1,.CMTXT
	 $RETF
	MOVE	S1,CR.FLG(S2)		;Get pointer to text
	MOVE	S1,.CMABP(S1)		;in atom buffer.
	$RETT

A$QSTR::MOVE	S1,CR.COD(S2)		;Quoted string.
	CAIE	S1,.CMQST
	 $RETF
	MOVE	S1,CR.FLG(S2)		;Get pointer to text
	MOVE	S1,.CMABP(S1)		;in atom buffer.
	$RETT

;
; Syntax handling $ACTION routines
;

ENT$BK:	$CALL	A$KEYW
	SKIPN	S1
	 $RETT
	MOVEM	S1,ENTBLK
	LOAD	S2,(S1),PRSMIN
	MOVEM	S2,NUMMIN		;Copy minimum
	LOAD	S2,(S1),PRSMAX
	MOVEM	S2,NUMMAX		;and maximum
	$RETT

PRM$BK:	$CALL	A$KEYW			;If
	SKIPE	S1			;there is
	 CAIN	S1,DEFSKP		;a parameter block
	  $RETT				;then
	MOVEM	S1,PRMBLK		;save it.
	LOAD	S2,(S1),PRSMIN
	MOVEM	S2,NUMMIN		;Copy minimum
	LOAD	S2,(S1),PRSMAX
	MOVEM	S2,NUMMAX		;and maximum
	$RETT

QUA$BK:	$CALL	A$KEYW			;If there is
	SKIPN	S1			;a qualifier block
	 $RETT
	MOVEM	S1,QUABLK 		;then save it.
	LOAD	S2,(S1),PRSMIN
	MOVEM	S2,NUMMIN		;Copy minimum
	LOAD	S2,(S1),PRSMAX
	MOVEM	S2,NUMMAX		;and maximum
	$RETT

NODLIM::LOAD	S1,CR.PDB(S2),RHMASK	; Get current PDB
	LOAD	S1,.CMFNP(S1),CM%FNC	;  to pick up function.
	CAIN	S1,.CMNUM		; If not numeric
	 JRST	NODLI1			;  then
	MOVEI	S1,^D1			;  must be
	MOVEM	S1,NUMMIN		; Node name:
	MOVEI	S1,^D6			;  set minimum/maximum
	MOVEM	S1,NUMMAX		;  for node name.
	$RETT
NODLI1:	LOAD	S1,ENTNOD##,PRSMIN 	; Node number:
	MOVEM	S1,NUMMIN		;  set minimum/maximum
	LOAD	S1,ENTNOD##,PRSMAX	;  for node number.
	MOVEM	S1,NUMMAX
	PJRST	NUMLIM			; Fall into NUMLIM.

OBJLIM::LOAD	S1,CR.PDB(S2),RHMASK	; Get current PDB
	LOAD	S1,.CMFNP(S1),CM%FNC	;  to pick up function.
	CAIN	S1,.CMNUM		; If not numeric
	 JRST	OBJLI1			;  then
	MOVEI	S1,^D1			;  must be
	MOVEM	S1,NUMMIN		; Object name:
	MOVEI	S1,^D16			;  set minimum/maximum
	MOVEM	S1,NUMMAX		;  for object name.
	$RETT
OBJLI1:	MOVX	S1,^D1			; Object number:
	MOVEM	S1,NUMMIN		;  set minimum/maximum
	MOVX	S1,^D255		;  for object number.
	MOVEM	S1,NUMMAX		; Fall into NUMLIM.
;
;   Note: uses AC13.
;
NUMLIM::$SAVE	<T1,T2,T3,T4>
	LOAD	T2,CR.PDB(S2),RHMASK
	SKIPN	13,.CMHLP(T2)
	 JRST	NUMLI2
NUMLI1:	ILDB	S1,13
	JUMPE	S1,NUMLI2
	CAIE	S1,","
	 JRST	NUMLI1
	$TEXT	NUMLI4,< ^D/NUMMIN/ to ^D/NUMMAX/^0>
NUMLI2:	LOAD	T1,-1(T2),RHMASK
	ADDI	T1,-1(T2)
	SKIPN	PB%ERR(T1)
	 $RETT
	$TEXT	<-1,,NUMERT>,<Specify decimal number in range ^D/NUMMIN/ to ^D/NUMMAX/^0>
	$RETT
NUMLI4:	IDPB	S1,13
	$RET

NUMERT:	ASCIZ/Specify decimal number in range XXXXX to YYYYY/
NUMERR::MOVE	S2,[POINT 7,NUMERT]
	$RETF

CHKNUM::$CALL	A$NUM			;Get number
	CAML	S1,NUMMIN		;Check the range
	CAMLE	S1,NUMMAX
	 JRST	[$SYNFAIL (<Value is out of range>)]
	$RETT

CHKHEX::$SAVE	<T1,T2,T3,T4>
	$CALL	A$FLD			;Get text pointer.
	SETZM	T4			;Alphabetic character flag
	MOVNI	T2,1			;and string length.
CHKX1:	ADDI	T2,1			;One more good character..
	ILDB	T1,S1			;Get the next.
	CAIL	T1,"0"			;Check numeric
	CAILE	T1,"9"			; (check for terminating null)
	 JUMPN T1,[CAIL	T1,"A"		;Check UPPER CASE
		CAILE	T1,"F"
		 JRST [	CAIL	T1,"a"	;Check lower case
			CAILE	T1,"f"
			 JRST [	$SYNFAIL(<Illegal character in number>)]
			JRST	CHKX2]
		JRST	CHKX2]
CHKX2:	JUMPN	T1,CHKX1		;If non-null, go for more.
	CAMGE	T2,NUMMIN		;Check the range
	 JRST	[$SYNFAIL(<Number too short>)]
	CAMLE	T2,NUMMAX
	 JRST	[$SYNFAIL(<Number too long>)]
	$RETT

CHKNAM::$SAVE	<T1,T2,T3,T4>
	$CALL	A$FLD			;Get text pointer.

	SETZ	T2,			;and string length.
CHKNO1:	ILDB	T1,S1			;Get the next.
	JUMPE	T1,CHKNO2		;Exit loop at end of string
	CAIL	T1,"A"			;Check UPPER CASE
	CAILE	T1,"Z"
	SKIPA				;Not, check for lower case
	 AOJA	T2,CHKNO1		;Yes, bump character count and continue
	CAIL	T1,"a"			;Check lower case
	CAILE	T1,"z"
	SKIPA				;Not, check for digit
	 AOJA	T2,CHKNO1		;Yes, bump character count and continue
	JUMPE	T2,[$SYNFAIL(<Name must start with alphabetic character>)]
	CAIL	T1,"0"			;Check numeric
	CAILE	T1,"9"			; (check for terminating null)
	 JRST	[$SYNFAIL(<Illegal character in name>)]
	AOJA	T2,CHKNO1		;Bump character count and continue
CHKNO2:	CAMGE	T2,NUMMIN		;Check the range
	 JRST	[$SYNFAIL(<Name too short>)]
	CAMLE	T2,NUMMAX
	 JRST	[$SYNFAIL(<Name too long>)]
	$RETT

CHKFLD::$CALL	A$FLD			;Get field pointer.
	JRST	CHKTX1
CHKTXT::$CALL	A$TEXT			;Get text pointer.
CHKTX1:	$SAVE	<T1,T2,T3,T4>
	MOVNI	T2,1			;Set string length.
CHKTX2:	ADDI	T2,1			;One more character..
	ILDB	T1,S1			;Get a byte
	JUMPN	T1,CHKTX2		;and loop if more.
	CAMGE	T2,NUMMIN		;Check the range
	 JRST	[$SYNFAIL(<Text too short>)]
	CAMLE	T2,NUMMAX
	 JRST	[$SYNFAIL(<Text too long>)]
	$RETT

	END