-- SaffronCG5Impl.mesa
 -- Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
 -- Generated by Rauen.pa at August 7, 1988 7:57:54 pm PDT
 --  using ThreeCasabaFour [1.2] of June 1, 1987 6:00:00 pm PDT

DIRECTORY
	SaffronAG7aDef,
	SaffronAG1aDef,
	SaffronAG7bDef,
	SaffronAG1bDef,
	SaffronAG2Def,
	SaffronAG3Def,
	SaffronAG4Def,
	SaffronAG5Def,
	SaffronGenericDef,
	ThreeC4Support,
	SaffronCG5Def USING[],
	SaffronATDef;

SaffronCG5Impl: CEDAR PROGRAM IMPORTS SaffronAG7aDef, SaffronAG1aDef, SaffronAG7bDef, SaffronAG1bDef, SaffronAG2Def, SaffronAG3Def, SaffronAG4Def, SaffronAG5Def EXPORTS SaffronCG5Def= 
BEGIN
OPEN SaffronAG7aDef, SaffronAG1aDef, SaffronAG7bDef, SaffronAG1bDef, SaffronAG2Def, SaffronAG3Def, SaffronAG4Def, SaffronAG5Def, SaffronGenericDef, ThreeC4Support, SaffronATDef;
SaffronCG5LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[262] _ Seedotestuntil;
prodLinkArray[263] _ Seedotestwhile;
prodLinkArray[264] _ Seedotestempty;
prodLinkArray[265] _ Seeoptargsexplist;
prodLinkArray[266] _ Seeoptargsempty;
prodLinkArray[267] _ Seeoptargsexp;
prodLinkArray[268] _ Seefreeplain;
prodLinkArray[269] _ Seefreezoned;
prodLinkArray[270] _ Seecasestmtlistempty;
prodLinkArray[271] _ Seecasestmtlistb;
prodLinkArray[272] _ Seecasestmtlistc;
prodLinkArray[273] _ SeecasestmtlistPa;
prodLinkArray[274] _ SeecasestmtlistPb;
prodLinkArray[275] _ Seecasestmtitem;
prodLinkArray[276] _ Seedeclistone;
prodLinkArray[277] _ Seedeclistmany;
prodLinkArray[278] _ Seedeclarationvalue;
prodLinkArray[279] _ Seedeclarationtype;
prodLinkArray[280] _ Seedeclarationopaquetype;
prodLinkArray[281] _ Seeentryentry;
prodLinkArray[282] _ Seeentryinternal;
prodLinkArray[283] _ Seeentryempty;
prodLinkArray[284] _ Seeoptsizepresent;
prodLinkArray[285] _ Seeoptsizeabsent;
prodLinkArray[286] _ Seeprimaryexplist;
prodLinkArray[287] _ Seeprimaryprefixop;
prodLinkArray[288] _ Seeprimaryval;
prodLinkArray[289] _ Seeprimaryall;
prodLinkArray[290] _ Seeprimarynew;
prodLinkArray[291] _ Seeprimarycons;
prodLinkArray[292] _ Seeprimarylistcons;
prodLinkArray[293] _ Seeprimarynil;
prodLinkArray[294] _ Seeprimarytypeop;
prodLinkArray[295] _ Seeprimarysize;
prodLinkArray[296] _ Seeprimarysize2;
prodLinkArray[297] _ Seeprimarybits;
prodLinkArray[298] _ Seeprimarybits2;
prodLinkArray[299] _ Seeprimarybytes;
prodLinkArray[300] _ Seeprimarybytes2;
prodLinkArray[301] _ Seeprimaryunits;
prodLinkArray[302] _ Seeprimaryunits2;
prodLinkArray[303] _ Seeprimarywords;
prodLinkArray[304] _ Seeprimarywords2;
prodLinkArray[305] _ Seeprimaryistype;
prodLinkArray[306] _ Seeprimaryaddress;
prodLinkArray[307] _ Seeprimarydescriptor;
prodLinkArray[308] _ Seeprimarylhs;
prodLinkArray[309] _ Seenewplain;
prodLinkArray[310] _ Seenewzoned;
prodLinkArray[311] _ Seeconsplain;
prodLinkArray[312] _ Seeconszoned;
prodLinkArray[313] _ Seelistconsplain;
prodLinkArray[314] _ Seelistconszoned;
prodLinkArray[315] _ Seedesclistexplicit;
prodLinkArray[316] _ Seedesclistdefault;
prodLinkArray[317] _ Seeoptcatchcatchlist;
prodLinkArray[318] _ Seeoptcatchempty;
prodLinkArray[319] _ Seeidentlist;
prodLinkArray[320] _ SeeidentlistPa;
prodLinkArray[321] _ SeeidentlistPb;
prodLinkArray[322] _ SeeidentlistPc;
prodLinkArray[323] _ SeeidentlistPd;
prodLinkArray[324] _ Seeprefixoplong;
prodLinkArray[325] _ Seeprefixopabs;
prodLinkArray[326] _ Seeprefixoppred;
prodLinkArray[327] _ Seeprefixopsucc;
prodLinkArray[328] _ Seeprefixopord;
prodLinkArray[329] _ Seeprefixopmin;
prodLinkArray[330] _ Seeprefixopmax;
prodLinkArray[331] _ Seeprefixopbase;
prodLinkArray[332] _ 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;

Seeprimarybits: 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[BuildExpbitsProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seeprimarybits2: 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[BuildExpbits2ProdNode[position, length, typeexp, exp], stack];
RETURN [stack]
END;

Seeprimarybytes: 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[BuildExpbytesProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seeprimarybytes2: 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[BuildExpbytes2ProdNode[position, length, typeexp, exp], stack];
RETURN [stack]
END;

Seeprimaryunits: 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[BuildExpunitsProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seeprimaryunits2: 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[BuildExpunits2ProdNode[position, length, typeexp, exp], stack];
RETURN [stack]
END;

Seeprimarywords: 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[BuildExpwordsProdNode[position, length, typeexp], stack];
RETURN [stack]
END;

Seeprimarywords2: 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[BuildExpwords2ProdNode[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..