-- SaffronATDef.mesa
 -- Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
 -- Generated by hederman.pa at August 17, 1987 4:32:54 pm PDT
 --  using ThreeCasabaFour [1.2] of June 1, 1987 6:00:00 pm PDT

DIRECTORY
	SaffronTreeDeclsDef,
	SaffronBaseDef;

SaffronATDef: CEDAR DEFINITIONS = 
BEGIN
OPEN SaffronTreeDeclsDef, SaffronBaseDef;
fooProcType:	TYPE = PROC[REF ANY] RETURNS[INT];

ExpPTreeVal:	PROC[ExpNode] RETURNS[ExpPTreeNode];

ScopePTreeVal:	PROC[ScopeNode] RETURNS[ScopePTreeNode];

ScopeVal:	PROC[ScopePTreeNode] RETURNS[ScopeNode];

ModulePVal:	PROC[ModulePPTreeNode] RETURNS[ModulePNode];

DefBodyPTreeVal:	PROC[DefBodyNode] RETURNS[DefBodyPTreeNode];

DefBodyVal:	PROC[DefBodyPTreeNode] RETURNS[DefBodyNode];


--Top

TopNode:	TYPE = REF TopNodeBody;
TopNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TopNodeProcs,
	data:	REF ANY];

TopNodeProcs:	TYPE = REF TopNodeProcsBody;
TopNodeProcsBody:	TYPE = RECORD[

	DoTop:	DoTopProcType, 
	Explore:	ExploreProcType];


--ModuleP

ModulePNode:	TYPE = REF ModulePNodeBody;
ModulePNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ModulePNodeProcs,
	data:	REF ANY];

ModulePNodeProcs:	TYPE = REF ModulePNodeProcsBody;
ModulePNodeProcsBody:	TYPE = RECORD[

	MakeEnvironment:	MakeEnvironmentProcType, 
	Explore:	ExploreProcType];


--Directory

DirectoryNode:	TYPE = REF DirectoryNodeBody;
DirectoryNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DirectoryNodeProcs,
	data:	REF ANY];

DirectoryNodeProcs:	TYPE = REF DirectoryNodeProcsBody;
DirectoryNodeProcsBody:	TYPE = RECORD[

	ProcessDirectoryClause:	ProcessDirectoryClauseProcType, 
	ExploreDirectoryClause:	ExploreDirectoryClauseProcType];


--IncludeItem

IncludeItemNode:	TYPE = REF IncludeItemNodeBody;
IncludeItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	IncludeItemNodeProcs,
	data:	REF ANY];

IncludeItemNodeProcs:	TYPE = REF IncludeItemNodeProcsBody;
IncludeItemNodeProcsBody:	TYPE = RECORD[

	ProcessDirectoryClause:	ProcessDirectoryClauseProcType, 
	ExploreDirectoryClause:	ExploreDirectoryClauseProcType];


--Using

UsingNode:	TYPE = REF UsingNodeBody;
UsingNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	UsingNodeProcs,
	data:	REF ANY];

UsingNodeProcs:	TYPE = REF UsingNodeProcsBody;
UsingNodeProcsBody:	TYPE = RECORD[

	MakeInterfaceTGN:	MakeInterfaceTGNProcType];


--DefBody

DefBodyNode:	TYPE = REF DefBodyNodeBody;
DefBodyNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DefBodyNodeProcs,
	data:	REF ANY];

DefBodyNodeProcs:	TYPE = REF DefBodyNodeProcsBody;
DefBodyNodeProcsBody:	TYPE = RECORD[

	MakeContextTree:	MakeContextTreeProcType, 
	MakeContextTree1:	MakeContextTree1ProcType];


--DefHead

DefHeadNode:	TYPE = REF DefHeadNodeBody;
DefHeadNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DefHeadNodeProcs,
	data:	REF ANY];

DefHeadNodeProcs:	TYPE = REF DefHeadNodeProcsBody;
DefHeadNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Cedar

CedarNode:	TYPE = REF CedarNodeBody;
CedarNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	CedarNodeProcs,
	data:	REF ANY];

CedarNodeProcs:	TYPE = REF CedarNodeProcsBody;
CedarNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ProgHead

ProgHeadNode:	TYPE = REF ProgHeadNodeBody;
ProgHeadNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ProgHeadNodeProcs,
	data:	REF ANY];

ProgHeadNodeProcs:	TYPE = REF ProgHeadNodeProcsBody;
ProgHeadNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Class

ClassNode:	TYPE = REF ClassNodeBody;
ClassNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ClassNodeProcs,
	data:	REF ANY];

ClassNodeProcs:	TYPE = REF ClassNodeProcsBody;
ClassNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Interface

InterfaceNode:	TYPE = REF InterfaceNodeBody;
InterfaceNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	InterfaceNodeProcs,
	data:	REF ANY];

InterfaceNodeProcs:	TYPE = REF InterfaceNodeProcsBody;
InterfaceNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ModuleList

