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

DIRECTORY
SaffronTreeBucketDef,
SaffronTreeDeclsDef,
SaffronGenericDef,
SaffronATDef;

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

<<StatementifthenProd>>

StatementifthenProdData: TYPE = REF StatementifthenProdDataBody;
StatementifthenProdDataBody: TYPE = RECORD[
Exp: ExpNode, Statement: StatementNode];

StatementifthenProdProcs: StatementNodeProcs;

BuildStatementifthenProdNode: PROC[position: INT, length: INT, Exp: ExpNode, Statement: StatementNode]
RETURNS[StatementNode];

StatementifthenProdfoo: fooProcType;

<<StatementifthenelseProd>>

StatementifthenelseProdData: TYPE = REF StatementifthenelseProdDataBody;
StatementifthenelseProdDataBody: TYPE = RECORD[
Exp: ExpNode, Statementthenpart: StatementNode, Statementelsepart: StatementNode];

StatementifthenelseProdProcs: StatementNodeProcs;

BuildStatementifthenelseProdNode: PROC[position: INT, length: INT, Exp: ExpNode, Statementthenpart: StatementNode, 
Statementelsepart: StatementNode]
RETURNS[StatementNode];

StatementifthenelseProdfoo: fooProcType;

<<StatementselectProd>>

StatementselectProdData: TYPE = REF StatementselectProdDataBody;
StatementselectProdDataBody: TYPE = RECORD[
SelectHead: SelectHeadNode, SelectStmtList: SelectStmtListNode, OptStatement: OptStatementNode];

StatementselectProdProcs: StatementNodeProcs;

BuildStatementselectProdNode: PROC[position: INT, length: INT, SelectHead: SelectHeadNode, SelectStmtList: SelectStmtListNode, 
OptStatement: OptStatementNode]
RETURNS[StatementNode];

StatementselectProdfoo: fooProcType;

<<StatementexpProd>>

StatementexpProdData: TYPE = REF StatementexpProdDataBody;
StatementexpProdDataBody: TYPE = RECORD[
Exp: ExpNode];

StatementexpProdProcs: StatementNodeProcs;

BuildStatementexpProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[StatementNode];

StatementexpProdfoo: fooProcType;

<<StatementassignProd>>

StatementassignProdData: TYPE = REF StatementassignProdDataBody;
StatementassignProdDataBody: TYPE = RECORD[
Explhs: ExpNode, Exprhs: ExpNode];

StatementassignProdProcs: StatementNodeProcs;

BuildStatementassignProdNode: PROC[position: INT, length: INT, Explhs: ExpNode, Exprhs: ExpNode]
RETURNS[StatementNode];

StatementassignProdfoo: fooProcType;

<<StatementmultiassignProd>>

StatementmultiassignProdData: TYPE = REF StatementmultiassignProdDataBody;
StatementmultiassignProdDataBody: TYPE = RECORD[
ExpList: ExpListNode, Exp: ExpNode];

StatementmultiassignProdProcs: StatementNodeProcs;

BuildStatementmultiassignProdNode: PROC[position: INT, length: INT, ExpList: ExpListNode, Exp: ExpNode]
RETURNS[StatementNode];

StatementmultiassignProdfoo: fooProcType;

<<StatementblockProd>>

StatementblockProdData: TYPE = REF StatementblockProdDataBody;
StatementblockProdDataBody: TYPE = RECORD[
Checked: CheckedNode, Block: BlockNode];

StatementblockProdProcs: StatementNodeProcs;

BuildStatementblockProdNode: PROC[position: INT, length: INT, Checked: CheckedNode, Block: BlockNode]
RETURNS[StatementNode];

StatementblockProdfoo: fooProcType;

<<StatementloopcontrolProd>>

StatementloopcontrolProdData: TYPE = REF StatementloopcontrolProdDataBody;
StatementloopcontrolProdDataBody: TYPE = RECORD[
ForClause: ForClauseNode, DoTest: DoTestNode, Scope: ScopeNode, DoExit: DoExitNode];

StatementloopcontrolProdProcs: StatementNodeProcs;

