
<<SaffronCG5Impl.mesa>>
<<Copyright Ó 1987 by Xerox Corporation.  All rights reserved.>>
<<Generated by BJackson.pa at April 27, 1987 10:56:59 pm PDT>>
<<using ThreeCasabaFour [1.1] of April 14, 1987 6:34:07 pm PDT>>

DIRECTORY
SaffronAG7Def,
SaffronAG2Def,
SaffronAG3Def,
SaffronAG1Def,
SaffronAG4Def,
SaffronAG5Def,
SaffronGenericDef,
ThreeC4Support,
SaffronCG5Def USING[],
SaffronATDef;

SaffronCG5Impl: CEDAR PROGRAM IMPORTS SaffronAG7Def, SaffronAG2Def, SaffronAG3Def, SaffronAG1Def, SaffronAG4Def, SaffronAG5Def 
EXPORTS SaffronCG5Def= 
BEGIN
OPEN SaffronAG7Def, SaffronAG2Def, SaffronAG3Def, SaffronAG1Def, SaffronAG4Def, SaffronAG5Def, SaffronGenericDef, ThreeC4Support, 
SaffronATDef;
SaffronCG5LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[259] _ Seedotestuntil;
prodLinkArray[260] _ Seedotestwhile;
prodLinkArray[261] _ Seedotestempty;
prodLinkArray[262] _ Seeoptargsexplist;
prodLinkArray[263] _ Seeoptargsempty;
prodLinkArray[264] _ Seeoptargsexp;
prodLinkArray[265] _ Seefreeplain;
prodLinkArray[266] _ Seefreezoned;
prodLinkArray[267] _ Seecasestmtlistempty;
prodLinkArray[268] _ Seecasestmtlistb;
prodLinkArray[269] _ Seecasestmtlistc;
prodLinkArray[270] _ SeecasestmtlistPa;
prodLinkArray[271] _ SeecasestmtlistPb;
prodLinkArray[272] _ Seecasestmtitem;
prodLinkArray[273] _ Seedeclistone;
prodLinkArray[274] _ Seedeclistmany;
prodLinkArray[275] _ Seedeclarationvalue;
prodLinkArray[276] _ Seedeclarationtype;
prodLinkArray[277] _ Seedeclarationopaquetype;
prodLinkArray[278] _ Seeentryentry;
prodLinkArray[279] _ Seeentryinternal;
prodLinkArray[280] _ Seeentryempty;
prodLinkArray[281] _ Seeoptsizepresent;
prodLinkArray[282] _ Seeoptsizeabsent;
prodLinkArray[283] _ Seeprimaryexplist;
prodLinkArray[284] _ Seeprimaryprefixop;
prodLinkArray[285] _ Seeprimaryval;
prodLinkArray[286] _ Seeprimaryall;
prodLinkArray[287] _ Seeprimarynew;
prodLinkArray[288] _ Seeprimarycons;
prodLinkArray[289] _ Seeprimarylistcons;
prodLinkArray[290] _ Seeprimarynil;
prodLinkArray[291] _ Seeprimarytypeop;
prodLinkArray[292] _ Seeprimarysize;
prodLinkArray[293] _ Seeprimarysize2;
prodLinkArray[294] _ Seeprimaryistype;
prodLinkArray[295] _ Seeprimaryaddress;
prodLinkArray[296] _ Seeprimarydescriptor;
prodLinkArray[297] _ Seeprimarylhs;
prodLinkArray[298] _ Seenewplain;
prodLinkArray[299] _ Seenewzoned;
prodLinkArray[300] _ Seeconsplain;
prodLinkArray[301] _ Seeconszoned;
prodLinkArray[302] _ Seelistconsplain;
prodLinkArray[303] _ Seelistconszoned;
prodLinkArray[304] _ Seedesclistexplicit;
prodLinkArray[305] _ Seedesclistdefault;
prodLinkArray[306] _ Seeoptcatchcatchlist;
prodLinkArray[307] _ Seeoptcatchempty;
prodLinkArray[308] _ Seeidentlist;
prodLinkArray[309] _ SeeidentlistPa;
prodLinkArray[310] _ SeeidentlistPb;
prodLinkArray[311] _ SeeidentlistPc;
prodLinkArray[312] _ SeeidentlistPd;
prodLinkArray[313] _ Seeprefixoplong;
prodLinkArray[314] _ Seeprefixopabs;
prodLinkArray[315] _ Seeprefixoppred;
prodLinkArray[316] _ Seeprefixopsucc;
prodLinkArray[317] _ Seeprefixopord;
prodLinkArray[318] _ Seeprefixopmin;
prodLinkArray[319] _ Seeprefixopmax;
prodLinkArray[320] _ Seeprefixopbase;
prodLinkArray[321] _ Seeprefixoplength;
END;

