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

DIRECTORY
SaffronAG5Def,
SaffronAG4Def,
SaffronAG9Def,
SaffronAG7Def,
SaffronAG1Def,
SaffronAG2Def,
SaffronAG6Def,
SaffronGenericDef,
ThreeC4Support,
SaffronCG4Def USING[],
SaffronATDef;

SaffronCG4Impl: CEDAR PROGRAM IMPORTS SaffronAG5Def, SaffronAG4Def, SaffronAG9Def, SaffronAG7Def, SaffronAG1Def, SaffronAG2Def, 
SaffronAG6Def EXPORTS SaffronCG4Def= 
BEGIN
OPEN SaffronAG5Def, SaffronAG4Def, SaffronAG9Def, SaffronAG7Def, SaffronAG1Def, SaffronAG2Def, SaffronAG6Def, SaffronGenericDef, 
ThreeC4Support, SaffronATDef;
SaffronCG4LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[181] _ Seerangea;
prodLinkArray[182] _ Seerangeb;
prodLinkArray[183] _ Seerangec;
prodLinkArray[184] _ Seeranged;
prodLinkArray[185] _ Seerangee;
prodLinkArray[186] _ Seetrashtrash;
prodLinkArray[187] _ Seetrashnull;
prodLinkArray[188] _ Seedefaultoptgetstrash;
prodLinkArray[189] _ Seedefaultoptgetsexportrash;
prodLinkArray[190] _ Seedefaultoptgets;
prodLinkArray[191] _ Seedefaultoptgetsexp;
prodLinkArray[192] _ Seeorderlistone;
prodLinkArray[193] _ Seeorderlistmore;
prodLinkArray[194] _ Seetrusted;
prodLinkArray[195] _ Seeoptrelationnegative;
prodLinkArray[196] _ Seeoptrelationpositive;
prodLinkArray[197] _ Seerelationtailrange;
prodLinkArray[198] _ Seerelationtailrelop;
prodLinkArray[199] _ Seerelopeq;
prodLinkArray[200] _ Seerelopne;
prodLinkArray[201] _ Seereloplt;
prodLinkArray[202] _ Seerelople;
prodLinkArray[203] _ Seerelopgt;
prodLinkArray[204] _ Seerelopge;
prodLinkArray[205] _ Seesharespresent;
prodLinkArray[206] _ Seesharesabsent;
prodLinkArray[207] _ Seestatementifthen;
prodLinkArray[208] _ Seestatementifthenelse;
prodLinkArray[209] _ Seestatementselect;
prodLinkArray[210] _ Seestatementbasicstmt;
prodLinkArray[211] _ Seebalstmtifthenelse;
prodLinkArray[212] _ Seebalstmtselect;
prodLinkArray[213] _ Seebalstmtbasicstmt;
prodLinkArray[214] _ Seebasicstmtexp;
prodLinkArray[215] _ Seebasicstmtassign;
prodLinkArray[216] _ Seebasicstmtmultiassign;
prodLinkArray[217] _ Seebasicstmtblock;
prodLinkArray[218] _ Seebasicstmtselect;
prodLinkArray[219] _ Seebasicstmtloopcontrol;
prodLinkArray[220] _ Seebasicstmtexit;
prodLinkArray[221] _ Seebasicstmtloop;
prodLinkArray[222] _ Seebasicstmti;
prodLinkArray[223] _ Seebasicstmtj;
prodLinkArray[224] _ Seebasicstmtreturn;
prodLinkArray[225] _ Seebasicstmttransfer;
prodLinkArray[226] _ Seebasicstmtfree;
prodLinkArray[227] _ Seebasicstmtwait;
prodLinkArray[228] _ Seebasicstmterror;
prodLinkArray[229] _ Seebasicstmtstop;
prodLinkArray[230] _ Seebasicstmtnull;
prodLinkArray[231] _ Seebasicstmtresume;
prodLinkArray[232] _ Seebasicstmtreject;
prodLinkArray[233] _ Seebasicstmtcontinue;
prodLinkArray[234] _ Seebasicstmtretry;
prodLinkArray[235] _ Seebasicstmtgetstate;
prodLinkArray[236] _ Seebasicstmtsetstate;
prodLinkArray[237] _ Seeforclauseassignation;
prodLinkArray[238] _ Seeforclauseiteration;
prodLinkArray[239] _ Seeforclauserepetition;
prodLinkArray[240] _ Seeforclauseempty;
prodLinkArray[241] _ Seecontrolidnew;
prodLinkArray[242] _ Seecontrolidold;
prodLinkArray[243] _ Seedirectionyes;
prodLinkArray[244] _ Seedirectionno;
prodLinkArray[245] _ Seedoexita;
prodLinkArray[246] _ Seedoexitb;
prodLinkArray[247] _ Seedoexitc;
prodLinkArray[248] _ Seedoexitd;
prodLinkArray[249] _ Seetransfersignal;
prodLinkArray[250] _ Seetransfererror;
prodLinkArray[251] _ Seetransferreturnwitherror;
prodLinkArray[252] _ Seetransferstart;
prodLinkArray[253] _ Seetransferrestart;
prodLinkArray[254] _ Seetransferjoin;
prodLinkArray[255] _ Seetransfernotify;
prodLinkArray[256] _ Seetransferbroadcast;
prodLinkArray[257] _ Seetransfertransferwith;
prodLinkArray[258] _ Seetransferreturnwith;
END;