BuildStatementloopcontrolProdNode: PROC[position: INT, length: INT, ForClause: ForClauseNode, DoTest: DoTestNode, Scope: ScopeNode, 
DoExit: DoExitNode]
RETURNS[StatementNode];

StatementloopcontrolProdfoo: fooProcType;

<<StatementexitProd>>

StatementexitProdData: TYPE = REF StatementexitProdDataBody;
StatementexitProdDataBody: TYPE = RECORD[
];

StatementexitProdProcs: StatementNodeProcs;

BuildStatementexitProdNode: PROC[position: INT, length: INT]
RETURNS[StatementNode];

StatementexitProdfoo: fooProcType;

<<StatementloopProd>>

StatementloopProdData: TYPE = REF StatementloopProdDataBody;
StatementloopProdDataBody: TYPE = RECORD[
];

StatementloopProdProcs: StatementNodeProcs;

BuildStatementloopProdNode: PROC[position: INT, length: INT]
RETURNS[StatementNode];

StatementloopProdfoo: fooProcType;

<<StatementgotoProd>>

StatementgotoProdData: TYPE = REF StatementgotoProdDataBody;
StatementgotoProdDataBody: TYPE = RECORD[
id: idNode];

StatementgotoProdProcs: StatementNodeProcs;

BuildStatementgotoProdNode: PROC[position: INT, length: INT, id: idNode]
RETURNS[StatementNode];

StatementgotoProdfoo: fooProcType;

<<StatementreturnProd>>

StatementreturnProdData: TYPE = REF StatementreturnProdDataBody;
StatementreturnProdDataBody: TYPE = RECORD[
OptArgs: OptArgsNode];

StatementreturnProdProcs: StatementNodeProcs;

BuildStatementreturnProdNode: PROC[position: INT, length: INT, OptArgs: OptArgsNode]
RETURNS[StatementNode];

StatementreturnProdfoo: fooProcType;

<<StatementtransferProd>>

StatementtransferProdData: TYPE = REF StatementtransferProdDataBody;
StatementtransferProdDataBody: TYPE = RECORD[
Transfer: TransferNode, Exp: ExpNode];

StatementtransferProdProcs: StatementNodeProcs;

BuildStatementtransferProdNode: PROC[position: INT, length: INT, Transfer: TransferNode, Exp: ExpNode]
RETURNS[StatementNode];

StatementtransferProdfoo: fooProcType;

<<StatementfreeProd>>

StatementfreeProdData: TYPE = REF StatementfreeProdDataBody;
StatementfreeProdDataBody: TYPE = RECORD[
Free: FreeNode, Exp: ExpNode, Catch: CatchNode];

StatementfreeProdProcs: StatementNodeProcs;

BuildStatementfreeProdNode: PROC[position: INT, length: INT, Free: FreeNode, Exp: ExpNode, Catch: CatchNode]
RETURNS[StatementNode];

StatementfreeProdfoo: fooProcType;

<<StatementwaitProd>>

StatementwaitProdData: TYPE = REF StatementwaitProdDataBody;
StatementwaitProdDataBody: TYPE = RECORD[
Exp: ExpNode];

StatementwaitProdProcs: StatementNodeProcs;

BuildStatementwaitProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[StatementNode];

StatementwaitProdfoo: fooProcType;

<<StatementerrorProd>>

StatementerrorProdData: TYPE = REF StatementerrorProdDataBody;
StatementerrorProdDataBody: TYPE = RECORD[
];

StatementerrorProdProcs: StatementNodeProcs;

BuildStatementerrorProdNode: PROC[position: INT, length: INT]
RETURNS[StatementNode];

StatementerrorProdfoo: fooProcType;

<<StatementstopProd>>

StatementstopProdData: TYPE = REF StatementstopProdDataBody;
StatementstopProdDataBody: TYPE = RECORD[
];

StatementstopProdProcs: StatementNodeProcs;

BuildStatementstopProdNode: PROC[position: INT, length: INT]
RETURNS[StatementNode];

StatementstopProdfoo: fooProcType;

<<StatementnullProd>>

StatementnullProdData: TYPE = REF StatementnullProdDataBody;
StatementnullProdDataBody: TYPE = RECORD[
];

