DIRECTORY
AbstractTypesDef,
WartDef,
AbstractProductionsDef;

AbstractProductionsImpl: CEDAR PROGRAM IMPORTS AbstractProductionsDef EXPORTS AbstractProductionsDef= 
BEGIN
OPEN AbstractTypesDef, WartDef, AbstractProductionsDef;

<<ProgramProd>>

ProgramProdProcs: PUBLIC ProgramNodeProcs _
NEW[ProgramNodeProcsBody _ [ProgramProdMakeSymbolTable]];

BuildProgramProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode, numberDprogno: numberDNode, numberDverno: 
numberDNode, ReferencedProgramList: ReferencedProgramListNode, DeclarationList: DeclarationListNode]
RETURNS[ProgramNode] =
BEGIN
data: ProgramProdData _
NEW[ProgramProdDataBody_[
identifier, numberDprogno, numberDverno, ReferencedProgramList, DeclarationList]];
RETURN[NEW[ProgramNodeBody_[position, length, ProgramProdProcs, data]]];
END;


<<ReferencedProgramListemptyProd>>

ReferencedProgramListemptyProdProcs: PUBLIC ReferencedProgramListNodeProcs _
NEW[ReferencedProgramListNodeProcsBody _ [ReferencedProgramListemptyProdReadInTable]];

BuildReferencedProgramListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[ReferencedProgramListNode] =
BEGIN
RETURN[NEW[ReferencedProgramListNodeBody_[position, length, ReferencedProgramListemptyProdProcs, NIL]]];
END;


<<ReferencedProgramListmoreProd>>

ReferencedProgramListmoreProdProcs: PUBLIC ReferencedProgramListNodeProcs _
NEW[ReferencedProgramListNodeProcsBody _ [ReferencedProgramListmoreProdReadInTable]];

BuildReferencedProgramListmoreProdNode: PUBLIC PROC[position: INT, length: INT, ReferencedProgramList: ReferencedProgramListNode, 
ReferencedProgram: ReferencedProgramNode]
RETURNS[ReferencedProgramListNode] =
BEGIN
data: ReferencedProgramListmoreProdData _
NEW[ReferencedProgramListmoreProdDataBody_[
ReferencedProgramList, ReferencedProgram]];
RETURN[NEW[ReferencedProgramListNodeBody_[position, length, ReferencedProgramListmoreProdProcs, data]]];
END;


<<ReferencedProgramProd>>

ReferencedProgramProdProcs: PUBLIC ReferencedProgramNodeProcs _
NEW[ReferencedProgramNodeProcsBody _ [ReferencedProgramProdReadInTable]];

BuildReferencedProgramProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode, numberDprogno: numberDNode, 
numberDverno: numberDNode]
RETURNS[ReferencedProgramNode] =
BEGIN
data: ReferencedProgramProdData _
NEW[ReferencedProgramProdDataBody_[
identifier, numberDprogno, numberDverno]];
RETURN[NEW[ReferencedProgramNodeBody_[position, length, ReferencedProgramProdProcs, data]]];
END;


<<DeclarationListemptyProd>>

DeclarationListemptyProdProcs: PUBLIC DeclarationListNodeProcs _
NEW[DeclarationListNodeProcsBody _ [DeclarationListemptyProdBuildTable, DeclarationListemptyProdRecordNames]];

BuildDeclarationListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[DeclarationListNode] =
BEGIN
RETURN[NEW[DeclarationListNodeBody_[position, length, DeclarationListemptyProdProcs, NIL]]];
END;


<<DeclarationListmoreProd>>

DeclarationListmoreProdProcs: PUBLIC DeclarationListNodeProcs _
NEW[DeclarationListNodeProcsBody _ [DeclarationListmoreProdBuildTable, DeclarationListmoreProdRecordNames]];

BuildDeclarationListmoreProdNode: PUBLIC PROC[position: INT, length: INT, DeclarationList: DeclarationListNode, Declaration: 
DeclarationNode]
RETURNS[DeclarationListNode] =
BEGIN
data: DeclarationListmoreProdData _
NEW[DeclarationListmoreProdDataBody_[
DeclarationList, Declaration]];
RETURN[NEW[DeclarationListNodeBody_[position, length, DeclarationListmoreProdProcs, data]]];
END;


<<DeclarationtypeProd>>

