DIRECTORY
ConcreteSyntaxDef USING[],
ThreeC4Support,
WartDef,
AbstractTypesDef,
AbstractProductionsDef;

ConcreteSyntaxImpl: CEDAR PROGRAM IMPORTS AbstractProductionsDef EXPORTS ConcreteSyntaxDef= 
BEGIN
OPEN ThreeC4Support, WartDef, AbstractTypesDef, AbstractProductionsDef;
ConcreteSyntaxLinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[0] _ SeeOuterProgram;
prodLinkArray[1] _ SeeProgram;
prodLinkArray[2] _ SeeDependencyListempty;
prodLinkArray[3] _ SeeDependencyListmore;
prodLinkArray[4] _ SeeReferencedProgramListone;
prodLinkArray[5] _ SeeReferencedProgramListmore;
prodLinkArray[6] _ SeeReferencedProgram;
prodLinkArray[7] _ SeeDeclarationLista;
prodLinkArray[8] _ SeeDeclarationListb;
prodLinkArray[9] _ SeeDeclarationtype;
prodLinkArray[10] _ SeeDeclarationconstant;
prodLinkArray[11] _ SeeDeclarationid;
prodLinkArray[12] _ SeeTypesimple;
prodLinkArray[13] _ SeeTypeConstructedType;
prodLinkArray[14] _ SeeSimpleTypepredefinedType;
prodLinkArray[15] _ SeeSimpleTypereferencedType;
prodLinkArray[16] _ SeePredefinedTypeboolean;
prodLinkArray[17] _ SeePredefinedTypeCardinal;
prodLinkArray[18] _ SeePredefinedTypelongCardinal;
prodLinkArray[19] _ SeePredefinedTypeinteger;
prodLinkArray[20] _ SeePredefinedTypelongInteger;
prodLinkArray[21] _ SeePredefinedTypestring;
prodLinkArray[22] _ SeePredefinedTypeunspecified;
prodLinkArray[23] _ SeePredefinedTypebulkDataSource;
prodLinkArray[24] _ SeePredefinedTypebulkDataSink;
prodLinkArray[25] _ SeeConstructedTypeenumeration;
prodLinkArray[26] _ SeeConstructedTypearray;
prodLinkArray[27] _ SeeConstructedTypesequence;
prodLinkArray[28] _ SeeConstructedTyperecord;
prodLinkArray[29] _ SeeConstructedTypeemptyRecord;
prodLinkArray[30] _ SeeConstructedTypechoice;
prodLinkArray[31] _ SeeConstructedTypeprocedure;
prodLinkArray[32] _ SeeConstructedTypeerror;
prodLinkArray[33] _ SeeReferencedTypelocalReference;
prodLinkArray[34] _ SeeReferencedTyperemoteReference;
prodLinkArray[35] _ SeeCorrespondenceListone;
prodLinkArray[36] _ SeeCorrespondenceListmore;
prodLinkArray[37] _ SeeCorrespondence;
prodLinkArray[38] _ SeeOptionalNumbernonEmpty;
prodLinkArray[39] _ SeeOptionalNumberlocalReference;
prodLinkArray[40] _ SeeOptionalNumberempty;
prodLinkArray[41] _ SeeMandatoryNumbervalue;
prodLinkArray[42] _ SeeMandatoryNumberlocalReference;
prodLinkArray[43] _ SeeCandidateListone;
prodLinkArray[44] _ SeeCandidateListmore;
prodLinkArray[45] _ SeeCandidateone;
prodLinkArray[46] _ SeeCandidatetwo;
prodLinkArray[47] _ SeeArgumentLista;
prodLinkArray[48] _ SeeArgumentListb;
prodLinkArray[49] _ SeeArgumentListc;
prodLinkArray[50] _ SeeResultLista;
prodLinkArray[51] _ SeeResultListb;
prodLinkArray[52] _ SeeResultListc;
prodLinkArray[53] _ SeeErrorLista;
prodLinkArray[54] _ SeeErrorListb;
prodLinkArray[55] _ SeeFieldLista;
prodLinkArray[56] _ SeeFieldListb;
prodLinkArray[57] _ SeeField;
prodLinkArray[58] _ SeeConstantpredefined;
prodLinkArray[59] _ SeeConstantconstructed;
prodLinkArray[60] _ SeeConstantchoiceConstant;
prodLinkArray[61] _ SeeConstantchoiceIdentifier;
prodLinkArray[62] _ SeeConstantremoteReference;
prodLinkArray[63] _ SeePredefinedConstanttrue;
prodLinkArray[64] _ SeePredefinedConstantfalse;
prodLinkArray[65] _ SeePredefinedConstantnumber;
prodLinkArray[66] _ SeePredefinedConstantnegativeNumber;
prodLinkArray[67] _ SeePredefinedConstantstring;
prodLinkArray[68] _ SeeConstructedConstantelementList;
prodLinkArray[69] _ SeeConstructedConstantcomponentlist;
prodLinkArray[70] _ SeeConstructedConstantempty;
prodLinkArray[71] _ SeeElementListone;
prodLinkArray[72] _ SeeElementListmore;
prodLinkArray[73] _ SeeElementListid;
prodLinkArray[74] _ SeeElementListidAndMore;
prodLinkArray[75] _ SeeComponentListone;
prodLinkArray[76] _ SeeComponentListmore;
prodLinkArray[77] _ SeeComponentmore;
prodLinkArray[78] _ SeeComponentone;
prodLinkArray[79] _ SeeNameListone;
prodLinkArray[80] _ SeeNameListmore;
prodLinkArray[81] _ Seenumbera;
prodLinkArray[82] _ Seenumberb;
prodLinkArray[83] _ Seenumberc;
END;

