DIRECTORY
WartDef,
AbstractTypesDef;

AbstractProductionsDef: CEDAR DEFINITIONS = 
BEGIN
OPEN WartDef, AbstractTypesDef;

<<ProgramProd>>

ProgramProdData: TYPE = REF ProgramProdDataBody;
ProgramProdDataBody: TYPE = RECORD[
identifier: identifierNode, numberDprogno: numberDNode, numberDverno: numberDNode, ReferencedProgramList: 
ReferencedProgramListNode, DeclarationList: DeclarationListNode];

ProgramProdProcs: ProgramNodeProcs;

BuildProgramProdNode: PROC[position: INT, length: INT, identifier: identifierNode, numberDprogno: numberDNode, numberDverno: 
numberDNode, ReferencedProgramList: ReferencedProgramListNode, DeclarationList: DeclarationListNode]
RETURNS[ProgramNode];

ProgramProdMakeSymbolTable: MakeSymbolTableProcType;

<<ReferencedProgramListemptyProd>>

ReferencedProgramListemptyProdData: TYPE = REF ReferencedProgramListemptyProdDataBody;
ReferencedProgramListemptyProdDataBody: TYPE = RECORD[
];

ReferencedProgramListemptyProdProcs: ReferencedProgramListNodeProcs;

BuildReferencedProgramListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ReferencedProgramListNode];

ReferencedProgramListemptyProdReadInTable: ReadInTableProcType;

<<ReferencedProgramListmoreProd>>

ReferencedProgramListmoreProdData: TYPE = REF ReferencedProgramListmoreProdDataBody;
ReferencedProgramListmoreProdDataBody: TYPE = RECORD[
ReferencedProgramList: ReferencedProgramListNode, ReferencedProgram: ReferencedProgramNode];

ReferencedProgramListmoreProdProcs: ReferencedProgramListNodeProcs;

BuildReferencedProgramListmoreProdNode: PROC[position: INT, length: INT, ReferencedProgramList: ReferencedProgramListNode, 
ReferencedProgram: ReferencedProgramNode]
RETURNS[ReferencedProgramListNode];

ReferencedProgramListmoreProdReadInTable: ReadInTableProcType;

<<ReferencedProgramProd>>

ReferencedProgramProdData: TYPE = REF ReferencedProgramProdDataBody;
ReferencedProgramProdDataBody: TYPE = RECORD[
identifier: identifierNode, numberDprogno: numberDNode, numberDverno: numberDNode];

ReferencedProgramProdProcs: ReferencedProgramNodeProcs;

BuildReferencedProgramProdNode: PROC[position: INT, length: INT, identifier: identifierNode, numberDprogno: numberDNode, 
numberDverno: numberDNode]
RETURNS[ReferencedProgramNode];

ReferencedProgramProdReadInTable: ReadInTableProcType;

<<DeclarationListemptyProd>>

DeclarationListemptyProdData: TYPE = REF DeclarationListemptyProdDataBody;
DeclarationListemptyProdDataBody: TYPE = RECORD[
];

DeclarationListemptyProdProcs: DeclarationListNodeProcs;

BuildDeclarationListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[DeclarationListNode];

DeclarationListemptyProdBuildTable: BuildTableProcType;
DeclarationListemptyProdRecordNames: RecordNamesProcType;

<<DeclarationListmoreProd>>

DeclarationListmoreProdData: TYPE = REF DeclarationListmoreProdDataBody;
DeclarationListmoreProdDataBody: TYPE = RECORD[
DeclarationList: DeclarationListNode, Declaration: DeclarationNode];

DeclarationListmoreProdProcs: DeclarationListNodeProcs;

BuildDeclarationListmoreProdNode: PROC[position: INT, length: INT, DeclarationList: DeclarationListNode, Declaration: 
DeclarationNode]
RETURNS[DeclarationListNode];

DeclarationListmoreProdBuildTable: BuildTableProcType;
DeclarationListmoreProdRecordNames: RecordNamesProcType;

