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

DIRECTORY
SaffronTreeBucketDef,
SaffronTreeDeclsDef,
SaffronGenericDef,
SaffronATDef;

SaffronAG5Def: CEDAR DEFINITIONS = 
BEGIN
OPEN SaffronTreeBucketDef, SaffronTreeDeclsDef, SaffronGenericDef, SaffronATDef;

<<DecListoneProd>>

DecListoneProdData: TYPE = REF DecListoneProdDataBody;
DecListoneProdDataBody: TYPE = RECORD[
Declaration: DeclarationNode];

DecListoneProdProcs: DecListNodeProcs;

BuildDecListoneProdNode: PROC[position: INT, length: INT, Declaration: DeclarationNode]
RETURNS[DecListNode];

DecListoneProdfoo: fooProcType;
DecListoneProdPreprocessDecls: PreprocessDeclsProcType;
DecListoneProdProcessDecls: ProcessDeclsProcType;

<<DecListmanyProd>>

DecListmanyProdData: TYPE = REF DecListmanyProdDataBody;
DecListmanyProdDataBody: TYPE = RECORD[
DecListhead: DecListNode, DecListtail: DecListNode];

DecListmanyProdProcs: DecListNodeProcs;

BuildDecListmanyProdNode: PROC[position: INT, length: INT, DecListhead: DecListNode, DecListtail: DecListNode]
RETURNS[DecListNode];

DecListmanyProdfoo: fooProcType;
DecListmanyProdPreprocessDecls: PreprocessDeclsProcType;
DecListmanyProdProcessDecls: ProcessDeclsProcType;

<<DeclarationvalueProd>>

DeclarationvalueProdData: TYPE = REF DeclarationvalueProdDataBody;
DeclarationvalueProdDataBody: TYPE = RECORD[
IdentList: IdentListNode, Access: AccessNode, Entry: EntryNode, ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode, Initialization: 
InitializationNode];

DeclarationvalueProdProcs: DeclarationNodeProcs;

BuildDeclarationvalueProdNode: PROC[position: INT, length: INT, IdentList: IdentListNode, Access: AccessNode, Entry: EntryNode, 
ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode, Initialization: InitializationNode]
RETURNS[DeclarationNode];

DeclarationvalueProdfoo: fooProcType;
DeclarationvalueProdPreprocessDecls: PreprocessDeclsProcType;
DeclarationvalueProdProcessDecls: ProcessDeclsProcType;
DeclarationvalueProdProcessOneDecl: ProcessOneDeclProcType;

<<DeclarationtypeProd>>

DeclarationtypeProdData: TYPE = REF DeclarationtypeProdDataBody;
DeclarationtypeProdDataBody: TYPE = RECORD[
IdentList: IdentListNode, Accessid: AccessNode, Accesstype: AccessNode, TypeExp: TypeExpNode, Default: DefaultNode];

DeclarationtypeProdProcs: DeclarationNodeProcs;

BuildDeclarationtypeProdNode: PROC[position: INT, length: INT, IdentList: IdentListNode, Accessid: AccessNode, Accesstype: 
AccessNode, TypeExp: TypeExpNode, Default: DefaultNode]
RETURNS[DeclarationNode];

DeclarationtypeProdfoo: fooProcType;
DeclarationtypeProdPreprocessDecls: PreprocessDeclsProcType;
DeclarationtypeProdProcessDecls: ProcessDeclsProcType;
DeclarationtypeProdProcessOneDecl: ProcessOneDeclProcType;

<<DeclarationopaquetypeProd>>

DeclarationopaquetypeProdData: TYPE = REF DeclarationopaquetypeProdDataBody;
DeclarationopaquetypeProdDataBody: TYPE = RECORD[
IdentList: IdentListNode, Access: AccessNode, OptSize: OptSizeNode];

DeclarationopaquetypeProdProcs: DeclarationNodeProcs;

BuildDeclarationopaquetypeProdNode: PROC[position: INT, length: INT, IdentList: IdentListNode, Access: AccessNode, OptSize: 
OptSizeNode]
RETURNS[DeclarationNode];

