DIRECTORY
	Rope,
	ThreeC4Support;

KipperMain1Def: CEDAR DEFINITIONS = 
BEGIN
OPEN Rope, ThreeC4Support;
KipperMain1LinkProc: PROC[SeeProdLinkArray, TokenLinkArray];

--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];


-- JunkProd

JunkProdData: TYPE = REF JunkProdDataBody;
JunkProdDataBody: TYPE = RECORD[
];

JunkProdProcs: JunkNodeProcs;

BuildJunkProdNode: PROC[position: INT, length: INT]
	RETURNS[JunkNode];

JunkProdfoo: fooProcType;
fooProcType: TYPE = PROC[REF ANY] RETURNS[INT];


--id

idNode: TYPE = REF idNodeBody;
idNodeBody: TYPE = RECORD[
	text: Rope.ROPE,
	position, length: INT];

NameNode: TYPE = REF NameNodeBody;
NameNodeBody: TYPE;

NameSeqNode: TYPE = REF NameSeqNodeBody;
NameSeqNodeBody: TYPE;

BuildName: PROC[idNode] RETURNS[NameNode];

BuildNullName: PROC RETURNS[NameNode];

FakeCopyName: PROC[NameNode] RETURNS[NameNode];

BuildImplModName: PROC[idNode] RETURNS[NameNode];

BuildEmptyNameSeq: PROC RETURNS[NameSeqNode];

AppendToNameSeq: PROC[NameSeqNode, NameNode] RETURNS[NameSeqNode];

PrefixToNameSeq: PROC[NameNode, NameSeqNode] RETURNS[NameSeqNode];

ElementSeqNode: TYPE = REF ElementSeqNodeBody;
ElementSeqNodeBody: TYPE;

BuildEmptyElementSeq: PROC RETURNS[ElementSeqNode];

AppendNameToElementSeq: PROC[ElementSeqNode, NameNode] RETURNS[ElementSeqNode];

TypeNode: TYPE = REF TypeNodeBody;
TypeNodeBody: TYPE;

FieldSeqNode: TYPE = REF FieldSeqNodeBody;
FieldSeqNodeBody: TYPE;

BuildEmptyFieldSeq: PROC RETURNS[FieldSeqNode];

BuildOnePairFieldSeq: PROC[NameSeqNode, TypeNode] RETURNS[FieldSeqNode];

ConcatFieldSeq: PROC[FieldSeqNode, FieldSeqNode] RETURNS[FieldSeqNode];

PrefixTypeToFieldSeq: PROC[TypeNode, FieldSeqNode] RETURNS[FieldSeqNode];

BuildNamedType: PROC[NameSeqNode, NameSeqNode] RETURNS[TypeNode];

BuildEnumeratedType: PROC[ElementSeqNode] RETURNS[TypeNode];

BuildRecordType: PROC[FieldSeqNode] RETURNS[TypeNode];

BuildRefType: PROC[TypeNode] RETURNS[TypeNode];

BuildRefAnyType: PROC RETURNS[TypeNode];

BuildListType: PROC[TypeNode] RETURNS[TypeNode];

BuildSeqType: PROC[NameNode, TypeNode, TypeNode] RETURNS[TypeNode];

TypeContextNode: TYPE = REF TypeContextNodeBody;
TypeContextNodeBody: TYPE;

BuildEmptyTypeContext: PROC[NameNode, NameNode] RETURNS[TypeContextNode];

FakeCopyContext: PROC[TypeContextNode] RETURNS[TypeContextNode];

NoteDefFileName: PROC[TypeContextNode, NameNode] RETURNS[TypeContextNode];

NoteImplFileName: PROC[TypeContextNode, NameNode] RETURNS[TypeContextNode];

RecordTypeDecl: PROC[TypeContextNode, NameNode, NameNode, NameNode, NameSeqNode, TypeNode] RETURNS[TypeContextNode];

LookUpType: PROC[TypeContextNode, NameSeqNode, NameSeqNode] RETURNS[TypeNode];

CloseTypeContext: PROC[TypeContextNode] RETURNS[TypeContextNode];

