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

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

SaffronCG1Impl: CEDAR PROGRAM IMPORTS SaffronAG7Def, SaffronAG4Def, SaffronAG2Def, SaffronAG5Def, SaffronAG9Def, SaffronAG1Def 
EXPORTS SaffronCG1Def= 
BEGIN
OPEN SaffronAG7Def, SaffronAG4Def, SaffronAG2Def, SaffronAG5Def, SaffronAG9Def, SaffronAG1Def, SaffronGenericDef, ThreeC4Support, 
SaffronATDef;
SaffronCG1LinkProc: PUBLIC PROC[prodLinkArray: SeeProdLinkArray, tknLinkArray: TokenLinkArray] =
BEGIN
prodLinkArray[0] _ Seemaingoal;
prodLinkArray[1] _ Seetopmodulep;
prodLinkArray[2] _ Seetopscope;
prodLinkArray[3] _ Seegoala;
prodLinkArray[4] _ Seegoalb;
prodLinkArray[5] _ Seemoduleimpl;
prodLinkArray[6] _ Seemoduledef;
prodLinkArray[7] _ Seedirectorya;
prodLinkArray[8] _ Seedirectoryb;
prodLinkArray[9] _ Seedirectoryc;
prodLinkArray[10] _ Seeincludelista;
prodLinkArray[11] _ Seeincludelistb;
prodLinkArray[12] _ Seeincludeitema;
prodLinkArray[13] _ Seeincludeitemb;
prodLinkArray[14] _ Seeincludeitemc;
prodLinkArray[15] _ Seeincludeitemd;
prodLinkArray[16] _ Seeusingnothing;
prodLinkArray[17] _ Seeusingrestricted;
prodLinkArray[18] _ Seeusingunrestricted;
prodLinkArray[19] _ Seedefbodya;
prodLinkArray[20] _ Seedefbodyb;
prodLinkArray[21] _ Seedefbodyc;
prodLinkArray[22] _ Seedefbodyd;
prodLinkArray[23] _ Seedefhead;
prodLinkArray[24] _ Seedefinitions;
prodLinkArray[25] _ Seecedaryes;
prodLinkArray[26] _ Seecedarno;
prodLinkArray[27] _ Seeproghead;
prodLinkArray[28] _ Seeresident;
prodLinkArray[29] _ Seeclassprogram;
prodLinkArray[30] _ Seeclassmonitor;
prodLinkArray[31] _ Seeinterface;
prodLinkArray[32] _ Seeexportsa;
prodLinkArray[33] _ Seeexportsb;
prodLinkArray[34] _ Seeexportsc;
prodLinkArray[35] _ Seebinditema;
prodLinkArray[36] _ Seebinditemb;
prodLinkArray[37] _ Seebinditemc;
prodLinkArray[38] _ Seecaselabeltype;
prodLinkArray[39] _ Seecaselabeltest;
prodLinkArray[40] _ SeecaselabelPone;
prodLinkArray[41] _ SeecaselabelPmore;
prodLinkArray[42] _ Seecasetesta;
prodLinkArray[43] _ Seecasetestb;
prodLinkArray[44] _ Seeblocka;
prodLinkArray[45] _ Seeblockb;
prodLinkArray[46] _ Seeexitslist;
prodLinkArray[47] _ Seeexitsempty;
prodLinkArray[48] _ Seepublicpublic;
prodLinkArray[49] _ Seepublicprivate;
prodLinkArray[50] _ Seepublicempty;
END;

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

Seetopmodulep: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
goal: ModulePNode;
goal _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTopmodulepProdNode[position, length, goal], stack];
RETURN[stack]
END;

Seetopscope: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
scope: ScopeNode;
scope _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildTopscopeProdNode[position, length, scope], stack];
RETURN[stack]
END;

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

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

Seemoduleimpl: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
directory: DirectoryNode;
identlist: IdentListNode;
cedar: CedarNode;
proghead: ProgHeadNode;
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;
proghead _ NARROW[stack.first];
stack _ stack.rest;
cedar _ NARROW[stack.first];
stack _ stack.rest;
identlist _ NARROW[stack.first];
stack _ stack.rest;
directory _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildModulePimplProdNode[position, length, directory, identlist, cedar, proghead, checked, block], stack];
RETURN[stack]
END;

Seemoduledef: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
directory: DirectoryNode;
identlist: IdentListNode;
cedar: CedarNode;
defhead: DefHeadNode;
defbody: DefBodyNode;
defbody _ NARROW[stack.first];
stack _ stack.rest;
defhead _ NARROW[stack.first];
stack _ stack.rest;
cedar _ NARROW[stack.first];
stack _ stack.rest;
identlist _ NARROW[stack.first];
stack _ stack.rest;
directory _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildModulePdefProdNode[position, length, directory, identlist, cedar, defhead, defbody], stack];
RETURN[stack]
END;

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

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

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

Seeincludelista: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
includeitem: IncludeItemNode;
includeitem _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDirectorymoreProdNode[position, length, BuildDirectoryemptyProdNode[includeitem.position, includeitem.position - 
includeitem.length], includeitem], stack];
RETURN[stack]
END;

Seeincludelistb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
includelist: DirectoryNode;
includeitem: IncludeItemNode;
includeitem _ NARROW[stack.first];
stack _ stack.rest;
includelist _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDirectorymoreProdNode[position, length, includelist, includeitem], stack];
RETURN[stack]
END;

