.TITLE	ETHERMON_PARSE Parser and Accessories for Ethernet Monitor
	.IDENT	/V1.0/

;
;  define funny system symbols used by this program
;
	.LIBRARY	/SYS$LIBRARY:LIB/
	$DSCDEF
	$NMADEF	GLOBAL
	.IF	NE NMA$C_STATE_ON
	.WARN	0	; inconsistency in FORTRAN code, fix it!!!!!
	.ENDC
	.IF	NDF NMA$C_PCLI_CCA
NMA$C_PCLI_CCA	==	2776	; protect pre-V5.4-3 code from link errors
	.ENDC
	.IF	NDF NMA$C_PCLI_APC
NMA$C_PCLI_APC	==	2777	; protect pre-V5.4-3 code from link errors
	.ENDC
	.IF	NDF NMA$C_PCLI_MED
NMA$C_PCLI_MED	==	2778	; protect pre-V5.4-3 code from link errors
	.ENDC
	$SHRDEF
	$SMGDEF
	$TPADEF

	.SBTTL	FORTRAN COMMON's

	.PSECT	LCV_EXIT,NOEXE,RD,WRT,GBL,SHR,OVR,PIC,LONG
LCV_EXIT:
	.BLKB	1	; flag to indicate EXIT command entered

	.PSECT	INPUT,NOEXE,RD,WRT,GBL,SHR,OVR,PIC,LONG
LCV_CMDFIL:
	.BLKB	1	; flag to indicate indirect command file open

	.PSECT	PARSE_ARGS,NOEXE,RD,WRT,GBL,SHR,OVR,PIC,LONG
ICVPRS_NUMBER:
	.BLKL	1	; generic parsed number
BCVPRS_ADDRNUM:
	.BLKB	6	; parsed address number
BCVPRS_PROTNUM:
	.BLKB	2	; parsed protocol number
BCVPRS_DSTADR:
	.BLKB	6	; parsed address for destination
BCVPRS_SRCADR:
	.BLKB	6	; parsed address for source
		;*** next three bytes must remain in this order ***
BCVPRS_DSTMOD:
	.BLKB	1	; filter mode for destination addr (1=EXCLUDE, 2=ONLY)
BCVPRS_SRCMOD:
	.BLKB	1	; filter mode for source addr (1=EXCLUDE, 2=ONLY)
BCVPRS_PRTMOD:
	.BLKB	1	; filter mode for protocol (1=EXCLUDE, 2=ONLY)
		;*** previous three bytes must remain in this order ***
BCVPRS_FLTMOD:
	.BLKB	1	; overall filter mode (1=ENABLE, 2=DISABLE)
NCVPRS_FILESPECLEN:
	.BLKW	1	; length of used filespec buffer
CCVPRS_FILESPEC:
	.BLKB	256	; file specification buffer
NCVPRS_SYMLEN:
	.BLKW	1	; length of used symbol name buffer
CCVPRS_SYMNAM:
	.BLKB	32	; symbol name buffer
NCVPRS_KEYLEN:
	.BLKW	1	; length of key name (DEFINE/KEY)
CCVPRS_KEYNAM:
	.BLKB	32	; key name buffer (DEFINE/KEY)
NCVPRS_STATELEN:
	.BLKW	1	; length of state name (DEFINE/KEY)
CCVPRS_STATENAM:
	.BLKB	32	; state name buffer (DEFINE/KEY)

	.PSECT	$LOCAL,NOEXE,RD,WRT,NOSHR,LCL,PIC,LONG
HOSTADDR_VECTOR:
	.BLKL	1	; address of GETHOSTBYADDR procedure
NETOF_VECTOR:
	.BLKL	1	; address of INET_NETOF procedure
NETADDR_VECTOR:
	.BLKL	1	; address of GETNETBYADDR procedure
BLV_SAVE_FLT_ENA:
	.BLKB	1	; place to save filter EXCLUDE/ONLY flag

	.SBTTL	Command Line Parse State Table

SEMICOLON	=	^X2B
COMMA		=	^X2C