DeclarationopaquetypeProdfoo: fooProcType;
DeclarationopaquetypeProdPreprocessDecls: PreprocessDeclsProcType;
DeclarationopaquetypeProdProcessDecls: ProcessDeclsProcType;
DeclarationopaquetypeProdProcessOneDecl: ProcessOneDeclProcType;

<<OptSizeabsentProd>>

OptSizeabsentProdData: TYPE = REF OptSizeabsentProdDataBody;
OptSizeabsentProdDataBody: TYPE = RECORD[
];

OptSizeabsentProdProcs: OptSizeNodeProcs;

BuildOptSizeabsentProdNode: PROC[position: INT, length: INT]
RETURNS[OptSizeNode];

OptSizeabsentProdfoo: fooProcType;

<<OptSizepresentProd>>

OptSizepresentProdData: TYPE = REF OptSizepresentProdDataBody;
OptSizepresentProdDataBody: TYPE = RECORD[
Exp: ExpNode];

OptSizepresentProdProcs: OptSizeNodeProcs;

BuildOptSizepresentProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[OptSizeNode];

OptSizepresentProdfoo: fooProcType;

<<EntryentryProd>>

EntryentryProdData: TYPE = REF EntryentryProdDataBody;
EntryentryProdDataBody: TYPE = RECORD[
];

EntryentryProdProcs: EntryNodeProcs;

BuildEntryentryProdNode: PROC[position: INT, length: INT]
RETURNS[EntryNode];

EntryentryProdfoo: fooProcType;

<<EntryinternalProd>>

EntryinternalProdData: TYPE = REF EntryinternalProdDataBody;
EntryinternalProdDataBody: TYPE = RECORD[
];

EntryinternalProdProcs: EntryNodeProcs;

BuildEntryinternalProdNode: PROC[position: INT, length: INT]
RETURNS[EntryNode];

EntryinternalProdfoo: fooProcType;

<<EntryemptyProd>>

EntryemptyProdData: TYPE = REF EntryemptyProdDataBody;
EntryemptyProdDataBody: TYPE = RECORD[
];

EntryemptyProdProcs: EntryNodeProcs;

BuildEntryemptyProdNode: PROC[position: INT, length: INT]
RETURNS[EntryNode];

EntryemptyProdfoo: fooProcType;

<<ExitListemptyProd>>

ExitListemptyProdData: TYPE = REF ExitListemptyProdDataBody;
ExitListemptyProdDataBody: TYPE = RECORD[
];

ExitListemptyProdProcs: ExitListNodeProcs;

BuildExitListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ExitListNode];

ExitListemptyProdfoo: fooProcType;

<<ExitListmoreProd>>

ExitListmoreProdData: TYPE = REF ExitListmoreProdDataBody;
ExitListmoreProdDataBody: TYPE = RECORD[
ExitList: ExitListNode, ExitItem: ExitItemNode];

ExitListmoreProdProcs: ExitListNodeProcs;

BuildExitListmoreProdNode: PROC[position: INT, length: INT, ExitList: ExitListNode, ExitItem: ExitItemNode]
RETURNS[ExitListNode];

ExitListmoreProdfoo: fooProcType;

<<ExitItemProd>>

ExitItemProdData: TYPE = REF ExitItemProdDataBody;
ExitItemProdDataBody: TYPE = RECORD[
IdList: IdListNode, Statement: StatementNode];

ExitItemProdProcs: ExitItemNodeProcs;

BuildExitItemProdNode: PROC[position: INT, length: INT, IdList: IdListNode, Statement: StatementNode]
RETURNS[ExitItemNode];

ExitItemProdfoo: fooProcType;

<<BindListemptyProd>>

BindListemptyProdData: TYPE = REF BindListemptyProdDataBody;
BindListemptyProdDataBody: TYPE = RECORD[
];

BindListemptyProdProcs: BindListNodeProcs;

BuildBindListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[BindListNode];

BindListemptyProdfoo: fooProcType;

<<BindListmoreProd>>