FormNameProcType: TYPE = PROC[REF ANY] RETURNS[NameNode];

FormNameSeqProcType: TYPE = PROC[REF ANY] RETURNS[NameSeqNode];

FormElementSeqProcType: TYPE = PROC[REF ANY] RETURNS[ElementSeqNode];

FormTypeProcType: TYPE = PROC[REF ANY] RETURNS[TypeNode];

FormFieldSeqProcType: TYPE = PROC[REF ANY] RETURNS[FieldSeqNode];

FormTypeIdDescProcType: TYPE = PROC[REF ANY] RETURNS[NameSeqNode, NameSeqNode];

EnlargeContextProcType: TYPE = PROC[REF ANY, NameNode, NameNode, TypeContextNode] RETURNS[TypeContextNode];

FormContextProcType: TYPE = PROC[REF ANY] RETURNS[TypeContextNode];

FormWhenceFromDeclProcType: TYPE = PROC[REF ANY, NameNode] RETURNS[NameNode];

FormIdProcType: TYPE = PROC[REF ANY] RETURNS[idNode];

FormVCaseHeadProcType: TYPE = PROC[REF ANY] RETURNS[idNode, TypeNode];


--ModuleBody

ModuleBodyNode: TYPE = REF ModuleBodyNodeBody;
ModuleBodyNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: ModuleBodyNodeProcs,
	data: REF ANY];

ModuleBodyNodeProcs: TYPE = REF ModuleBodyNodeProcsBody;
ModuleBodyNodeProcsBody: TYPE = RECORD[

	FormContext: FormContextProcType];


-- ModuleBodyProd

ModuleBodyProdData: TYPE = REF ModuleBodyProdDataBody;
ModuleBodyProdDataBody: TYPE = RECORD[
id: idNode, DecList: DecListNode];

ModuleBodyProdProcs: ModuleBodyNodeProcs;

BuildModuleBodyProdNode: PROC[position: INT, length: INT, id: idNode, DecList: DecListNode]
	RETURNS[ModuleBodyNode];

ModuleBodyProdFormContext: FormContextProcType;

--DecList

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

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

	EnlargeContext: EnlargeContextProcType];


-- DecListoneProd

DecListoneProdData: TYPE = REF DecListoneProdDataBody;
DecListoneProdDataBody: TYPE = RECORD[
Declaration: DeclarationNode];

DecListoneProdProcs: DecListNodeProcs;

BuildDecListoneProdNode: PROC[position: INT, length: INT, Declaration: DeclarationNode]
	RETURNS[DecListNode];

DecListoneProdEnlargeContext: EnlargeContextProcType;

-- DecListmoreProd

DecListmoreProdData: TYPE = REF DecListmoreProdDataBody;
DecListmoreProdDataBody: TYPE = RECORD[
DecList: DecListNode, Declaration: DeclarationNode];

DecListmoreProdProcs: DecListNodeProcs;

BuildDecListmoreProdNode: PROC[position: INT, length: INT, DecList: DecListNode, Declaration: DeclarationNode]
	RETURNS[DecListNode];

DecListmoreProdEnlargeContext: EnlargeContextProcType;

--Declaration

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

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

	EnlargeContext: EnlargeContextProcType];


-- DeclarationtypeProd

DeclarationtypeProdData: TYPE = REF DeclarationtypeProdDataBody;
DeclarationtypeProdDataBody: TYPE = RECORD[
IdListR: IdListRNode, DeclFrom: DeclFromNode, TypeExp: TypeExpNode];

DeclarationtypeProdProcs: DeclarationNodeProcs;

BuildDeclarationtypeProdNode: PROC[position: INT, length: INT, IdListR: IdListRNode, DeclFrom: DeclFromNode, TypeExp: TypeExpNode]
	RETURNS[DeclarationNode];

DeclarationtypeProdEnlargeContext: EnlargeContextProcType;

--DeclFrom

DeclFromNode: TYPE = REF DeclFromNodeBody;
DeclFromNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: DeclFromNodeProcs,
	data: REF ANY];