ModuleListNode:	TYPE = REF ModuleListNodeBody;
ModuleListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ModuleListNodeProcs,
	data:	REF ANY];

ModuleListNodeProcs:	TYPE = REF ModuleListNodeProcsBody;
ModuleListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ModuleItem

ModuleItemNode:	TYPE = REF ModuleItemNodeBody;
ModuleItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ModuleItemNodeProcs,
	data:	REF ANY];

ModuleItemNodeProcs:	TYPE = REF ModuleItemNodeProcsBody;
ModuleItemNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Lambda

LambdaNode:	TYPE = REF LambdaNodeBody;
LambdaNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	LambdaNodeProcs,
	data:	REF ANY];

LambdaNodeProcs:	TYPE = REF LambdaNodeProcsBody;
LambdaNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Locks

LocksNode:	TYPE = REF LocksNodeBody;
LocksNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	LocksNodeProcs,
	data:	REF ANY];

LocksNodeProcs:	TYPE = REF LocksNodeProcsBody;
LocksNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Shares

SharesNode:	TYPE = REF SharesNodeBody;
SharesNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SharesNodeProcs,
	data:	REF ANY];

SharesNodeProcs:	TYPE = REF SharesNodeProcsBody;
SharesNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Entry

EntryNode:	TYPE = REF EntryNodeBody;
EntryNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	EntryNodeProcs,
	data:	REF ANY];

EntryNodeProcs:	TYPE = REF EntryNodeProcsBody;
EntryNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Inline

InlineNode:	TYPE = REF InlineNodeBody;
InlineNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	InlineNodeProcs,
	data:	REF ANY];

InlineNodeProcs:	TYPE = REF InlineNodeProcsBody;
InlineNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--OptSize

OptSizeNode:	TYPE = REF OptSizeNodeBody;
OptSizeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OptSizeNodeProcs,
	data:	REF ANY];

OptSizeNodeProcs:	TYPE = REF OptSizeNodeProcsBody;
OptSizeNodeProcsBody:	TYPE = RECORD[

	GetExpVal:	GetExpValProcType];


--OptType

OptTypeNode:	TYPE = REF OptTypeNodeBody;
OptTypeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OptTypeNodeProcs,
	data:	REF ANY];

OptTypeNodeProcs:	TYPE = REF OptTypeNodeProcsBody;
OptTypeNodeProcsBody:	TYPE = RECORD[

	MakeType:	MakeTypeProcType];


--BindList

BindListNode:	TYPE = REF BindListNodeBody;
BindListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	BindListNodeProcs,
	data:	REF ANY];

BindListNodeProcs:	TYPE = REF BindListNodeProcsBody;
BindListNodeProcsBody:	TYPE = RECORD[

	MakeBindListContextTreeWithScope:	MakeBindListContextTreeWithScopeProcType, 
	MakeBindListContextTreeWithDefBody:	MakeBindListContextTreeWithDefBodyProcType, 
	UpdateLocalContext:	UpdateLocalContextProcType];


--Uncounted

UncountedNode:	TYPE = REF UncountedNodeBody;
UncountedNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	UncountedNodeProcs,
	data:	REF ANY];

UncountedNodeProcs:	TYPE = REF UncountedNodeProcsBody;
UncountedNodeProcsBody:	TYPE = RECORD[

	GetBooleanVal:	GetBooleanValProcType];


--MachineDependent

MachineDependentNode:	TYPE = REF MachineDependentNodeBody;
MachineDependentNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	MachineDependentNodeProcs,
	data:	REF ANY];

MachineDependentNodeProcs:	TYPE = REF MachineDependentNodeProcsBody;
MachineDependentNodeProcsBody:	TYPE = RECORD[

	GetBooleanVal:	GetBooleanValProcType];


--Monitored

MonitoredNode:	TYPE = REF MonitoredNodeBody;
MonitoredNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	MonitoredNodeProcs,
	data:	REF ANY];

MonitoredNodeProcs:	TYPE = REF MonitoredNodeProcsBody;
MonitoredNodeProcsBody:	TYPE = RECORD[

	GetBooleanVal:	GetBooleanValProcType];


--ElementList

ElementListNode:	TYPE = REF ElementListNodeBody;
ElementListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ElementListNodeProcs,
	data:	REF ANY];

ElementListNodeProcs:	TYPE = REF ElementListNodeProcsBody;
ElementListNodeProcsBody:	TYPE = RECORD[

	MakeElementList:	MakeElementListProcType];


--Element

ElementNode:	TYPE = REF ElementNodeBody;
ElementNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ElementNodeProcs,
	data:	REF ANY];

ElementNodeProcs:	TYPE = REF ElementNodeProcsBody;
ElementNodeProcsBody:	TYPE = RECORD[

	ElementInfo:	ElementInfoProcType];


--RecList

RecListNode:	TYPE = REF RecListNodeBody;
RecListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	RecListNodeProcs,
	data:	REF ANY];

