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

DIRECTORY
SaffronTreeBucketDef,
SaffronGenericDef,
SaffronATDef;

SaffronAG2Def: CEDAR DEFINITIONS = 
BEGIN
OPEN SaffronTreeBucketDef, SaffronGenericDef, SaffronATDef;

<<RelopeqProd>>

RelopeqProdData: TYPE = REF RelopeqProdDataBody;
RelopeqProdDataBody: TYPE = RECORD[
];

RelopeqProdProcs: RelopNodeProcs;

BuildRelopeqProdNode: PROC[position: INT, length: INT]
RETURNS[RelopNode];

RelopeqProdfoo: fooProcType;

<<RelopneProd>>

RelopneProdData: TYPE = REF RelopneProdDataBody;
RelopneProdDataBody: TYPE = RECORD[
];

RelopneProdProcs: RelopNodeProcs;

BuildRelopneProdNode: PROC[position: INT, length: INT]
RETURNS[RelopNode];

RelopneProdfoo: fooProcType;

<<RelopltProd>>

RelopltProdData: TYPE = REF RelopltProdDataBody;
RelopltProdDataBody: TYPE = RECORD[
];

RelopltProdProcs: RelopNodeProcs;

BuildRelopltProdNode: PROC[position: INT, length: INT]
RETURNS[RelopNode];

RelopltProdfoo: fooProcType;

<<RelopleProd>>

RelopleProdData: TYPE = REF RelopleProdDataBody;
RelopleProdDataBody: TYPE = RECORD[
];

RelopleProdProcs: RelopNodeProcs;

BuildRelopleProdNode: PROC[position: INT, length: INT]
RETURNS[RelopNode];

RelopleProdfoo: fooProcType;

<<RelopgtProd>>

RelopgtProdData: TYPE = REF RelopgtProdDataBody;
RelopgtProdDataBody: TYPE = RECORD[
];

RelopgtProdProcs: RelopNodeProcs;

BuildRelopgtProdNode: PROC[position: INT, length: INT]
RETURNS[RelopNode];

RelopgtProdfoo: fooProcType;

<<RelopgeProd>>

RelopgeProdData: TYPE = REF RelopgeProdDataBody;
RelopgeProdDataBody: TYPE = RECORD[
];

RelopgeProdProcs: RelopNodeProcs;

BuildRelopgeProdNode: PROC[position: INT, length: INT]
RETURNS[RelopNode];

RelopgeProdfoo: fooProcType;

<<RangetypeidProd>>

RangetypeidProdData: TYPE = REF RangetypeidProdDataBody;
RangetypeidProdDataBody: TYPE = RECORD[
TypeId: TypeIdNode];

RangetypeidProdProcs: RangeNodeProcs;

BuildRangetypeidProdNode: PROC[position: INT, length: INT, TypeId: TypeIdNode]
RETURNS[RangeNode];

RangetypeidProdfoo: fooProcType;

<<RangesubrangeProd>>

RangesubrangeProdData: TYPE = REF RangesubrangeProdDataBody;
RangesubrangeProdDataBody: TYPE = RECORD[
Subrange: SubrangeNode];

RangesubrangeProdProcs: RangeNodeProcs;

BuildRangesubrangeProdNode: PROC[position: INT, length: INT, Subrange: SubrangeNode]
RETURNS[RangeNode];

RangesubrangeProdfoo: fooProcType;

<<CatchProd>>

CatchProdData: TYPE = REF CatchProdDataBody;
CatchProdDataBody: TYPE = RECORD[
CatchCaseList: CatchCaseListNode, CatchAny: CatchAnyNode];

CatchProdProcs: CatchNodeProcs;

BuildCatchProdNode: PROC[position: INT, length: INT, CatchCaseList: CatchCaseListNode, CatchAny: CatchAnyNode]
RETURNS[CatchNode];

CatchProdfoo: fooProcType;

<<CatchAnyabsentProd>>

CatchAnyabsentProdData: TYPE = REF CatchAnyabsentProdDataBody;
CatchAnyabsentProdDataBody: TYPE = RECORD[
];