PROT_AARP	=	^XF380
PROT_APPLETALK	=	^X9B80
PROT_ARP	=	^X0608
PROT_DECNET	=	^X0360
PROT_DOMAIN	=	^X1980
PROT_IP		=	^X0008
PROT_LAT	=	^X0460
PROT_LAVC	=	^X0760
PROT_LOOPBACK	=	^X0090
PROT_MOP_DLA	=	^X0160
PROT_MOP_RC	=	^X0260
PROT_RARP	=	^X3580
PROT_XNS	=	^X0006

	$INIT_STATE	CMDLIN_STATE,CMDLIN_KEY

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT
	$TRAN	'@',STATE_INDIRECT,verify_no_file_open
	$TRAN	'ADD',STATE_ADD
	$TRAN	'CLEAR',STATE_CLEAR
	$TRAN	'DEFINE',STATE_DEFINE
	$TRAN	'DELETE',STATE_DELETE
	$TRAN	'DISPLAY',STATE_DISPLAY
	$TRAN	'EXIT',TPA$_EXIT,EXIT_COMMAND
	$TRAN	'HELP',STATE_HELP
	$TRAN	'LOAD',STATE_LOAD
	$TRAN	'MAP',STATE_MAP
	$TRAN	'MONITOR',STATE_DISPLAY
	$TRAN	'PING',STATE_PING
	$TRAN	'QUERY',STATE_QUERY
	$TRAN	'SAVE',STATE_SAVE
	$TRAN	'SET',STATE_SET
	$TRAN	'SHOW',STATE_SHOW
	$TRAN	'SPAWN',STATE_SPAWN
	$TRAN	'SUMMARIZE',STATE_SUMMARIZE
	$TRAN	'TRACE',STATE_TRACE
	$TRAN	'WAIT',STATE_WAIT

	$STATE	ENDLIN
	$TRAN	TPA$_EOS,TPA$_EXIT
	$TRAN	'!',TPA$_EXIT
	$TRAN	SEMICOLON,TPA$_EXIT

	$STATE	STATE_INDIRECT
	$TRAN	TPA$_FILESPEC,,save_filespec

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,OPEN_INDIRECT_FILE

	$STATE	STATE_ADD
	$TRAN	'FILTER',STATE_ADD_FILTER

	$STATE	STATE_ADD_FILTER
	$TRAN	!FILTER_quals,STATE_ADD_FILTER
	$TRAN	!ENDLIN,TPA$_EXIT,ADD_FILTER

	$STATE	STATE_CLEAR
	$TRAN	'FILTER',STATE_CLEAR_FILTER
	$TRAN	'FLAGS',STATE_CLEAR_FLAGS

	$STATE	STATE_CLEAR_FILTER
	$TRAN	!ALL_qual,STATE_CLEAR_FILTER_2,,,,-1
	$TRAN	TPA$_DECIMAL,STATE_CLEAR_FILTER_2,,,,1

	$STATE	STATE_CLEAR_FILTER_2
	$TRAN	!ENDLIN,TPA$_EXIT,CLEAR_FILTER

	$STATE	STATE_CLEAR_FLAGS
	$TRAN	!ENDLIN,TPA$_EXIT,CLEAR_FLAGS

	$STATE	STATE_DEFINE
	$TRAN	!KEY_qual

	$STATE	STATE_DEFINE_2
	$TRAN	'/'
	$TRAN	TPA$_LAMBDA,STATE_DEFINE_KEY_NAME

	$STATE
	$TRAN	!qual_IF_STATE,STATE_DEFINE_2
	$TRAN	'LOCK_STATE',STATE_DEFINE_2,,SMG$M_KEY_LOCK,ICVPRS_NUMBER
	$TRAN	'NOECHO',STATE_DEFINE_2,,SMG$M_KEY_NOECHO,ICVPRS_NUMBER
	$TRAN	!qual_SET_STATE,STATE_DEFINE_2
	$TRAN	'TERMINATE',STATE_DEFINE_2,,SMG$M_KEY_TERMINATE,ICVPRS_NUMBER

	$STATE	STATE_DEFINE_KEY_NAME
	$TRAN	TPA$_STRING,,save_key

	$STATE
	$TRAN	!skip_to_EOS,,save_filespec

	$STATE
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,DEFINE_KEY

	$STATE	STATE_DELETE
	$TRAN	!KEY_qual

	$STATE	STATE_DELETE_KEY_2
	$TRAN	!qual_STATE,STATE_DELETE_KEY_2
	$TRAN	TPA$_STRING,STATE_DELETE_KEY_2,save_key
	$TRAN	!ENDLIN,TPA$_EXIT,DELETE_KEY

	$STATE	STATE_DISPLAY
	$TRAN	'DESTINATIONS',,,,,1
	$TRAN	'PROTOCOLS',,,,,2
	$TRAN	'SIZES',,,,,3
	$TRAN	'SOURCES',,,,,4
	$TRAN	'STATISTICS',,,,,5
	$TRAN	'THROUGHPUT',,,,,6

	$STATE	STATE_DISPLAY_2
	$TRAN	!ENDLIN,TPA$_EXIT,DISPLAY
	$TRAN	'/'

	$STATE
	$TRAN	'ALL_STATISTICS',STATE_DISPLAY_2,,1,ICVPRS_NUMBER
	$TRAN	'NOFILTER',STATE_DISPLAY_2,,2,ICVPRS_NUMBER

	$STATE	STATE_HELP
	$TRAN	!skip_to_end,TPA$_EXIT,HELP

	$STATE	STATE_LOAD
	$TRAN	!LOAD_SAVE_qual,,save_filter_mode
	$TRAN	!LOAD_Internet_qual,,save_filter_mode
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	TPA$_FILESPEC,,save_filespec
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,LOAD

	$STATE	STATE_MAP
	$TRAN	!ENDLIN,TPA$_EXIT,MAP

	$STATE	STATE_PING
	$TRAN	'/'
	$TRAN	TPA$_LAMBDA,STATE_PING_2

	$STATE
	$TRAN	'IEEE_LOOPBACK',,,1,ICVPRS_NUMBER
	$TRAN	'IEEE_MOP',,,2,ICVPRS_NUMBER
	$TRAN	'INTERNET',,,3,ICVPRS_NUMBER
	$TRAN	'LOOPBACK',,,4,ICVPRS_NUMBER
	$TRAN	'MOP',,,5,ICVPRS_NUMBER

	$STATE	STATE_PING_2
	$TRAN	!address_num,STATE_PING_3,,,,1
	$TRAN	!Internet_num,STATE_PING_3,check_Internet_num,,,1
	$TRAN	!DECnet_num,STATE_PING_3,check_DECnet_num,,,1
	$TRAN	!UB_num,STATE_PING_3,,,,1
	$TRAN	TPA$_STRING,STATE_PING_3,check_node_name,,,1
	$TRAN	!ENDLIN,TPA$_EXIT,PING,,,0

	$STATE	STATE_PING_3
	$TRAN	!ENDLIN,TPA$_EXIT,PING

	$STATE	STATE_QUERY
	$TRAN	!QUERY_qualifiers

	$STATE	STATE_QUERY_2
	$TRAN	!LITTLEEND_qual,STATE_QUERY_2
	$TRAN	!address_num
	$TRAN	!Internet_num,,check_Internet_num
	$TRAN	!DECnet_num,,check_DECnet_num
	$TRAN	!UB_num
	$TRAN	TPA$_STRING,,check_node_name
	$TRAN	!ENDLIN,TPA$_EXIT,QUERY,,,0

	$STATE
	$TRAN	TPA$_LAMBDA,,save_addr_as_src

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,QUERY,,,1
	$TRAN	!address_num
	$TRAN	!Internet_num,,check_Internet_num
	$TRAN	!DECnet_num,,check_DECnet_num
	$TRAN	!UB_num
	$TRAN	TPA$_STRING,,check_node_name

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,QUERY,,,2

	$STATE	STATE_SAVE
	$TRAN	!LOAD_SAVE_qual,,save_filter_mode
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	TPA$_FILESPEC,,save_filespec
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SAVE

	$STATE	STATE_SET
	$TRAN	'ADDRESS_NAME',STATE_SET_ADDRNAM
	$TRAN	'FILTER',STATE_SET_FILTER
	$TRAN	'INTERVAL',STATE_SET_INTERVAL
	$TRAN	'KEYPAD',STATE_SET_KEYPAD
	$TRAN	'MANUFACTURER',STATE_SET_MANUF
	$TRAN	'MESSAGES',STATE_SET_MESSAGES
	$TRAN	'PROTOCOL_NAME',STATE_SET_PROTNAM

	$STATE	STATE_SET_ADDRNAM
	$TRAN	!address_num

	$STATE
	$TRAN	TPA$_SYMBOL,,save_filespec
	$TRAN	!quoted_string,,save_filespec

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SET_ADDRNAM

	$STATE	STATE_SET_FILTER
	$TRAN	!FILTER_SIZE_qual,STATE_SET_FILTER_3
	$TRAN	TPA$_DECIMAL,,save_number

	$STATE	STATE_SET_FILTER_2
	$TRAN	!FILTER_quals,STATE_SET_FILTER_2
	$TRAN	!ENDLIN,TPA$_EXIT,SET_FILTER

	$STATE	STATE_SET_FILTER_3
	$TRAN	!ENDLIN,TPA$_EXIT,SET_FILTER_SIZE

	$STATE	STATE_SET_INTERVAL
	$TRAN	TPA$_DECIMAL

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SET_INTERVAL

	$STATE	STATE_SET_KEYPAD
	$TRAN	'APPLICATIONS',,,,,SMG$M_KEYPAD_APPLICATION
	$TRAN	'NUMERIC',,,,,0

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SET_KEYPAD

	$STATE	STATE_SET_MANUF
	$TRAN	!manuf_num

	$STATE
	$TRAN	TPA$_SYMBOL,,save_symbol

	$STATE
	$TRAN	TPA$_SYMBOL,,save_filespec
	$TRAN	!quoted_string,,save_filespec

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SET_MANUFNAM

	$STATE	STATE_SET_MESSAGES
	$TRAN	'DEBUG',,,,,3
	$TRAN	'DUPIP',,,,,-3
	$TRAN	'NEWNODE',,,,,-1
	$TRAN	'NODUPIP',,,,,-4
	$TRAN	'NONEWNODE',,,,,-2
	$TRAN	'OFF',,,,,0
	$TRAN	'ON',,,,,1

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SET_MESSAGES

	$STATE	STATE_SET_PROTNAM
	$TRAN	!protocol_num

	$STATE
	$TRAN	TPA$_SYMBOL,,save_filespec
	$TRAN	!quoted_string,,save_filespec

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SET_PROTNAM

	$STATE	STATE_SHOW
	$TRAN	'ADDRESS_NAMES',STATE_SHOW_ADDRESS
	$TRAN	'BRIDGES',STATE_SHOW_BRIDGES
	$TRAN	'FILTERS',STATE_SHOW_FILTER
	$TRAN	'KEYS',STATE_SHOW_KEYS
	$TRAN	'MANUFACTURERS',STATE_SHOW_MANUF
	$TRAN	'MESSAGES',STATE_SHOW_MESSAGES
	$TRAN	'PERFORMANCE',STATE_SHOW_PERF
	$TRAN	'PORT_STATUS',STATE_SHOW_PORT
	$TRAN	'PROTOCOL_NAMES',STATE_SHOW_PROTOCOL

	$STATE	STATE_SHOW_ADDRESS
	$TRAN	!ALL_qual,STATE_SHOW_ADDRESS,,1,ICVPRS_NUMBER
	$TRAN	!FULL_qual,STATE_SHOW_ADDRESS,,2,ICVPRS_NUMBER
	$TRAN	!wildcard_Internet,STATE_SHOW_ADDRESS
	$TRAN	!wildcard_address,STATE_SHOW_ADDRESS
	$TRAN	!UB_num,STATE_SHOW_ADDRESS,,16128,ICVPRS_NUMBER
	$TRAN	!NOSORT_qual,STATE_SHOW_ADDRESS
	$TRAN	!OUTPUT_qual,STATE_SHOW_ADDRESS,,8,ICVPRS_NUMBER
	$TRAN	!PROTOCOL_qual,STATE_SHOW_ADDRESS,,4,ICVPRS_NUMBER
	$TRAN	!SORT_qual,STATE_SHOW_ADDRESS
	$TRAN	!TYPE_qual,STATE_SHOW_ADDRESS,,16,ICVPRS_NUMBER
	$TRAN	TPA$_STRING,STATE_SHOW_ADDRESS,check_node_name,16128,ICVPRS_NUMBER
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_ADDRESS_NAMES

	$STATE	STATE_SHOW_BRIDGES
	$TRAN	!MAP_qual,STATE_SHOW_BRIDGES_MAP
	$TRAN	TPA$_LAMBDA

	$STATE	STATE_SHOW_BRIDGES_2
	$TRAN	!OUTPUT_qual,STATE_SHOW_BRIDGES_2,,8,ICVPRS_NUMBER
	$TRAN	!FULL_qual,STATE_SHOW_BRIDGES_2,,2,ICVPRS_NUMBER
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_BRIDGES

	$STATE	STATE_SHOW_BRIDGES_MAP
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_BRIDGES_MAP

	$STATE	STATE_SHOW_FILTER
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_FILTER

	$STATE	STATE_SHOW_KEYS
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_KEY

	$STATE	STATE_SHOW_MANUF
	$TRAN	!ALL_qual,STATE_SHOW_MANUF,,1,ICVPRS_NUMBER
	$TRAN	!OUTPUT_qual,STATE_SHOW_MANUF,,8,ICVPRS_NUMBER
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_MANUF_NAMES

	$STATE	STATE_SHOW_MESSAGES
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_MESSAGES

	$STATE	STATE_SHOW_PERF
	$TRAN	'/'
	$TRAN	TPA$_LAMBDA,STATE_SHOW_PERF_2

	$STATE
	$TRAN	'INTERVAL',,,8,BCVPRS_PROTNUM

	$STATE
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	!delta_time,,get_delta_time

	$STATE	STATE_SHOW_PERF_2
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_PERFORMANCE

	$STATE	STATE_SHOW_PORT
	$TRAN	!ZERO_qual,,,-1,ICVPRS_NUMBER
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_PORT_STATUS

	$STATE	STATE_SHOW_PROTOCOL
	$TRAN	!ALL_qual,STATE_SHOW_PROTOCOL,,1,ICVPRS_NUMBER
	$TRAN	!OUTPUT_qual,STATE_SHOW_PROTOCOL,,8,ICVPRS_NUMBER
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	!ENDLIN,TPA$_EXIT,SHOW_PROTOCOL_NAMES

	$STATE	STATE_SPAWN
	$TRAN	!ENDLIN,TPA$_EXIT,SPAWN_NOCMD
	$TRAN	TPA$_LAMBDA

	$STATE	STATE_SPAWN_END
	$TRAN	!skip_to_end,TPA$_EXIT,SPAWN_CMD

	$STATE	STATE_SUMMARIZE
	$TRAN	'DESTINATIONS',,,1,ICVPRS_NUMBER
	$TRAN	'INTERNET',,,7,ICVPRS_NUMBER
	$TRAN	'PROTOCOLS',,,2,ICVPRS_NUMBER
	$TRAN	'SIZES',,,3,ICVPRS_NUMBER
	$TRAN	'SOURCES',,,4,ICVPRS_NUMBER
	$TRAN	'STATISTICS',,,5,ICVPRS_NUMBER

	$STATE	STATE_SUMMARIZE_2
	$TRAN	!OUTPUT_qual,STATE_SUMMARIZE_2,,256,ICVPRS_NUMBER
	$TRAN	!ENDLIN,TPA$_EXIT,SUMMARIZE
	$TRAN	'/'

	$STATE
	$TRAN	'INTERVAL',,,8,BCVPRS_PROTNUM

	$STATE
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	!delta_time,STATE_SUMMARIZE_2,get_delta_time

	$STATE	STATE_TRACE
	$TRAN	!ENDLIN,TPA$_EXIT,TRACE
	$TRAN	!OUTPUT_qual,STATE_TRACE,,4,BCVPRS_PROTNUM
	$TRAN	'/'

	$STATE
	$TRAN	'ABORT',STATE_TRACE,,128,BCVPRS_PROTNUM
	$TRAN	'ANALYZER',STATE_TRACE_ANALYZER
	$TRAN	'ASCII',STATE_TRACE,,1,BCVPRS_PROTNUM
	$TRAN	'BINARY',STATE_TRACE,,2,BCVPRS_PROTNUM
	$TRAN	'INTERVAL',STATE_TRACE_INTERVAL,,8,BCVPRS_PROTNUM
	$TRAN	'NOSTATISTICS',STATE_TRACE,,2048,BCVPRS_PROTNUM
	$TRAN	'PARALLEL',STATE_TRACE,,16,BCVPRS_PROTNUM
	$TRAN	'REPEAT',STATE_TRACE_REPEAT,,48,BCVPRS_PROTNUM ; implies parallel
	$TRAN	'SNIFFER',STATE_TRACE,,256,BCVPRS_PROTNUM
	$TRAN	'STATISTICS',STATE_TRACE,,1024,BCVPRS_PROTNUM
	$TRAN	'TRUNCATE',STATE_TRACE_TRUNCATE,,512,BCVPRS_PROTNUM

	$STATE	STATE_TRACE_ANALYZER
	$TRAN	':'
	$TRAN	'='

	$STATE
	$TRAN	TPA$_SYMBOL,STATE_TRACE,save_symbol,4096,BCVPRS_PROTNUM

	$STATE	STATE_TRACE_INTERVAL
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	!delta_time,STATE_TRACE,get_delta_time

	$STATE	STATE_TRACE_REPEAT
	$TRAN	'='
	$TRAN	':'
	$TRAN	TPA$_LAMBDA,STATE_TRACE

	$STATE
	$TRAN	TPA$_DECIMAL,,,,ICVPRS_NUMBER

	$STATE
	$TRAN	TPA$_LAMBDA,STATE_TRACE,,64,BCVPRS_PROTNUM

	$STATE	STATE_TRACE_TRUNCATE
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	TPA$_DECIMAL,STATE_TRACE,,,BCVPRS_ADDRNUM

	$STATE	STATE_WAIT
	$TRAN	'FOREVER',,max_out_delta_time,,,1
	$TRAN	!delta_time,,get_delta_time,,,2

	$STATE
	$TRAN	!skip_to_end,TPA$_EXIT,WAIT
	.SBTTL	Parser Subexpressions

	$STATE	ALL_qual
	$TRAN	'/'

	$STATE
	$TRAN	'ALL',TPA$_EXIT

	$STATE	address_num
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,,,0

	$STATE
	$TRAN	'-'

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,,,1

	$STATE
	$TRAN	'-'

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,,,2

	$STATE
	$TRAN	'-'

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,,,3

	$STATE
	$TRAN	'-'

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,,,4

	$STATE
	$TRAN	'-'

	$STATE
	$TRAN	TPA$_HEX,TPA$_EXIT,VALIDATE_ADDRNUM,,,5

	$STATE	DECnet_num
	$TRAN	TPA$_DECIMAL,,validate_DECnet_num,,,0

	$STATE
	$TRAN	'.'

	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,validate_DECnet_num,,,1

	$STATE	delta_time
	$TRAN	TPA$_DECIMAL,,validate_time,,,23
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	':'
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE
	$TRAN	TPA$_DECIMAL,,validate_time,,,59
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	':'
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE
	$TRAN	TPA$_DECIMAL,,validate_time,,,59
	$TRAN	TPA$_LAMBDA

	$STATE
	$TRAN	'.'
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,validate_time,,,99

	$STATE	FILTER_quals
	$TRAN	'/'

	$STATE
	$TRAN	'DISABLE',TPA$_EXIT,save_filter_mode,,,2
	$TRAN	'ENABLE',TPA$_EXIT,save_filter_mode,,,1
	$TRAN	'EXCLUDE',,save_filter_switch,,,1
	$TRAN	'NODESTINATION',TPA$_EXIT,mark_filter_switch,,,0
	$TRAN	'NOPROTOCOL',TPA$_EXIT,mark_filter_switch,,,2
	$TRAN	'NOSOURCE',TPA$_EXIT,mark_filter_switch,,,1
	$TRAN	'ONLY',,save_filter_switch,,,2

	$STATE
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	'('
	$TRAN	!FILTER_qual_subqual,TPA$_EXIT

	$STATE	FILTER_qual_2
	$TRAN	!FILTER_qual_subqual

	$STATE
	$TRAN	COMMA,FILTER_qual_2
	$TRAN	')',TPA$_EXIT

	$STATE	FILTER_qual_subqual
	$TRAN	'ADDRESS',FILTER_qual_subqual_ADR
	$TRAN	'DESTINATION',FILTER_qual_subqual_DST
	$TRAN	'MULTICAST',TPA$_EXIT,save_addr_as_dst,,,4
	$TRAN	'PROTOCOL',FILTER_qual_subqual_PRO
	$TRAN	'SOURCE',FILTER_qual_subqual_SRC

	$STATE	FILTER_qual_subqual_ADR
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	!address_num,TPA$_EXIT,save_addr_as_src,,,4
	$TRAN	!manuf_num,TPA$_EXIT,save_addr_as_src,,,6
	$TRAN	!Internet_num,,check_Internet_num,,,4
	$TRAN	!DECnet_num,,check_DECnet_num,,,4
	$TRAN	!UB_num,TPA$_EXIT,save_addr_as_src,,,4
	$TRAN	TPA$_STRING,,check_node_name,,,4

	$STATE
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,save_addr_as_src

	$STATE	FILTER_qual_subqual_DST
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	!address_num,TPA$_EXIT,save_addr_as_dst,,,0
	$TRAN	!manuf_num,TPA$_EXIT,save_addr_as_dst,,,2
	$TRAN	!Internet_num,,check_Internet_num,,,0
	$TRAN	!DECnet_num,,check_DECnet_num,,,0
	$TRAN	!UB_num,TPA$_EXIT,save_addr_as_dst,,,0
	$TRAN	TPA$_STRING,,check_node_name,,,0

	$STATE
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,save_addr_as_dst

	$STATE	FILTER_qual_subqual_PRO
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	!protocol_num,TPA$_EXIT,save_protocol_mode

	$STATE	FILTER_qual_subqual_SRC
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	!address_num,TPA$_EXIT,save_addr_as_src,,,0
	$TRAN	!manuf_num,TPA$_EXIT,save_addr_as_src,,,2
	$TRAN	!Internet_num,,check_Internet_num,,,0
	$TRAN	!DECnet_num,,check_DECnet_num,,,0
	$TRAN	!UB_num,TPA$_EXIT,save_addr_as_src,,,0
	$TRAN	TPA$_STRING,,check_node_name,,,0

	$STATE
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,save_addr_as_src

	$STATE	FILTER_SIZE_qual
	$TRAN	'/'

	$STATE
	$TRAN	'SIZE'

	$STATE
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	!FILTER_SIZE_subqual,TPA$_EXIT
	$TRAN	'('

	$STATE	FILTER_SIZE_qual_2
	$TRAN	!FILTER_SIZE_subqual

	$STATE
	$TRAN	COMMA,FILTER_SIZE_qual_2
	$TRAN	')',TPA$_EXIT

	$STATE	FILTER_SIZE_subqual
	$TRAN	'DISABLE',TPA$_EXIT,,2,BCVPRS_PROTNUM
	$TRAN	'ENABLE',TPA$_EXIT,,1,BCVPRS_PROTNUM
	$TRAN	'MAXIMUM',FILTER_SIZE_subqual_max
	$TRAN	'MINIMUM',FILTER_SIZE_subqual_min

	$STATE	FILTER_SIZE_subqual_max
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,VALIDATE_MSGLEN,,BCVPRS_SRCADR

	$STATE	FILTER_SIZE_subqual_min
	$TRAN	'='
	$TRAN	':'

	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,VALIDATE_MSGLEN,,BCVPRS_DSTADR

	$STATE	FULL_qual
	$TRAN	'/'

	$STATE
	$TRAN	'FULL',TPA$_EXIT

	$STATE	Internet_num
	$TRAN	TPA$_DECIMAL,,validate_Inetnum,,,0

	$STATE
	$TRAN	'.'

	$STATE
	$TRAN	TPA$_DECIMAL,,validate_Inetnum,,,1

	$STATE
	$TRAN	'.'

	$STATE
	$TRAN	TPA$_DECIMAL,,validate_Inetnum,,,2

	$STATE
	$TRAN	'.'

	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,validate_Inetnum,,,3

	$STATE	KEY_qual
	$TRAN	'/'

	$STATE
	$TRAN	'KEY',TPA$_EXIT

	$STATE	LITTLEEND_qual
	$TRAN	'/'

	$STATE
	$TRAN	'LITTLE2_ENDIAN',TPA$_EXIT,,1,ICVPRS_NUMBER
	$TRAN	'LITTLE3_ENDIAN',TPA$_EXIT,,2,ICVPRS_NUMBER

	$STATE	LOAD_SAVE_qual
	$TRAN	'/'

	$STATE
	$TRAN	'ADDRESSES',TPA$_EXIT,,,,1
	$TRAN	'FILTERS',TPA$_EXIT,,,,2
	$TRAN	'MANUFACTURERS',TPA$_EXIT,,,,5
	$TRAN	'PROTOCOLS',TPA$_EXIT,,,,3

	$STATE	LOAD_Internet_qual
	$TRAN	'/'

	$STATE
	$TRAN	'INTERNET',TPA$_EXIT,,,,4

	$STATE	manuf_num
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,,,0

	$STATE
	$TRAN	'-'

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,,,1

	$STATE
	$TRAN	'-'

	$STATE
	$TRAN	TPA$_HEX,TPA$_EXIT,VALIDATE_ADDRNUM,,,2

	$STATE	MAP_qual
	$TRAN	'/'

	$STATE
	$TRAN	'MAP'

	$STATE
	$TRAN	':'
	$TRAN	'='
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE
	$TRAN	TPA$_FILESPEC,TPA$_EXIT,save_filespec

	$STATE	NOSORT_qual
	$TRAN	'/'

	$STATE
	$TRAN	'NOSORT',TPA$_EXIT,,1048576,ICVPRS_NUMBER

	$STATE	OUTPUT_qual
	$TRAN	'/'

	$STATE
	$TRAN	'OUTPUT'

	$STATE
	$TRAN	':'
	$TRAN	'='
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE
	$TRAN	TPA$_FILESPEC,TPA$_EXIT,save_filespec

	$STATE	PROTOCOL_qual
	$TRAN	'/'

	$STATE
	$TRAN	'PROTOCOL'

	$STATE		; fall into protocol number subexpression
	$TRAN	':'
	$TRAN	'='

	$STATE	protocol_num
	$TRAN	!numeric_protocol_num,TPA$_EXIT
	$TRAN	'AARP',TPA$_EXIT,STORE_PROTNUM,,,PROT_AARP
	$TRAN	'APPLETALK',TPA$_EXIT,STORE_PROTNUM,,,PROT_APPLETALK
	$TRAN	'ARP',TPA$_EXIT,STORE_PROTNUM,,,PROT_ARP
	$TRAN	'DECNET',TPA$_EXIT,STORE_PROTNUM,,,PROT_DECNET
	$TRAN	'DOMAIN',TPA$_EXIT,STORE_PROTNUM,,,PROT_DOMAIN
	$TRAN	'IP',TPA$_EXIT,STORE_PROTNUM,,,PROT_IP
	$TRAN	'LAT',TPA$_EXIT,STORE_PROTNUM,,,PROT_LAT
	$TRAN	'LAVC',TPA$_EXIT,STORE_PROTNUM,,,PROT_LAVC
	$TRAN	'LOOPBACK',TPA$_EXIT,STORE_PROTNUM,,,PROT_LOOPBACK
	$TRAN	'MOP_DLA',TPA$_EXIT,STORE_PROTNUM,,,PROT_MOP_DLA
	$TRAN	'MOP_RC',TPA$_EXIT,STORE_PROTNUM,,,PROT_MOP_RC
	$TRAN	'RARP',TPA$_EXIT,STORE_PROTNUM,,,PROT_RARP
	$TRAN	'XNS',TPA$_EXIT,STORE_PROTNUM,,,PROT_XNS

	$STATE	numeric_protocol_num
	$TRAN	TPA$_HEX,,VALIDATE_PROTNUM,,,0

	$STATE
	$TRAN	'-'

	$STATE
	$TRAN	TPA$_HEX,TPA$_EXIT,VALIDATE_PROTNUM,,,1

	$STATE	qual_IF_STATE
	$TRAN	'IF_STATE'

	$STATE
	$TRAN	'='

	$STATE
	$TRAN	TPA$_SYMBOL,TPA$_EXIT,save_symbol

	$STATE	qual_SET_STATE
	$TRAN	'SET_STATE'

	$STATE
	$TRAN	'='

	$STATE
	$TRAN	TPA$_SYMBOL,TPA$_EXIT,save_keystate

	$STATE	qual_STATE
	$TRAN	'/'

	$STATE
	$TRAN	'STATE'

	$STATE
	$TRAN	'='

	$STATE
	$TRAN	TPA$_SYMBOL,TPA$_EXIT,save_keystate

	$STATE	QUERY_qualifiers
	$TRAN	'/'

	$STATE
	$TRAN	'DECBRIDGE',TPA$_EXIT,STORE_PROTNUM,,,2
	$TRAN	'DECMOP',TPA$_EXIT,STORE_PROTNUM,,,3
	$TRAN	'UB_BRIDGE',TPA$_EXIT,STORE_PROTNUM,,,1

	$STATE	quoted_string
	$TRAN	'"'

	$STATE	quoted_string_2
	$TRAN	'"',TPA$_EXIT
	$TRAN	TPA$_ANY,quoted_string_2

	$STATE	skip_to_end
	$TRAN	!ENDLIN,TPA$_EXIT
	$TRAN	TPA$_ANY,skip_to_end

	$STATE	skip_to_EOS
	$TRAN	TPA$_EOS,TPA$_EXIT
	$TRAN	TPA$_ANY,skip_to_EOS

	$STATE	SORT_qual
	$TRAN	'/'

	$STATE
	$TRAN	'SORT'

	$STATE
	$TRAN	'='
	$TRAN	':'
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE
	$TRAN	'ETHERNET',TPA$_EXIT
	$TRAN	'INTERNET',TPA$_EXIT,,2097152,ICVPRS_NUMBER
	$TRAN	'NONE',TPA$_EXIT,,1048576,ICVPRS_NUMBER

	$STATE	TYPE_qual
	$TRAN	'/'

	$STATE
	$TRAN	'TYPE'

	$STATE
	$TRAN	'='

	$STATE
	$TRAN	!TYPE_qual_val,TPA$_EXIT
	$TRAN	'%',TYPE_qual_val_hex
	$TRAN	'('

	$STATE	TYPE_qual_2
	$TRAN	!TYPE_qual_val

	$STATE
	$TRAN	COMMA,TYPE_qual_2
	$TRAN	')',TPA$_EXIT

	$STATE	TYPE_qual_val
	$TRAN	'DECBRIDGE',TPA$_EXIT,,128,BCVPRS_SRCADR
	$TRAN	'DECNET',TPA$_EXIT,,8,BCVPRS_SRCADR
	$TRAN	'DECSERVER',TPA$_EXIT,,256,BCVPRS_SRCADR
	$TRAN	'DESTINATION',TPA$_EXIT,,4,BCVPRS_SRCADR
	$TRAN	'DNSSERVER',TPA$_EXIT,,65536,BCVPRS_SRCADR  ; Internet DNS server
	$TRAN	'IARP',TPA$_EXIT,,131072,BCVPRS_SRCADR	    ; IP address confirmed by ARP
	$TRAN	'INETGATEWAY',TPA$_EXIT,,32768,BCVPRS_SRCADR ; Internet IP gateway/router
	$TRAN	'INETNAME',TPA$_EXIT,,2048,BCVPRS_SRCADR
	$TRAN	'INTERNET',TPA$_EXIT,,16,BCVPRS_SRCADR
	$TRAN	'LAVC',TPA$_EXIT,,512,BCVPRS_SRCADR
	$TRAN	'LINE2ADDR',TPA$_EXIT,,524288,BCVPRS_SRCADR ; base address port 2
	$TRAN	'MACNUM',TPA$_EXIT,,8192,BCVPRS_SRCADR	  ; Macintosh zone.node number
	$TRAN	'MACZONE',TPA$_EXIT,,4096,BCVPRS_SRCADR   ; Macintosh zone name
	$TRAN	'MOP',TPA$_EXIT,,16384,BCVPRS_SRCADR	  ; DEC MOP parameters
	$TRAN	'OTHERADDR',TPA$_EXIT,,262144,BCVPRS_SRCADR ; has two addresses
	$TRAN	'SOURCE',TPA$_EXIT,,2,BCVPRS_SRCADR
	$TRAN	'UB',TPA$_EXIT,,32,BCVPRS_SRCADR
	$TRAN	'VITALINK',TPA$_EXIT,,1024,BCVPRS_SRCADR
	$TRAN	'XYPLEX',TPA$_EXIT,,64,BCVPRS_SRCADR

	$STATE	TYPE_qual_val_hex
	$TRAN	'X'

	$STATE
	$TRAN	TPA$_HEX,TPA$_EXIT,,,BCVPRS_SRCADR

	$STATE	UB_num
	$TRAN	'UB'

	$STATE
	$TRAN	'#'

	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,validate_UB_num

	$STATE	wildcard_address
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,256,ICVPRS_NUMBER,0
	$TRAN	'*'

	$STATE
	$TRAN	'-'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,512,ICVPRS_NUMBER,1
	$TRAN	'*'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE
	$TRAN	'-'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,1024,ICVPRS_NUMBER,2
	$TRAN	'*'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE
	$TRAN	'-'
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,2048,ICVPRS_NUMBER,3
	$TRAN	'*'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE
	$TRAN	'-'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE
	$TRAN	TPA$_HEX,,VALIDATE_ADDRNUM,4096,ICVPRS_NUMBER,4
	$TRAN	'*'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE
	$TRAN	'-'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE
	$TRAN	TPA$_HEX,TPA$_EXIT,VALIDATE_ADDRNUM,8192,ICVPRS_NUMBER,5
	$TRAN	'*',TPA$_EXIT
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,16128

	$STATE	wildcard_Internet
	$TRAN	TPA$_DECIMAL,,validate_wInetnum,65536,ICVPRS_NUMBER,0
	$TRAN	'*'

	$STATE
	$TRAN	'.'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,983040

	$STATE
	$TRAN	TPA$_DECIMAL,,validate_wInetnum,131072,ICVPRS_NUMBER,1
	$TRAN	'*'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,983040

	$STATE
	$TRAN	'.'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,983040

	$STATE
	$TRAN	TPA$_DECIMAL,,validate_wInetnum,262144,ICVPRS_NUMBER,2
	$TRAN	'*'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,983040

	$STATE
	$TRAN	'.'
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,983040

	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,validate_wInetnum,524288,ICVPRS_NUMBER,3
	$TRAN	'*',TPA$_EXIT
	$TRAN	TPA$_LAMBDA,TPA$_FAIL,clear_mask,,,983040

	$STATE	ZERO_qual
	$TRAN	'/'

	$STATE
	$TRAN	'ZERO',TPA$_EXIT

	$END_STATE

	.SBTTL	Command Parsing Subroutine

	.PSECT	$CODE,EXE,RD,NOWRT,LCL,SHR,PIC,LONG