RecListNodeProcs:	TYPE = REF RecListNodeProcsBody;
RecListNodeProcsBody:	TYPE = RECORD[

	MakeFieldList:	MakeFieldListProcType];


--PairList

PairListNode:	TYPE = REF PairListNodeBody;
PairListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	PairListNodeProcs,
	data:	REF ANY];

PairListNodeProcs:	TYPE = REF PairListNodeProcsBody;
PairListNodeProcsBody:	TYPE = RECORD[

	AddPairsToFieldList:	AddPairsToFieldListProcType];


--PairItem

PairItemNode:	TYPE = REF PairItemNodeBody;
PairItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	PairItemNodeProcs,
	data:	REF ANY];

PairItemNodeProcs:	TYPE = REF PairItemNodeProcsBody;
PairItemNodeProcsBody:	TYPE = RECORD[

	AddPairsToFieldList:	AddPairsToFieldListProcType];


--TypeList

TypeListNode:	TYPE = REF TypeListNodeBody;
TypeListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TypeListNodeProcs,
	data:	REF ANY];

TypeListNodeProcs:	TYPE = REF TypeListNodeProcsBody;
TypeListNodeProcsBody:	TYPE = RECORD[

	AddToFieldList:	AddToFieldListProcType];


--TypeItem

TypeItemNode:	TYPE = REF TypeItemNodeBody;
TypeItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TypeItemNodeProcs,
	data:	REF ANY];

TypeItemNodeProcs:	TYPE = REF TypeItemNodeProcsBody;
TypeItemNodeProcsBody:	TYPE = RECORD[

	AddToFieldList:	AddToFieldListProcType];


--IdentList

IdentListNode:	TYPE = REF IdentListNodeBody;
IdentListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	IdentListNodeProcs,
	data:	REF ANY];

IdentListNodeProcs:	TYPE = REF IdentListNodeProcsBody;
IdentListNodeProcsBody:	TYPE = RECORD[

	AddNamesToFieldList:	AddNamesToFieldListProcType, 
	PutNewNamesInLocalContext1:	PutNewNamesInLocalContext1ProcType, 
	RecAddArcsfromLVTGNtoTGN:	RecAddArcsfromLVTGNtoTGNProcType, 
	MakeNameSequence:	MakeNameSequenceProcType, 
	AddNamesToSequence:	AddNamesToSequenceProcType];


--Tag

TagNode:	TYPE = REF TagNodeBody;
TagNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TagNodeProcs,
	data:	REF ANY];

TagNodeProcs:	TYPE = REF TagNodeProcsBody;
TagNodeProcsBody:	TYPE = RECORD[

	MakeVariantFlavor:	MakeVariantFlavorProcType, 
	MakeTagType:	MakeTagTypeProcType, 
	GetSequenceTagInfo:	GetSequenceTagInfoProcType];


--TagType

TagTypeNode:	TYPE = REF TagTypeNodeBody;
TagTypeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TagTypeNodeProcs,
	data:	REF ANY];

TagTypeNodeProcs:	TYPE = REF TagTypeNodeProcsBody;
TagTypeNodeProcsBody:	TYPE = RECORD[

	MakeTagType:	MakeTagTypeProcType];


--VariantList

VariantListNode:	TYPE = REF VariantListNodeBody;
VariantListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	VariantListNodeProcs,
	data:	REF ANY];

VariantListNodeProcs:	TYPE = REF VariantListNodeProcsBody;
VariantListNodeProcsBody:	TYPE = RECORD[

	MakeUnionList:	MakeUnionListProcType, 
	AddVariantsToUnionList:	AddVariantsToUnionListProcType, 
	MakeStarTagType:	MakeStarTagTypeProcType, 
	AddVariantNamesToEnumTypeTGN:	AddVariantNamesToEnumTypeTGNProcType];


--VariantItem

VariantItemNode:	TYPE = REF VariantItemNodeBody;
VariantItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	VariantItemNodeProcs,
	data:	REF ANY];

VariantItemNodeProcs:	TYPE = REF VariantItemNodeProcsBody;
VariantItemNodeProcsBody:	TYPE = RECORD[

	AddVariantsToUnionList:	AddVariantsToUnionListProcType, 
	AddVariantNamesToEnumTypeTGN:	AddVariantNamesToEnumTypeTGNProcType];


--Packed

PackedNode:	TYPE = REF PackedNodeBody;
PackedNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	PackedNodeProcs,
	data:	REF ANY];

PackedNodeProcs:	TYPE = REF PackedNodeProcsBody;
PackedNodeProcsBody:	TYPE = RECORD[

	GetBooleanVal:	GetBooleanValProcType];


--Ordered

OrderedNode:	TYPE = REF OrderedNodeBody;
OrderedNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OrderedNodeProcs,
	data:	REF ANY];