CatchAnyabsentProdProcs: CatchAnyNodeProcs;

BuildCatchAnyabsentProdNode: PROC[position: INT, length: INT]
RETURNS[CatchAnyNode];

CatchAnyabsentProdfoo: fooProcType;

<<CatchAnypresentProd>>

CatchAnypresentProdData: TYPE = REF CatchAnypresentProdDataBody;
CatchAnypresentProdDataBody: TYPE = RECORD[
Statement: StatementNode];

CatchAnypresentProdProcs: CatchAnyNodeProcs;

BuildCatchAnypresentProdNode: PROC[position: INT, length: INT, Statement: StatementNode]
RETURNS[CatchAnyNode];

CatchAnypresentProdfoo: fooProcType;

<<CatchCaseListemptyProd>>

CatchCaseListemptyProdData: TYPE = REF CatchCaseListemptyProdDataBody;
CatchCaseListemptyProdDataBody: TYPE = RECORD[
];

CatchCaseListemptyProdProcs: CatchCaseListNodeProcs;

BuildCatchCaseListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[CatchCaseListNode];

CatchCaseListemptyProdfoo: fooProcType;

<<CatchCaseListmoreProd>>

CatchCaseListmoreProdData: TYPE = REF CatchCaseListmoreProdDataBody;
CatchCaseListmoreProdDataBody: TYPE = RECORD[
CatchCaseList: CatchCaseListNode, CatchCase: CatchCaseNode];

CatchCaseListmoreProdProcs: CatchCaseListNodeProcs;

BuildCatchCaseListmoreProdNode: PROC[position: INT, length: INT, CatchCaseList: CatchCaseListNode, CatchCase: CatchCaseNode]
RETURNS[CatchCaseListNode];

CatchCaseListmoreProdfoo: fooProcType;

<<CatchCaseProd>>

CatchCaseProdData: TYPE = REF CatchCaseProdDataBody;
CatchCaseProdDataBody: TYPE = RECORD[
SignalList: SignalListNode, Statement: StatementNode];

CatchCaseProdProcs: CatchCaseNodeProcs;

BuildCatchCaseProdNode: PROC[position: INT, length: INT, SignalList: SignalListNode, Statement: StatementNode]
RETURNS[CatchCaseNode];

CatchCaseProdfoo: fooProcType;

<<SignalListoneProd>>

SignalListoneProdData: TYPE = REF SignalListoneProdDataBody;
SignalListoneProdDataBody: TYPE = RECORD[
Exp: ExpNode];

SignalListoneProdProcs: SignalListNodeProcs;

BuildSignalListoneProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[SignalListNode];

SignalListoneProdfoo: fooProcType;

<<SignalListmoreProd>>

SignalListmoreProdData: TYPE = REF SignalListmoreProdDataBody;
SignalListmoreProdDataBody: TYPE = RECORD[
SignalList: SignalListNode, Exp: ExpNode];

SignalListmoreProdProcs: SignalListNodeProcs;

BuildSignalListmoreProdNode: PROC[position: INT, length: INT, SignalList: SignalListNode, Exp: ExpNode]
RETURNS[SignalListNode];

SignalListmoreProdfoo: fooProcType;

<<ExpListkeylistProd>>

ExpListkeylistProdData: TYPE = REF ExpListkeylistProdDataBody;
ExpListkeylistProdDataBody: TYPE = RECORD[
KeyList: KeyListNode];

ExpListkeylistProdProcs: ExpListNodeProcs;

BuildExpListkeylistProdNode: PROC[position: INT, length: INT, KeyList: KeyListNode]
RETURNS[ExpListNode];

ExpListkeylistProdfoo: fooProcType;

<<ExpListorderlistProd>>

ExpListorderlistProdData: TYPE = REF ExpListorderlistProdDataBody;
ExpListorderlistProdDataBody: TYPE = RECORD[
OrderList: OrderListNode];

ExpListorderlistProdProcs: ExpListNodeProcs;

BuildExpListorderlistProdNode: PROC[position: INT, length: INT, OrderList: OrderListNode]
RETURNS[ExpListNode];

