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

DIRECTORY
SaffronAG5Def,
SaffronGenericDef,
SaffronATDef;

SaffronAG5Impl: CEDAR PROGRAM IMPORTS SaffronAG5Def EXPORTS SaffronAG5Def= 
BEGIN
OPEN SaffronAG5Def, SaffronGenericDef, SaffronATDef;

<<DecListoneProd>>

DecListoneProdProcs: PUBLIC DecListNodeProcs _
NEW[DecListNodeProcsBody _ [DecListoneProdfoo, DecListoneProdPreprocessDecls, DecListoneProdProcessDecls]];

BuildDecListoneProdNode: PUBLIC PROC[position: INT, length: INT, Declaration: DeclarationNode]
RETURNS[DecListNode] =
BEGIN
data: DecListoneProdData _
NEW[DecListoneProdDataBody_[
Declaration]];
RETURN[NEW[DecListNodeBody_[position, length, DecListoneProdProcs, data]]];
END;


<<DecListmanyProd>>

DecListmanyProdProcs: PUBLIC DecListNodeProcs _
NEW[DecListNodeProcsBody _ [DecListmanyProdfoo, DecListmanyProdPreprocessDecls, DecListmanyProdProcessDecls]];

BuildDecListmanyProdNode: PUBLIC PROC[position: INT, length: INT, DecListhead: DecListNode, DecListtail: DecListNode]
RETURNS[DecListNode] =
BEGIN
data: DecListmanyProdData _
NEW[DecListmanyProdDataBody_[
DecListhead, DecListtail]];
RETURN[NEW[DecListNodeBody_[position, length, DecListmanyProdProcs, data]]];
END;


<<DeclarationvalueProd>>

DeclarationvalueProdProcs: PUBLIC DeclarationNodeProcs _
NEW[DeclarationNodeProcsBody _ [DeclarationvalueProdfoo, DeclarationvalueProdPreprocessDecls, DeclarationvalueProdProcessDecls, 
DeclarationvalueProdProcessOneDecl]];

BuildDeclarationvalueProdNode: PUBLIC PROC[position: INT, length: INT, IdentList: IdentListNode, Access: AccessNode, Entry: 
EntryNode, ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode, Initialization: InitializationNode]
RETURNS[DeclarationNode] =
BEGIN
data: DeclarationvalueProdData _
NEW[DeclarationvalueProdDataBody_[
IdentList, Access, Entry, ReadOnly, TypeExp, Initialization]];
RETURN[NEW[DeclarationNodeBody_[position, length, DeclarationvalueProdProcs, data]]];
END;


<<DeclarationtypeProd>>

DeclarationtypeProdProcs: PUBLIC DeclarationNodeProcs _
NEW[DeclarationNodeProcsBody _ [DeclarationtypeProdfoo, DeclarationtypeProdPreprocessDecls, DeclarationtypeProdProcessDecls, 
DeclarationtypeProdProcessOneDecl]];

BuildDeclarationtypeProdNode: PUBLIC PROC[position: INT, length: INT, IdentList: IdentListNode, Accessid: AccessNode, Accesstype: 
AccessNode, TypeExp: TypeExpNode, Default: DefaultNode]
RETURNS[DeclarationNode] =
BEGIN
data: DeclarationtypeProdData _
NEW[DeclarationtypeProdDataBody_[
IdentList, Accessid, Accesstype, TypeExp, Default]];
RETURN[NEW[DeclarationNodeBody_[position, length, DeclarationtypeProdProcs, data]]];
END;


<<DeclarationopaquetypeProd>>

DeclarationopaquetypeProdProcs: PUBLIC DeclarationNodeProcs _
NEW[DeclarationNodeProcsBody _ [DeclarationopaquetypeProdfoo, DeclarationopaquetypeProdPreprocessDecls, 
DeclarationopaquetypeProdProcessDecls, DeclarationopaquetypeProdProcessOneDecl]];

BuildDeclarationopaquetypeProdNode: PUBLIC PROC[position: INT, length: INT, IdentList: IdentListNode, Access: AccessNode, OptSize: 
OptSizeNode]
RETURNS[DeclarationNode] =
BEGIN
data: DeclarationopaquetypeProdData _
NEW[DeclarationopaquetypeProdDataBody_[
IdentList, Access, OptSize]];
RETURN[NEW[DeclarationNodeBody_[position, length, DeclarationopaquetypeProdProcs, data]]];
END;