OrderedNodeProcs:	TYPE = REF OrderedNodeProcsBody;
OrderedNodeProcsBody:	TYPE = RECORD[

	GetBooleanVal:	GetBooleanValProcType];


--Base

BaseNode:	TYPE = REF BaseNodeBody;
BaseNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	BaseNodeProcs,
	data:	REF ANY];

BaseNodeProcs:	TYPE = REF BaseNodeProcsBody;
BaseNodeProcsBody:	TYPE = RECORD[

	GetBooleanVal:	GetBooleanValProcType];


--PointerType

PointerTypeNode:	TYPE = REF PointerTypeNodeBody;
PointerTypeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	PointerTypeNodeProcs,
	data:	REF ANY];

PointerTypeNodeProcs:	TYPE = REF PointerTypeNodeProcsBody;
PointerTypeNodeProcsBody:	TYPE = RECORD[

	GetPointerTypeInfo:	GetPointerTypeInfoProcType];


--OptInterval

OptIntervalNode:	TYPE = REF OptIntervalNodeBody;
OptIntervalNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OptIntervalNodeProcs,
	data:	REF ANY];

OptIntervalNodeProcs:	TYPE = REF OptIntervalNodeProcsBody;
OptIntervalNodeProcsBody:	TYPE = RECORD[

	GetBoundsVal:	GetBoundsValProcType];


--DecList

DecListNode:	TYPE = REF DecListNodeBody;
DecListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DecListNodeProcs,
	data:	REF ANY];

DecListNodeProcs:	TYPE = REF DecListNodeProcsBody;
DecListNodeProcsBody:	TYPE = RECORD[

	UpdateLocalContext:	UpdateLocalContextProcType, 
	PutNewNamesInLocalContext:	PutNewNamesInLocalContextProcType, 
	FillInLocalContext:	FillInLocalContextProcType, 
	HangContextsFromContextTree:	HangContextsFromContextTreeProcType];


--Declaration

DeclarationNode:	TYPE = REF DeclarationNodeBody;
DeclarationNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DeclarationNodeProcs,
	data:	REF ANY];

DeclarationNodeProcs:	TYPE = REF DeclarationNodeProcsBody;
DeclarationNodeProcsBody:	TYPE = RECORD[

	PutNewNamesInLocalContext:	PutNewNamesInLocalContextProcType, 
	FillInLocalContext:	FillInLocalContextProcType, 
	HangContextsFromContextTree:	HangContextsFromContextTreeProcType];


--OptDecList

OptDecListNode:	TYPE = REF OptDecListNodeBody;
OptDecListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OptDecListNodeProcs,
	data:	REF ANY];

OptDecListNodeProcs:	TYPE = REF OptDecListNodeProcsBody;
OptDecListNodeProcsBody:	TYPE = RECORD[

	UpdateLocalContext:	UpdateLocalContextProcType, 
	HangContextsFromContextTree:	HangContextsFromContextTreeProcType];


--DescList

DescListNode:	TYPE = REF DescListNodeBody;
DescListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DescListNodeProcs,
	data:	REF ANY];

DescListNodeProcs:	TYPE = REF DescListNodeProcsBody;
DescListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Initialization

InitializationNode:	TYPE = REF InitializationNodeBody;
InitializationNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	InitializationNodeProcs,
	data:	REF ANY];

InitializationNodeProcs:	TYPE = REF InitializationNodeProcsBody;
InitializationNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--InitialValue

InitialValueNode:	TYPE = REF InitialValueNodeBody;
InitialValueNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	InitialValueNodeProcs,
	data:	REF ANY];

InitialValueNodeProcs:	TYPE = REF InitialValueNodeProcsBody;
InitialValueNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Scope

ScopeNode:	TYPE = REF ScopeNodeBody;
ScopeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ScopeNodeProcs,
	data:	REF ANY];

ScopeNodeProcs:	TYPE = REF ScopeNodeProcsBody;
ScopeNodeProcsBody:	TYPE = RECORD[

	MakeContextTree:	MakeContextTreeProcType, 
	MakeContextTree1:	MakeContextTree1ProcType];


--Ident

IdentNode:	TYPE = REF IdentNodeBody;
IdentNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	IdentNodeProcs,
	data:	REF ANY];

IdentNodeProcs:	TYPE = REF IdentNodeProcsBody;
IdentNodeProcsBody:	TYPE = RECORD[

	AddNamesToFieldList:	AddNamesToFieldListProcType, 
	PutNewNamesInLocalContext1:	PutNewNamesInLocalContext1ProcType, 
	RecAddArcsfromLVTGNtoTGN:	RecAddArcsfromLVTGNtoTGNProcType, 
	GetIdentInfo:	GetIdentInfoProcType, 
	AddNamesToSequence:	AddNamesToSequenceProcType];


--OptArgs

OptArgsNode:	TYPE = REF OptArgsNodeBody;
OptArgsNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OptArgsNodeProcs,
	data:	REF ANY];