StatementnullProdProcs: StatementNodeProcs;

BuildStatementnullProdNode: PROC[position: INT, length: INT]
RETURNS[StatementNode];

StatementnullProdfoo: fooProcType;

<<StatementresumeProd>>

StatementresumeProdData: TYPE = REF StatementresumeProdDataBody;
StatementresumeProdDataBody: TYPE = RECORD[
OptArgs: OptArgsNode];

StatementresumeProdProcs: StatementNodeProcs;

BuildStatementresumeProdNode: PROC[position: INT, length: INT, OptArgs: OptArgsNode]
RETURNS[StatementNode];

StatementresumeProdfoo: fooProcType;

<<StatementrejectProd>>

StatementrejectProdData: TYPE = REF StatementrejectProdDataBody;
StatementrejectProdDataBody: TYPE = RECORD[
];

StatementrejectProdProcs: StatementNodeProcs;

BuildStatementrejectProdNode: PROC[position: INT, length: INT]
RETURNS[StatementNode];

StatementrejectProdfoo: fooProcType;

<<StatementcontinueProd>>

StatementcontinueProdData: TYPE = REF StatementcontinueProdDataBody;
StatementcontinueProdDataBody: TYPE = RECORD[
];

StatementcontinueProdProcs: StatementNodeProcs;

BuildStatementcontinueProdNode: PROC[position: INT, length: INT]
RETURNS[StatementNode];

StatementcontinueProdfoo: fooProcType;

<<StatementretryProd>>

StatementretryProdData: TYPE = REF StatementretryProdDataBody;
StatementretryProdDataBody: TYPE = RECORD[
];

StatementretryProdProcs: StatementNodeProcs;

BuildStatementretryProdNode: PROC[position: INT, length: INT]
RETURNS[StatementNode];

StatementretryProdfoo: fooProcType;

<<StatementgetstateProd>>

StatementgetstateProdData: TYPE = REF StatementgetstateProdDataBody;
StatementgetstateProdDataBody: TYPE = RECORD[
Exp: ExpNode];

StatementgetstateProdProcs: StatementNodeProcs;

BuildStatementgetstateProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[StatementNode];

StatementgetstateProdfoo: fooProcType;

<<StatementsetstateProd>>

StatementsetstateProdData: TYPE = REF StatementsetstateProdDataBody;
StatementsetstateProdDataBody: TYPE = RECORD[
Exp: ExpNode];

StatementsetstateProdProcs: StatementNodeProcs;

BuildStatementsetstateProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[StatementNode];

StatementsetstateProdfoo: fooProcType;

<<OptStatementabsentProd>>

OptStatementabsentProdData: TYPE = REF OptStatementabsentProdDataBody;
OptStatementabsentProdDataBody: TYPE = RECORD[
];

OptStatementabsentProdProcs: OptStatementNodeProcs;

BuildOptStatementabsentProdNode: PROC[position: INT, length: INT]
RETURNS[OptStatementNode];

OptStatementabsentProdfoo: fooProcType;

<<OptStatementpresentProd>>

OptStatementpresentProdData: TYPE = REF OptStatementpresentProdDataBody;
OptStatementpresentProdDataBody: TYPE = RECORD[
Statement: StatementNode];

OptStatementpresentProdProcs: OptStatementNodeProcs;

BuildOptStatementpresentProdNode: PROC[position: INT, length: INT, Statement: StatementNode]
RETURNS[OptStatementNode];

OptStatementpresentProdfoo: fooProcType;

<<SelectStmtListemptyProd>>

SelectStmtListemptyProdData: TYPE = REF SelectStmtListemptyProdDataBody;
SelectStmtListemptyProdDataBody: TYPE = RECORD[
];

SelectStmtListemptyProdProcs: SelectStmtListNodeProcs;

BuildSelectStmtListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[SelectStmtListNode];

SelectStmtListemptyProdfoo: fooProcType;

<<SelectStmtListmoreProd>>

SelectStmtListmoreProdData: TYPE = REF SelectStmtListmoreProdDataBody;
SelectStmtListmoreProdDataBody: TYPE = RECORD[
SelectStmtList: SelectStmtListNode, SelectStmtItem: SelectStmtItemNode];

