[Cyan]<CedarChest6.1>Sirocco>AbstractProductionsDef.Mesa!1

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..