DeclFromNodeProcs: TYPE = REF DeclFromNodeProcsBody;
DeclFromNodeProcsBody: TYPE = RECORD[

	FormWhenceFromDecl: FormWhenceFromDeclProcType];


-- DeclFrombuiltinProd

DeclFrombuiltinProdData: TYPE = REF DeclFrombuiltinProdDataBody;
DeclFrombuiltinProdDataBody: TYPE = RECORD[
];

DeclFrombuiltinProdProcs: DeclFromNodeProcs;

BuildDeclFrombuiltinProdNode: PROC[position: INT, length: INT]
	RETURNS[DeclFromNode];

DeclFrombuiltinProdFormWhenceFromDecl: FormWhenceFromDeclProcType;

-- DeclFromfromcedardefProd

DeclFromfromcedardefProdData: TYPE = REF DeclFromfromcedardefProdDataBody;
DeclFromfromcedardefProdDataBody: TYPE = RECORD[
id: idNode];

DeclFromfromcedardefProdProcs: DeclFromNodeProcs;

BuildDeclFromfromcedardefProdNode: PROC[position: INT, length: INT, id: idNode]
	RETURNS[DeclFromNode];

DeclFromfromcedardefProdFormWhenceFromDecl: FormWhenceFromDeclProcType;

-- DeclFromnominalProd

DeclFromnominalProdData: TYPE = REF DeclFromnominalProdDataBody;
DeclFromnominalProdDataBody: TYPE = RECORD[
];

DeclFromnominalProdProcs: DeclFromNodeProcs;

BuildDeclFromnominalProdNode: PROC[position: INT, length: INT]
	RETURNS[DeclFromNode];

DeclFromnominalProdFormWhenceFromDecl: FormWhenceFromDeclProcType;

--TypeExp

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

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

	FormType: FormTypeProcType];


-- TypeExptypeidProd

TypeExptypeidProdData: TYPE = REF TypeExptypeidProdDataBody;
TypeExptypeidProdDataBody: TYPE = RECORD[
TypeId: TypeIdNode];

TypeExptypeidProdProcs: TypeExpNodeProcs;

BuildTypeExptypeidProdNode: PROC[position: INT, length: INT, TypeId: TypeIdNode]
	RETURNS[TypeExpNode];

TypeExptypeidProdFormType: FormTypeProcType;

-- TypeExpelementsProd

TypeExpelementsProdData: TYPE = REF TypeExpelementsProdDataBody;
TypeExpelementsProdDataBody: TYPE = RECORD[
ElementList: ElementListNode];

TypeExpelementsProdProcs: TypeExpNodeProcs;

BuildTypeExpelementsProdNode: PROC[position: INT, length: INT, ElementList: ElementListNode]
	RETURNS[TypeExpNode];

TypeExpelementsProdFormType: FormTypeProcType;

-- TypeExprecordProd

TypeExprecordProdData: TYPE = REF TypeExprecordProdDataBody;
TypeExprecordProdDataBody: TYPE = RECORD[
FieldList: FieldListNode];

TypeExprecordProdProcs: TypeExpNodeProcs;

BuildTypeExprecordProdNode: PROC[position: INT, length: INT, FieldList: FieldListNode]
	RETURNS[TypeExpNode];

TypeExprecordProdFormType: FormTypeProcType;

-- TypeExprefProd

TypeExprefProdData: TYPE = REF TypeExprefProdDataBody;
TypeExprefProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode];

TypeExprefProdProcs: TypeExpNodeProcs;

BuildTypeExprefProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode]
	RETURNS[TypeExpNode];

TypeExprefProdFormType: FormTypeProcType;

-- TypeExprefAnyProd

TypeExprefAnyProdData: TYPE = REF TypeExprefAnyProdDataBody;
TypeExprefAnyProdDataBody: TYPE = RECORD[
];

TypeExprefAnyProdProcs: TypeExpNodeProcs;

BuildTypeExprefAnyProdNode: PROC[position: INT, length: INT]
	RETURNS[TypeExpNode];