SeeOuterProgram: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Program: ProgramNode;
Program _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[Program, stack];
RETURN[stack]
END;

SeeProgram: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
numberDa: numberDNode;
numberDb: numberDNode;
DependencyList: ReferencedProgramListNode;
DeclarationList: DeclarationListNode;
DeclarationList _ NARROW[stack.first];
stack _ stack.rest;
DependencyList _ NARROW[stack.first];
stack _ stack.rest;
numberDb _ NARROW[stack.first];
stack _ stack.rest;
numberDa _ NARROW[stack.first];
stack _ stack.rest;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildProgramProdNode[position, length, identifier, numberDa, numberDb, DependencyList, DeclarationList], stack];
RETURN[stack]
END;

SeeDependencyListempty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildReferencedProgramListemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeDependencyListmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ReferencedProgramList: ReferencedProgramListNode;
ReferencedProgramList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[ReferencedProgramList, stack];
RETURN[stack]
END;

SeeReferencedProgramListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ReferencedProgram: ReferencedProgramNode;
ReferencedProgram _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildReferencedProgramListmoreProdNode[position, length, 
BuildReferencedProgramListemptyProdNode[ReferencedProgram.position, ReferencedProgram.position - ReferencedProgram.length], 
ReferencedProgram], stack];
RETURN[stack]
END;

SeeReferencedProgramListmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ReferencedProgramList: ReferencedProgramListNode;
ReferencedProgram: ReferencedProgramNode;
ReferencedProgram _ NARROW[stack.first];
stack _ stack.rest;
ReferencedProgramList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildReferencedProgramListmoreProdNode[position, length, ReferencedProgramList, ReferencedProgram], stack];
RETURN[stack]
END;

SeeReferencedProgram: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
numberDa: numberDNode;
numberDb: numberDNode;
numberDb _ NARROW[stack.first];
stack _ stack.rest;
numberDa _ NARROW[stack.first];
stack _ stack.rest;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildReferencedProgramProdNode[position, length, identifier, numberDa, numberDb], stack];
RETURN[stack]
END;

SeeDeclarationLista: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildDeclarationListemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeDeclarationListb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
DeclarationList: DeclarationListNode;
Declaration: DeclarationNode;
Declaration _ NARROW[stack.first];
stack _ stack.rest;
DeclarationList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDeclarationListmoreProdNode[position, length, DeclarationList, Declaration], stack];
RETURN[stack]
END;

SeeDeclarationtype: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
Type: TypeNode;
Type _ NARROW[stack.first];
stack _ stack.rest;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDeclarationtypeProdNode[position, length, identifier, Type], stack];
RETURN[stack]
END;

SeeDeclarationconstant: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
Type: TypeNode;
Constant: ConstantNode;
Constant _ NARROW[stack.first];
stack _ stack.rest;
Type _ NARROW[stack.first];
stack _ stack.rest;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDeclarationconstantProdNode[position, length, identifier, Type, Constant], stack];
RETURN[stack]
END;