DeclarationtypeProdProcs: PUBLIC DeclarationNodeProcs _
NEW[DeclarationNodeProcsBody _ [DeclarationtypeProdBuildTable, DeclarationtypeProdRecordNames]];

BuildDeclarationtypeProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode, Type: TypeNode]
RETURNS[DeclarationNode] =
BEGIN
data: DeclarationtypeProdData _
NEW[DeclarationtypeProdDataBody_[
identifier, Type]];
RETURN[NEW[DeclarationNodeBody_[position, length, DeclarationtypeProdProcs, data]]];
END;


<<DeclarationconstantProd>>

DeclarationconstantProdProcs: PUBLIC DeclarationNodeProcs _
NEW[DeclarationNodeProcsBody _ [DeclarationconstantProdBuildTable, DeclarationconstantProdRecordNames]];

BuildDeclarationconstantProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode, Type: TypeNode, Constant: 
ConstantNode]
RETURNS[DeclarationNode] =
BEGIN
data: DeclarationconstantProdData _
NEW[DeclarationconstantProdDataBody_[
identifier, Type, Constant]];
RETURN[NEW[DeclarationNodeBody_[position, length, DeclarationconstantProdProcs, data]]];
END;


<<TypearrayProd>>

TypearrayProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypearrayProdCanonicaliseType]];

BuildTypearrayProdNode: PUBLIC PROC[position: INT, length: INT, Constant: ConstantNode, Type: TypeNode]
RETURNS[TypeNode] =
BEGIN
data: TypearrayProdData _
NEW[TypearrayProdDataBody_[
Constant, Type]];
RETURN[NEW[TypeNodeBody_[position, length, TypearrayProdProcs, data]]];
END;


<<TypebooleanProd>>

TypebooleanProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypebooleanProdCanonicaliseType]];

BuildTypebooleanProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypebooleanProdProcs, NIL]]];
END;


<<TypebulkDataSinkProd>>

TypebulkDataSinkProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypebulkDataSinkProdCanonicaliseType]];

BuildTypebulkDataSinkProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypebulkDataSinkProdProcs, NIL]]];
END;


<<TypebulkDataSourceProd>>

TypebulkDataSourceProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypebulkDataSourceProdCanonicaliseType]];

BuildTypebulkDataSourceProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypebulkDataSourceProdProcs, NIL]]];
END;


<<TypecardinalProd>>

TypecardinalProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypecardinalProdCanonicaliseType]];

BuildTypecardinalProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypecardinalProdProcs, NIL]]];
END;


<<TypechoiceProd>>

TypechoiceProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypechoiceProdCanonicaliseType]];

BuildTypechoiceProdNode: PUBLIC PROC[position: INT, length: INT, Type: TypeNode, CandidateList: CandidateListNode]
RETURNS[TypeNode] =
BEGIN
data: TypechoiceProdData _
NEW[TypechoiceProdDataBody_[
Type, CandidateList]];
RETURN[NEW[TypeNodeBody_[position, length, TypechoiceProdProcs, data]]];
END;


<<TypeemptyRecordProd>>

TypeemptyRecordProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypeemptyRecordProdCanonicaliseType]];

BuildTypeemptyRecordProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypeemptyRecordProdProcs, NIL]]];
END;


<<TypeenumerationProd>>

TypeenumerationProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypeenumerationProdCanonicaliseType]];

BuildTypeenumerationProdNode: PUBLIC PROC[position: INT, length: INT, CorrespondenceList: CorrespondenceListNode]
RETURNS[TypeNode] =
BEGIN
data: TypeenumerationProdData _
NEW[TypeenumerationProdDataBody_[
CorrespondenceList]];
RETURN[NEW[TypeNodeBody_[position, length, TypeenumerationProdProcs, data]]];
END;


<<TypeerrorProd>>

TypeerrorProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypeerrorProdCanonicaliseType]];

BuildTypeerrorProdNode: PUBLIC PROC[position: INT, length: INT, FieldList: FieldListNode]
RETURNS[TypeNode] =
BEGIN
data: TypeerrorProdData _
NEW[TypeerrorProdDataBody_[
FieldList]];
RETURN[NEW[TypeNodeBody_[position, length, TypeerrorProdProcs, data]]];
END;


<<TypeintegerProd>>

TypeintegerProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypeintegerProdCanonicaliseType]];

BuildTypeintegerProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypeintegerProdProcs, NIL]]];
END;