<<OptSizeabsentProd>>

OptSizeabsentProdProcs: PUBLIC OptSizeNodeProcs _
NEW[OptSizeNodeProcsBody _ [OptSizeabsentProdfoo]];

BuildOptSizeabsentProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[OptSizeNode] =
BEGIN
RETURN[NEW[OptSizeNodeBody_[position, length, OptSizeabsentProdProcs, NIL]]];
END;


<<OptSizepresentProd>>

OptSizepresentProdProcs: PUBLIC OptSizeNodeProcs _
NEW[OptSizeNodeProcsBody _ [OptSizepresentProdfoo]];

BuildOptSizepresentProdNode: PUBLIC PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[OptSizeNode] =
BEGIN
data: OptSizepresentProdData _
NEW[OptSizepresentProdDataBody_[
Exp]];
RETURN[NEW[OptSizeNodeBody_[position, length, OptSizepresentProdProcs, data]]];
END;


<<EntryentryProd>>

EntryentryProdProcs: PUBLIC EntryNodeProcs _
NEW[EntryNodeProcsBody _ [EntryentryProdfoo]];

BuildEntryentryProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[EntryNode] =
BEGIN
RETURN[NEW[EntryNodeBody_[position, length, EntryentryProdProcs, NIL]]];
END;


<<EntryinternalProd>>

EntryinternalProdProcs: PUBLIC EntryNodeProcs _
NEW[EntryNodeProcsBody _ [EntryinternalProdfoo]];

BuildEntryinternalProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[EntryNode] =
BEGIN
RETURN[NEW[EntryNodeBody_[position, length, EntryinternalProdProcs, NIL]]];
END;


<<EntryemptyProd>>

EntryemptyProdProcs: PUBLIC EntryNodeProcs _
NEW[EntryNodeProcsBody _ [EntryemptyProdfoo]];

BuildEntryemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[EntryNode] =
BEGIN
RETURN[NEW[EntryNodeBody_[position, length, EntryemptyProdProcs, NIL]]];
END;


<<ExitListemptyProd>>

ExitListemptyProdProcs: PUBLIC ExitListNodeProcs _
NEW[ExitListNodeProcsBody _ [ExitListemptyProdfoo]];

BuildExitListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[ExitListNode] =
BEGIN
RETURN[NEW[ExitListNodeBody_[position, length, ExitListemptyProdProcs, NIL]]];
END;


<<ExitListmoreProd>>

ExitListmoreProdProcs: PUBLIC ExitListNodeProcs _
NEW[ExitListNodeProcsBody _ [ExitListmoreProdfoo]];

BuildExitListmoreProdNode: PUBLIC PROC[position: INT, length: INT, ExitList: ExitListNode, ExitItem: ExitItemNode]
RETURNS[ExitListNode] =
BEGIN
data: ExitListmoreProdData _
NEW[ExitListmoreProdDataBody_[
ExitList, ExitItem]];
RETURN[NEW[ExitListNodeBody_[position, length, ExitListmoreProdProcs, data]]];
END;


<<ExitItemProd>>

ExitItemProdProcs: PUBLIC ExitItemNodeProcs _
NEW[ExitItemNodeProcsBody _ [ExitItemProdfoo]];

BuildExitItemProdNode: PUBLIC PROC[position: INT, length: INT, IdList: IdListNode, Statement: StatementNode]
RETURNS[ExitItemNode] =
BEGIN
data: ExitItemProdData _
NEW[ExitItemProdDataBody_[
IdList, Statement]];
RETURN[NEW[ExitItemNodeBody_[position, length, ExitItemProdProcs, data]]];
END;


<<BindListemptyProd>>

BindListemptyProdProcs: PUBLIC BindListNodeProcs _
NEW[BindListNodeProcsBody _ [BindListemptyProdfoo]];

BuildBindListemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[BindListNode] =
BEGIN
RETURN[NEW[BindListNodeBody_[position, length, BindListemptyProdProcs, NIL]]];
END;