BACKSLASH_STR:
	.ASCID	"\"

	.ENTRY	EVALUATE_COMMAND,^M<R2,R3,R4,R5>
	CLRL	ICVPRS_NUMBER		; clear any variables related to filters,
	CLRW	BCVPRS_PROTNUM
	CLRL	BCVPRS_SRCADR
	CLRW	BCVPRS_SRCADR+4
	CLRL	BCVPRS_DSTADR
	CLRW	BCVPRS_DSTADR+4
	CLRB	BCVPRS_DSTMOD
	CLRB	BCVPRS_SRCMOD
	CLRB	BCVPRS_PRTMOD
	CLRB	BCVPRS_FLTMOD
	CLRW	NCVPRS_FILESPECLEN
	CLRW	NCVPRS_SYMLEN
	CLRW	NCVPRS_KEYLEN
	CLRW	NCVPRS_STATELEN
	CLRB	BLV_SAVE_FLT_ENA
	SUBL2	#TPA$K_LENGTH0,SP	; build TPARSE argblk on stack,
	MOVC5	#0,(SP),#0,#TPA$K_LENGTH0,(SP) ; clear block,
	MOVAB	(SP),R5			; get pointer to block,
	MOVL	#TPA$K_COUNT0,TPA$L_COUNT(R5) ; fill in the block,
	MOVL	#TPA$M_ABBREV,TPA$L_OPTIONS(R5)
	MOVAQ	@4(AP),R0
	MOVZWL	(R0),TPA$L_STRINGCNT(R5)
	MOVAB	@4(R0),TPA$L_STRINGPTR(R5)
	PUSHAB	CMDLIN_KEY		; call the parser,
	PUSHAB	CMDLIN_STATE
	PUSHAL	(R5)
	CALLS	#3,G^LIB$TPARSE
	BLBS	R0,99$			; exit if successful,
	CMPL	R0,#LIB$_SYNTAXERR	; else test what type of error it was,
	BEQL	80$			; do special work if syntax error,