<<TypelocalReferenceProd>>

TypelocalReferenceProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypelocalReferenceProdCanonicaliseType]];

BuildTypelocalReferenceProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[TypeNode] =
BEGIN
data: TypelocalReferenceProdData _
NEW[TypelocalReferenceProdDataBody_[
identifier]];
RETURN[NEW[TypeNodeBody_[position, length, TypelocalReferenceProdProcs, data]]];
END;


<<TypelongCardinalProd>>

TypelongCardinalProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypelongCardinalProdCanonicaliseType]];

BuildTypelongCardinalProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypelongCardinalProdProcs, NIL]]];
END;


<<TypelongIntegerProd>>

TypelongIntegerProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypelongIntegerProdCanonicaliseType]];

BuildTypelongIntegerProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypelongIntegerProdProcs, NIL]]];
END;


<<TypeprocedureProd>>

TypeprocedureProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypeprocedureProdCanonicaliseType]];

BuildTypeprocedureProdNode: PUBLIC PROC[position: INT, length: INT, FieldListarg: FieldListNode, FieldListres: FieldListNode, 
NameList: NameListNode]
RETURNS[TypeNode] =
BEGIN
data: TypeprocedureProdData _
NEW[TypeprocedureProdDataBody_[
FieldListarg, FieldListres, NameList]];
RETURN[NEW[TypeNodeBody_[position, length, TypeprocedureProdProcs, data]]];
END;


<<TyperecordProd>>

TyperecordProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TyperecordProdCanonicaliseType]];

BuildTyperecordProdNode: PUBLIC PROC[position: INT, length: INT, FieldList: FieldListNode]
RETURNS[TypeNode] =
BEGIN
data: TyperecordProdData _
NEW[TyperecordProdDataBody_[
FieldList]];
RETURN[NEW[TypeNodeBody_[position, length, TyperecordProdProcs, data]]];
END;


<<TyperemoteReferenceProd>>

TyperemoteReferenceProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TyperemoteReferenceProdCanonicaliseType]];

BuildTyperemoteReferenceProdNode: PUBLIC PROC[position: INT, length: INT, identifiera: identifierNode, identifierb: identifierNode]
RETURNS[TypeNode] =
BEGIN
data: TyperemoteReferenceProdData _
NEW[TyperemoteReferenceProdDataBody_[
identifiera, identifierb]];
RETURN[NEW[TypeNodeBody_[position, length, TyperemoteReferenceProdProcs, data]]];
END;


<<TypesequenceProd>>

TypesequenceProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypesequenceProdCanonicaliseType]];

BuildTypesequenceProdNode: PUBLIC PROC[position: INT, length: INT, Constant: ConstantNode, Type: TypeNode]
RETURNS[TypeNode] =
BEGIN
data: TypesequenceProdData _
NEW[TypesequenceProdDataBody_[
Constant, Type]];
RETURN[NEW[TypeNodeBody_[position, length, TypesequenceProdProcs, data]]];
END;


<<TypestringProd>>

TypestringProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypestringProdCanonicaliseType]];

BuildTypestringProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypestringProdProcs, NIL]]];
END;


<<TypeunspecifiedProd>>

TypeunspecifiedProdProcs: PUBLIC TypeNodeProcs _
NEW[TypeNodeProcsBody _ [TypeunspecifiedProdCanonicaliseType]];

BuildTypeunspecifiedProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TypeNode] =
BEGIN
RETURN[NEW[TypeNodeBody_[position, length, TypeunspecifiedProdProcs, NIL]]];
END;


<<CorrespondenceListoneProd>>

CorrespondenceListoneProdProcs: PUBLIC CorrespondenceListNodeProcs _
NEW[CorrespondenceListNodeProcsBody _ [CorrespondenceListoneProdCanonicaliseCorrespondenceList, 
CorrespondenceListoneProdCheckCorrespondenceList]];

BuildCorrespondenceListoneProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode, Constant: ConstantNode]
RETURNS[CorrespondenceListNode] =
BEGIN
data: CorrespondenceListoneProdData _
NEW[CorrespondenceListoneProdDataBody_[
identifier, Constant]];
RETURN[NEW[CorrespondenceListNodeBody_[position, length, CorrespondenceListoneProdProcs, data]]];
END;


<<CorrespondenceListmoreProd>>