<<DeclarationtypeProd>>

DeclarationtypeProdData: TYPE = REF DeclarationtypeProdDataBody;
DeclarationtypeProdDataBody: TYPE = RECORD[
identifier: identifierNode, Type: TypeNode];

DeclarationtypeProdProcs: DeclarationNodeProcs;

BuildDeclarationtypeProdNode: PROC[position: INT, length: INT, identifier: identifierNode, Type: TypeNode]
RETURNS[DeclarationNode];

DeclarationtypeProdBuildTable: BuildTableProcType;
DeclarationtypeProdRecordNames: RecordNamesProcType;

<<DeclarationconstantProd>>

DeclarationconstantProdData: TYPE = REF DeclarationconstantProdDataBody;
DeclarationconstantProdDataBody: TYPE = RECORD[
identifier: identifierNode, Type: TypeNode, Constant: ConstantNode];

DeclarationconstantProdProcs: DeclarationNodeProcs;

BuildDeclarationconstantProdNode: PROC[position: INT, length: INT, identifier: identifierNode, Type: TypeNode, Constant: 
ConstantNode]
RETURNS[DeclarationNode];

DeclarationconstantProdBuildTable: BuildTableProcType;
DeclarationconstantProdRecordNames: RecordNamesProcType;

<<TypearrayProd>>

TypearrayProdData: TYPE = REF TypearrayProdDataBody;
TypearrayProdDataBody: TYPE = RECORD[
Constant: ConstantNode, Type: TypeNode];

TypearrayProdProcs: TypeNodeProcs;

BuildTypearrayProdNode: PROC[position: INT, length: INT, Constant: ConstantNode, Type: TypeNode]
RETURNS[TypeNode];

TypearrayProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypebooleanProd>>

TypebooleanProdData: TYPE = REF TypebooleanProdDataBody;
TypebooleanProdDataBody: TYPE = RECORD[
];

TypebooleanProdProcs: TypeNodeProcs;

BuildTypebooleanProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypebooleanProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypebulkDataSinkProd>>

TypebulkDataSinkProdData: TYPE = REF TypebulkDataSinkProdDataBody;
TypebulkDataSinkProdDataBody: TYPE = RECORD[
];

TypebulkDataSinkProdProcs: TypeNodeProcs;

BuildTypebulkDataSinkProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypebulkDataSinkProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypebulkDataSourceProd>>

TypebulkDataSourceProdData: TYPE = REF TypebulkDataSourceProdDataBody;
TypebulkDataSourceProdDataBody: TYPE = RECORD[
];

TypebulkDataSourceProdProcs: TypeNodeProcs;

BuildTypebulkDataSourceProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypebulkDataSourceProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypecardinalProd>>

TypecardinalProdData: TYPE = REF TypecardinalProdDataBody;
TypecardinalProdDataBody: TYPE = RECORD[
];

TypecardinalProdProcs: TypeNodeProcs;

BuildTypecardinalProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypecardinalProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypechoiceProd>>

TypechoiceProdData: TYPE = REF TypechoiceProdDataBody;
TypechoiceProdDataBody: TYPE = RECORD[
Type: TypeNode, CandidateList: CandidateListNode];

TypechoiceProdProcs: TypeNodeProcs;

BuildTypechoiceProdNode: PROC[position: INT, length: INT, Type: TypeNode, CandidateList: CandidateListNode]
RETURNS[TypeNode];

TypechoiceProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypeemptyRecordProd>>

TypeemptyRecordProdData: TYPE = REF TypeemptyRecordProdDataBody;
TypeemptyRecordProdDataBody: TYPE = RECORD[
];

TypeemptyRecordProdProcs: TypeNodeProcs;

BuildTypeemptyRecordProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypeemptyRecordProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypeenumerationProd>>

TypeenumerationProdData: TYPE = REF TypeenumerationProdDataBody;
TypeenumerationProdDataBody: TYPE = RECORD[
CorrespondenceList: CorrespondenceListNode];