Seeincludeitema: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
id: idNode;
string: stringNode;
using: UsingNode;
using _ NARROW[stack.first];
stack _ stack.rest;
string _ NARROW[stack.first];
stack _ stack.rest;
id _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildIncludeItemfrompProdNode[position, length, id, string, using], stack];
RETURN[stack]
END;

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

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

Seeincludeitemd: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
idlocal: idNode;
idglobal: idNode;
using: UsingNode;
using _ NARROW[stack.first];
stack _ stack.rest;
idglobal _ NARROW[stack.first];
stack _ stack.rest;
idlocal _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildIncludeItemtypeandidProdNode[position, length, idlocal, idglobal, using], stack];
RETURN[stack]
END;

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

Seeusingrestricted: 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[BuildUsingrestrictedProdNode[position, length, idlist], stack];
RETURN[stack]
END;

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

Seedefbodya: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
open: BindListNode;
declist: DecListNode;
declist _ NARROW[stack.first];
stack _ stack.rest;
open _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDefBodyProdNode[position, length, open, declist], stack];
RETURN[stack]
END;

Seedefbodyb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
open: BindListNode;
declist: DecListNode;
declist _ NARROW[stack.first];
stack _ stack.rest;
open _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDefBodyProdNode[position, length, open, declist], stack];
RETURN[stack]
END;

Seedefbodyc: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
open: BindListNode;
declist: DecListNode;
declist _ NARROW[stack.first];
stack _ stack.rest;
open _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDefBodyProdNode[position, length, open, declist], stack];
RETURN[stack]
END;

Seedefbodyd: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
open: BindListNode;
declist: DecListNode;
declist _ NARROW[stack.first];
stack _ stack.rest;
open _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDefBodyProdNode[position, length, open, declist], stack];
RETURN[stack]
END;

Seedefhead: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
definitions: JunkNode;
locks: LocksNode;
imports: ModuleListNode;
shares: SharesNode;
tilde: JunkNode;
public: AccessNode;
public _ NARROW[stack.first];
stack _ stack.rest;
tilde _ NARROW[stack.first];
stack _ stack.rest;
shares _ NARROW[stack.first];
stack _ stack.rest;
imports _ NARROW[stack.first];
stack _ stack.rest;
locks _ NARROW[stack.first];
stack _ stack.rest;
definitions _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildDefHeadProdNode[position, length, locks, imports, shares, public], stack];
RETURN[stack]
END;

Seedefinitions: 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;

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

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

Seeproghead: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
resident: JunkNode;
safe: SafeNode;
class: ClassNode;
arguments: ArgumentsNode;
locks: LocksNode;
interface: InterfaceNode;
tilde: JunkNode;
public: AccessNode;
public _ NARROW[stack.first];
stack _ stack.rest;
tilde _ NARROW[stack.first];
stack _ stack.rest;
interface _ NARROW[stack.first];
stack _ stack.rest;
locks _ NARROW[stack.first];
stack _ stack.rest;
arguments _ NARROW[stack.first];
stack _ stack.rest;
class _ NARROW[stack.first];
stack _ stack.rest;
safe _ NARROW[stack.first];
stack _ stack.rest;
resident _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildProgHeadProdNode[position, length, safe, class, arguments, locks, interface, public], stack];
RETURN[stack]
END;

Seeresident: 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;

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

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

Seeinterface: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
imports: ModuleListNode;
exports: ModuleListNode;
shares: SharesNode;
shares _ NARROW[stack.first];
stack _ stack.rest;
exports _ NARROW[stack.first];
stack _ stack.rest;
imports _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildInterfaceProdNode[position, length, imports, exports, shares], stack];
RETURN[stack]
END;

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

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

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

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

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

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

Seecaselabeltype: 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[BuildSelectLabeltypeProdNode[position, length, ident, typeexp], stack];
RETURN[stack]
END;

Seecaselabeltest: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
caselabelP: SelectTestListNode;
caselabelP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSelectLabeltestProdNode[position, length, caselabelP], stack];
RETURN[stack]
END;

SeecaselabelPone: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
casetest: RelationNode;
casetest _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSelectTestListoneProdNode[position, length, casetest], stack];
RETURN[stack]
END;

SeecaselabelPmore: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
caselabelP: SelectTestListNode;
casetest: RelationNode;
casetest _ NARROW[stack.first];
stack _ stack.rest;
caselabelP _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildSelectTestListmoreProdNode[position, length, caselabelP, casetest], stack];
RETURN[stack]
END;

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

Seecasetestb: 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[BuildRelationpositiveProdNode[position, length, BuildRelationTailrelopProdNode[exp.position, exp.position + exp.length 
- exp.position, BuildRelopeqProdNode[exp.position, exp.position - exp.length], exp]], stack];
RETURN[stack]
END;

Seeblocka: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
scope: ScopeNode;
exits: ExitListNode;
exits _ NARROW[stack.first];
stack _ stack.rest;
scope _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildBlockProdNode[position, length, scope, exits], stack];
RETURN[stack]
END;

Seeblockb: PROC[nodes: LIST OF REF ANY, position: INT, length: INT]
RETURNS[LIST OF REF ANY] =
BEGIN
stack: LIST OF REF ANY _ nodes;
scope: ScopeNode;
exits: ExitListNode;
exits _ NARROW[stack.first];
stack _ stack.rest;
scope _ NARROW[stack.first];
stack _ stack.rest;
stack _ CONS[BuildBlockProdNode[position, length, scope, exits], stack];
RETURN[stack]
END;

Seeexitslist: 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[exitlist, stack];
RETURN[stack]
END;

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

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

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

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

END..