90$:	PUSHL	R0			; else build message vector on stack,
	PUSHL	#1
	$PUTMSG_S	MSGVEC=12(SP)	; report error,
99$:	RET				; return.
80$:	MOVL	R0,R4			; preserve error status,
	BBC	#TPA$V_AMBIG,TPA$L_OPTIONS(R5),81$ ; skip if not ambiguous error,
	MOVL	#CLI$_ABVERB,R4		; else change error status,
81$:	BICL3	#STS$M_MSG_NO,R4,R2	; extract facility & severity of msg,
	BISL2	#SHR$_TEXT,R2		; add new message number to it,
	MOVQ	#<<DSC$K_DTYPE_T@16>+<DSC$K_CLASS_D@24>>,-(SP) ; make string dsc,
	MOVZWL	@4(AP),R0		; compute length of valid string,
	SUBL2	TPA$L_STRINGCNT(R5),R0
	BLEQ	82$			; skip if no valid beginning,
	MOVAQ	@4(AP),R1		; else put OK text at beginning of line,
	PUSHAQ	-8(R5)
	PUSHL	4(R1)
	PUSHL	R0
	CALLS	#3,G^OTS$SCOPY_R_DX
82$:	PUSHAQ	BACKSLASH_STR		; append a backslash,
	PUSHAQ	-8(R5)
	CALLS	#2,G^STR$APPEND
	PUSHAQ	TPA$L_TOKENCNT(R5)	; append the offending text,
	PUSHAQ	-8(R5)
	CALLS	#2,G^STR$APPEND
	PUSHAQ	BACKSLASH_STR		; append a backslash aghain,
	PUSHAQ	-8(R5)
	CALLS	#2,G^STR$APPEND
	PUSHAQ	-8(R5)			; build message vector on stack,
	PUSHL	#1
	PUSHL	R2
	PUSHL	#0
	PUSHL	R4
	PUSHL	#5
	$PUTMSG_S	MSGVEC=12(SP)	; report error,
	PUSHAQ	-8(R5)			; release the string buffer,
	CALLS	#1,G^STR$FREE1_DX
	RET				; exit.

	.SBTTL	Command Execution Support Subroutines

	.ENTRY	EXIT_COMMAND,^M<>
	MNEGB	#1,LCV_EXIT		; flag EXIT command as entered,
	RET				; return.

	.ENTRY	VALIDATE_MSGLEN,^M<>
	CMPL	TPA$L_NUMBER(AP),#46	; test if number is too small,
	BLSSU	98$			; skip if error,
	CMPL	TPA$L_NUMBER(AP),#4470	; test if number is too large,
	BLEQU	99$			; skip if OK,