TypeenumerationProdProcs: TypeNodeProcs;

BuildTypeenumerationProdNode: PROC[position: INT, length: INT, CorrespondenceList: CorrespondenceListNode]
RETURNS[TypeNode];

TypeenumerationProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypeerrorProd>>

TypeerrorProdData: TYPE = REF TypeerrorProdDataBody;
TypeerrorProdDataBody: TYPE = RECORD[
FieldList: FieldListNode];

TypeerrorProdProcs: TypeNodeProcs;

BuildTypeerrorProdNode: PROC[position: INT, length: INT, FieldList: FieldListNode]
RETURNS[TypeNode];

TypeerrorProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypeintegerProd>>

TypeintegerProdData: TYPE = REF TypeintegerProdDataBody;
TypeintegerProdDataBody: TYPE = RECORD[
];

TypeintegerProdProcs: TypeNodeProcs;

BuildTypeintegerProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypeintegerProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypelocalReferenceProd>>

TypelocalReferenceProdData: TYPE = REF TypelocalReferenceProdDataBody;
TypelocalReferenceProdDataBody: TYPE = RECORD[
identifier: identifierNode];

TypelocalReferenceProdProcs: TypeNodeProcs;

BuildTypelocalReferenceProdNode: PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[TypeNode];

TypelocalReferenceProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypelongCardinalProd>>

TypelongCardinalProdData: TYPE = REF TypelongCardinalProdDataBody;
TypelongCardinalProdDataBody: TYPE = RECORD[
];

TypelongCardinalProdProcs: TypeNodeProcs;

BuildTypelongCardinalProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypelongCardinalProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypelongIntegerProd>>

TypelongIntegerProdData: TYPE = REF TypelongIntegerProdDataBody;
TypelongIntegerProdDataBody: TYPE = RECORD[
];

TypelongIntegerProdProcs: TypeNodeProcs;

BuildTypelongIntegerProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypelongIntegerProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypeprocedureProd>>

TypeprocedureProdData: TYPE = REF TypeprocedureProdDataBody;
TypeprocedureProdDataBody: TYPE = RECORD[
FieldListarg: FieldListNode, FieldListres: FieldListNode, NameList: NameListNode];

TypeprocedureProdProcs: TypeNodeProcs;

BuildTypeprocedureProdNode: PROC[position: INT, length: INT, FieldListarg: FieldListNode, FieldListres: FieldListNode, NameList: 
NameListNode]
RETURNS[TypeNode];

TypeprocedureProdCanonicaliseType: CanonicaliseTypeProcType;

<<TyperecordProd>>

TyperecordProdData: TYPE = REF TyperecordProdDataBody;
TyperecordProdDataBody: TYPE = RECORD[
FieldList: FieldListNode];

TyperecordProdProcs: TypeNodeProcs;

BuildTyperecordProdNode: PROC[position: INT, length: INT, FieldList: FieldListNode]
RETURNS[TypeNode];

TyperecordProdCanonicaliseType: CanonicaliseTypeProcType;

<<TyperemoteReferenceProd>>

TyperemoteReferenceProdData: TYPE = REF TyperemoteReferenceProdDataBody;
TyperemoteReferenceProdDataBody: TYPE = RECORD[
identifiera: identifierNode, identifierb: identifierNode];

TyperemoteReferenceProdProcs: TypeNodeProcs;

BuildTyperemoteReferenceProdNode: PROC[position: INT, length: INT, identifiera: identifierNode, identifierb: identifierNode]
RETURNS[TypeNode];

TyperemoteReferenceProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypesequenceProd>>

TypesequenceProdData: TYPE = REF TypesequenceProdDataBody;
TypesequenceProdDataBody: TYPE = RECORD[
Constant: ConstantNode, Type: TypeNode];

TypesequenceProdProcs: TypeNodeProcs;