Seedotestuntil: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDoTestuntilProdNode[position, length, exp], stack];
RETURN[stack]
END;

Seedotestwhile: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDoTestwhileProdNode[position, length, exp], stack];
RETURN[stack]
END;

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

Seeoptargsexplist: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
explist: ExpListNode;
explist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOptArgsexplistProdNode[position, length, explist], stack];
RETURN[stack]
END;

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

Seeoptargsexp: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOptArgsexpProdNode[position, length, lhs], stack];
RETURN[stack]
END;

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

Seefreezoned: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildFreezonedProdNode[position, length, lhs], stack];
RETURN[stack]
END;

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

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

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

SeecasestmtlistPa: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casestmtitem: SelectStmtItemNode;
casestmtitem _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSelectStmtListmoreProdNode[position, length, BuildSelectStmtListemptyProdNode[casestmtitem.position, 
casestmtitem.position - casestmtitem.length], casestmtitem], stack];
RETURN[stack]
END;

SeecasestmtlistPb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casestmtlistP: SelectStmtListNode;
casestmtitem: SelectStmtItemNode;
casestmtitem _ NARROW[stack.first];
stack _ stack.rest;
casestmtlistP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSelectStmtListmoreProdNode[position, length, casestmtlistP, casestmtitem], stack];
RETURN[stack]
END;

Seecasestmtitem: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
caselabel: SelectLabelNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
caselabel _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSelectStmtItemProdNode[position, length, caselabel, statement], stack];
RETURN[stack]
END;

Seedeclistone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
declaration: DeclarationNode;
declaration _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDecListoneProdNode[position, length, declaration], stack];
RETURN[stack]
END;

Seedeclistmany: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
declist: DecListNode;
declaration: DeclarationNode;
declaration _ NARROW[stack.first];
stack _ stack.rest;
declist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDecListmanyProdNode[position, length, declist, BuildDecListoneProdNode[declaration.position, declaration.length, 
declaration]], stack];
RETURN[stack]
END;

Seedeclarationvalue: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identlist: IdentListNode;
public: AccessNode;
entry: EntryNode;
readonly: ReadOnlyNode;
typeexp: TypeExpNode;
initialization: InitializationNode;
initialization _ NARROW[stack.first];
stack _ stack.rest;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
readonly _ NARROW[stack.first];
stack _ stack.rest;
entry _ NARROW[stack.first];
stack _ stack.rest;
public _ NARROW[stack.first];
stack _ stack.rest;
identlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDeclarationvalueProdNode[position, length, identlist, public, entry, readonly, typeexp, initialization], 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;
identlist: IdentListNode;
publicid: AccessNode;
tilde: JunkNode;
publictype: AccessNode;
typeexp: TypeExpNode;
default: DefaultNode;
default _ NARROW[stack.first];
stack _ stack.rest;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
publictype _ NARROW[stack.first];
stack _ stack.rest;
tilde _ NARROW[stack.first];
stack _ stack.rest;
publicid _ NARROW[stack.first];
stack _ stack.rest;
identlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDeclarationtypeProdNode[position, length, identlist, publicid, publictype, typeexp, default], stack];
RETURN[stack]
END;

Seedeclarationopaquetype: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
identlist: IdentListNode;
public: AccessNode;
optsize: OptSizeNode;
optsize _ NARROW[stack.first];
stack _ stack.rest;
public _ NARROW[stack.first];
stack _ stack.rest;
identlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDeclarationopaquetypeProdNode[position, length, identlist, public, optsize], stack];
RETURN[stack]
END;

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

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

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

Seeoptsizepresent: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOptSizepresentProdNode[position, length, exp], stack];
RETURN[stack]
END;

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

Seeprimaryexplist: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
explist: ExpListNode;
explist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpexplistProdNode[position, length, explist], stack];
RETURN[stack]
END;

Seeprimaryprefixop: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
prefixop: PrefixOpNode;
orderlist: OrderListNode;
orderlist _ NARROW[stack.first];
stack _ stack.rest;
prefixop _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpprefixopProdNode[position, length, prefixop, orderlist], stack];
RETURN[stack]
END;

Seeprimaryval: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
orderlist: OrderListNode;
orderlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpvalProdNode[position, length, orderlist], stack];
RETURN[stack]
END;

Seeprimaryall: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
orderlist: OrderListNode;
orderlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpallProdNode[position, length, orderlist], stack];
RETURN[stack]
END;