CorrespondenceListmoreProdProcs: PUBLIC CorrespondenceListNodeProcs _
NEW[CorrespondenceListNodeProcsBody _ [CorrespondenceListmoreProdCanonicaliseCorrespondenceList, 
CorrespondenceListmoreProdCheckCorrespondenceList]];

BuildCorrespondenceListmoreProdNode: PUBLIC PROC[position: INT, length: INT, CorrespondenceListvalue: CorrespondenceListNode, 
CorrespondenceListnext: CorrespondenceListNode]
RETURNS[CorrespondenceListNode] =
BEGIN
data: CorrespondenceListmoreProdData _
NEW[CorrespondenceListmoreProdDataBody_[
CorrespondenceListvalue, CorrespondenceListnext]];
RETURN[NEW[CorrespondenceListNodeBody_[position, length, CorrespondenceListmoreProdProcs, data]]];
END;


<<CandidateListoneProd>>

CandidateListoneProdProcs: PUBLIC CandidateListNodeProcs _
NEW[CandidateListNodeProcsBody _ [CandidateListoneProdCanonicaliseCandidateList, CandidateListoneProdEmptyWorkTableOfNames]];

BuildCandidateListoneProdNode: PUBLIC PROC[position: INT, length: INT, NameList: NameListNode, Type: TypeNode]
RETURNS[CandidateListNode] =
BEGIN
data: CandidateListoneProdData _
NEW[CandidateListoneProdDataBody_[
NameList, Type]];
RETURN[NEW[CandidateListNodeBody_[position, length, CandidateListoneProdProcs, data]]];
END;


<<CandidateListmoreProd>>

CandidateListmoreProdProcs: PUBLIC CandidateListNodeProcs _
NEW[CandidateListNodeProcsBody _ [CandidateListmoreProdCanonicaliseCandidateList, CandidateListmoreProdEmptyWorkTableOfNames]];

BuildCandidateListmoreProdNode: PUBLIC PROC[position: INT, length: INT, CandidateListvalue: CandidateListNode, CandidateListnext: 
CandidateListNode]
RETURNS[CandidateListNode] =
BEGIN
data: CandidateListmoreProdData _
NEW[CandidateListmoreProdDataBody_[
CandidateListvalue, CandidateListnext]];
RETURN[NEW[CandidateListNodeBody_[position, length, CandidateListmoreProdProcs, data]]];
END;


<<FieldListemptyProd>>

FieldListemptyProdProcs: PUBLIC FieldListNodeProcs _
NEW[FieldListNodeProcsBody _ [FieldListemptyProdCanonicaliseFieldList]];

BuildFieldListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[FieldListNode] =
BEGIN
RETURN[NEW[FieldListNodeBody_[position, length, FieldListemptyProdProcs, NIL]]];
END;


<<FieldListoneProd>>

FieldListoneProdProcs: PUBLIC FieldListNodeProcs _
NEW[FieldListNodeProcsBody _ [FieldListoneProdCanonicaliseFieldList]];

BuildFieldListoneProdNode: PUBLIC PROC[position: INT, length: INT, NameList: NameListNode, Type: TypeNode]
RETURNS[FieldListNode] =
BEGIN
data: FieldListoneProdData _
NEW[FieldListoneProdDataBody_[
NameList, Type]];
RETURN[NEW[FieldListNodeBody_[position, length, FieldListoneProdProcs, data]]];
END;


<<FieldListmoreProd>>

FieldListmoreProdProcs: PUBLIC FieldListNodeProcs _
NEW[FieldListNodeProcsBody _ [FieldListmoreProdCanonicaliseFieldList]];

BuildFieldListmoreProdNode: PUBLIC PROC[position: INT, length: INT, FieldListvalue: FieldListNode, FieldListrest: FieldListNode]
RETURNS[FieldListNode] =
BEGIN
data: FieldListmoreProdData _
NEW[FieldListmoreProdDataBody_[
FieldListvalue, FieldListrest]];
RETURN[NEW[FieldListNodeBody_[position, length, FieldListmoreProdProcs, data]]];
END;


<<ConstantchoiceProd>>

ConstantchoiceProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantchoiceProdCoerce, ConstantchoiceProdGetCARDINAL, ConstantchoiceProdConstantToRope]];

BuildConstantchoiceProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode, Constant: ConstantNode]
RETURNS[ConstantNode] =
BEGIN
data: ConstantchoiceProdData _
NEW[ConstantchoiceProdDataBody_[
identifier, Constant]];
RETURN[NEW[ConstantNodeBody_[position, length, ConstantchoiceProdProcs, data]]];
END;