BuildTypesequenceProdNode: PROC[position: INT, length: INT, Constant: ConstantNode, Type: TypeNode]
RETURNS[TypeNode];

TypesequenceProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypestringProd>>

TypestringProdData: TYPE = REF TypestringProdDataBody;
TypestringProdDataBody: TYPE = RECORD[
];

TypestringProdProcs: TypeNodeProcs;

BuildTypestringProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypestringProdCanonicaliseType: CanonicaliseTypeProcType;

<<TypeunspecifiedProd>>

TypeunspecifiedProdData: TYPE = REF TypeunspecifiedProdDataBody;
TypeunspecifiedProdDataBody: TYPE = RECORD[
];

TypeunspecifiedProdProcs: TypeNodeProcs;

BuildTypeunspecifiedProdNode: PROC[position: INT, length: INT]
RETURNS[TypeNode];

TypeunspecifiedProdCanonicaliseType: CanonicaliseTypeProcType;

<<CorrespondenceListoneProd>>

CorrespondenceListoneProdData: TYPE = REF CorrespondenceListoneProdDataBody;
CorrespondenceListoneProdDataBody: TYPE = RECORD[
identifier: identifierNode, Constant: ConstantNode];

CorrespondenceListoneProdProcs: CorrespondenceListNodeProcs;

BuildCorrespondenceListoneProdNode: PROC[position: INT, length: INT, identifier: identifierNode, Constant: ConstantNode]
RETURNS[CorrespondenceListNode];

CorrespondenceListoneProdCanonicaliseCorrespondenceList: CanonicaliseCorrespondenceListProcType;
CorrespondenceListoneProdCheckCorrespondenceList: CheckCorrespondenceListProcType;

<<CorrespondenceListmoreProd>>

CorrespondenceListmoreProdData: TYPE = REF CorrespondenceListmoreProdDataBody;
CorrespondenceListmoreProdDataBody: TYPE = RECORD[
CorrespondenceListvalue: CorrespondenceListNode, CorrespondenceListnext: CorrespondenceListNode];

CorrespondenceListmoreProdProcs: CorrespondenceListNodeProcs;

BuildCorrespondenceListmoreProdNode: PROC[position: INT, length: INT, CorrespondenceListvalue: CorrespondenceListNode, 
CorrespondenceListnext: CorrespondenceListNode]
RETURNS[CorrespondenceListNode];

CorrespondenceListmoreProdCanonicaliseCorrespondenceList: CanonicaliseCorrespondenceListProcType;
CorrespondenceListmoreProdCheckCorrespondenceList: CheckCorrespondenceListProcType;

<<CandidateListoneProd>>

CandidateListoneProdData: TYPE = REF CandidateListoneProdDataBody;
CandidateListoneProdDataBody: TYPE = RECORD[
NameList: NameListNode, Type: TypeNode];

CandidateListoneProdProcs: CandidateListNodeProcs;

BuildCandidateListoneProdNode: PROC[position: INT, length: INT, NameList: NameListNode, Type: TypeNode]
RETURNS[CandidateListNode];

CandidateListoneProdCanonicaliseCandidateList: CanonicaliseCandidateListProcType;
CandidateListoneProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;

<<CandidateListmoreProd>>

CandidateListmoreProdData: TYPE = REF CandidateListmoreProdDataBody;
CandidateListmoreProdDataBody: TYPE = RECORD[
CandidateListvalue: CandidateListNode, CandidateListnext: CandidateListNode];

CandidateListmoreProdProcs: CandidateListNodeProcs;

BuildCandidateListmoreProdNode: PROC[position: INT, length: INT, CandidateListvalue: CandidateListNode, CandidateListnext: 
CandidateListNode]
RETURNS[CandidateListNode];

CandidateListmoreProdCanonicaliseCandidateList: CanonicaliseCandidateListProcType;
CandidateListmoreProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;

<<FieldListemptyProd>>

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

FieldListemptyProdProcs: FieldListNodeProcs;

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

FieldListemptyProdCanonicaliseFieldList: CanonicaliseFieldListProcType;

