!	CLI Table Blocks
!	Each block begins with a standard header, as follows
!		+------------------------------+
!		| subtype | type |    length   |
!		+------------------------------+
!		| TRO Count      |    Flags    |
!		+------------------------------+
!	all references to other blocks are made via Table relative offsets (TRO)
!	the TRO count specifies how many such references there are, and the
!	reference longwords always follow the header immediately. The rest of
!	each block contains other information necessary for the definition
!	of the item.Following the fixed portion of the block is a variable
!	portion, which contains any variable length strings. Each of these
!	strings is referenced from the fixed portion of the block by a
!	word Block relative offset (BRO)
!	These are the valid block types starting at 1.
!		vector		Vector (root) block
!		command		Command block
!		type		Type block
!		entity		Entity block
!		expression	Expression block
!		cdu_visited	for CDU internal use
!vector block
!	the primary vector block appears at the beginning of a CLI table,
!	and contains references to all other blocks and block lists.
!
! standard header, valid subtypes starting at 1
!	DCL
!	MCR
!	Verb
!	command
! flags - broken into two bytes, low byte contains structure level
!Two TRO's,
! verbtbl	TRO of verb name table
! comdptr	TRO of command block pointer table
!the  verb name table is composed of the standard header, followed by one
! longword for each verb or synonym, the longword contains the first
! four characters of the verb name padded with nulls as necessary
!the command block pointer table is composed of the standard header,
! followed by one longword for each entry in the verb table. This
! longword contains the TRO of the corresponding command block.
!
!command block
!
! a command block is used to define a verb or a syntax change brought about
! by a parameter or qualifier. There is one command block for each verb
! (but not its synonyms), and one for each syntax change within a verb
!
! standard header, valid subtypes starting at 1
!	verb
!	syntax
! flags --bits, starting at zero I guess
!	abbrev
!	nostat
!	foreign
!	immed
!	mcrparse
!	parms
!	quals
!	disallows
!TRO's --
! parms		TRO of first parameter, Entity block
!   max parms=8
! quals		TRO of first qualifier
! disallows	TRO of top-level disallow boolean Expression block
!HANDLER (byte) How does CLI handle verb (starting at 0)
! none	It doesn't
! cli	Calls a cli routine
! user	calls a user routine
! image	imvokes an image
! same	same handling as verb
!PARMCNT Two nibbles (1 byte)
! MINPARM	first four bits
! MAXPARM	second four bits
!VERBTYP (byte) Verb type code for use with old CLI interface
!PAD (byte)
!NAME (word) BRO of verb or syntax name
!IMAGE (word) BRO of routine or image reference
!OUTPUTS (word) BRO of outputs list
!PREFIX (word) BRO of prefix string
!  -- end of fixed portion --
! variable section --
! Max sizes --
! max_name = 1+31
! max_image= 64
! max_outputs=1+7
! max_prefix=1+31
!--folowing the fixed portion, the verb names are stored as a sequence
! of ascic strings within an overall ascic string, or the syntax name is
! stored as a single ascic string.
! the routine or image reference is stored as follows
!	CLI routine	Routine name as ascic string
!	user routine	longword routine address, then ascic string
!	image		ascic string
! outputs list consists of a counted sequence of bytes. each byte contains
! either the negation of the parameter number or the qualifier number
! the prefix string is stored as an ascic string
!
!TYPE block
!
!	a type block is used as a header of a chain of entity blocks
!	that describe TYPE keywords there is one TYPE block for each
!	user specified type definition
!
! standard header, valid subtypes starting at 1
!	type
!no  flags
!TRO ..
! keywrds	TRO of first keyword entity block
!NAME (word)	BRO of type name
!Prefix (word)	BRO of prefix string
!-- end of fixed --
!-- following the fixed portion the type name is stored as ascic string,
! so is the prefix string
!
!Entity block
!
!	an entity block is used to define each parameter, qualifier, and data
!	type keyword. These blocks are liked off the command block for the
!	verb, in the case of parameters and qualifiers, or off of the type
!	block, in the case of type keywords.
!
! standard header, valid subtypes starting at 1
!	parameter
!	qualifier
!	keyword
!flags, bits starting at 0 ..
!	val		can take a value
!	neg		can be replaced with no
!	deftrue		present by default
!	batdef		present by default if batch
!	valreq		a value is required
!	list		can be a list of values
!	concat		can be a concatenated list
!	impcat		implicit concatenated list
!	verb		global placement
!	parm		local placement (both means positional)
!	mcroptdelim	MCR SET UIC kluge
!	mcrignore	MCR ignores this entity
!
!TROs
! NEXT		TRO of next entity block
! SYNTAX	TRO of syntax change command block
! USER_TYPE	TRO of user defined type
!NUMBER (byte) Entity number. Cli should only use for parameters
!VALTYP (byte) Value type, starting at zero,
!	user_defined	defined by user
!	infile		input file spec
!	outfile		output file spec
!	number		decimal integer
!	privilege	priv keyword
!	datetime	date/time
!	protection	protection spec
!	process		process name
!	inlog		input logical name
!	outlog		output logical name
!	insym		input symbol name
!	outsym		output symbol name
!	node		DECnet node spec
!	device		node/device spec
!	dir		node/dev/dir spec
!	uic		UIC spec
!	restofline	rest of command line
!	parenvalue	parenthesized value
!	file		any file spec
!	expression	general DCL expression
!	test1		Three hooks for testing
!	test2
!	test3
!	acl		ACL spec
!NAME (word)	BRO of entity name
!LABEL (word)	BRO of label used to retrieve entity
!PROMPT (word)	BRO of parameter prompt
!DEFVAL (word)	BRO of parameter default value(s)
! --max sizes --
! Name=1+31
! label=1+31
! prompt=1+31
! defval=1+95
!-- end of fixed portion--
!-- following the fixed portion are the Name, Label, Prompt and default values,
! stored as ascic strings. The default values are stored as a sequence of ascic
! strings, within the overall ascic string.
!
!expression block
!
!	an expression block is used to represent, within a boolean expression,
!	one operator and its operands. The operands are themselves expression
!	blocks, either subexpressions or paths. Paths represent the hierarchical
!	path to an entity whose presence is to be determined.
!
! standard header, valid subtypes starting at 1
!	path	entity path
!	not	boolean NOT
!	any2	"	ANY2
!	and	"	AND
!	or	"	OR
!	xor	"	XOR
!	neg	"	NEG
! no flags defined
!TR0 Count
! operand_list character length 0 tag l
!(max 8 entities)