OptArgsNodeProcs:	TYPE = REF OptArgsNodeProcsBody;
OptArgsNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--BindItem

BindItemNode:	TYPE = REF BindItemNodeBody;
BindItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	BindItemNodeProcs,
	data:	REF ANY];

BindItemNodeProcs:	TYPE = REF BindItemNodeProcsBody;
BindItemNodeProcsBody:	TYPE = RECORD[

	UpdateLocalContext:	UpdateLocalContextProcType];


--KeyList

KeyListNode:	TYPE = REF KeyListNodeBody;
KeyListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	KeyListNodeProcs,
	data:	REF ANY];

KeyListNodeProcs:	TYPE = REF KeyListNodeProcsBody;
KeyListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--KeyItem

KeyItemNode:	TYPE = REF KeyItemNodeBody;
KeyItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	KeyItemNodeProcs,
	data:	REF ANY];

KeyItemNodeProcs:	TYPE = REF KeyItemNodeProcsBody;
KeyItemNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Relation

RelationNode:	TYPE = REF RelationNodeBody;
RelationNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	RelationNodeProcs,
	data:	REF ANY];

RelationNodeProcs:	TYPE = REF RelationNodeProcsBody;
RelationNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Access

AccessNode:	TYPE = REF AccessNodeBody;
AccessNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	AccessNodeProcs,
	data:	REF ANY];

AccessNodeProcs:	TYPE = REF AccessNodeProcsBody;
AccessNodeProcsBody:	TYPE = RECORD[

	GetAccessVal:	GetAccessValProcType];


--Bounds

BoundsNode:	TYPE = REF BoundsNodeBody;
BoundsNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	BoundsNodeProcs,
	data:	REF ANY];

BoundsNodeProcs:	TYPE = REF BoundsNodeProcsBody;
BoundsNodeProcsBody:	TYPE = RECORD[

	GetLowerAndUpper:	GetLowerAndUpperProcType];


--Default

DefaultNode:	TYPE = REF DefaultNodeBody;
DefaultNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DefaultNodeProcs,
	data:	REF ANY];

DefaultNodeProcs:	TYPE = REF DefaultNodeProcsBody;
DefaultNodeProcsBody:	TYPE = RECORD[

	GetDefaultExpVal:	GetDefaultExpValProcType];


--Position

PositionNode:	TYPE = REF PositionNodeBody;
PositionNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	PositionNodeProcs,
	data:	REF ANY];

PositionNodeProcs:	TYPE = REF PositionNodeProcsBody;
PositionNodeProcsBody:	TYPE = RECORD[

	GetPositionVal:	GetPositionValProcType];


--OptBits

OptBitsNode:	TYPE = REF OptBitsNodeBody;
OptBitsNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OptBitsNodeProcs,
	data:	REF ANY];

OptBitsNodeProcs:	TYPE = REF OptBitsNodeProcsBody;
OptBitsNodeProcsBody:	TYPE = RECORD[

	GetBoundsVal:	GetBoundsValProcType];


--Relop

RelopNode:	TYPE = REF RelopNodeBody;
RelopNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	RelopNodeProcs,
	data:	REF ANY];

RelopNodeProcs:	TYPE = REF RelopNodeProcsBody;
RelopNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--RelationTail

RelationTailNode:	TYPE = REF RelationTailNodeBody;
RelationTailNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	RelationTailNodeProcs,
	data:	REF ANY];

RelationTailNodeProcs:	TYPE = REF RelationTailNodeProcsBody;
RelationTailNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ExpList

ExpListNode:	TYPE = REF ExpListNodeBody;
ExpListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ExpListNodeProcs,
	data:	REF ANY];

ExpListNodeProcs:	TYPE = REF ExpListNodeProcsBody;
ExpListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Exp

ExpNode:	TYPE = REF ExpNodeBody;
ExpNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ExpNodeProcs,
	data:	REF ANY];

ExpNodeProcs:	TYPE = REF ExpNodeProcsBody;
ExpNodeProcsBody:	TYPE = RECORD[

	IdVal:	IdValProcType];


--OptExp

OptExpNode:	TYPE = REF OptExpNodeBody;
OptExpNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OptExpNodeProcs,
	data:	REF ANY];

OptExpNodeProcs:	TYPE = REF OptExpNodeProcsBody;
OptExpNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--OrderList

OrderListNode:	TYPE = REF OrderListNodeBody;
OrderListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OrderListNodeProcs,
	data:	REF ANY];

OrderListNodeProcs:	TYPE = REF OrderListNodeProcsBody;
OrderListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--MultOp

MultOpNode:	TYPE = REF MultOpNodeBody;
MultOpNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	MultOpNodeProcs,
	data:	REF ANY];

MultOpNodeProcs:	TYPE = REF MultOpNodeProcsBody;
MultOpNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--AddOp

AddOpNode:	TYPE = REF AddOpNodeBody;
AddOpNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	AddOpNodeProcs,
	data:	REF ANY];