98$:	MOVL	#ETH__MSGLEN,R0		; else report error.
99$:	RET

	.ENTRY	validate_time,^M<>
	CMPL	TPA$L_NUMBER(AP),-	; check if number in range,
		TPA$L_PARAM(AP)
	BLEQU	99$			; skip out if OK,
	MOVZWL	#SS$_IVTIME,R0		; else report error.
99$:	RET

day_prolog:
	.ASCID	"0 "

	.ENTRY	get_delta_time,^M<>
	CLRQ	-(SP)			; make an empty dynamic string descriptor,
	MOVW	#^X020E,2(SP)
	PUSHAQ	day_prolog		; build properly formatted time string,
	PUSHAQ	4(SP)
	CALLS	#2,G^STR$APPEND
	PUSHAQ	TPA$L_TOKENCNT(AP)
	PUSHAQ	4(SP)
	CALLS	#2,G^STR$APPEND
	$BINTIM_S	TIMBUF=4(SP),-	; attempt to translate time,
			TIMADR=BCVPRS_DSTADR
	PUSHR	#^M<R0>			; preserve $BINTIM status,
	PUSHAQ	4(SP)			; release the dynamic string,
	CALLS	#1,G^STR$FREE1_DX
	POPR	#^M<R0>			; restore $BINTIM status,
	RET				; return w/results (whatever they are).

	.ENTRY	max_out_delta_time,^M<>
	MOVQ	#^X7FFFFFFFFFFFFFFF,BCVPRS_DSTADR ; store latest possible time,
	RET				; return.

	.ENTRY	save_number,^M<>
	MOVL	TPA$L_NUMBER(AP),ICVPRS_NUMBER ; copy number from argblk to COMMON,
	RET				; exit.

	.ENTRY	save_filter_mode,^M<>
	MOVB	TPA$L_PARAM(AP),BCVPRS_FLTMOD ; save filter mode,
	RET				; exit.

	.ENTRY	mark_filter_switch,^M<>
	MOVL	TPA$L_PARAM(AP),R1	; get number of desired target,
	MNEGB	#1,BCVPRS_DSTMOD[R1]	; mark filter mode as "clear it",
	RET				; exit.

	.ENTRY	save_filter_switch,^M<>
	MOVB	TPA$L_PARAM(AP),BLV_SAVE_FLT_ENA ; save filter EXCLUDE/ONLY switch,
	RET				; exit.

	.ENTRY	VALIDATE_ADDRNUM,^M<>
	MOVL	TPA$L_PARAM(AP),R1	; get index into buffer array,
	MOVB	TPA$L_NUMBER(AP),BCVPRS_ADDRNUM[R1] ; copy value into buffer,
	CMPL	TPA$L_TOKENCNT(AP),#2	; test if number too long,
	BGTRU	98$			; bomb if too long,
	CMPL	TPA$L_NUMBER(AP),#^XFF	; is number in range?
	BLEQU	99$			; skip out if so,