SeeDeclarationid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifiername: identifierNode;
Type: TypeNode;
identifierconstant: identifierNode;
identifierconstant _ NARROW[stack.first];
stack _ stack.rest;
Type _ NARROW[stack.first];
stack _ stack.rest;
identifiername _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDeclarationconstantProdNode[position, length, identifiername, Type, 
BuildConstantidProdNode[identifierconstant.position, identifierconstant.length, identifierconstant]], stack];
RETURN[stack]
END;

SeeTypesimple: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
SimpleType: TypeNode;
SimpleType _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[SimpleType, stack];
RETURN[stack]
END;

SeeTypeConstructedType: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ConstructedType: TypeNode;
ConstructedType _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[ConstructedType, stack];
RETURN[stack]
END;

SeeSimpleTypepredefinedType: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
PredefinedType: TypeNode;
PredefinedType _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[PredefinedType, stack];
RETURN[stack]
END;

SeeSimpleTypereferencedType: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ReferencedType: TypeNode;
ReferencedType _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[ReferencedType, stack];
RETURN[stack]
END;

SeePredefinedTypeboolean: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypebooleanProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedTypeCardinal: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypecardinalProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedTypelongCardinal: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypelongCardinalProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedTypeinteger: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypeintegerProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedTypelongInteger: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypelongIntegerProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedTypestring: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypestringProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedTypeunspecified: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypeunspecifiedProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedTypebulkDataSource: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypebulkDataSourceProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedTypebulkDataSink: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypebulkDataSinkProdNode[position, length], stack];
RETURN[stack]
END;

SeeConstructedTypeenumeration: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
CorrespondenceList: CorrespondenceListNode;
CorrespondenceList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeenumerationProdNode[position, length, CorrespondenceList], stack];
RETURN[stack]
END;

SeeConstructedTypearray: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
MandatoryNumber: ConstantNode;
SimpleType: TypeNode;
SimpleType _ NARROW[stack.first];
stack _ stack.rest;
MandatoryNumber _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypearrayProdNode[position, length, MandatoryNumber, SimpleType], stack];
RETURN[stack]
END;

SeeConstructedTypesequence: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
OptionalNumber: ConstantNode;
SimpleType: TypeNode;
SimpleType _ NARROW[stack.first];
stack _ stack.rest;
OptionalNumber _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypesequenceProdNode[position, length, OptionalNumber, SimpleType], stack];
RETURN[stack]
END;

SeeConstructedTyperecord: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
FieldList: FieldListNode;
FieldList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTyperecordProdNode[position, length, FieldList], stack];
RETURN[stack]
END;

SeeConstructedTypeemptyRecord: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildTypeemptyRecordProdNode[position, length], stack];
RETURN[stack]
END;

SeeConstructedTypechoice: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ReferencedType: TypeNode;
CandidateList: CandidateListNode;
CandidateList _ NARROW[stack.first];
stack _ stack.rest;
ReferencedType _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypechoiceProdNode[position, length, ReferencedType, CandidateList], stack];
RETURN[stack]
END;

SeeConstructedTypeprocedure: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ArgumentList: FieldListNode;
ResultList: FieldListNode;
ErrorList: NameListNode;
ErrorList _ NARROW[stack.first];
stack _ stack.rest;
ResultList _ NARROW[stack.first];
stack _ stack.rest;
ArgumentList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeprocedureProdNode[position, length, ArgumentList, ResultList, ErrorList], stack];
RETURN[stack]
END;

SeeConstructedTypeerror: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ArgumentList: FieldListNode;
ArgumentList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypeerrorProdNode[position, length, ArgumentList], stack];
RETURN[stack]
END;

SeeReferencedTypelocalReference: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTypelocalReferenceProdNode[position, length, identifier], stack];
RETURN[stack]
END;

SeeReferencedTyperemoteReference: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifierremote: identifierNode;
identifierid: identifierNode;
identifierid _ NARROW[stack.first];
stack _ stack.rest;
identifierremote _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTyperemoteReferenceProdNode[position, length, identifierremote, identifierid], stack];
RETURN[stack]
END;

SeeCorrespondenceListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Correspondence: CorrespondenceListNode;
Correspondence _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[Correspondence, stack];
RETURN[stack]
END;

SeeCorrespondenceListmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Correspondence: CorrespondenceListNode;
CorrespondenceList: CorrespondenceListNode;
CorrespondenceList _ NARROW[stack.first];
stack _ stack.rest;
Correspondence _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCorrespondenceListmoreProdNode[position, length, Correspondence, CorrespondenceList], stack];
RETURN[stack]
END;

SeeCorrespondence: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
MandatoryNumber: ConstantNode;
MandatoryNumber _ NARROW[stack.first];
stack _ stack.rest;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCorrespondenceListoneProdNode[position, length, identifier, MandatoryNumber], stack];
RETURN[stack]
END;

SeeOptionalNumbernonEmpty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Constant: ConstantNode;
Constant _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[Constant, stack];
RETURN[stack]
END;

SeeOptionalNumberlocalReference: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantidProdNode[position, length, identifier], stack];
RETURN[stack]
END;

SeeOptionalNumberempty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildConstantunboundedProdNode[position, length], stack];
RETURN[stack]
END;

SeeMandatoryNumbervalue: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Constant: ConstantNode;
Constant _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[Constant, stack];
RETURN[stack]
END;

SeeMandatoryNumberlocalReference: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantidProdNode[position, length, identifier], stack];
RETURN[stack]
END;

SeeCandidateListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Candidate: CandidateListNode;
Candidate _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[Candidate, stack];
RETURN[stack]
END;

SeeCandidateListmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Candidate: CandidateListNode;
CandidateList: CandidateListNode;
CandidateList _ NARROW[stack.first];
stack _ stack.rest;
Candidate _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCandidateListmoreProdNode[position, length, Candidate, CandidateList], stack];
RETURN[stack]
END;

SeeCandidateone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
NameList: NameListNode;
SimpleType: TypeNode;
SimpleType _ NARROW[stack.first];
stack _ stack.rest;
NameList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCandidateListoneProdNode[position, length, NameList, SimpleType], stack];
RETURN[stack]
END;

SeeCandidatetwo: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
NameList: NameListNode;
number: numberNode;
SimpleType: TypeNode;
SimpleType _ NARROW[stack.first];
stack _ stack.rest;
number _ NARROW[stack.first];
stack _ stack.rest;
NameList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildCandidateListoneProdNode[position, length, NameList, SimpleType], stack];
RETURN[stack]
END;

SeeArgumentLista: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildFieldListemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeArgumentListb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
FieldList: FieldListNode;
FieldList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[FieldList, stack];
RETURN[stack]
END;

SeeArgumentListc: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildFieldListemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeResultLista: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildFieldListemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeResultListb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
FieldList: FieldListNode;
FieldList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[FieldList, stack];
RETURN[stack]
END;

SeeResultListc: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildFieldListemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeErrorLista: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildNameListemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeErrorListb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
NameList: NameListNode;
NameList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[NameList, stack];
RETURN[stack]
END;

SeeFieldLista: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Field: FieldListNode;
Field _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildFieldListmoreProdNode[position, length, Field, BuildFieldListemptyProdNode[Field.position, Field.position - 
Field.length]], stack];
RETURN[stack]
END;

SeeFieldListb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Field: FieldListNode;
FieldList: FieldListNode;
FieldList _ NARROW[stack.first];
stack _ stack.rest;
Field _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildFieldListmoreProdNode[position, length, Field, FieldList], stack];
RETURN[stack]
END;

SeeField: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
NameList: NameListNode;
SimpleType: TypeNode;
SimpleType _ NARROW[stack.first];
stack _ stack.rest;
NameList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildFieldListoneProdNode[position, length, NameList, SimpleType], stack];
RETURN[stack]
END;

SeeConstantpredefined: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
PredefinedConstant: ConstantNode;
PredefinedConstant _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[PredefinedConstant, stack];
RETURN[stack]
END;

SeeConstantconstructed: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ConstructedConstant: ConstantNode;
ConstructedConstant _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[ConstructedConstant, stack];
RETURN[stack]
END;

SeeConstantchoiceConstant: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
Constant: ConstantNode;
Constant _ NARROW[stack.first];
stack _ stack.rest;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantchoiceProdNode[position, length, identifier, Constant], stack];
RETURN[stack]
END;