BindListmoreProdData: TYPE = REF BindListmoreProdDataBody;
BindListmoreProdDataBody: TYPE = RECORD[
BindList: BindListNode, BindItem: BindItemNode];

BindListmoreProdProcs: BindListNodeProcs;

BuildBindListmoreProdNode: PROC[position: INT, length: INT, BindList: BindListNode, BindItem: BindItemNode]
RETURNS[BindListNode];

BindListmoreProdfoo: fooProcType;

<<BindItemnamedProd>>

BindItemnamedProdData: TYPE = REF BindItemnamedProdDataBody;
BindItemnamedProdDataBody: TYPE = RECORD[
id: idNode, Exp: ExpNode];

BindItemnamedProdProcs: BindItemNodeProcs;

BuildBindItemnamedProdNode: PROC[position: INT, length: INT, id: idNode, Exp: ExpNode]
RETURNS[BindItemNode];

BindItemnamedProdfoo: fooProcType;

<<BindItemunnamedProd>>

BindItemunnamedProdData: TYPE = REF BindItemunnamedProdDataBody;
BindItemunnamedProdDataBody: TYPE = RECORD[
Exp: ExpNode];

BindItemunnamedProdProcs: BindItemNodeProcs;

BuildBindItemunnamedProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[BindItemNode];

BindItemunnamedProdfoo: fooProcType;

<<ForClauseassignationProd>>

ForClauseassignationProdData: TYPE = REF ForClauseassignationProdDataBody;
ForClauseassignationProdDataBody: TYPE = RECORD[
ControlId: ControlIdNode, Expinitial: ExpNode, Expnext: ExpNode];

ForClauseassignationProdProcs: ForClauseNodeProcs;

BuildForClauseassignationProdNode: PROC[position: INT, length: INT, ControlId: ControlIdNode, Expinitial: ExpNode, Expnext: ExpNode]
RETURNS[ForClauseNode];

ForClauseassignationProdfoo: fooProcType;

<<ForClauseiterationProd>>

ForClauseiterationProdData: TYPE = REF ForClauseiterationProdDataBody;
ForClauseiterationProdDataBody: TYPE = RECORD[
ControlId: ControlIdNode, Decreasing: DecreasingNode, Range: RangeNode];

ForClauseiterationProdProcs: ForClauseNodeProcs;

BuildForClauseiterationProdNode: PROC[position: INT, length: INT, ControlId: ControlIdNode, Decreasing: DecreasingNode, Range: 
RangeNode]
RETURNS[ForClauseNode];

ForClauseiterationProdfoo: fooProcType;

<<ForClauserepetitionProd>>

ForClauserepetitionProdData: TYPE = REF ForClauserepetitionProdDataBody;
ForClauserepetitionProdDataBody: TYPE = RECORD[
Range: RangeNode];

ForClauserepetitionProdProcs: ForClauseNodeProcs;

BuildForClauserepetitionProdNode: PROC[position: INT, length: INT, Range: RangeNode]
RETURNS[ForClauseNode];

ForClauserepetitionProdfoo: fooProcType;

<<ForClauseemptyProd>>

ForClauseemptyProdData: TYPE = REF ForClauseemptyProdDataBody;
ForClauseemptyProdDataBody: TYPE = RECORD[
];

ForClauseemptyProdProcs: ForClauseNodeProcs;

BuildForClauseemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ForClauseNode];

ForClauseemptyProdfoo: fooProcType;

<<ControlIdnewProd>>

ControlIdnewProdData: TYPE = REF ControlIdnewProdDataBody;
ControlIdnewProdDataBody: TYPE = RECORD[
Ident: IdentNode, TypeExp: TypeExpNode];

ControlIdnewProdProcs: ControlIdNodeProcs;

BuildControlIdnewProdNode: PROC[position: INT, length: INT, Ident: IdentNode, TypeExp: TypeExpNode]
RETURNS[ControlIdNode];

ControlIdnewProdfoo: fooProcType;

<<ControlIdoldProd>>

ControlIdoldProdData: TYPE = REF ControlIdoldProdDataBody;
ControlIdoldProdDataBody: TYPE = RECORD[
id: idNode];