ExpListorderlistProdfoo: fooProcType;

<<KeyListoneProd>>

KeyListoneProdData: TYPE = REF KeyListoneProdDataBody;
KeyListoneProdDataBody: TYPE = RECORD[
KeyItem: KeyItemNode];

KeyListoneProdProcs: KeyListNodeProcs;

BuildKeyListoneProdNode: PROC[position: INT, length: INT, KeyItem: KeyItemNode]
RETURNS[KeyListNode];

KeyListoneProdfoo: fooProcType;

<<KeyListmoreProd>>

KeyListmoreProdData: TYPE = REF KeyListmoreProdDataBody;
KeyListmoreProdDataBody: TYPE = RECORD[
KeyList: KeyListNode, KeyItem: KeyItemNode];

KeyListmoreProdProcs: KeyListNodeProcs;

BuildKeyListmoreProdNode: PROC[position: INT, length: INT, KeyList: KeyListNode, KeyItem: KeyItemNode]
RETURNS[KeyListNode];

KeyListmoreProdfoo: fooProcType;

<<KeyItemProd>>

KeyItemProdData: TYPE = REF KeyItemProdDataBody;
KeyItemProdDataBody: TYPE = RECORD[
id: idNode, OptExp: OptExpNode];

KeyItemProdProcs: KeyItemNodeProcs;

BuildKeyItemProdNode: PROC[position: INT, length: INT, id: idNode, OptExp: OptExpNode]
RETURNS[KeyItemNode];

KeyItemProdfoo: fooProcType;

<<OrderListoneProd>>

OrderListoneProdData: TYPE = REF OrderListoneProdDataBody;
OrderListoneProdDataBody: TYPE = RECORD[
OptExp: OptExpNode];

OrderListoneProdProcs: OrderListNodeProcs;

BuildOrderListoneProdNode: PROC[position: INT, length: INT, OptExp: OptExpNode]
RETURNS[OrderListNode];

OrderListoneProdfoo: fooProcType;

<<OrderListmoreProd>>

OrderListmoreProdData: TYPE = REF OrderListmoreProdDataBody;
OrderListmoreProdDataBody: TYPE = RECORD[
OrderList: OrderListNode, OptExp: OptExpNode];

OrderListmoreProdProcs: OrderListNodeProcs;

BuildOrderListmoreProdNode: PROC[position: INT, length: INT, OrderList: OrderListNode, OptExp: OptExpNode]
RETURNS[OrderListNode];

OrderListmoreProdfoo: fooProcType;

<<OptExpemptyProd>>

OptExpemptyProdData: TYPE = REF OptExpemptyProdDataBody;
OptExpemptyProdDataBody: TYPE = RECORD[
];

OptExpemptyProdProcs: OptExpNodeProcs;

BuildOptExpemptyProdNode: PROC[position: INT, length: INT]
RETURNS[OptExpNode];

OptExpemptyProdfoo: fooProcType;

<<OptExptrashProd>>

OptExptrashProdData: TYPE = REF OptExptrashProdDataBody;
OptExptrashProdDataBody: TYPE = RECORD[
];

OptExptrashProdProcs: OptExpNodeProcs;

BuildOptExptrashProdNode: PROC[position: INT, length: INT]
RETURNS[OptExpNode];

OptExptrashProdfoo: fooProcType;

<<OptExpexpProd>>

OptExpexpProdData: TYPE = REF OptExpexpProdDataBody;
OptExpexpProdDataBody: TYPE = RECORD[
Exp: ExpNode];

OptExpexpProdProcs: OptExpNodeProcs;

BuildOptExpexpProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[OptExpNode];

OptExpexpProdfoo: fooProcType;

<<OptTypeabsentProd>>

OptTypeabsentProdData: TYPE = REF OptTypeabsentProdDataBody;
OptTypeabsentProdDataBody: TYPE = RECORD[
];

OptTypeabsentProdProcs: OptTypeNodeProcs;

BuildOptTypeabsentProdNode: PROC[position: INT, length: INT]
RETURNS[OptTypeNode];