<<ConstantcomponentlistProd>>

ConstantcomponentlistProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantcomponentlistProdCoerce, ConstantcomponentlistProdGetCARDINAL, 
ConstantcomponentlistProdConstantToRope]];

BuildConstantcomponentlistProdNode: PUBLIC PROC[position: INT, length: INT, ComponentList: ComponentListNode]
RETURNS[ConstantNode] =
BEGIN
data: ConstantcomponentlistProdData _
NEW[ConstantcomponentlistProdDataBody_[
ComponentList]];
RETURN[NEW[ConstantNodeBody_[position, length, ConstantcomponentlistProdProcs, data]]];
END;


<<ConstantelementListProd>>

ConstantelementListProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantelementListProdCoerce, ConstantelementListProdGetCARDINAL, 
ConstantelementListProdConstantToRope]];

BuildConstantelementListProdNode: PUBLIC PROC[position: INT, length: INT, ElementList: ElementListNode]
RETURNS[ConstantNode] =
BEGIN
data: ConstantelementListProdData _
NEW[ConstantelementListProdDataBody_[
ElementList]];
RETURN[NEW[ConstantNodeBody_[position, length, ConstantelementListProdProcs, data]]];
END;


<<ConstantemptyProd>>

ConstantemptyProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantemptyProdCoerce, ConstantemptyProdGetCARDINAL, ConstantemptyProdConstantToRope]];

BuildConstantemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[ConstantNode] =
BEGIN
RETURN[NEW[ConstantNodeBody_[position, length, ConstantemptyProdProcs, NIL]]];
END;


<<ConstantfalseProd>>

ConstantfalseProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantfalseProdCoerce, ConstantfalseProdGetCARDINAL, ConstantfalseProdConstantToRope]];

BuildConstantfalseProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[ConstantNode] =
BEGIN
RETURN[NEW[ConstantNodeBody_[position, length, ConstantfalseProdProcs, NIL]]];
END;


<<ConstantidProd>>

ConstantidProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantidProdCoerce, ConstantidProdGetCARDINAL, ConstantidProdConstantToRope]];

BuildConstantidProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[ConstantNode] =
BEGIN
data: ConstantidProdData _
NEW[ConstantidProdDataBody_[
identifier]];
RETURN[NEW[ConstantNodeBody_[position, length, ConstantidProdProcs, data]]];
END;


<<ConstantnegativeNumberProd>>

ConstantnegativeNumberProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantnegativeNumberProdCoerce, ConstantnegativeNumberProdGetCARDINAL, 
ConstantnegativeNumberProdConstantToRope]];

BuildConstantnegativeNumberProdNode: PUBLIC PROC[position: INT, length: INT, number: numberNode]
RETURNS[ConstantNode] =
BEGIN
data: ConstantnegativeNumberProdData _
NEW[ConstantnegativeNumberProdDataBody_[
number]];
RETURN[NEW[ConstantNodeBody_[position, length, ConstantnegativeNumberProdProcs, data]]];
END;


<<ConstantnumberProd>>

ConstantnumberProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantnumberProdCoerce, ConstantnumberProdGetCARDINAL, ConstantnumberProdConstantToRope]];

BuildConstantnumberProdNode: PUBLIC PROC[position: INT, length: INT, number: numberNode]
RETURNS[ConstantNode] =
BEGIN
data: ConstantnumberProdData _
NEW[ConstantnumberProdDataBody_[
number]];
RETURN[NEW[ConstantNodeBody_[position, length, ConstantnumberProdProcs, data]]];
END;


<<ConstantremoteReferenceProd>>

ConstantremoteReferenceProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantremoteReferenceProdCoerce, ConstantremoteReferenceProdGetCARDINAL, 
ConstantremoteReferenceProdConstantToRope]];

BuildConstantremoteReferenceProdNode: PUBLIC PROC[position: INT, length: INT, identifierleft: identifierNode, identifierright: 
identifierNode]
RETURNS[ConstantNode] =
BEGIN
data: ConstantremoteReferenceProdData _
NEW[ConstantremoteReferenceProdDataBody_[
identifierleft, identifierright]];
RETURN[NEW[ConstantNodeBody_[position, length, ConstantremoteReferenceProdProcs, data]]];
END;


<<ConstantstringProd>>

ConstantstringProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantstringProdCoerce, ConstantstringProdGetCARDINAL, ConstantstringProdConstantToRope]];

BuildConstantstringProdNode: PUBLIC PROC[position: INT, length: INT, Rope: RopeNode]
RETURNS[ConstantNode] =
BEGIN
data: ConstantstringProdData _
NEW[ConstantstringProdDataBody_[
Rope]];
RETURN[NEW[ConstantNodeBody_[position, length, ConstantstringProdProcs, data]]];
END;


<<ConstanttrueProd>>

ConstanttrueProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstanttrueProdCoerce, ConstanttrueProdGetCARDINAL, ConstanttrueProdConstantToRope]];

BuildConstanttrueProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[ConstantNode] =
BEGIN
RETURN[NEW[ConstantNodeBody_[position, length, ConstanttrueProdProcs, NIL]]];
END;


<<ConstantunboundedProd>>

ConstantunboundedProdProcs: PUBLIC ConstantNodeProcs _
NEW[ConstantNodeProcsBody _ [ConstantunboundedProdCoerce, ConstantunboundedProdGetCARDINAL, ConstantunboundedProdConstantToRope]];

BuildConstantunboundedProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[ConstantNode] =
BEGIN
RETURN[NEW[ConstantNodeBody_[position, length, ConstantunboundedProdProcs, NIL]]];
END;


<<ElementListoneProd>>

ElementListoneProdProcs: PUBLIC ElementListNodeProcs _
NEW[ElementListNodeProcsBody _ [ElementListoneProdCoerceElementList, ElementListoneProdConstantToRope, ElementListoneProdSize, 
ElementListoneProdConstructFunction]];

BuildElementListoneProdNode: PUBLIC PROC[position: INT, length: INT, Constant: ConstantNode]
RETURNS[ElementListNode] =
BEGIN
data: ElementListoneProdData _
NEW[ElementListoneProdDataBody_[
Constant]];
RETURN[NEW[ElementListNodeBody_[position, length, ElementListoneProdProcs, data]]];
END;


<<ElementListmoreProd>>

ElementListmoreProdProcs: PUBLIC ElementListNodeProcs _
NEW[ElementListNodeProcsBody _ [ElementListmoreProdCoerceElementList, ElementListmoreProdConstantToRope, ElementListmoreProdSize, 
ElementListmoreProdConstructFunction]];

BuildElementListmoreProdNode: PUBLIC PROC[position: INT, length: INT, Constant: ConstantNode, ElementList: ElementListNode]
RETURNS[ElementListNode] =
BEGIN
data: ElementListmoreProdData _
NEW[ElementListmoreProdDataBody_[
Constant, ElementList]];
RETURN[NEW[ElementListNodeBody_[position, length, ElementListmoreProdProcs, data]]];
END;


<<ComponentListoneProd>>

ComponentListoneProdProcs: PUBLIC ComponentListNodeProcs _
NEW[ComponentListNodeProcsBody _ [ComponentListoneProdCoerceComponents, ComponentListoneProdConstantToRope, 
ComponentListoneProdCheckAllNames]];

BuildComponentListoneProdNode: PUBLIC PROC[position: INT, length: INT, Component: ComponentNode]
RETURNS[ComponentListNode] =
BEGIN
data: ComponentListoneProdData _
NEW[ComponentListoneProdDataBody_[
Component]];
RETURN[NEW[ComponentListNodeBody_[position, length, ComponentListoneProdProcs, data]]];
END;


<<ComponentListmoreProd>>

ComponentListmoreProdProcs: PUBLIC ComponentListNodeProcs _
NEW[ComponentListNodeProcsBody _ [ComponentListmoreProdCoerceComponents, ComponentListmoreProdConstantToRope, 
ComponentListmoreProdCheckAllNames]];

BuildComponentListmoreProdNode: PUBLIC PROC[position: INT, length: INT, Component: ComponentNode, ComponentList: ComponentListNode]
RETURNS[ComponentListNode] =
BEGIN
data: ComponentListmoreProdData _
NEW[ComponentListmoreProdDataBody_[
Component, ComponentList]];
RETURN[NEW[ComponentListNodeBody_[position, length, ComponentListmoreProdProcs, data]]];
END;


<<ComponentProd>>

ComponentProdProcs: PUBLIC ComponentNodeProcs _
NEW[ComponentNodeProcsBody _ [ComponentProdCoerceComponents, ComponentProdConstantToRope, ComponentProdCheckAllNames]];