<<BindListmoreProd>>

BindListmoreProdProcs: PUBLIC BindListNodeProcs _
NEW[BindListNodeProcsBody _ [BindListmoreProdfoo]];

BuildBindListmoreProdNode: PUBLIC PROC[position: INT, length: INT, BindList: BindListNode, BindItem: BindItemNode]
RETURNS[BindListNode] =
BEGIN
data: BindListmoreProdData _
NEW[BindListmoreProdDataBody_[
BindList, BindItem]];
RETURN[NEW[BindListNodeBody_[position, length, BindListmoreProdProcs, data]]];
END;


<<BindItemnamedProd>>

BindItemnamedProdProcs: PUBLIC BindItemNodeProcs _
NEW[BindItemNodeProcsBody _ [BindItemnamedProdfoo]];

BuildBindItemnamedProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode, Exp: ExpNode]
RETURNS[BindItemNode] =
BEGIN
data: BindItemnamedProdData _
NEW[BindItemnamedProdDataBody_[
id, Exp]];
RETURN[NEW[BindItemNodeBody_[position, length, BindItemnamedProdProcs, data]]];
END;


<<BindItemunnamedProd>>

BindItemunnamedProdProcs: PUBLIC BindItemNodeProcs _
NEW[BindItemNodeProcsBody _ [BindItemunnamedProdfoo]];

BuildBindItemunnamedProdNode: PUBLIC PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[BindItemNode] =
BEGIN
data: BindItemunnamedProdData _
NEW[BindItemunnamedProdDataBody_[
Exp]];
RETURN[NEW[BindItemNodeBody_[position, length, BindItemunnamedProdProcs, data]]];
END;


<<ForClauseassignationProd>>

ForClauseassignationProdProcs: PUBLIC ForClauseNodeProcs _
NEW[ForClauseNodeProcsBody _ [ForClauseassignationProdfoo]];

BuildForClauseassignationProdNode: PUBLIC PROC[position: INT, length: INT, ControlId: ControlIdNode, Expinitial: ExpNode, Expnext: 
ExpNode]
RETURNS[ForClauseNode] =
BEGIN
data: ForClauseassignationProdData _
NEW[ForClauseassignationProdDataBody_[
ControlId, Expinitial, Expnext]];
RETURN[NEW[ForClauseNodeBody_[position, length, ForClauseassignationProdProcs, data]]];
END;


<<ForClauseiterationProd>>

ForClauseiterationProdProcs: PUBLIC ForClauseNodeProcs _
NEW[ForClauseNodeProcsBody _ [ForClauseiterationProdfoo]];

BuildForClauseiterationProdNode: PUBLIC PROC[position: INT, length: INT, ControlId: ControlIdNode, Decreasing: DecreasingNode, 
Range: RangeNode]
RETURNS[ForClauseNode] =
BEGIN
data: ForClauseiterationProdData _
NEW[ForClauseiterationProdDataBody_[
ControlId, Decreasing, Range]];
RETURN[NEW[ForClauseNodeBody_[position, length, ForClauseiterationProdProcs, data]]];
END;


<<ForClauserepetitionProd>>

ForClauserepetitionProdProcs: PUBLIC ForClauseNodeProcs _
NEW[ForClauseNodeProcsBody _ [ForClauserepetitionProdfoo]];

BuildForClauserepetitionProdNode: PUBLIC PROC[position: INT, length: INT, Range: RangeNode]
RETURNS[ForClauseNode] =
BEGIN
data: ForClauserepetitionProdData _
NEW[ForClauserepetitionProdDataBody_[
Range]];
RETURN[NEW[ForClauseNodeBody_[position, length, ForClauserepetitionProdProcs, data]]];
END;


<<ForClauseemptyProd>>

ForClauseemptyProdProcs: PUBLIC ForClauseNodeProcs _
NEW[ForClauseNodeProcsBody _ [ForClauseemptyProdfoo]];

BuildForClauseemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[ForClauseNode] =
BEGIN
RETURN[NEW[ForClauseNodeBody_[position, length, ForClauseemptyProdProcs, NIL]]];
END;


<<ControlIdnewProd>>

ControlIdnewProdProcs: PUBLIC ControlIdNodeProcs _
NEW[ControlIdNodeProcsBody _ [ControlIdnewProdfoo]];