TypeExprefAnyProdFormType: FormTypeProcType;

-- TypeExplistProd

TypeExplistProdData: TYPE = REF TypeExplistProdDataBody;
TypeExplistProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode];

TypeExplistProdProcs: TypeExpNodeProcs;

BuildTypeExplistProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode]
	RETURNS[TypeExpNode];

TypeExplistProdFormType: FormTypeProcType;

--TypeId

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

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

	FormTypeIdDesc: FormTypeIdDescProcType];


-- TypeIdmodProd

TypeIdmodProdData: TYPE = REF TypeIdmodProdDataBody;
TypeIdmodProdDataBody: TYPE = RECORD[
id: idNode, TypeId: TypeIdNode];

TypeIdmodProdProcs: TypeIdNodeProcs;

BuildTypeIdmodProdNode: PROC[position: INT, length: INT, id: idNode, TypeId: TypeIdNode]
	RETURNS[TypeIdNode];

TypeIdmodProdFormTypeIdDesc: FormTypeIdDescProcType;

-- TypeIdoneProd

TypeIdoneProdData: TYPE = REF TypeIdoneProdDataBody;
TypeIdoneProdDataBody: TYPE = RECORD[
IdListL: IdListLNode];

TypeIdoneProdProcs: TypeIdNodeProcs;

BuildTypeIdoneProdNode: PROC[position: INT, length: INT, IdListL: IdListLNode]
	RETURNS[TypeIdNode];

TypeIdoneProdFormTypeIdDesc: FormTypeIdDescProcType;

--ElementList

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

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

	FormElementSeq: FormElementSeqProcType];


-- ElementListemptyProd

ElementListemptyProdData: TYPE = REF ElementListemptyProdDataBody;
ElementListemptyProdDataBody: TYPE = RECORD[
];

ElementListemptyProdProcs: ElementListNodeProcs;

BuildElementListemptyProdNode: PROC[position: INT, length: INT]
	RETURNS[ElementListNode];

ElementListemptyProdFormElementSeq: FormElementSeqProcType;

-- ElementListmoreProd

ElementListmoreProdData: TYPE = REF ElementListmoreProdDataBody;
ElementListmoreProdDataBody: TYPE = RECORD[
ElementList: ElementListNode, Element: ElementNode];

ElementListmoreProdProcs: ElementListNodeProcs;

BuildElementListmoreProdNode: PROC[position: INT, length: INT, ElementList: ElementListNode, Element: ElementNode]
	RETURNS[ElementListNode];

ElementListmoreProdFormElementSeq: FormElementSeqProcType;

--Element

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

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

	FormName: FormNameProcType];


-- ElementidProd

ElementidProdData: TYPE = REF ElementidProdDataBody;
ElementidProdDataBody: TYPE = RECORD[
id: idNode];

ElementidProdProcs: ElementNodeProcs;

BuildElementidProdNode: PROC[position: INT, length: INT, id: idNode]
	RETURNS[ElementNode];

ElementidProdFormName: FormNameProcType;

--FieldList

FieldListNode: TYPE = REF FieldListNodeBody;
FieldListNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: FieldListNodeProcs,
	data: REF ANY];

FieldListNodeProcs: TYPE = REF FieldListNodeProcsBody;
FieldListNodeProcsBody: TYPE = RECORD[

	FormFieldSeq: FormFieldSeqProcType];


-- FieldListemptyProd

FieldListemptyProdData: TYPE = REF FieldListemptyProdDataBody;
FieldListemptyProdDataBody: TYPE = RECORD[
];

FieldListemptyProdProcs: FieldListNodeProcs;

BuildFieldListemptyProdNode: PROC[position: INT, length: INT]
	RETURNS[FieldListNode];

FieldListemptyProdFormFieldSeq: FormFieldSeqProcType;

-- FieldListnullProd

FieldListnullProdData: TYPE = REF FieldListnullProdDataBody;
FieldListnullProdDataBody: TYPE = RECORD[
];

FieldListnullProdProcs: FieldListNodeProcs;