SelectStmtListmoreProdProcs: SelectStmtListNodeProcs;

BuildSelectStmtListmoreProdNode: PROC[position: INT, length: INT, SelectStmtList: SelectStmtListNode, SelectStmtItem: 
SelectStmtItemNode]
RETURNS[SelectStmtListNode];

SelectStmtListmoreProdfoo: fooProcType;

<<SelectStmtItemProd>>

SelectStmtItemProdData: TYPE = REF SelectStmtItemProdDataBody;
SelectStmtItemProdDataBody: TYPE = RECORD[
SelectLabel: SelectLabelNode, Statement: StatementNode];

SelectStmtItemProdProcs: SelectStmtItemNodeProcs;

BuildSelectStmtItemProdNode: PROC[position: INT, length: INT, SelectLabel: SelectLabelNode, Statement: StatementNode]
RETURNS[SelectStmtItemNode];

SelectStmtItemProdfoo: fooProcType;

<<BlockProd>>

BlockProdData: TYPE = REF BlockProdDataBody;
BlockProdDataBody: TYPE = RECORD[
Scope: ScopeNode, ExitList: ExitListNode];

BlockProdProcs: BlockNodeProcs;

BuildBlockProdNode: PROC[position: INT, length: INT, Scope: ScopeNode, ExitList: ExitListNode]
RETURNS[BlockNode];

BlockProdfoo: fooProcType;

<<ScopeProd>>

ScopeProdData: TYPE = REF ScopeProdDataBody;
ScopeProdDataBody: TYPE = RECORD[
BindList: BindListNode, Catch: CatchNode, OptDecList: OptDecListNode, StatementList: StatementListNode];

ScopeProdProcs: ScopeNodeProcs;

BuildScopeProdNode: PROC[position: INT, length: INT, BindList: BindListNode, Catch: CatchNode, OptDecList: OptDecListNode, 
StatementList: StatementListNode]
RETURNS[ScopeNode];

ScopeProdfoo: fooProcType;
ScopeProdNewScope: NewScopeProcType;

<<OptDecListabsentProd>>

OptDecListabsentProdData: TYPE = REF OptDecListabsentProdDataBody;
OptDecListabsentProdDataBody: TYPE = RECORD[
];

OptDecListabsentProdProcs: OptDecListNodeProcs;

BuildOptDecListabsentProdNode: PROC[position: INT, length: INT]
RETURNS[OptDecListNode];

OptDecListabsentProdfoo: fooProcType;
OptDecListabsentProdPreprocessDecls: PreprocessDeclsProcType;
OptDecListabsentProdProcessDecls: ProcessDeclsProcType;

<<OptDecListpresentProd>>

OptDecListpresentProdData: TYPE = REF OptDecListpresentProdDataBody;
OptDecListpresentProdDataBody: TYPE = RECORD[
DecList: DecListNode];

OptDecListpresentProdProcs: OptDecListNodeProcs;

BuildOptDecListpresentProdNode: PROC[position: INT, length: INT, DecList: DecListNode]
RETURNS[OptDecListNode];

OptDecListpresentProdfoo: fooProcType;
OptDecListpresentProdPreprocessDecls: PreprocessDeclsProcType;
OptDecListpresentProdProcessDecls: ProcessDeclsProcType;

<<StatementListemptyProd>>

StatementListemptyProdData: TYPE = REF StatementListemptyProdDataBody;
StatementListemptyProdDataBody: TYPE = RECORD[
];

StatementListemptyProdProcs: StatementListNodeProcs;

BuildStatementListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[StatementListNode];

StatementListemptyProdfoo: fooProcType;

<<StatementListmoreProd>>

StatementListmoreProdData: TYPE = REF StatementListmoreProdDataBody;
StatementListmoreProdDataBody: TYPE = RECORD[
StatementList: StatementListNode, Statement: StatementNode];

StatementListmoreProdProcs: StatementListNodeProcs;

BuildStatementListmoreProdNode: PROC[position: INT, length: INT, StatementList: StatementListNode, Statement: StatementNode]
RETURNS[StatementListNode];

StatementListmoreProdfoo: fooProcType;
END..