BuildControlIdnewProdNode: PUBLIC PROC[position: INT, length: INT, Ident: IdentNode, TypeExp: TypeExpNode]
RETURNS[ControlIdNode] =
BEGIN
data: ControlIdnewProdData _
NEW[ControlIdnewProdDataBody_[
Ident, TypeExp]];
RETURN[NEW[ControlIdNodeBody_[position, length, ControlIdnewProdProcs, data]]];
END;


<<ControlIdoldProd>>

ControlIdoldProdProcs: PUBLIC ControlIdNodeProcs _
NEW[ControlIdNodeProcsBody _ [ControlIdoldProdfoo]];

BuildControlIdoldProdNode: PUBLIC PROC[position: INT, length: INT, id: idNode]
RETURNS[ControlIdNode] =
BEGIN
data: ControlIdoldProdData _
NEW[ControlIdoldProdDataBody_[
id]];
RETURN[NEW[ControlIdNodeBody_[position, length, ControlIdoldProdProcs, data]]];
END;


<<DecreasingyesProd>>

DecreasingyesProdProcs: PUBLIC DecreasingNodeProcs _
NEW[DecreasingNodeProcsBody _ [DecreasingyesProdfoo]];

BuildDecreasingyesProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[DecreasingNode] =
BEGIN
RETURN[NEW[DecreasingNodeBody_[position, length, DecreasingyesProdProcs, NIL]]];
END;


<<DecreasingnoProd>>

DecreasingnoProdProcs: PUBLIC DecreasingNodeProcs _
NEW[DecreasingNodeProcsBody _ [DecreasingnoProdfoo]];

BuildDecreasingnoProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[DecreasingNode] =
BEGIN
RETURN[NEW[DecreasingNodeBody_[position, length, DecreasingnoProdProcs, NIL]]];
END;


<<DoTestuntilProd>>

DoTestuntilProdProcs: PUBLIC DoTestNodeProcs _
NEW[DoTestNodeProcsBody _ [DoTestuntilProdfoo]];

BuildDoTestuntilProdNode: PUBLIC PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[DoTestNode] =
BEGIN
data: DoTestuntilProdData _
NEW[DoTestuntilProdDataBody_[
Exp]];
RETURN[NEW[DoTestNodeBody_[position, length, DoTestuntilProdProcs, data]]];
END;


<<DoTestwhileProd>>

DoTestwhileProdProcs: PUBLIC DoTestNodeProcs _
NEW[DoTestNodeProcsBody _ [DoTestwhileProdfoo]];

BuildDoTestwhileProdNode: PUBLIC PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[DoTestNode] =
BEGIN
data: DoTestwhileProdData _
NEW[DoTestwhileProdDataBody_[
Exp]];
RETURN[NEW[DoTestNodeBody_[position, length, DoTestwhileProdProcs, data]]];
END;


<<DoTestemptyProd>>

DoTestemptyProdProcs: PUBLIC DoTestNodeProcs _
NEW[DoTestNodeProcsBody _ [DoTestemptyProdfoo]];

BuildDoTestemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[DoTestNode] =
BEGIN
RETURN[NEW[DoTestNodeBody_[position, length, DoTestemptyProdProcs, NIL]]];
END;


<<DoExitProd>>

DoExitProdProcs: PUBLIC DoExitNodeProcs _
NEW[DoExitNodeProcsBody _ [DoExitProdfoo]];

BuildDoExitProdNode: PUBLIC PROC[position: INT, length: INT, ExitList: ExitListNode, OptStatement: OptStatementNode]
RETURNS[DoExitNode] =
BEGIN
data: DoExitProdData _
NEW[DoExitProdDataBody_[
ExitList, OptStatement]];
RETURN[NEW[DoExitNodeBody_[position, length, DoExitProdProcs, data]]];
END;


<<OptArgsexplistProd>>

OptArgsexplistProdProcs: PUBLIC OptArgsNodeProcs _
NEW[OptArgsNodeProcsBody _ [OptArgsexplistProdfoo]];