<<FieldListoneProd>>

FieldListoneProdData: TYPE = REF FieldListoneProdDataBody;
FieldListoneProdDataBody: TYPE = RECORD[
NameList: NameListNode, Type: TypeNode];

FieldListoneProdProcs: FieldListNodeProcs;

BuildFieldListoneProdNode: PROC[position: INT, length: INT, NameList: NameListNode, Type: TypeNode]
RETURNS[FieldListNode];

FieldListoneProdCanonicaliseFieldList: CanonicaliseFieldListProcType;

<<FieldListmoreProd>>

FieldListmoreProdData: TYPE = REF FieldListmoreProdDataBody;
FieldListmoreProdDataBody: TYPE = RECORD[
FieldListvalue: FieldListNode, FieldListrest: FieldListNode];

FieldListmoreProdProcs: FieldListNodeProcs;

BuildFieldListmoreProdNode: PROC[position: INT, length: INT, FieldListvalue: FieldListNode, FieldListrest: FieldListNode]
RETURNS[FieldListNode];

FieldListmoreProdCanonicaliseFieldList: CanonicaliseFieldListProcType;

<<ConstantchoiceProd>>

ConstantchoiceProdData: TYPE = REF ConstantchoiceProdDataBody;
ConstantchoiceProdDataBody: TYPE = RECORD[
identifier: identifierNode, Constant: ConstantNode];

ConstantchoiceProdProcs: ConstantNodeProcs;

BuildConstantchoiceProdNode: PROC[position: INT, length: INT, identifier: identifierNode, Constant: ConstantNode]
RETURNS[ConstantNode];

ConstantchoiceProdCoerce: CoerceProcType;
ConstantchoiceProdGetCARDINAL: GetCARDINALProcType;
ConstantchoiceProdConstantToRope: ConstantToRopeProcType;

<<ConstantcomponentlistProd>>

ConstantcomponentlistProdData: TYPE = REF ConstantcomponentlistProdDataBody;
ConstantcomponentlistProdDataBody: TYPE = RECORD[
ComponentList: ComponentListNode];

ConstantcomponentlistProdProcs: ConstantNodeProcs;

BuildConstantcomponentlistProdNode: PROC[position: INT, length: INT, ComponentList: ComponentListNode]
RETURNS[ConstantNode];

ConstantcomponentlistProdCoerce: CoerceProcType;
ConstantcomponentlistProdGetCARDINAL: GetCARDINALProcType;
ConstantcomponentlistProdConstantToRope: ConstantToRopeProcType;

<<ConstantelementListProd>>

ConstantelementListProdData: TYPE = REF ConstantelementListProdDataBody;
ConstantelementListProdDataBody: TYPE = RECORD[
ElementList: ElementListNode];

ConstantelementListProdProcs: ConstantNodeProcs;

BuildConstantelementListProdNode: PROC[position: INT, length: INT, ElementList: ElementListNode]
RETURNS[ConstantNode];

ConstantelementListProdCoerce: CoerceProcType;
ConstantelementListProdGetCARDINAL: GetCARDINALProcType;
ConstantelementListProdConstantToRope: ConstantToRopeProcType;

<<ConstantemptyProd>>

ConstantemptyProdData: TYPE = REF ConstantemptyProdDataBody;
ConstantemptyProdDataBody: TYPE = RECORD[
];

ConstantemptyProdProcs: ConstantNodeProcs;

BuildConstantemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ConstantNode];

ConstantemptyProdCoerce: CoerceProcType;
ConstantemptyProdGetCARDINAL: GetCARDINALProcType;
ConstantemptyProdConstantToRope: ConstantToRopeProcType;

<<ConstantfalseProd>>

ConstantfalseProdData: TYPE = REF ConstantfalseProdDataBody;
ConstantfalseProdDataBody: TYPE = RECORD[
];

ConstantfalseProdProcs: ConstantNodeProcs;