OptTypeabsentProdfoo: fooProcType;

<<OptTypepresentProd>>

OptTypepresentProdData: TYPE = REF OptTypepresentProdDataBody;
OptTypepresentProdDataBody: TYPE = RECORD[
TypeExp: TypeExpNode];

OptTypepresentProdProcs: OptTypeNodeProcs;

BuildOptTypepresentProdNode: PROC[position: INT, length: INT, TypeExp: TypeExpNode]
RETURNS[OptTypeNode];

OptTypepresentProdfoo: fooProcType;

<<QualifierprefixopProd>>

QualifierprefixopProdData: TYPE = REF QualifierprefixopProdDataBody;
QualifierprefixopProdDataBody: TYPE = RECORD[
PrefixOp: PrefixOpNode];

QualifierprefixopProdProcs: QualifierNodeProcs;

BuildQualifierprefixopProdNode: PROC[position: INT, length: INT, PrefixOp: PrefixOpNode]
RETURNS[QualifierNode];

QualifierprefixopProdfoo: fooProcType;

<<QualifiertypeopProd>>

QualifiertypeopProdData: TYPE = REF QualifiertypeopProdDataBody;
QualifiertypeopProdDataBody: TYPE = RECORD[
TypeOp: TypeOpNode];

QualifiertypeopProdProcs: QualifierNodeProcs;

BuildQualifiertypeopProdNode: PROC[position: INT, length: INT, TypeOp: TypeOpNode]
RETURNS[QualifierNode];

QualifiertypeopProdfoo: fooProcType;

<<QualifiersizeProd>>

QualifiersizeProdData: TYPE = REF QualifiersizeProdDataBody;
QualifiersizeProdDataBody: TYPE = RECORD[
];

QualifiersizeProdProcs: QualifierNodeProcs;

BuildQualifiersizeProdNode: PROC[position: INT, length: INT]
RETURNS[QualifierNode];

QualifiersizeProdfoo: fooProcType;

<<QualifierapplyProd>>

QualifierapplyProdData: TYPE = REF QualifierapplyProdDataBody;
QualifierapplyProdDataBody: TYPE = RECORD[
ExpList: ExpListNode, Catch: CatchNode];

QualifierapplyProdProcs: QualifierNodeProcs;

BuildQualifierapplyProdNode: PROC[position: INT, length: INT, ExpList: ExpListNode, Catch: CatchNode]
RETURNS[QualifierNode];

QualifierapplyProdfoo: fooProcType;

<<QualifierselectProd>>

QualifierselectProdData: TYPE = REF QualifierselectProdDataBody;
QualifierselectProdDataBody: TYPE = RECORD[
id: idNode];

QualifierselectProdProcs: QualifierNodeProcs;

BuildQualifierselectProdNode: PROC[position: INT, length: INT, id: idNode]
RETURNS[QualifierNode];

QualifierselectProdfoo: fooProcType;

<<QualifierindirectProd>>

QualifierindirectProdData: TYPE = REF QualifierindirectProdDataBody;
QualifierindirectProdDataBody: TYPE = RECORD[
];

QualifierindirectProdProcs: QualifierNodeProcs;

BuildQualifierindirectProdNode: PROC[position: INT, length: INT]
RETURNS[QualifierNode];

QualifierindirectProdfoo: fooProcType;

<<PrefixOplongProd>>

PrefixOplongProdData: TYPE = REF PrefixOplongProdDataBody;
PrefixOplongProdDataBody: TYPE = RECORD[
];

PrefixOplongProdProcs: PrefixOpNodeProcs;

BuildPrefixOplongProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOplongProdfoo: fooProcType;

<<PrefixOpabsProd>>

PrefixOpabsProdData: TYPE = REF PrefixOpabsProdDataBody;
PrefixOpabsProdDataBody: TYPE = RECORD[
];

PrefixOpabsProdProcs: PrefixOpNodeProcs;

BuildPrefixOpabsProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOpabsProdfoo: fooProcType;

<<PrefixOppredProd>>

PrefixOppredProdData: TYPE = REF PrefixOppredProdDataBody;
PrefixOppredProdDataBody: TYPE = RECORD[
];