Seerangea: 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[BuildRangetypeidProdNode[position, length, BuildTypeIdidProdNode[id.position, id.length, id]], stack];
RETURN[stack]
END;

Seerangeb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
id: idNode;
interval: IntervalNode;
interval _ NARROW[stack.first];
stack _ stack.rest;
id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRangesubrangeProdNode[position, length, BuildSubrangenamedProdNode[id.position, interval.position + 
interval.length - id.position, BuildTypeIdidProdNode[id.position, id.length, id], interval]], stack];
RETURN[stack]
END;

Seerangec: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeid: TypeIdNode;
interval: IntervalNode;
interval _ NARROW[stack.first];
stack _ stack.rest;
typeid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRangesubrangeProdNode[position, length, BuildSubrangenamedProdNode[typeid.position, interval.position + 
interval.length - typeid.position, typeid, interval]], stack];
RETURN[stack]
END;

Seeranged: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
interval: IntervalNode;
interval _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRangesubrangeProdNode[position, length, BuildSubrangeunnamedProdNode[interval.position, interval.length, 
interval]], stack];
RETURN[stack]
END;

Seerangee: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
typeid: TypeIdNode;
typeid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRangetypeidProdNode[position, length, typeid], stack];
RETURN[stack]
END;

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

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

Seedefaultoptgetstrash: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
trash: JunkNode;
trash _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDefaultgetstrashProdNode[position, length], stack];
RETURN[stack]
END;

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

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

Seedefaultoptgetsexp: 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[BuildDefaultgetsexpProdNode[position, length, exp], stack];
RETURN[stack]
END;

Seeorderlistone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
optexp: OptExpNode;
optexp _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildOrderListoneProdNode[position, length, optexp], stack];
RETURN[stack]
END;

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

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

Seeoptrelationnegative: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relationtail: RelationTailNode;
relationtail _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRelationnegativeProdNode[position, length, relationtail], stack];
RETURN[stack]
END;

Seeoptrelationpositive: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relationtail: RelationTailNode;
relationtail _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRelationpositiveProdNode[position, length, relationtail], stack];
RETURN[stack]
END;

Seerelationtailrange: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
range: RangeNode;
range _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRelationTailrangeProdNode[position, length, range], stack];
RETURN[stack]
END;

Seerelationtailrelop: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
relop: RelopNode;
sum: ExpNode;
sum _ NARROW[stack.first];
stack _ stack.rest;
relop _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildRelationTailrelopProdNode[position, length, relop, sum], stack];
RETURN[stack]
END;

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

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

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

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

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

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

Seesharespresent: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
idlist: IdListNode;
idlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSharespresentProdNode[position, length, idlist], stack];
RETURN[stack]
END;

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

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

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

Seestatementselect: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casehead: SelectHeadNode;
casestmtlist: SelectStmtListNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
casestmtlist _ NARROW[stack.first];
stack _ stack.rest;
casehead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementselectProdNode[position, length, casehead, casestmtlist, 
BuildOptStatementpresentProdNode[statement.position, statement.length, statement]], stack];
RETURN[stack]
END;

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

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

Seebalstmtselect: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casehead: SelectHeadNode;
casestmtlist: SelectStmtListNode;
balstmt: StatementNode;
balstmt _ NARROW[stack.first];
stack _ stack.rest;
casestmtlist _ NARROW[stack.first];
stack _ stack.rest;
casehead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementselectProdNode[position, length, casehead, casestmtlist, 
BuildOptStatementpresentProdNode[balstmt.position, balstmt.length, balstmt]], stack];
RETURN[stack]
END;

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

Seebasicstmtexp: 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[BuildStatementexpProdNode[position, length, lhs], stack];
RETURN[stack]
END;

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

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

Seebasicstmtblock: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
trusted: JunkNode;
checked: CheckedNode;
block: BlockNode;
block _ NARROW[stack.first];
stack _ stack.rest;
checked _ NARROW[stack.first];
stack _ stack.rest;
trusted _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementblockProdNode[position, length, checked, block], stack];
RETURN[stack]
END;