BuildFieldListnullProdNode: PROC[position: INT, length: INT]
	RETURNS[FieldListNode];

FieldListnullProdFormFieldSeq: FormFieldSeqProcType;

-- FieldListpairsProd

FieldListpairsProdData: TYPE = REF FieldListpairsProdDataBody;
FieldListpairsProdDataBody: TYPE = RECORD[
PairList: PairListNode];

FieldListpairsProdProcs: FieldListNodeProcs;

BuildFieldListpairsProdNode: PROC[position: INT, length: INT, PairList: PairListNode]
	RETURNS[FieldListNode];

FieldListpairsProdFormFieldSeq: FormFieldSeqProcType;

-- FieldListvpairsProd

FieldListvpairsProdData: TYPE = REF FieldListvpairsProdDataBody;
FieldListvpairsProdDataBody: TYPE = RECORD[
PairList: PairListNode, VPair: VPairNode];

FieldListvpairsProdProcs: FieldListNodeProcs;

BuildFieldListvpairsProdNode: PROC[position: INT, length: INT, PairList: PairListNode, VPair: VPairNode]
	RETURNS[FieldListNode];

FieldListvpairsProdFormFieldSeq: FormFieldSeqProcType;

-- FieldListtypesProd

FieldListtypesProdData: TYPE = REF FieldListtypesProdDataBody;
FieldListtypesProdDataBody: TYPE = RECORD[
TypeList: TypeListNode];

FieldListtypesProdProcs: FieldListNodeProcs;

BuildFieldListtypesProdNode: PROC[position: INT, length: INT, TypeList: TypeListNode]
	RETURNS[FieldListNode];

FieldListtypesProdFormFieldSeq: FormFieldSeqProcType;

-- FieldListvtypesProd

FieldListvtypesProdData: TYPE = REF FieldListvtypesProdDataBody;
FieldListvtypesProdDataBody: TYPE = RECORD[
TypeList: TypeListNode, VPart: VPartNode];

FieldListvtypesProdProcs: FieldListNodeProcs;

BuildFieldListvtypesProdNode: PROC[position: INT, length: INT, TypeList: TypeListNode, VPart: VPartNode]
	RETURNS[FieldListNode];

FieldListvtypesProdFormFieldSeq: FormFieldSeqProcType;

--PairList

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

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

	FormFieldSeq: FormFieldSeqProcType];


-- PairListemptyProd

PairListemptyProdData: TYPE = REF PairListemptyProdDataBody;
PairListemptyProdDataBody: TYPE = RECORD[
];

PairListemptyProdProcs: PairListNodeProcs;

BuildPairListemptyProdNode: PROC[position: INT, length: INT]
	RETURNS[PairListNode];

PairListemptyProdFormFieldSeq: FormFieldSeqProcType;

-- PairListoneProd

PairListoneProdData: TYPE = REF PairListoneProdDataBody;
PairListoneProdDataBody: TYPE = RECORD[
PairItem: PairItemNode];

PairListoneProdProcs: PairListNodeProcs;

BuildPairListoneProdNode: PROC[position: INT, length: INT, PairItem: PairItemNode]
	RETURNS[PairListNode];

PairListoneProdFormFieldSeq: FormFieldSeqProcType;

-- PairListmoreProd

PairListmoreProdData: TYPE = REF PairListmoreProdDataBody;
PairListmoreProdDataBody: TYPE = RECORD[
PairList: PairListNode, PairItem: PairItemNode];

PairListmoreProdProcs: PairListNodeProcs;

BuildPairListmoreProdNode: PROC[position: INT, length: INT, PairList: PairListNode, PairItem: PairItemNode]
	RETURNS[PairListNode];

PairListmoreProdFormFieldSeq: FormFieldSeqProcType;

--PairItem

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

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

	FormFieldSeq: FormFieldSeqProcType];


-- PairItemProd

PairItemProdData: TYPE = REF PairItemProdDataBody;
PairItemProdDataBody: TYPE = RECORD[
IdListR: IdListRNode, TypeExp: TypeExpNode];

