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