BuildComponentProdNode: PUBLIC PROC[position: INT, length: INT, NameList: NameListNode, Constant: ConstantNode]
RETURNS[ComponentNode] =
BEGIN
data: ComponentProdData _
NEW[ComponentProdDataBody_[
NameList, Constant]];
RETURN[NEW[ComponentNodeBody_[position, length, ComponentProdProcs, data]]];
END;


<<NameListemptyProd>>

NameListemptyProdProcs: PUBLIC NameListNodeProcs _
NEW[NameListNodeProcsBody _ [NameListemptyProdCheckIfErrorNames, NameListemptyProdCanonicaliseFieldsFromNameList, 
NameListemptyProdCoerceComponentNameList, NameListemptyProdNameListToRope, NameListemptyProdEmptyWorkTableOfNames, 
NameListemptyProdTypeOfNameList]];

BuildNameListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[NameListNode] =
BEGIN
RETURN[NEW[NameListNodeBody_[position, length, NameListemptyProdProcs, NIL]]];
END;


<<NameListoneProd>>

NameListoneProdProcs: PUBLIC NameListNodeProcs _
NEW[NameListNodeProcsBody _ [NameListoneProdCheckIfErrorNames, NameListoneProdCanonicaliseFieldsFromNameList, 
NameListoneProdCoerceComponentNameList, NameListoneProdNameListToRope, NameListoneProdEmptyWorkTableOfNames, 
NameListoneProdTypeOfNameList]];

BuildNameListoneProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode]
RETURNS[NameListNode] =
BEGIN
data: NameListoneProdData _
NEW[NameListoneProdDataBody_[
identifier]];
RETURN[NEW[NameListNodeBody_[position, length, NameListoneProdProcs, data]]];
END;


<<NameListmoreProd>>

NameListmoreProdProcs: PUBLIC NameListNodeProcs _
NEW[NameListNodeProcsBody _ [NameListmoreProdCheckIfErrorNames, NameListmoreProdCanonicaliseFieldsFromNameList, 
NameListmoreProdCoerceComponentNameList, NameListmoreProdNameListToRope, NameListmoreProdEmptyWorkTableOfNames, 
NameListmoreProdTypeOfNameList]];

BuildNameListmoreProdNode: PUBLIC PROC[position: INT, length: INT, identifier: identifierNode, NameList: NameListNode]
RETURNS[NameListNode] =
BEGIN
data: NameListmoreProdData _
NEW[NameListmoreProdDataBody_[
identifier, NameList]];
RETURN[NEW[NameListNodeBody_[position, length, NameListmoreProdProcs, data]]];
END;


<<numberdecimalProd>>

numberdecimalProdProcs: PUBLIC numberNodeProcs _
NEW[numberNodeProcsBody _ [numberdecimalProdGetCARDINAL, numberdecimalProdNumberToCard]];

BuildnumberdecimalProdNode: PUBLIC PROC[position: INT, length: INT, numberD: numberDNode]
RETURNS[numberNode] =
BEGIN
data: numberdecimalProdData _
NEW[numberdecimalProdDataBody_[
numberD]];
RETURN[NEW[numberNodeBody_[position, length, numberdecimalProdProcs, data]]];
END;


<<numberhexProd>>

numberhexProdProcs: PUBLIC numberNodeProcs _
NEW[numberNodeProcsBody _ [numberhexProdGetCARDINAL, numberhexProdNumberToCard]];

BuildnumberhexProdNode: PUBLIC PROC[position: INT, length: INT, numberH: numberHNode]
RETURNS[numberNode] =
BEGIN
data: numberhexProdData _
NEW[numberhexProdDataBody_[
numberH]];
RETURN[NEW[numberNodeBody_[position, length, numberhexProdProcs, data]]];
END;


<<numberoctalProd>>

numberoctalProdProcs: PUBLIC numberNodeProcs _
NEW[numberNodeProcsBody _ [numberoctalProdGetCARDINAL, numberoctalProdNumberToCard]];

BuildnumberoctalProdNode: PUBLIC PROC[position: INT, length: INT, numberO: numberONode]
RETURNS[numberNode] =
BEGIN
data: numberoctalProdData _
NEW[numberoctalProdDataBody_[
numberO]];
RETURN[NEW[numberNodeBody_[position, length, numberoctalProdProcs, data]]];
END;

END..