AddOpNodeProcs:	TYPE = REF AddOpNodeProcsBody;
AddOpNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ReadOnly

ReadOnlyNode:	TYPE = REF ReadOnlyNodeBody;
ReadOnlyNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ReadOnlyNodeProcs,
	data:	REF ANY];

ReadOnlyNodeProcs:	TYPE = REF ReadOnlyNodeProcsBody;
ReadOnlyNodeProcsBody:	TYPE = RECORD[

	GetBooleanVal:	GetBooleanValProcType];


--CatchAny

CatchAnyNode:	TYPE = REF CatchAnyNodeBody;
CatchAnyNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	CatchAnyNodeProcs,
	data:	REF ANY];

CatchAnyNodeProcs:	TYPE = REF CatchAnyNodeProcsBody;
CatchAnyNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Interval

IntervalNode:	TYPE = REF IntervalNodeBody;
IntervalNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	IntervalNodeProcs,
	data:	REF ANY];

IntervalNodeProcs:	TYPE = REF IntervalNodeProcsBody;
IntervalNodeProcsBody:	TYPE = RECORD[

	GetBoundsVal:	GetBoundsValProcType];


--SelectExpList

SelectExpListNode:	TYPE = REF SelectExpListNodeBody;
SelectExpListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SelectExpListNodeProcs,
	data:	REF ANY];

SelectExpListNodeProcs:	TYPE = REF SelectExpListNodeProcsBody;
SelectExpListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--SelectExpItem

SelectExpItemNode:	TYPE = REF SelectExpItemNodeBody;
SelectExpItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SelectExpItemNodeProcs,
	data:	REF ANY];

SelectExpItemNodeProcs:	TYPE = REF SelectExpItemNodeProcsBody;
SelectExpItemNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--TypeId

TypeIdNode:	TYPE = REF TypeIdNodeBody;
TypeIdNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TypeIdNodeProcs,
	data:	REF ANY];

TypeIdNodeProcs:	TYPE = REF TypeIdNodeProcsBody;
TypeIdNodeProcsBody:	TYPE = RECORD[

	MakeType:	MakeTypeProcType, 
	LookupTypeId:	LookupTypeIdProcType];


--TypeApply

TypeApplyNode:	TYPE = REF TypeApplyNodeBody;
TypeApplyNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TypeApplyNodeProcs,
	data:	REF ANY];

TypeApplyNodeProcs:	TYPE = REF TypeApplyNodeProcsBody;
TypeApplyNodeProcsBody:	TYPE = RECORD[

	MakeType:	MakeTypeProcType];


--Range

RangeNode:	TYPE = REF RangeNodeBody;
RangeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	RangeNodeProcs,
	data:	REF ANY];

RangeNodeProcs:	TYPE = REF RangeNodeProcsBody;
RangeNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--PrefixOp

PrefixOpNode:	TYPE = REF PrefixOpNodeBody;
PrefixOpNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	PrefixOpNodeProcs,
	data:	REF ANY];

PrefixOpNodeProcs:	TYPE = REF PrefixOpNodeProcsBody;
PrefixOpNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--New

NewNode:	TYPE = REF NewNodeBody;
NewNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	NewNodeProcs,
	data:	REF ANY];

NewNodeProcs:	TYPE = REF NewNodeProcsBody;
NewNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Free

FreeNode:	TYPE = REF FreeNodeBody;
FreeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	FreeNodeProcs,
	data:	REF ANY];

FreeNodeProcs:	TYPE = REF FreeNodeProcsBody;
FreeNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Cons

ConsNode:	TYPE = REF ConsNodeBody;
ConsNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ConsNodeProcs,
	data:	REF ANY];

ConsNodeProcs:	TYPE = REF ConsNodeProcsBody;
ConsNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ListCons

ListConsNode:	TYPE = REF ListConsNodeBody;
ListConsNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ListConsNodeProcs,
	data:	REF ANY];

ListConsNodeProcs:	TYPE = REF ListConsNodeProcsBody;
ListConsNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Safe

SafeNode:	TYPE = REF SafeNodeBody;
SafeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SafeNodeProcs,
	data:	REF ANY];

SafeNodeProcs:	TYPE = REF SafeNodeProcsBody;
SafeNodeProcsBody:	TYPE = RECORD[

	GetBooleanVal:	GetBooleanValProcType];


--TransferMode

TransferModeNode:	TYPE = REF TransferModeNodeBody;
TransferModeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TransferModeNodeProcs,
	data:	REF ANY];

TransferModeNodeProcs:	TYPE = REF TransferModeNodeProcsBody;
TransferModeNodeProcsBody:	TYPE = RECORD[

	MakeTransferMode:	MakeTransferModeProcType];


--ExitItem

ExitItemNode:	TYPE = REF ExitItemNodeBody;
ExitItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ExitItemNodeProcs,
	data:	REF ANY];