ControlIdoldProdProcs: ControlIdNodeProcs;

BuildControlIdoldProdNode: PROC[position: INT, length: INT, id: idNode]
RETURNS[ControlIdNode];

ControlIdoldProdfoo: fooProcType;

<<DecreasingyesProd>>

DecreasingyesProdData: TYPE = REF DecreasingyesProdDataBody;
DecreasingyesProdDataBody: TYPE = RECORD[
];

DecreasingyesProdProcs: DecreasingNodeProcs;

BuildDecreasingyesProdNode: PROC[position: INT, length: INT]
RETURNS[DecreasingNode];

DecreasingyesProdfoo: fooProcType;

<<DecreasingnoProd>>

DecreasingnoProdData: TYPE = REF DecreasingnoProdDataBody;
DecreasingnoProdDataBody: TYPE = RECORD[
];

DecreasingnoProdProcs: DecreasingNodeProcs;

BuildDecreasingnoProdNode: PROC[position: INT, length: INT]
RETURNS[DecreasingNode];

DecreasingnoProdfoo: fooProcType;

<<DoTestuntilProd>>

DoTestuntilProdData: TYPE = REF DoTestuntilProdDataBody;
DoTestuntilProdDataBody: TYPE = RECORD[
Exp: ExpNode];

DoTestuntilProdProcs: DoTestNodeProcs;

BuildDoTestuntilProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[DoTestNode];

DoTestuntilProdfoo: fooProcType;

<<DoTestwhileProd>>

DoTestwhileProdData: TYPE = REF DoTestwhileProdDataBody;
DoTestwhileProdDataBody: TYPE = RECORD[
Exp: ExpNode];

DoTestwhileProdProcs: DoTestNodeProcs;

BuildDoTestwhileProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[DoTestNode];

DoTestwhileProdfoo: fooProcType;

<<DoTestemptyProd>>

DoTestemptyProdData: TYPE = REF DoTestemptyProdDataBody;
DoTestemptyProdDataBody: TYPE = RECORD[
];

DoTestemptyProdProcs: DoTestNodeProcs;

BuildDoTestemptyProdNode: PROC[position: INT, length: INT]
RETURNS[DoTestNode];

DoTestemptyProdfoo: fooProcType;

<<DoExitProd>>

DoExitProdData: TYPE = REF DoExitProdDataBody;
DoExitProdDataBody: TYPE = RECORD[
ExitList: ExitListNode, OptStatement: OptStatementNode];

DoExitProdProcs: DoExitNodeProcs;

BuildDoExitProdNode: PROC[position: INT, length: INT, ExitList: ExitListNode, OptStatement: OptStatementNode]
RETURNS[DoExitNode];

DoExitProdfoo: fooProcType;

<<OptArgsexplistProd>>

OptArgsexplistProdData: TYPE = REF OptArgsexplistProdDataBody;
OptArgsexplistProdDataBody: TYPE = RECORD[
ExpList: ExpListNode];

OptArgsexplistProdProcs: OptArgsNodeProcs;

BuildOptArgsexplistProdNode: PROC[position: INT, length: INT, ExpList: ExpListNode]
RETURNS[OptArgsNode];

OptArgsexplistProdfoo: fooProcType;

<<OptArgsexpProd>>

OptArgsexpProdData: TYPE = REF OptArgsexpProdDataBody;
OptArgsexpProdDataBody: TYPE = RECORD[
Exp: ExpNode];

OptArgsexpProdProcs: OptArgsNodeProcs;

BuildOptArgsexpProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[OptArgsNode];

OptArgsexpProdfoo: fooProcType;

<<OptArgsemptyProd>>

OptArgsemptyProdData: TYPE = REF OptArgsemptyProdDataBody;
OptArgsemptyProdDataBody: TYPE = RECORD[
];

OptArgsemptyProdProcs: OptArgsNodeProcs;

BuildOptArgsemptyProdNode: PROC[position: INT, length: INT]
RETURNS[OptArgsNode];