BuildOptArgsexplistProdNode: PUBLIC PROC[position: INT, length: INT, ExpList: ExpListNode]
RETURNS[OptArgsNode] =
BEGIN
data: OptArgsexplistProdData _
NEW[OptArgsexplistProdDataBody_[
ExpList]];
RETURN[NEW[OptArgsNodeBody_[position, length, OptArgsexplistProdProcs, data]]];
END;


<<OptArgsexpProd>>

OptArgsexpProdProcs: PUBLIC OptArgsNodeProcs _
NEW[OptArgsNodeProcsBody _ [OptArgsexpProdfoo]];

BuildOptArgsexpProdNode: PUBLIC PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[OptArgsNode] =
BEGIN
data: OptArgsexpProdData _
NEW[OptArgsexpProdDataBody_[
Exp]];
RETURN[NEW[OptArgsNodeBody_[position, length, OptArgsexpProdProcs, data]]];
END;


<<OptArgsemptyProd>>

OptArgsemptyProdProcs: PUBLIC OptArgsNodeProcs _
NEW[OptArgsNodeProcsBody _ [OptArgsemptyProdfoo]];

BuildOptArgsemptyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[OptArgsNode] =
BEGIN
RETURN[NEW[OptArgsNodeBody_[position, length, OptArgsemptyProdProcs, NIL]]];
END;


<<TransfersignalProd>>

TransfersignalProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransfersignalProdfoo]];

BuildTransfersignalProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransfersignalProdProcs, NIL]]];
END;


<<TransfererrorProd>>

TransfererrorProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransfererrorProdfoo]];

BuildTransfererrorProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransfererrorProdProcs, NIL]]];
END;


<<TransferreturnwitherrorProd>>

TransferreturnwitherrorProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransferreturnwitherrorProdfoo]];

BuildTransferreturnwitherrorProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransferreturnwitherrorProdProcs, NIL]]];
END;


<<TransferstartProd>>

TransferstartProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransferstartProdfoo]];

BuildTransferstartProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransferstartProdProcs, NIL]]];
END;


<<TransferrestartProd>>

TransferrestartProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransferrestartProdfoo]];

BuildTransferrestartProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransferrestartProdProcs, NIL]]];
END;


<<TransferjoinProd>>

TransferjoinProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransferjoinProdfoo]];

BuildTransferjoinProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransferjoinProdProcs, NIL]]];
END;


<<TransfernotifyProd>>

TransfernotifyProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransfernotifyProdfoo]];

BuildTransfernotifyProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransfernotifyProdProcs, NIL]]];
END;


<<TransferbroadcastProd>>

TransferbroadcastProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransferbroadcastProdfoo]];

BuildTransferbroadcastProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransferbroadcastProdProcs, NIL]]];
END;


<<TransfertransferwithProd>>

TransfertransferwithProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransfertransferwithProdfoo]];

BuildTransfertransferwithProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransfertransferwithProdProcs, NIL]]];
END;


<<TransferreturnwithProd>>

TransferreturnwithProdProcs: PUBLIC TransferNodeProcs _
NEW[TransferNodeProcsBody _ [TransferreturnwithProdfoo]];

BuildTransferreturnwithProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[TransferNode] =
BEGIN
RETURN[NEW[TransferNodeBody_[position, length, TransferreturnwithProdProcs, NIL]]];
END;


<<FreeplainProd>>

FreeplainProdProcs: PUBLIC FreeNodeProcs _
NEW[FreeNodeProcsBody _ [FreeplainProdfoo]];

BuildFreeplainProdNode: PUBLIC PROC[position: INT, length: INT]
RETURNS[FreeNode] =
BEGIN
RETURN[NEW[FreeNodeBody_[position, length, FreeplainProdProcs, NIL]]];
END;


<<FreezonedProd>>

FreezonedProdProcs: PUBLIC FreeNodeProcs _
NEW[FreeNodeProcsBody _ [FreezonedProdfoo]];

BuildFreezonedProdNode: PUBLIC PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[FreeNode] =
BEGIN
data: FreezonedProdData _
NEW[FreezonedProdDataBody_[
Exp]];
RETURN[NEW[FreeNodeBody_[position, length, FreezonedProdProcs, data]]];
END;

END..