98$:	MOVL	#ETH__BADADDRNUM,R0 ; else report syntax error.
99$:	RET

DECnet_num_limits:
	.LONG	63
	.LONG	1023

	.ENTRY	validate_DECnet_num,^M<>
	MOVL	TPA$L_PARAM(AP),R1	; get index into buffer array,
	MOVW	TPA$L_NUMBER(AP),BCVPRS_ADDRNUM[R1] ; copy value into buffer,
	TSTL	TPA$L_NUMBER(AP)	; test if number is non-zero,
	BEQL	98$			; abort if not,
	CMPL	TPA$L_NUMBER(AP),-	; is number in range?
		DECnet_num_limits[R1]
	BLEQU	99$			; skip out if so,
98$:	MOVL	#ETH__INVNODSPC,R0	; else report syntax error.
99$:	RET

	.ENTRY	validate_Inetnum,^M<>
	MOVL	TPA$L_PARAM(AP),R1	; get index into buffer array,
	MOVB	TPA$L_NUMBER(AP),BCVPRS_ADDRNUM[R1] ; copy value into buffer,
	CMPL	TPA$L_NUMBER(AP),#^XFF	; is number in range?
	BLSSU	99$			; skip out if so,
	MOVL	#ETH__BADADDRNUM,R0 ; else report syntax error.