PairItemProdProcs: PairItemNodeProcs;

BuildPairItemProdNode: PROC[position: INT, length: INT, IdListR: IdListRNode, TypeExp: TypeExpNode]
	RETURNS[PairItemNode];

PairItemProdFormFieldSeq: FormFieldSeqProcType;

--VPair

VPairNode: TYPE = REF VPairNodeBody;
VPairNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: VPairNodeProcs,
	data: REF ANY];

VPairNodeProcs: TYPE = REF VPairNodeProcsBody;
VPairNodeProcsBody: TYPE = RECORD[

	FormFieldSeq: FormFieldSeqProcType];


-- VPairProd

VPairProdData: TYPE = REF VPairProdDataBody;
VPairProdDataBody: TYPE = RECORD[
IdListR: IdListRNode, VPart: VPartNode];

VPairProdProcs: VPairNodeProcs;

BuildVPairProdNode: PROC[position: INT, length: INT, IdListR: IdListRNode, VPart: VPartNode]
	RETURNS[VPairNode];

VPairProdFormFieldSeq: FormFieldSeqProcType;

--TypeList

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

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

	FormFieldSeq: FormFieldSeqProcType];


-- TypeListemptyProd

TypeListemptyProdData: TYPE = REF TypeListemptyProdDataBody;
TypeListemptyProdDataBody: TYPE = RECORD[
];

TypeListemptyProdProcs: TypeListNodeProcs;

BuildTypeListemptyProdNode: PROC[position: INT, length: INT]
	RETURNS[TypeListNode];

TypeListemptyProdFormFieldSeq: FormFieldSeqProcType;

-- TypeListoneProd

TypeListoneProdData: TYPE = REF TypeListoneProdDataBody;
TypeListoneProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode];

TypeListoneProdProcs: TypeListNodeProcs;

BuildTypeListoneProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode]
	RETURNS[TypeListNode];

TypeListoneProdFormFieldSeq: FormFieldSeqProcType;

-- TypeListmoreProd

TypeListmoreProdData: TYPE = REF TypeListmoreProdDataBody;
TypeListmoreProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode, TypeList: TypeListNode];

TypeListmoreProdProcs: TypeListNodeProcs;

BuildTypeListmoreProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode, TypeList: TypeListNode]
	RETURNS[TypeListNode];

TypeListmoreProdFormFieldSeq: FormFieldSeqProcType;

--VPart

VPartNode: TYPE = REF VPartNodeBody;
VPartNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: VPartNodeProcs,
	data: REF ANY];

VPartNodeProcs: TYPE = REF VPartNodeProcsBody;
VPartNodeProcsBody: TYPE = RECORD[

	FormType: FormTypeProcType];


-- VPartseqProd

VPartseqProdData: TYPE = REF VPartseqProdDataBody;
VPartseqProdDataBody: TYPE = RECORD[
VCaseHead: VCaseHeadNode, TypeExp: TypeExpNode];

VPartseqProdProcs: VPartNodeProcs;

BuildVPartseqProdNode: PROC[position: INT, length: INT, VCaseHead: VCaseHeadNode, TypeExp: TypeExpNode]
	RETURNS[VPartNode];

VPartseqProdFormType: FormTypeProcType;

--VCaseHead

VCaseHeadNode: TYPE = REF VCaseHeadNodeBody;
VCaseHeadNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: VCaseHeadNodeProcs,
	data: REF ANY];

VCaseHeadNodeProcs: TYPE = REF VCaseHeadNodeProcsBody;
VCaseHeadNodeProcsBody: TYPE = RECORD[

	FormVCaseHead: FormVCaseHeadProcType];


-- VCaseHeadidentProd

VCaseHeadidentProdData: TYPE = REF VCaseHeadidentProdDataBody;
VCaseHeadidentProdDataBody: TYPE = RECORD[
Ident: IdentNode, Tagtype: TagtypeNode];

VCaseHeadidentProdProcs: VCaseHeadNodeProcs;