BuildConstantfalseProdNode: PROC[position: INT, length: INT]
RETURNS[ConstantNode];

ConstantfalseProdCoerce: CoerceProcType;
ConstantfalseProdGetCARDINAL: GetCARDINALProcType;
ConstantfalseProdConstantToRope: ConstantToRopeProcType;

<<ConstantidProd>>

ConstantidProdData: TYPE = REF ConstantidProdDataBody;
ConstantidProdDataBody: TYPE = RECORD[
identifier: identifierNode];

ConstantidProdProcs: ConstantNodeProcs;

BuildConstantidProdNode: PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[ConstantNode];

ConstantidProdCoerce: CoerceProcType;
ConstantidProdGetCARDINAL: GetCARDINALProcType;
ConstantidProdConstantToRope: ConstantToRopeProcType;

<<ConstantnegativeNumberProd>>

ConstantnegativeNumberProdData: TYPE = REF ConstantnegativeNumberProdDataBody;
ConstantnegativeNumberProdDataBody: TYPE = RECORD[
number: numberNode];

ConstantnegativeNumberProdProcs: ConstantNodeProcs;

BuildConstantnegativeNumberProdNode: PROC[position: INT, length: INT, number: numberNode]
RETURNS[ConstantNode];

ConstantnegativeNumberProdCoerce: CoerceProcType;
ConstantnegativeNumberProdGetCARDINAL: GetCARDINALProcType;
ConstantnegativeNumberProdConstantToRope: ConstantToRopeProcType;

<<ConstantnumberProd>>

ConstantnumberProdData: TYPE = REF ConstantnumberProdDataBody;
ConstantnumberProdDataBody: TYPE = RECORD[
number: numberNode];

ConstantnumberProdProcs: ConstantNodeProcs;

BuildConstantnumberProdNode: PROC[position: INT, length: INT, number: numberNode]
RETURNS[ConstantNode];

ConstantnumberProdCoerce: CoerceProcType;
ConstantnumberProdGetCARDINAL: GetCARDINALProcType;
ConstantnumberProdConstantToRope: ConstantToRopeProcType;

<<ConstantremoteReferenceProd>>

ConstantremoteReferenceProdData: TYPE = REF ConstantremoteReferenceProdDataBody;
ConstantremoteReferenceProdDataBody: TYPE = RECORD[
identifierleft: identifierNode, identifierright: identifierNode];

ConstantremoteReferenceProdProcs: ConstantNodeProcs;

BuildConstantremoteReferenceProdNode: PROC[position: INT, length: INT, identifierleft: identifierNode, identifierright: 
identifierNode]
RETURNS[ConstantNode];

ConstantremoteReferenceProdCoerce: CoerceProcType;
ConstantremoteReferenceProdGetCARDINAL: GetCARDINALProcType;
ConstantremoteReferenceProdConstantToRope: ConstantToRopeProcType;

<<ConstantstringProd>>

ConstantstringProdData: TYPE = REF ConstantstringProdDataBody;
ConstantstringProdDataBody: TYPE = RECORD[
Rope: RopeNode];

ConstantstringProdProcs: ConstantNodeProcs;

BuildConstantstringProdNode: PROC[position: INT, length: INT, Rope: RopeNode]
RETURNS[ConstantNode];

ConstantstringProdCoerce: CoerceProcType;
ConstantstringProdGetCARDINAL: GetCARDINALProcType;
ConstantstringProdConstantToRope: ConstantToRopeProcType;

<<ConstanttrueProd>>

ConstanttrueProdData: TYPE = REF ConstanttrueProdDataBody;
ConstanttrueProdDataBody: TYPE = RECORD[
];

ConstanttrueProdProcs: ConstantNodeProcs;

BuildConstanttrueProdNode: PROC[position: INT, length: INT]
RETURNS[ConstantNode];

ConstanttrueProdCoerce: CoerceProcType;
ConstanttrueProdGetCARDINAL: GetCARDINALProcType;
ConstanttrueProdConstantToRope: ConstantToRopeProcType;