99$:	RET

	.ENTRY	validate_wInetnum,^M<>
	MOVL	TPA$L_PARAM(AP),R1	; get index into buffer array,
	MOVB	TPA$L_NUMBER(AP),BCVPRS_DSTADR[R1] ; copy value into buffer,
	CMPL	TPA$L_NUMBER(AP),#^XFF	; is number in range?
	BLSSU	99$			; skip out if so,
	MOVL	#ETH__BADADDRNUM,R0 ; else report syntax error.
99$:	RET

	.ENTRY	validate_UB_num,^M<>
	TSTL	TPA$L_NUMBER(AP)	; test if number is non-zero,
	BEQL	98$			; abort if not,
	CMPL	TPA$L_NUMBER(AP),#^X00FFFFFF ; test if out of range number,
	BGTR	98$
	MOVW	#^XDD00,BCVPRS_ADDRNUM	; else store U-B prefix in address buffer,
	CMPL	TPA$L_NUMBER(AP),#65535	; is number in old range?
	BGTR	50$			; no, use as new format.
	CLRB	BCVPRS_ADDRNUM+2	; yes, store 0 as third manuf. byte,
	MOVB	TPA$L_NUMBER(AP),-	; store byte-swapped 16-bit serial #,
		BCVPRS_ADDRNUM+4
	MOVB	TPA$L_NUMBER+1(AP),BCVPRS_ADDRNUM+3
	CLRB	BCVPRS_ADDRNUM+5
	BRB	99$
50$:	MOVB	#1,BCVPRS_ADDRNUM+2	; yes, store 1 as third manuf. byte,
	MOVB	TPA$L_NUMBER(AP),-	; store byte-swapped 24-bit serial #,
		BCVPRS_ADDRNUM+5
	MOVB	TPA$L_NUMBER+1(AP),BCVPRS_ADDRNUM+4
	MOVB	TPA$L_NUMBER+2(AP),BCVPRS_ADDRNUM+3
	BRB	99$
98$:	MOVL	#ETH__INVNODSPC,R0	; else report syntax error.
99$:	RET

	.ENTRY	VALIDATE_PROTNUM,^M<>
	MOVL	TPA$L_PARAM(AP),R1	; get index into buffer array,
	MOVB	TPA$L_NUMBER(AP),BCVPRS_PROTNUM[R1] ; copy value into buffer,
	CMPL	TPA$L_NUMBER(AP),#^XFF	; is number in range?
	BLEQU	99$			; skip out if so,