PrefixOppredProdProcs: PrefixOpNodeProcs;

BuildPrefixOppredProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOppredProdfoo: fooProcType;

<<PrefixOpsuccProd>>

PrefixOpsuccProdData: TYPE = REF PrefixOpsuccProdDataBody;
PrefixOpsuccProdDataBody: TYPE = RECORD[
];

PrefixOpsuccProdProcs: PrefixOpNodeProcs;

BuildPrefixOpsuccProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOpsuccProdfoo: fooProcType;

<<PrefixOpordProd>>

PrefixOpordProdData: TYPE = REF PrefixOpordProdDataBody;
PrefixOpordProdDataBody: TYPE = RECORD[
];

PrefixOpordProdProcs: PrefixOpNodeProcs;

BuildPrefixOpordProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOpordProdfoo: fooProcType;

<<PrefixOpminProd>>

PrefixOpminProdData: TYPE = REF PrefixOpminProdDataBody;
PrefixOpminProdDataBody: TYPE = RECORD[
];

PrefixOpminProdProcs: PrefixOpNodeProcs;

BuildPrefixOpminProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOpminProdfoo: fooProcType;

<<PrefixOpmaxProd>>

PrefixOpmaxProdData: TYPE = REF PrefixOpmaxProdDataBody;
PrefixOpmaxProdDataBody: TYPE = RECORD[
];

PrefixOpmaxProdProcs: PrefixOpNodeProcs;

BuildPrefixOpmaxProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOpmaxProdfoo: fooProcType;

<<PrefixOpbaseProd>>

PrefixOpbaseProdData: TYPE = REF PrefixOpbaseProdDataBody;
PrefixOpbaseProdDataBody: TYPE = RECORD[
];

PrefixOpbaseProdProcs: PrefixOpNodeProcs;

BuildPrefixOpbaseProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOpbaseProdfoo: fooProcType;

<<PrefixOplengthProd>>

PrefixOplengthProdData: TYPE = REF PrefixOplengthProdDataBody;
PrefixOplengthProdDataBody: TYPE = RECORD[
];

PrefixOplengthProdProcs: PrefixOpNodeProcs;

BuildPrefixOplengthProdNode: PROC[position: INT, length: INT]
RETURNS[PrefixOpNode];

PrefixOplengthProdfoo: fooProcType;

<<TypeOpcodeProd>>

TypeOpcodeProdData: TYPE = REF TypeOpcodeProdDataBody;
TypeOpcodeProdDataBody: TYPE = RECORD[
];

TypeOpcodeProdProcs: TypeOpNodeProcs;

BuildTypeOpcodeProdNode: PROC[position: INT, length: INT]
RETURNS[TypeOpNode];

TypeOpcodeProdfoo: fooProcType;

<<TypeOpfirstProd>>

TypeOpfirstProdData: TYPE = REF TypeOpfirstProdDataBody;
TypeOpfirstProdDataBody: TYPE = RECORD[
];

TypeOpfirstProdProcs: TypeOpNodeProcs;

BuildTypeOpfirstProdNode: PROC[position: INT, length: INT]
RETURNS[TypeOpNode];

TypeOpfirstProdfoo: fooProcType;

<<TypeOplastProd>>

TypeOplastProdData: TYPE = REF TypeOplastProdDataBody;
TypeOplastProdDataBody: TYPE = RECORD[
];

TypeOplastProdProcs: TypeOpNodeProcs;

BuildTypeOplastProdNode: PROC[position: INT, length: INT]
RETURNS[TypeOpNode];

TypeOplastProdfoo: fooProcType;

<<TypeOpnilProd>>

TypeOpnilProdData: TYPE = REF TypeOpnilProdDataBody;
TypeOpnilProdDataBody: TYPE = RECORD[
];

TypeOpnilProdProcs: TypeOpNodeProcs;

BuildTypeOpnilProdNode: PROC[position: INT, length: INT]
RETURNS[TypeOpNode];

TypeOpnilProdfoo: fooProcType;
END..