SeeConstantchoiceIdentifier: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifierfirst: identifierNode;
identifiernext: identifierNode;
identifiernext _ NARROW[stack.first];
stack _ stack.rest;
identifierfirst _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantchoiceProdNode[position, length, identifierfirst, BuildConstantidProdNode[identifiernext.position, 
identifiernext.length, identifiernext]], stack];
RETURN[stack]
END;

SeeConstantremoteReference: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifierleft: identifierNode;
identifierright: identifierNode;
identifierright _ NARROW[stack.first];
stack _ stack.rest;
identifierleft _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantremoteReferenceProdNode[position, length, identifierleft, identifierright], stack];
RETURN[stack]
END;

SeePredefinedConstanttrue: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildConstanttrueProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedConstantfalse: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildConstantfalseProdNode[position, length], stack];
RETURN[stack]
END;

SeePredefinedConstantnumber: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
number: numberNode;
number _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantnumberProdNode[position, length, number], stack];
RETURN[stack]
END;

SeePredefinedConstantnegativeNumber: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
number: numberNode;
number _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantnegativeNumberProdNode[position, length, number], stack];
RETURN[stack]
END;

SeePredefinedConstantstring: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Rope: RopeNode;
Rope _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantstringProdNode[position, length, Rope], stack];
RETURN[stack]
END;

SeeConstructedConstantelementList: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ElementList: ElementListNode;
ElementList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantelementListProdNode[position, length, ElementList], stack];
RETURN[stack]
END;

SeeConstructedConstantcomponentlist: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
ComponentList: ComponentListNode;
ComponentList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConstantcomponentlistProdNode[position, length, ComponentList], stack];
RETURN[stack]
END;

SeeConstructedConstantempty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildConstantemptyProdNode[position, length], stack];
RETURN[stack]
END;

SeeElementListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Constant: ConstantNode;
Constant _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementListoneProdNode[position, length, Constant], stack];
RETURN[stack]
END;

SeeElementListmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Constant: ConstantNode;
ElementList: ElementListNode;
ElementList _ NARROW[stack.first];
stack _ stack.rest;
Constant _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementListmoreProdNode[position, length, Constant, ElementList], stack];
RETURN[stack]
END;

SeeElementListid: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementListoneProdNode[position, length, BuildConstantidProdNode[identifier.position, identifier.length, 
identifier]], stack];
RETURN[stack]
END;

SeeElementListidAndMore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
ElementList: ElementListNode;
ElementList _ NARROW[stack.first];
stack _ stack.rest;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildElementListmoreProdNode[position, length, BuildConstantidProdNode[identifier.position, identifier.length, 
identifier], ElementList], stack];
RETURN[stack]
END;

SeeComponentListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Component: ComponentNode;
Component _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildComponentListoneProdNode[position, length, Component], stack];
RETURN[stack]
END;

SeeComponentListmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
Component: ComponentNode;
ComponentList: ComponentListNode;
ComponentList _ NARROW[stack.first];
stack _ stack.rest;
Component _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildComponentListmoreProdNode[position, length, Component, ComponentList], stack];
RETURN[stack]
END;

SeeComponentmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
NameList: NameListNode;
Constant: ConstantNode;
Constant _ NARROW[stack.first];
stack _ stack.rest;
NameList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildComponentProdNode[position, length, NameList, Constant], stack];
RETURN[stack]
END;

SeeComponentone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
NameList: NameListNode;
identifier: identifierNode;
identifier _ NARROW[stack.first];
stack _ stack.rest;
NameList _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildComponentProdNode[position, length, NameList, BuildConstantidProdNode[identifier.position, identifier.length, 
identifier]], stack];
RETURN[stack]
END;

SeeNameListone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildNameListoneProdNode[position, length, identifier], stack];
RETURN[stack]
END;

SeeNameListmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identifier: identifierNode;
NameList: NameListNode;
NameList _ NARROW[stack.first];
stack _ stack.rest;
identifier _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildNameListmoreProdNode[position, length, identifier, NameList], stack];
RETURN[stack]
END;

Seenumbera: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
numberD: numberDNode;
numberD _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildnumberdecimalProdNode[position, length, numberD], stack];
RETURN[stack]
END;

Seenumberb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
numberO: numberONode;
numberO _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildnumberoctalProdNode[position, length, numberO], stack];
RETURN[stack]
END;

Seenumberc: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
numberH: numberHNode;
numberH _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildnumberhexProdNode[position, length, numberH], stack];
RETURN[stack]
END;

END..