<<ConstantunboundedProd>>

ConstantunboundedProdData: TYPE = REF ConstantunboundedProdDataBody;
ConstantunboundedProdDataBody: TYPE = RECORD[
];

ConstantunboundedProdProcs: ConstantNodeProcs;

BuildConstantunboundedProdNode: PROC[position: INT, length: INT]
RETURNS[ConstantNode];

ConstantunboundedProdCoerce: CoerceProcType;
ConstantunboundedProdGetCARDINAL: GetCARDINALProcType;
ConstantunboundedProdConstantToRope: ConstantToRopeProcType;

<<ElementListoneProd>>

ElementListoneProdData: TYPE = REF ElementListoneProdDataBody;
ElementListoneProdDataBody: TYPE = RECORD[
Constant: ConstantNode];

ElementListoneProdProcs: ElementListNodeProcs;

BuildElementListoneProdNode: PROC[position: INT, length: INT, Constant: ConstantNode]
RETURNS[ElementListNode];

ElementListoneProdCoerceElementList: CoerceElementListProcType;
ElementListoneProdConstantToRope: ConstantToRopeProcType;
ElementListoneProdSize: SizeProcType;
ElementListoneProdConstructFunction: ConstructFunctionProcType;

<<ElementListmoreProd>>

ElementListmoreProdData: TYPE = REF ElementListmoreProdDataBody;
ElementListmoreProdDataBody: TYPE = RECORD[
Constant: ConstantNode, ElementList: ElementListNode];

ElementListmoreProdProcs: ElementListNodeProcs;

BuildElementListmoreProdNode: PROC[position: INT, length: INT, Constant: ConstantNode, ElementList: ElementListNode]
RETURNS[ElementListNode];

ElementListmoreProdCoerceElementList: CoerceElementListProcType;
ElementListmoreProdConstantToRope: ConstantToRopeProcType;
ElementListmoreProdSize: SizeProcType;
ElementListmoreProdConstructFunction: ConstructFunctionProcType;

<<ComponentListoneProd>>

ComponentListoneProdData: TYPE = REF ComponentListoneProdDataBody;
ComponentListoneProdDataBody: TYPE = RECORD[
Component: ComponentNode];

ComponentListoneProdProcs: ComponentListNodeProcs;

BuildComponentListoneProdNode: PROC[position: INT, length: INT, Component: ComponentNode]
RETURNS[ComponentListNode];

ComponentListoneProdCoerceComponents: CoerceComponentsProcType;
ComponentListoneProdConstantToRope: ConstantToRopeProcType;
ComponentListoneProdCheckAllNames: CheckAllNamesProcType;

<<ComponentListmoreProd>>

ComponentListmoreProdData: TYPE = REF ComponentListmoreProdDataBody;
ComponentListmoreProdDataBody: TYPE = RECORD[
Component: ComponentNode, ComponentList: ComponentListNode];

ComponentListmoreProdProcs: ComponentListNodeProcs;

BuildComponentListmoreProdNode: PROC[position: INT, length: INT, Component: ComponentNode, ComponentList: ComponentListNode]
RETURNS[ComponentListNode];

ComponentListmoreProdCoerceComponents: CoerceComponentsProcType;
ComponentListmoreProdConstantToRope: ConstantToRopeProcType;
ComponentListmoreProdCheckAllNames: CheckAllNamesProcType;

<<ComponentProd>>

ComponentProdData: TYPE = REF ComponentProdDataBody;
ComponentProdDataBody: TYPE = RECORD[
NameList: NameListNode, Constant: ConstantNode];

ComponentProdProcs: ComponentNodeProcs;

BuildComponentProdNode: PROC[position: INT, length: INT, NameList: NameListNode, Constant: ConstantNode]
RETURNS[ComponentNode];

ComponentProdCoerceComponents: CoerceComponentsProcType;
ComponentProdConstantToRope: ConstantToRopeProcType;
ComponentProdCheckAllNames: CheckAllNamesProcType;