Seebasicstmtselect: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casehead: SelectHeadNode;
casestmtlist: SelectStmtListNode;
casestmtlist _ NARROW[stack.first];
stack _ stack.rest;
casehead _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementselectProdNode[position, length, casehead, casestmtlist, 
BuildOptStatementabsentProdNode[casestmtlist.position + casestmtlist.length, casestmtlist.position + casestmtlist.length - 
casestmtlist.position - casestmtlist.length]], stack];
RETURN[stack]
END;

Seebasicstmtloopcontrol: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
forclause: ForClauseNode;
dotest: DoTestNode;
scope: ScopeNode;
doexit: DoExitNode;
doexit _ NARROW[stack.first];
stack _ stack.rest;
scope _ NARROW[stack.first];
stack _ stack.rest;
dotest _ NARROW[stack.first];
stack _ stack.rest;
forclause _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementloopcontrolProdNode[position, length, forclause, dotest, scope, doexit], stack];
RETURN[stack]
END;

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

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

Seebasicstmti: 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[BuildStatementgotoProdNode[position, length, id], stack];
RETURN[stack]
END;

Seebasicstmtj: 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[BuildStatementgotoProdNode[position, length, id], stack];
RETURN[stack]
END;

Seebasicstmtreturn: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
optargs: OptArgsNode;
optargs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementreturnProdNode[position, length, optargs], stack];
RETURN[stack]
END;

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

Seebasicstmtfree: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
free: FreeNode;
exp: ExpNode;
optcatch: CatchNode;
optcatch _ NARROW[stack.first];
stack _ stack.rest;
exp _ NARROW[stack.first];
stack _ stack.rest;
free _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementfreeProdNode[position, length, free, exp, optcatch], stack];
RETURN[stack]
END;

Seebasicstmtwait: 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[BuildStatementwaitProdNode[position, length, lhs], stack];
RETURN[stack]
END;

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

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

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

Seebasicstmtresume: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
optargs: OptArgsNode;
optargs _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildStatementresumeProdNode[position, length, optargs], stack];
RETURN[stack]
END;

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

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

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

Seebasicstmtgetstate: 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[BuildStatementgetstateProdNode[position, length, lhs], stack];
RETURN[stack]
END;

Seebasicstmtsetstate: 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[BuildStatementsetstateProdNode[position, length, exp], stack];
RETURN[stack]
END;

Seeforclauseassignation: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
controlid: ControlIdNode;
expinitial: ExpNode;
expnext: ExpNode;
expnext _ NARROW[stack.first];
stack _ stack.rest;
expinitial _ NARROW[stack.first];
stack _ stack.rest;
controlid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildForClauseassignationProdNode[position, length, controlid, expinitial, expnext], stack];
RETURN[stack]
END;

Seeforclauseiteration: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
controlid: ControlIdNode;
direction: DecreasingNode;
range: RangeNode;
range _ NARROW[stack.first];
stack _ stack.rest;
direction _ NARROW[stack.first];
stack _ stack.rest;
controlid _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildForClauseiterationProdNode[position, length, controlid, direction, range], stack];
RETURN[stack]
END;

Seeforclauserepetition: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
range: RangeNode;
range _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildForClauserepetitionProdNode[position, length, range], stack];
RETURN[stack]
END;

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

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

Seecontrolidold: 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[BuildControlIdoldProdNode[position, length, id], stack];
RETURN[stack]
END;

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

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

Seedoexita: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
stack _ CONS[BuildDoExitProdNode[position, length, BuildExitListemptyProdNode[position, length], 
BuildOptStatementabsentProdNode[position, length]], stack];
RETURN[stack]
END;

Seedoexitb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlist: ExitListNode;
exitlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDoExitProdNode[position, length, exitlist, BuildOptStatementabsentProdNode[exitlist.position + exitlist.length, 
exitlist.position + exitlist.length - exitlist.position - exitlist.length]], stack];
RETURN[stack]
END;

Seedoexitc: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlist: ExitListNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
exitlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDoExitProdNode[position, length, exitlist, BuildOptStatementpresentProdNode[statement.position, statement.length, 
statement]], stack];
RETURN[stack]
END;

Seedoexitd: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
exitlist: ExitListNode;
statement: StatementNode;
statement _ NARROW[stack.first];
stack _ stack.rest;
exitlist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDoExitProdNode[position, length, exitlist, BuildOptStatementpresentProdNode[statement.position, statement.length, 
statement]], stack];
RETURN[stack]
END;

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

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

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

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

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

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

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

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

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

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

END..