OptArgsemptyProdfoo: fooProcType;

<<TransfersignalProd>>

TransfersignalProdData: TYPE = REF TransfersignalProdDataBody;
TransfersignalProdDataBody: TYPE = RECORD[
];

TransfersignalProdProcs: TransferNodeProcs;

BuildTransfersignalProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransfersignalProdfoo: fooProcType;

<<TransfererrorProd>>

TransfererrorProdData: TYPE = REF TransfererrorProdDataBody;
TransfererrorProdDataBody: TYPE = RECORD[
];

TransfererrorProdProcs: TransferNodeProcs;

BuildTransfererrorProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransfererrorProdfoo: fooProcType;

<<TransferreturnwitherrorProd>>

TransferreturnwitherrorProdData: TYPE = REF TransferreturnwitherrorProdDataBody;
TransferreturnwitherrorProdDataBody: TYPE = RECORD[
];

TransferreturnwitherrorProdProcs: TransferNodeProcs;

BuildTransferreturnwitherrorProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferreturnwitherrorProdfoo: fooProcType;

<<TransferstartProd>>

TransferstartProdData: TYPE = REF TransferstartProdDataBody;
TransferstartProdDataBody: TYPE = RECORD[
];

TransferstartProdProcs: TransferNodeProcs;

BuildTransferstartProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferstartProdfoo: fooProcType;

<<TransferrestartProd>>

TransferrestartProdData: TYPE = REF TransferrestartProdDataBody;
TransferrestartProdDataBody: TYPE = RECORD[
];

TransferrestartProdProcs: TransferNodeProcs;

BuildTransferrestartProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferrestartProdfoo: fooProcType;

<<TransferjoinProd>>

TransferjoinProdData: TYPE = REF TransferjoinProdDataBody;
TransferjoinProdDataBody: TYPE = RECORD[
];

TransferjoinProdProcs: TransferNodeProcs;

BuildTransferjoinProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferjoinProdfoo: fooProcType;

<<TransfernotifyProd>>

TransfernotifyProdData: TYPE = REF TransfernotifyProdDataBody;
TransfernotifyProdDataBody: TYPE = RECORD[
];

TransfernotifyProdProcs: TransferNodeProcs;

BuildTransfernotifyProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransfernotifyProdfoo: fooProcType;

<<TransferbroadcastProd>>

TransferbroadcastProdData: TYPE = REF TransferbroadcastProdDataBody;
TransferbroadcastProdDataBody: TYPE = RECORD[
];

TransferbroadcastProdProcs: TransferNodeProcs;

BuildTransferbroadcastProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferbroadcastProdfoo: fooProcType;

<<TransfertransferwithProd>>

TransfertransferwithProdData: TYPE = REF TransfertransferwithProdDataBody;
TransfertransferwithProdDataBody: TYPE = RECORD[
];

TransfertransferwithProdProcs: TransferNodeProcs;

BuildTransfertransferwithProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransfertransferwithProdfoo: fooProcType;

<<TransferreturnwithProd>>

TransferreturnwithProdData: TYPE = REF TransferreturnwithProdDataBody;
TransferreturnwithProdDataBody: TYPE = RECORD[
];

TransferreturnwithProdProcs: TransferNodeProcs;

BuildTransferreturnwithProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferreturnwithProdfoo: fooProcType;

<<FreeplainProd>>

FreeplainProdData: TYPE = REF FreeplainProdDataBody;
FreeplainProdDataBody: TYPE = RECORD[
];

FreeplainProdProcs: FreeNodeProcs;

BuildFreeplainProdNode: PROC[position: INT, length: INT]
RETURNS[FreeNode];

FreeplainProdfoo: fooProcType;

<<FreezonedProd>>

FreezonedProdData: TYPE = REF FreezonedProdDataBody;
FreezonedProdDataBody: TYPE = RECORD[
Exp: ExpNode];

FreezonedProdProcs: FreeNodeProcs;

BuildFreezonedProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[FreeNode];

FreezonedProdfoo: fooProcType;
END..