98$:	MOVL	#ETH__BADPROTNUM,R0 ; else report syntax error.
99$:	RET

	.ENTRY	STORE_PROTNUM,^M<>
	MOVW	TPA$L_PARAM(AP),BCVPRS_PROTNUM ; copy protocol number to buffer,
	RET

	.ENTRY	check_DECnet_num,^M<>
	MOVZWL	BCVPRS_ADDRNUM,R1	; get network area number,
	ASHL	#10,R1,R1		; shift into position,
	BISW2	BCVPRS_ADDRNUM+2,R1	; OR in the node number,
	MOVW	R1,BCVPRS_ADDRNUM+4	; use as top 2 bytes of Ethernet addr,
	MOVL	#^X000400AA,BCVPRS_ADDRNUM ; fill in DECnet low longword,
	RET				; return successfully.

	.ENTRY	save_addr_as_dst,^M<>
	MOVL	BCVPRS_ADDRNUM,BCVPRS_DSTADR ; copy 1st part of address,
	MOVW	BCVPRS_ADDRNUM+4,BCVPRS_DSTADR+4 ; copy rest of address,
	ADDB3	TPA$L_PARAM(AP),BLV_SAVE_FLT_ENA,-
		BCVPRS_DSTMOD		; save mode of address,
	RET				; exit.

	.ENTRY	save_addr_as_src,^M<>
	MOVL	BCVPRS_ADDRNUM,BCVPRS_SRCADR ; copy 1st part of address,
	MOVW	BCVPRS_ADDRNUM+4,BCVPRS_SRCADR+4 ; copy rest of address,
	ADDB3	TPA$L_PARAM(AP),BLV_SAVE_FLT_ENA,-
		BCVPRS_SRCMOD		; save mode of address,
	RET				; exit.

	.ENTRY	save_protocol_mode,^M<>
	MOVB	BLV_SAVE_FLT_ENA,BCVPRS_PRTMOD ; save mode of protocol,
	RET				; exit.

	.ENTRY	verify_no_file_open,^M<>
	BLBC	LCV_CMDFIL,99$		; skip if no indirect file now open,
	MOVL	#ETH__TOOMANYIND,R0	; else report too many files open,
99$:	RET				; exit.

	.ENTRY	save_filespec,^M<R2,R3,R4,R5>
	PUSHR	#^M<R0>			; preserve success status,
	MOVC5	TPA$L_TOKENCNT(AP),-	; copy string to COMMON buffer,
		@TPA$L_TOKENPTR(AP),#^A/ /,#128,CCVPRS_FILESPEC
	MOVW	TPA$L_TOKENCNT(AP),NCVPRS_FILESPECLEN ; save string length,
	CMPW	TPA$L_TOKENCNT(AP),#128
	BLEQU	90$
	MOVW	#128,NCVPRS_FILESPECLEN ; adjust if string truncated,
90$:	POPR	#^M<R0>			; restore success status,
	RET				; exit.

	.ENTRY	save_symbol,^M<R2,R3,R4,R5>
	PUSHR	#^M<R0>			; preserve success status,
	MOVC5	TPA$L_TOKENCNT(AP),-	; copy string to COMMON buffer,
		@TPA$L_TOKENPTR(AP),#^A/ /,#32,CCVPRS_SYMNAM
	MOVW	TPA$L_TOKENCNT(AP),NCVPRS_SYMLEN ; save string length,
	CMPW	TPA$L_TOKENCNT(AP),#32
	BLEQU	90$
	MOVW	#32,NCVPRS_SYMLEN	; adjust if string truncated,
90$:	POPR	#^M<R0>			; restore success status,
	RET				; exit.

	.ENTRY	save_key,^M<R2,R3,R4,R5>
	PUSHR	#^M<R0>			; preserve success status,
	MOVC5	TPA$L_TOKENCNT(AP),-	; copy string to COMMON buffer,
		@TPA$L_TOKENPTR(AP),#^A/ /,#32,CCVPRS_KEYNAM
	MOVW	TPA$L_TOKENCNT(AP),NCVPRS_KEYLEN ; save string length,
	CMPW	TPA$L_TOKENCNT(AP),#32
	BLEQU	90$
	MOVW	#32,NCVPRS_KEYLEN	; adjust if string truncated,
90$:	POPR	#^M<R0>			; restore success status,
	RET				; exit.

	.ENTRY	save_keystate,^M<R2,R3,R4,R5>
	PUSHR	#^M<R0>			; preserve success status,
	MOVC5	TPA$L_TOKENCNT(AP),-	; copy string to COMMON buffer,
		@TPA$L_TOKENPTR(AP),#^A/ /,#32,CCVPRS_STATENAM
	MOVW	TPA$L_TOKENCNT(AP),NCVPRS_STATELEN ; save string length,
	CMPW	TPA$L_TOKENCNT(AP),#32
	BLEQU	90$
	MOVW	#32,NCVPRS_STATELEN	; adjust if string truncated,
90$:	POPR	#^M<R0>			; restore success status,
	RET				; exit.

	.ENTRY	clear_mask,^M<>
	BICL2	TPA$L_PARAM(AP),ICVPRS_NUMBER ; remove all set flags from subexp
	RET				; exit.

	.SBTTL	Internet Real Host Name Fetcher

	.ENTRY	SETUP_HOSTADDR_CALL,^M<>
	CLRL	HOSTADDR_VECTOR
	PUSHAL	HOSTADDR_VECTOR		; attempt to link up to socket library,
	PUSHAQ	@8(AP)
	PUSHAQ	@4(AP)
	CALLS	#3,G^LIB$FIND_IMAGE_SYMBOL
	BLBC	R0,99$			; exit if first try failed,
	CLRL	NETOF_VECTOR
	PUSHAL	NETOF_VECTOR		; attempt to link up to socket library,
	PUSHAQ	@12(AP)
	PUSHAQ	@4(AP)
	CALLS	#3,G^LIB$FIND_IMAGE_SYMBOL
	BLBC	R0,99$			; exit if second try failed,
	CLRL	NETADDR_VECTOR
	TSTW	@16(AP)			; test if any procedure name was passed,
	BEQL	99$			; skip last call if not,
	PUSHAL	NETADDR_VECTOR		; attempt to link up to socket library,
	PUSHAQ	@16(AP)
	PUSHAQ	@4(AP)
	CALLS	#3,G^LIB$FIND_IMAGE_SYMBOL
99$:	RET

	.ENTRY	GET_HOST_NAME,^M<R2,R3,R4>
	MOVL	HOSTADDR_VECTOR,R0	; check if address found
	BEQL	99$			; skip out if not
	PUSHL	#2			; hopefully AF_INET
	PUSHL	#4			; length of binary address
	PUSHAB	@4(AP)			; address buffer
	CALLS	#3,(R0)			; call GETHOSTBYADDR
	TSTL	R0			; check the result
	BEQL	99$			; skip out if nothing
	PUSHL	R0			; else preserve structure address,
	MOVL	(R0),R1			; get pointer to official name,
	TSTB	(R1)			; test if any name,
	BEQL	98$			; skip out if not,
	MOVQ	@8(AP),R3		; else load descriptor of string buffer,
	MOVZWL	R3,R2			; load maximum length count,
50$:	MOVB	(R1)+,(R4)+		; copy next byte of name,
	BEQL	60$			; skip out if end of string,
	SOBGTR	R2,50$			; decrement maximum count and loop,
60$:	SUBW3	R2,R3,@12(AP)		; compute stored length of string,
	MOVL	NETOF_VECTOR,R0		; test if address found,
	BEQL	98$
	PUSHAB	@4(AP)			; extract network number,
	CALLS	#1,(R0)
	MOVL	NETADDR_VECTOR,R1	; test if address found,
	BEQL	98$
	PUSHL	R0			; convert network number to name,
	CALLS	#1,(R1)
	TSTL	R0			; check the result
	BEQL	98$			; skip out if nothing
	MOVL	(R0),R1			; get pointer to official name,
	TSTB	(R1)			; test if any name,
	BEQL	98$			; skip out if not,
	DECL	R2
	BLEQ	98$			; skip out if no room for more,
	MOVB	#^A/./,(R4)+		; add separating period,
70$:	MOVB	(R1)+,(R4)+		; copy next byte of name,
	BEQL	80$			; skip out if end of string,
	SOBGTR	R2,70$			; decrement maximum count and loop,
80$:	SUBW3	R2,R3,@12(AP)		; compute stored length of string,
98$:	MOVL	(SP)+,R0		; restore R0,
99$:	RET

	.END