Seeprimarynew: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
new: NewNode;
typeexp: TypeExpNode;
initialization: InitializationNode;
optcatch: CatchNode;
optcatch _ NARROW[stack.first];
stack _ stack.rest;
initialization _ NARROW[stack.first];
stack _ stack.rest;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
new _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpnewProdNode[position, length, new, typeexp, initialization, optcatch], stack];
RETURN[stack]
END;

Seeprimarycons: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
cons: ConsNode;
explist: ExpListNode;
optcatch: CatchNode;
optcatch _ NARROW[stack.first];
stack _ stack.rest;
explist _ NARROW[stack.first];
stack _ stack.rest;
cons _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpconsProdNode[position, length, cons, explist, optcatch], stack];
RETURN[stack]
END;

Seeprimarylistcons: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
listcons: ListConsNode;
explist: ExpListNode;
explist _ NARROW[stack.first];
stack _ stack.rest;
listcons _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExplistconsProdNode[position, length, listcons, explist], stack];
RETURN[stack]
END;

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

Seeprimarytypeop: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeop: TypeOpNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
typeop _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExptypeopProdNode[position, length, typeop, typeexp], stack];
RETURN[stack]
END;

Seeprimarysize: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpsizeProdNode[position, length, typeexp], stack];
RETURN[stack]
END;

Seeprimarysize2: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeexp: TypeExpNode;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpsize2ProdNode[position, length, typeexp, exp], stack];
RETURN[stack]
END;

Seeprimaryistype: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
typeexp: TypeExpNode;
typeexp _ NARROW[stack.first];
stack _ stack.rest;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpistypeProdNode[position, length, exp, typeexp], stack];
RETURN[stack]
END;

Seeprimaryaddress: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpaddressProdNode[position, length, lhs], stack];
RETURN[stack]
END;

Seeprimarydescriptor: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
desclist: DescListNode;
desclist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildExpdescriptorProdNode[position, length, desclist], stack];
RETURN[stack]
END;

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

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

Seenewzoned: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildNewzonedProdNode[position, length, lhs], stack];
RETURN[stack]
END;

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

Seeconszoned: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildConszonedProdNode[position, length, lhs], stack];
RETURN[stack]
END;

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

Seelistconszoned: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
lhs: ExpNode;
lhs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildListConszonedProdNode[position, length, lhs], stack];
RETURN[stack]
END;

Seedesclistexplicit: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
expbase: ExpNode;
explength: ExpNode;
opttype: OptTypeNode;
opttype _ NARROW[stack.first];
stack _ stack.rest;
explength _ NARROW[stack.first];
stack _ stack.rest;
expbase _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDescListexplicitlengthProdNode[position, length, expbase, explength, opttype], stack];
RETURN[stack]
END;

Seedesclistdefault: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exp: ExpNode;
exp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDescListdefaultlengthProdNode[position, length, exp], stack];
RETURN[stack]
END;

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

Seeoptcatchempty: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildCatchProdNode[position, length, BuildCatchCaseListemptyProdNode[position, length], 
BuildCatchAnyabsentProdNode[position, length]], stack];
RETURN[stack]
END;

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

SeeidentlistPa: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
id: idNode;
id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildIdentListoneProdNode[position, length, BuildIdentidProdNode[id.position, id.length, id]], stack];
RETURN[stack]
END;

SeeidentlistPb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
id: idNode;
positionP: PositionNode;
positionP _ NARROW[stack.first];
stack _ stack.rest;
id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildIdentListoneProdNode[position, length, BuildIdentidpositionProdNode[id.position, positionP.position + 
positionP.length - id.position, id, positionP]], stack];
RETURN[stack]
END;

SeeidentlistPc: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
id: idNode;
identlistP: IdentListNode;
identlistP _ NARROW[stack.first];
stack _ stack.rest;
id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildIdentListmanyProdNode[position, length, BuildIdentListoneProdNode[id.position, id.length, 
BuildIdentidProdNode[id.position, id.length, id]], identlistP], stack];
RETURN[stack]
END;

SeeidentlistPd: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
id: idNode;
positionP: PositionNode;
identlistP: IdentListNode;
identlistP _ NARROW[stack.first];
stack _ stack.rest;
positionP _ NARROW[stack.first];
stack _ stack.rest;
id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildIdentListmanyProdNode[position, length, BuildIdentListoneProdNode[id.position, positionP.position + 
positionP.length - id.position, BuildIdentidpositionProdNode[id.position, positionP.position + positionP.length - id.position, id, 
positionP]], identlistP], stack];
RETURN[stack]
END;

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

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

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

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

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

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

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

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

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

END..