ExitItemNodeProcs:	TYPE = REF ExitItemNodeProcsBody;
ExitItemNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--SelectHead

SelectHeadNode:	TYPE = REF SelectHeadNodeBody;
SelectHeadNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SelectHeadNodeProcs,
	data:	REF ANY];

SelectHeadNodeProcs:	TYPE = REF SelectHeadNodeProcsBody;
SelectHeadNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--SelectStmtList

SelectStmtListNode:	TYPE = REF SelectStmtListNodeBody;
SelectStmtListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SelectStmtListNodeProcs,
	data:	REF ANY];

SelectStmtListNodeProcs:	TYPE = REF SelectStmtListNodeProcsBody;
SelectStmtListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--SelectStmtItem

SelectStmtItemNode:	TYPE = REF SelectStmtItemNodeBody;
SelectStmtItemNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SelectStmtItemNodeProcs,
	data:	REF ANY];

SelectStmtItemNodeProcs:	TYPE = REF SelectStmtItemNodeProcsBody;
SelectStmtItemNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ForClause

ForClauseNode:	TYPE = REF ForClauseNodeBody;
ForClauseNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ForClauseNodeProcs,
	data:	REF ANY];

ForClauseNodeProcs:	TYPE = REF ForClauseNodeProcsBody;
ForClauseNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ControlId

ControlIdNode:	TYPE = REF ControlIdNodeBody;
ControlIdNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ControlIdNodeProcs,
	data:	REF ANY];

ControlIdNodeProcs:	TYPE = REF ControlIdNodeProcsBody;
ControlIdNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Decreasing

DecreasingNode:	TYPE = REF DecreasingNodeBody;
DecreasingNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DecreasingNodeProcs,
	data:	REF ANY];

DecreasingNodeProcs:	TYPE = REF DecreasingNodeProcsBody;
DecreasingNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Transfer

TransferNode:	TYPE = REF TransferNodeBody;
TransferNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TransferNodeProcs,
	data:	REF ANY];

TransferNodeProcs:	TYPE = REF TransferNodeProcsBody;
TransferNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--SelectLabel

SelectLabelNode:	TYPE = REF SelectLabelNodeBody;
SelectLabelNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SelectLabelNodeProcs,
	data:	REF ANY];

SelectLabelNodeProcs:	TYPE = REF SelectLabelNodeProcsBody;
SelectLabelNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--SelectTestList

SelectTestListNode:	TYPE = REF SelectTestListNodeBody;
SelectTestListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SelectTestListNodeProcs,
	data:	REF ANY];

SelectTestListNodeProcs:	TYPE = REF SelectTestListNodeProcsBody;
SelectTestListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Block

BlockNode:	TYPE = REF BlockNodeBody;
BlockNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	BlockNodeProcs,
	data:	REF ANY];

BlockNodeProcs:	TYPE = REF BlockNodeProcsBody;
BlockNodeProcsBody:	TYPE = RECORD[

	HangContextsFromContextTree:	HangContextsFromContextTreeProcType];


--Checked

CheckedNode:	TYPE = REF CheckedNodeBody;
CheckedNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	CheckedNodeProcs,
	data:	REF ANY];

CheckedNodeProcs:	TYPE = REF CheckedNodeProcsBody;
CheckedNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--CodeList

CodeListNode:	TYPE = REF CodeListNodeBody;
CodeListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	CodeListNodeProcs,
	data:	REF ANY];

CodeListNodeProcs:	TYPE = REF CodeListNodeProcsBody;
CodeListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Statement

StatementNode:	TYPE = REF StatementNodeBody;
StatementNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	StatementNodeProcs,
	data:	REF ANY];

StatementNodeProcs:	TYPE = REF StatementNodeProcsBody;
StatementNodeProcsBody:	TYPE = RECORD[

	HangContextsFromContextTree:	HangContextsFromContextTreeProcType];


--OptStatement

OptStatementNode:	TYPE = REF OptStatementNodeBody;
OptStatementNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	OptStatementNodeProcs,
	data:	REF ANY];

OptStatementNodeProcs:	TYPE = REF OptStatementNodeProcsBody;
OptStatementNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--StatementList

StatementListNode:	TYPE = REF StatementListNodeBody;
StatementListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	StatementListNodeProcs,
	data:	REF ANY];

StatementListNodeProcs:	TYPE = REF StatementListNodeProcsBody;
StatementListNodeProcsBody:	TYPE = RECORD[

	HangContextsFromContextTree:	HangContextsFromContextTreeProcType];


--DoTest

DoTestNode:	TYPE = REF DoTestNodeBody;
DoTestNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DoTestNodeProcs,
	data:	REF ANY];

DoTestNodeProcs:	TYPE = REF DoTestNodeProcsBody;
DoTestNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--DoExit

DoExitNode:	TYPE = REF DoExitNodeBody;
DoExitNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	DoExitNodeProcs,
	data:	REF ANY];