BuildVCaseHeadidentProdNode: PROC[position: INT, length: INT, Ident: IdentNode, Tagtype: TagtypeNode]
	RETURNS[VCaseHeadNode];

VCaseHeadidentProdFormVCaseHead: FormVCaseHeadProcType;

--Tagtype

TagtypeNode: TYPE = REF TagtypeNodeBody;
TagtypeNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: TagtypeNodeProcs,
	data: REF ANY];

TagtypeNodeProcs: TYPE = REF TagtypeNodeProcsBody;
TagtypeNodeProcsBody: TYPE = RECORD[

	FormType: FormTypeProcType];


-- TagtypeexpProd

TagtypeexpProdData: TYPE = REF TagtypeexpProdDataBody;
TagtypeexpProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode];

TagtypeexpProdProcs: TagtypeNodeProcs;

BuildTagtypeexpProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode]
	RETURNS[TagtypeNode];

TagtypeexpProdFormType: FormTypeProcType;

--IdListR

IdListRNode: TYPE = REF IdListRNodeBody;
IdListRNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: IdListRNodeProcs,
	data: REF ANY];

IdListRNodeProcs: TYPE = REF IdListRNodeProcsBody;
IdListRNodeProcsBody: TYPE = RECORD[

	FormNameSeq: FormNameSeqProcType];


-- IdListRoneProd

IdListRoneProdData: TYPE = REF IdListRoneProdDataBody;
IdListRoneProdDataBody: TYPE = RECORD[
id: idNode];

IdListRoneProdProcs: IdListRNodeProcs;

BuildIdListRoneProdNode: PROC[position: INT, length: INT, id: idNode]
	RETURNS[IdListRNode];

IdListRoneProdFormNameSeq: FormNameSeqProcType;

-- IdListRmoreProd

IdListRmoreProdData: TYPE = REF IdListRmoreProdDataBody;
IdListRmoreProdDataBody: TYPE = RECORD[
id: idNode, IdListR: IdListRNode];

IdListRmoreProdProcs: IdListRNodeProcs;

BuildIdListRmoreProdNode: PROC[position: INT, length: INT, id: idNode, IdListR: IdListRNode]
	RETURNS[IdListRNode];

IdListRmoreProdFormNameSeq: FormNameSeqProcType;

--IdListL

IdListLNode: TYPE = REF IdListLNodeBody;
IdListLNodeBody: TYPE = RECORD[
	position: INT, length: INT,
	procs: IdListLNodeProcs,
	data: REF ANY];

IdListLNodeProcs: TYPE = REF IdListLNodeProcsBody;
IdListLNodeProcsBody: TYPE = RECORD[

	FormNameSeq: FormNameSeqProcType];


-- IdListLoneProd

IdListLoneProdData: TYPE = REF IdListLoneProdDataBody;
IdListLoneProdDataBody: TYPE = RECORD[
id: idNode];

IdListLoneProdProcs: IdListLNodeProcs;

BuildIdListLoneProdNode: PROC[position: INT, length: INT, id: idNode]
	RETURNS[IdListLNode];

IdListLoneProdFormNameSeq: FormNameSeqProcType;

-- IdListLmoreProd

IdListLmoreProdData: TYPE = REF IdListLmoreProdDataBody;
IdListLmoreProdDataBody: TYPE = RECORD[
IdListL: IdListLNode, id: idNode];

IdListLmoreProdProcs: IdListLNodeProcs;

BuildIdListLmoreProdNode: PROC[position: INT, length: INT, IdListL: IdListLNode, id: idNode]
	RETURNS[IdListLNode];

IdListLmoreProdFormNameSeq: FormNameSeqProcType;

--Ident

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

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

	FormId: FormIdProcType];


-- IdentProd

IdentProdData: TYPE = REF IdentProdDataBody;
IdentProdDataBody: TYPE = RECORD[
id: idNode];

IdentProdProcs: IdentNodeProcs;

BuildIdentProdNode: PROC[position: INT, length: INT, id: idNode]
	RETURNS[IdentNode];

IdentProdFormId: FormIdProcType;
END..