<<NameListemptyProd>>

NameListemptyProdData: TYPE = REF NameListemptyProdDataBody;
NameListemptyProdDataBody: TYPE = RECORD[
];

NameListemptyProdProcs: NameListNodeProcs;

BuildNameListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[NameListNode];

NameListemptyProdCheckIfErrorNames: CheckIfErrorNamesProcType;
NameListemptyProdCanonicaliseFieldsFromNameList: CanonicaliseFieldsFromNameListProcType;
NameListemptyProdCoerceComponentNameList: CoerceComponentNameListProcType;
NameListemptyProdNameListToRope: NameListToRopeProcType;
NameListemptyProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;
NameListemptyProdTypeOfNameList: TypeOfNameListProcType;

<<NameListoneProd>>

NameListoneProdData: TYPE = REF NameListoneProdDataBody;
NameListoneProdDataBody: TYPE = RECORD[
identifier: identifierNode];

NameListoneProdProcs: NameListNodeProcs;

BuildNameListoneProdNode: PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[NameListNode];

NameListoneProdCheckIfErrorNames: CheckIfErrorNamesProcType;
NameListoneProdCanonicaliseFieldsFromNameList: CanonicaliseFieldsFromNameListProcType;
NameListoneProdCoerceComponentNameList: CoerceComponentNameListProcType;
NameListoneProdNameListToRope: NameListToRopeProcType;
NameListoneProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;
NameListoneProdTypeOfNameList: TypeOfNameListProcType;

<<NameListmoreProd>>

NameListmoreProdData: TYPE = REF NameListmoreProdDataBody;
NameListmoreProdDataBody: TYPE = RECORD[
identifier: identifierNode, NameList: NameListNode];

NameListmoreProdProcs: NameListNodeProcs;

BuildNameListmoreProdNode: PROC[position: INT, length: INT, identifier: identifierNode, NameList: NameListNode]
RETURNS[NameListNode];

NameListmoreProdCheckIfErrorNames: CheckIfErrorNamesProcType;
NameListmoreProdCanonicaliseFieldsFromNameList: CanonicaliseFieldsFromNameListProcType;
NameListmoreProdCoerceComponentNameList: CoerceComponentNameListProcType;
NameListmoreProdNameListToRope: NameListToRopeProcType;
NameListmoreProdEmptyWorkTableOfNames: EmptyWorkTableOfNamesProcType;
NameListmoreProdTypeOfNameList: TypeOfNameListProcType;

<<numberdecimalProd>>

numberdecimalProdData: TYPE = REF numberdecimalProdDataBody;
numberdecimalProdDataBody: TYPE = RECORD[
numberD: numberDNode];

numberdecimalProdProcs: numberNodeProcs;

BuildnumberdecimalProdNode: PROC[position: INT, length: INT, numberD: numberDNode]
RETURNS[numberNode];

numberdecimalProdGetCARDINAL: GetCARDINALProcType;
numberdecimalProdNumberToCard: NumberToCardProcType;

<<numberhexProd>>

numberhexProdData: TYPE = REF numberhexProdDataBody;
numberhexProdDataBody: TYPE = RECORD[
numberH: numberHNode];

numberhexProdProcs: numberNodeProcs;

BuildnumberhexProdNode: PROC[position: INT, length: INT, numberH: numberHNode]
RETURNS[numberNode];

numberhexProdGetCARDINAL: GetCARDINALProcType;
numberhexProdNumberToCard: NumberToCardProcType;

<<numberoctalProd>>

numberoctalProdData: TYPE = REF numberoctalProdDataBody;
numberoctalProdDataBody: TYPE = RECORD[
numberO: numberONode];

numberoctalProdProcs: numberNodeProcs;

BuildnumberoctalProdNode: PROC[position: INT, length: INT, numberO: numberONode]
RETURNS[numberNode];

numberoctalProdGetCARDINAL: GetCARDINALProcType;
numberoctalProdNumberToCard: NumberToCardProcType;
END..