DoExitNodeProcs:	TYPE = REF DoExitNodeProcsBody;
DoExitNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--TransferOp

TransferOpNode:	TYPE = REF TransferOpNodeBody;
TransferOpNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TransferOpNodeProcs,
	data:	REF ANY];

TransferOpNodeProcs:	TYPE = REF TransferOpNodeProcsBody;
TransferOpNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Catch

CatchNode:	TYPE = REF CatchNodeBody;
CatchNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	CatchNodeProcs,
	data:	REF ANY];

CatchNodeProcs:	TYPE = REF CatchNodeProcsBody;
CatchNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--CatchCase

CatchCaseNode:	TYPE = REF CatchCaseNodeBody;
CatchCaseNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	CatchCaseNodeProcs,
	data:	REF ANY];

CatchCaseNodeProcs:	TYPE = REF CatchCaseNodeProcsBody;
CatchCaseNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--CatchCaseList

CatchCaseListNode:	TYPE = REF CatchCaseListNodeBody;
CatchCaseListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	CatchCaseListNodeProcs,
	data:	REF ANY];

CatchCaseListNodeProcs:	TYPE = REF CatchCaseListNodeProcsBody;
CatchCaseListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--TypeOp

TypeOpNode:	TYPE = REF TypeOpNodeBody;
TypeOpNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TypeOpNodeProcs,
	data:	REF ANY];

TypeOpNodeProcs:	TYPE = REF TypeOpNodeProcsBody;
TypeOpNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--IdList

IdListNode:	TYPE = REF IdListNodeBody;
IdListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	IdListNodeProcs,
	data:	REF ANY];

IdListNodeProcs:	TYPE = REF IdListNodeProcsBody;
IdListNodeProcsBody:	TYPE = RECORD[

	AddNamesToUnionList:	AddNamesToUnionListProcType, 
	AddVariantNamesToEnumTypeTGN:	AddVariantNamesToEnumTypeTGNProcType, 
	AddIdsToInterfaceTGN:	AddIdsToInterfaceTGNProcType];


--Arguments

ArgumentsNode:	TYPE = REF ArgumentsNodeBody;
ArgumentsNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ArgumentsNodeProcs,
	data:	REF ANY];

ArgumentsNodeProcs:	TYPE = REF ArgumentsNodeProcsBody;
ArgumentsNodeProcsBody:	TYPE = RECORD[

	MakeArgumentLists:	MakeArgumentListsProcType];


--ParameterList

ParameterListNode:	TYPE = REF ParameterListNodeBody;
ParameterListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ParameterListNodeProcs,
	data:	REF ANY];

ParameterListNodeProcs:	TYPE = REF ParameterListNodeProcsBody;
ParameterListNodeProcsBody:	TYPE = RECORD[

	MakeFieldList:	MakeFieldListProcType];


--TypeExp

TypeExpNode:	TYPE = REF TypeExpNodeBody;
TypeExpNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	TypeExpNodeProcs,
	data:	REF ANY];

TypeExpNodeProcs:	TYPE = REF TypeExpNodeProcsBody;
TypeExpNodeProcsBody:	TYPE = RECORD[

	MakeType:	MakeTypeProcType];


--Num

NumNode:	TYPE = REF NumNodeBody;
NumNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	NumNodeProcs,
	data:	REF ANY];

NumNodeProcs:	TYPE = REF NumNodeProcsBody;
NumNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Qualifier

QualifierNode:	TYPE = REF QualifierNodeBody;
QualifierNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	QualifierNodeProcs,
	data:	REF ANY];

QualifierNodeProcs:	TYPE = REF QualifierNodeProcsBody;
QualifierNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--SignalList

SignalListNode:	TYPE = REF SignalListNodeBody;
SignalListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SignalListNodeProcs,
	data:	REF ANY];

SignalListNodeProcs:	TYPE = REF SignalListNodeProcsBody;
SignalListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--ExitList

ExitListNode:	TYPE = REF ExitListNodeBody;
ExitListNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	ExitListNodeProcs,
	data:	REF ANY];

ExitListNodeProcs:	TYPE = REF ExitListNodeProcsBody;
ExitListNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Junk

JunkNode:	TYPE = REF JunkNodeBody;
JunkNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	JunkNodeProcs,
	data:	REF ANY];

JunkNodeProcs:	TYPE = REF JunkNodeProcsBody;
JunkNodeProcsBody:	TYPE = RECORD[

	foo:	fooProcType];


--Subrange

SubrangeNode:	TYPE = REF SubrangeNodeBody;
SubrangeNodeBody:	TYPE = RECORD[
	position:	INT, length:	INT,
	procs:	SubrangeNodeProcs,
	data:	REF ANY];

SubrangeNodeProcs:	TYPE = REF SubrangeNodeProcsBody;
SubrangeNodeProcsBody:	TYPE = RECORD[

	MakeType:	MakeTypeProcType];

END..