DIRECTORY
SaffronTreeBucketDef,
SaffronGenericDef,
SaffronATDef;

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


ModulePimplProdData: TYPE = REF ModulePimplProdDataBody;
ModulePimplProdDataBody: TYPE = RECORD[
Directory: DirectoryNode, IdentList: IdentListNode, Cedar: CedarNode, ProgHead: ProgHeadNode, Checked: CheckedNode, Block: BlockNode];

ModulePimplProdProcs: ModulePNodeProcs;

BuildModulePimplProdNode: PROC[position: INT, length: INT, Directory: DirectoryNode, IdentList: IdentListNode, Cedar: CedarNode, ProgHead: ProgHeadNode, Checked: CheckedNode, Block: BlockNode]
RETURNS[ModulePNode];

ModulePimplProdfoo: fooProcType;


ModulePdefProdData: TYPE = REF ModulePdefProdDataBody;
ModulePdefProdDataBody: TYPE = RECORD[
Directory: DirectoryNode, IdentList: IdentListNode, Cedar: CedarNode, DefHead: DefHeadNode, DefBody: DefBodyNode];

ModulePdefProdProcs: ModulePNodeProcs;

BuildModulePdefProdNode: PROC[position: INT, length: INT, Directory: DirectoryNode, IdentList: IdentListNode, Cedar: CedarNode, DefHead: DefHeadNode, DefBody: DefBodyNode]
RETURNS[ModulePNode];

ModulePdefProdfoo: fooProcType;


DirectoryemptyProdData: TYPE = REF DirectoryemptyProdDataBody;
DirectoryemptyProdDataBody: TYPE = RECORD[
];

DirectoryemptyProdProcs: DirectoryNodeProcs;

BuildDirectoryemptyProdNode: PROC[position: INT, length: INT]
RETURNS[DirectoryNode];

DirectoryemptyProdfoo: fooProcType;


DirectorymoreProdData: TYPE = REF DirectorymoreProdDataBody;
DirectorymoreProdDataBody: TYPE = RECORD[
Directory: DirectoryNode, IncludeItem: IncludeItemNode];

DirectorymoreProdProcs: DirectoryNodeProcs;

BuildDirectorymoreProdNode: PROC[position: INT, length: INT, Directory: DirectoryNode, IncludeItem: IncludeItemNode]
RETURNS[DirectoryNode];

DirectorymoreProdfoo: fooProcType;


IncludeItemfrompProdData: TYPE = REF IncludeItemfrompProdDataBody;
IncludeItemfrompProdDataBody: TYPE = RECORD[
id: idNode, string: stringNode, Using: UsingNode];

IncludeItemfrompProdProcs: IncludeItemNodeProcs;

BuildIncludeItemfrompProdNode: PROC[position: INT, length: INT, id: idNode, string: stringNode, Using: UsingNode]
RETURNS[IncludeItemNode];

IncludeItemfrompProdfoo: fooProcType;


IncludeItemtypeProdData: TYPE = REF IncludeItemtypeProdDataBody;
IncludeItemtypeProdDataBody: TYPE = RECORD[
id: idNode, Using: UsingNode];

IncludeItemtypeProdProcs: IncludeItemNodeProcs;

BuildIncludeItemtypeProdNode: PROC[position: INT, length: INT, id: idNode, Using: UsingNode]
RETURNS[IncludeItemNode];

IncludeItemtypeProdfoo: fooProcType;


IncludeItemplainProdData: TYPE = REF IncludeItemplainProdDataBody;
IncludeItemplainProdDataBody: TYPE = RECORD[
id: idNode, Using: UsingNode];

IncludeItemplainProdProcs: IncludeItemNodeProcs;

BuildIncludeItemplainProdNode: PROC[position: INT, length: INT, id: idNode, Using: UsingNode]
RETURNS[IncludeItemNode];

IncludeItemplainProdfoo: fooProcType;


IncludeItemtypeandidProdData: TYPE = REF IncludeItemtypeandidProdDataBody;
IncludeItemtypeandidProdDataBody: TYPE = RECORD[
idlocal: idNode, idglobal: idNode, Using: UsingNode];

IncludeItemtypeandidProdProcs: IncludeItemNodeProcs;

BuildIncludeItemtypeandidProdNode: PROC[position: INT, length: INT, idlocal: idNode, idglobal: idNode, Using: UsingNode]
RETURNS[IncludeItemNode];

IncludeItemtypeandidProdfoo: fooProcType;


UsingrestrictedProdData: TYPE = REF UsingrestrictedProdDataBody;
UsingrestrictedProdDataBody: TYPE = RECORD[
IdList: IdListNode];

UsingrestrictedProdProcs: UsingNodeProcs;

BuildUsingrestrictedProdNode: PROC[position: INT, length: INT, IdList: IdListNode]
RETURNS[UsingNode];

UsingrestrictedProdfoo: fooProcType;


UsingnothingProdData: TYPE = REF UsingnothingProdDataBody;
UsingnothingProdDataBody: TYPE = RECORD[
];

UsingnothingProdProcs: UsingNodeProcs;

BuildUsingnothingProdNode: PROC[position: INT, length: INT]
RETURNS[UsingNode];

UsingnothingProdfoo: fooProcType;


UsingunrestrictedProdData: TYPE = REF UsingunrestrictedProdDataBody;
UsingunrestrictedProdDataBody: TYPE = RECORD[
];

UsingunrestrictedProdProcs: UsingNodeProcs;

BuildUsingunrestrictedProdNode: PROC[position: INT, length: INT]
RETURNS[UsingNode];

UsingunrestrictedProdfoo: fooProcType;


DefBodyProdData: TYPE = REF DefBodyProdDataBody;
DefBodyProdDataBody: TYPE = RECORD[
BindList: BindListNode, DecList: DecListNode];

DefBodyProdProcs: DefBodyNodeProcs;

BuildDefBodyProdNode: PROC[position: INT, length: INT, BindList: BindListNode, DecList: DecListNode]
RETURNS[DefBodyNode];

DefBodyProdfoo: fooProcType;


DefHeadProdData: TYPE = REF DefHeadProdDataBody;
DefHeadProdDataBody: TYPE = RECORD[
Locks: LocksNode, ModuleList: ModuleListNode, Shares: SharesNode, Access: AccessNode];

DefHeadProdProcs: DefHeadNodeProcs;

BuildDefHeadProdNode: PROC[position: INT, length: INT, Locks: LocksNode, ModuleList: ModuleListNode, Shares: SharesNode, Access: AccessNode]
RETURNS[DefHeadNode];

DefHeadProdfoo: fooProcType;


CedaryesProdData: TYPE = REF CedaryesProdDataBody;
CedaryesProdDataBody: TYPE = RECORD[
];

CedaryesProdProcs: CedarNodeProcs;

BuildCedaryesProdNode: PROC[position: INT, length: INT]
RETURNS[CedarNode];

CedaryesProdfoo: fooProcType;


CedarnoProdData: TYPE = REF CedarnoProdDataBody;
CedarnoProdDataBody: TYPE = RECORD[
];

CedarnoProdProcs: CedarNodeProcs;

BuildCedarnoProdNode: PROC[position: INT, length: INT]
RETURNS[CedarNode];

CedarnoProdfoo: fooProcType;


ProgHeadProdData: TYPE = REF ProgHeadProdDataBody;
ProgHeadProdDataBody: TYPE = RECORD[
Safe: SafeNode, Class: ClassNode, Arguments: ArgumentsNode, Locks: LocksNode, Interface: InterfaceNode, Access: AccessNode];

ProgHeadProdProcs: ProgHeadNodeProcs;

BuildProgHeadProdNode: PROC[position: INT, length: INT, Safe: SafeNode, Class: ClassNode, Arguments: ArgumentsNode, Locks: LocksNode, Interface: InterfaceNode, Access: AccessNode]
RETURNS[ProgHeadNode];

ProgHeadProdfoo: fooProcType;


ClassprogramProdData: TYPE = REF ClassprogramProdDataBody;
ClassprogramProdDataBody: TYPE = RECORD[
];

ClassprogramProdProcs: ClassNodeProcs;

BuildClassprogramProdNode: PROC[position: INT, length: INT]
RETURNS[ClassNode];

ClassprogramProdfoo: fooProcType;


ClassmonitorProdData: TYPE = REF ClassmonitorProdDataBody;
ClassmonitorProdDataBody: TYPE = RECORD[
];

ClassmonitorProdProcs: ClassNodeProcs;

BuildClassmonitorProdNode: PROC[position: INT, length: INT]
RETURNS[ClassNode];

ClassmonitorProdfoo: fooProcType;


InterfaceProdData: TYPE = REF InterfaceProdDataBody;
InterfaceProdDataBody: TYPE = RECORD[
ModuleListimports: ModuleListNode, ModuleListexports: ModuleListNode, Shares: SharesNode];

InterfaceProdProcs: InterfaceNodeProcs;

BuildInterfaceProdNode: PROC[position: INT, length: INT, ModuleListimports: ModuleListNode, ModuleListexports: ModuleListNode, Shares: SharesNode]
RETURNS[InterfaceNode];

InterfaceProdfoo: fooProcType;


ModuleListemptyProdData: TYPE = REF ModuleListemptyProdDataBody;
ModuleListemptyProdDataBody: TYPE = RECORD[
];

ModuleListemptyProdProcs: ModuleListNodeProcs;

BuildModuleListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ModuleListNode];

ModuleListemptyProdfoo: fooProcType;


ModuleListmoreProdData: TYPE = REF ModuleListmoreProdDataBody;
ModuleListmoreProdDataBody: TYPE = RECORD[
ModuleList: ModuleListNode, ModuleItem: ModuleItemNode];

ModuleListmoreProdProcs: ModuleListNodeProcs;

BuildModuleListmoreProdNode: PROC[position: INT, length: INT, ModuleList: ModuleListNode, ModuleItem: ModuleItemNode]
RETURNS[ModuleListNode];

ModuleListmoreProdfoo: fooProcType;


ModuleItemoneProdData: TYPE = REF ModuleItemoneProdDataBody;
ModuleItemoneProdDataBody: TYPE = RECORD[
id: idNode];

ModuleItemoneProdProcs: ModuleItemNodeProcs;

BuildModuleItemoneProdNode: PROC[position: INT, length: INT, id: idNode]
RETURNS[ModuleItemNode];

ModuleItemoneProdfoo: fooProcType;


ModuleItemtwoProdData: TYPE = REF ModuleItemtwoProdDataBody;
ModuleItemtwoProdDataBody: TYPE = RECORD[
idrecord: idNode, idtype: idNode];

ModuleItemtwoProdProcs: ModuleItemNodeProcs;

BuildModuleItemtwoProdNode: PROC[position: INT, length: INT, idrecord: idNode, idtype: idNode]
RETURNS[ModuleItemNode];

ModuleItemtwoProdfoo: fooProcType;


SharesabsentProdData: TYPE = REF SharesabsentProdDataBody;
SharesabsentProdDataBody: TYPE = RECORD[
];

SharesabsentProdProcs: SharesNodeProcs;

BuildSharesabsentProdNode: PROC[position: INT, length: INT]
RETURNS[SharesNode];

SharesabsentProdfoo: fooProcType;


SharespresentProdData: TYPE = REF SharespresentProdDataBody;
SharespresentProdDataBody: TYPE = RECORD[
IdList: IdListNode];

SharespresentProdProcs: SharesNodeProcs;

BuildSharespresentProdNode: PROC[position: INT, length: INT, IdList: IdListNode]
RETURNS[SharesNode];

SharespresentProdfoo: fooProcType;


LocksabsentProdData: TYPE = REF LocksabsentProdDataBody;
LocksabsentProdDataBody: TYPE = RECORD[
];

LocksabsentProdProcs: LocksNodeProcs;

BuildLocksabsentProdNode: PROC[position: INT, length: INT]
RETURNS[LocksNode];

LocksabsentProdfoo: fooProcType;


LockspresentProdData: TYPE = REF LockspresentProdDataBody;
LockspresentProdDataBody: TYPE = RECORD[
Exp: ExpNode, Lambda: LambdaNode];

LockspresentProdProcs: LocksNodeProcs;

BuildLockspresentProdNode: PROC[position: INT, length: INT, Exp: ExpNode, Lambda: LambdaNode]
RETURNS[LocksNode];

LockspresentProdfoo: fooProcType;


LambdaabsentProdData: TYPE = REF LambdaabsentProdDataBody;
LambdaabsentProdDataBody: TYPE = RECORD[
];

LambdaabsentProdProcs: LambdaNodeProcs;

BuildLambdaabsentProdNode: PROC[position: INT, length: INT]
RETURNS[LambdaNode];

LambdaabsentProdfoo: fooProcType;


LambdapresentProdData: TYPE = REF LambdapresentProdDataBody;
LambdapresentProdDataBody: TYPE = RECORD[
Ident: IdentNode, TypeExp: TypeExpNode];

LambdapresentProdProcs: LambdaNodeProcs;

BuildLambdapresentProdNode: PROC[position: INT, length: INT, Ident: IdentNode, TypeExp: TypeExpNode]
RETURNS[LambdaNode];

LambdapresentProdfoo: fooProcType;
END..

ÄSaffronAG9Def.mesa
Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
Generated by BJackson.pa at April 27, 1987 10:51:26 pm PDT
using ThreeCasabaFour [1.1] of April 14, 1987 6:34:07 pm PDT
ModulePimplProd
ModulePdefProd
DirectoryemptyProd
DirectorymoreProd
IncludeItemfrompProd
IncludeItemtypeProd
IncludeItemplainProd
IncludeItemtypeandidProd
UsingrestrictedProd
UsingnothingProd
UsingunrestrictedProd
DefBodyProd
DefHeadProd
CedaryesProd
CedarnoProd
ProgHeadProd
ClassprogramProd
ClassmonitorProd
InterfaceProd
ModuleListemptyProd
ModuleListmoreProd
ModuleItemoneProd
ModuleItemtwoProd
SharesabsentProd
SharespresentProd
LocksabsentProd
LockspresentProd
LambdaabsentProd
LambdapresentProd
�Ê
˜š
œ™Jš
œ<™<Jš
œ:™:Jš
œ<™<—J˜š
Ïk	˜	J˜J˜J˜
—J˜JšÏn
œ�œ
�œ˜#Jš
�˜Jš�œ7˜;J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšž	œž	œžœ
žœžœžœ
˜†
J˜Jšžœ˜'J˜šžœ�œ�œ
�œž	œž	œžœ
žœžœžœ˜À
Jš�œ˜—J˜J˜ J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jš
ž	œž	œžœ
žœžœ˜rJ˜Jšžœ˜&J˜šžœ�œ�œ
�œž	œž	œžœ
žœžœ˜«
Jš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*J˜J˜Jšžœ˜,J˜šžœ�œ�œ
�œ
˜=Jš�œ˜—J˜J˜#J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšž	œžœ˜8J˜Jšžœ˜+J˜šžœ�œ�œ
�œž	œžœ˜tJš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,Jšœ žœ
˜2J˜Jšžœ˜0J˜š
žœ�œ�œ
�œ"žœ˜qJš�œ˜—J˜J˜%J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšœžœ
˜J˜Jšžœ˜/J˜š
žœ�œ�œ
�œžœ˜\Jš�œ˜—J˜J˜$J˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,Jšœžœ
˜J˜Jšžœ˜0J˜š
žœ�œ�œ
�œžœ˜]Jš�œ˜—J˜J˜%J˜Jš
œ™J˜Jšœ�œ�œ"˜JJšœ"�œ�œ
˜0Jšœ#žœ
˜5J˜Jšžœ˜4J˜š
ž!œ�œ�œ
�œ%žœ˜xJš�œ˜—J˜J˜)J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœ˜J˜Jšžœ˜)J˜š
žœ�œ�œ
�œžœ
˜RJš�œ˜—J˜J˜$J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜&J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜DJšœ�œ�œ
˜-J˜J˜Jšžœ˜+J˜šžœ�œ�œ
�œ
˜@Jš�œ˜—J˜J˜&J˜Jš
œ™J˜Jšœ�œ�œ˜0Jšœ�œ�œ
˜#Jšžœžœ˜.J˜Jšžœ˜#J˜šžœ�œ�œ
�œžœžœ˜dJš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜0Jšœ�œ�œ
˜#Jšžœ
ž
œžœžœ˜VJ˜Jšžœ˜#J˜šžœ�œ�œ
�œžœ
ž
œžœžœ
˜Œ
Jš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜2Jšœ�œ�œ
˜$J˜J˜Jšžœ˜"J˜šžœ�œ�œ
�œ
˜7Jš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜0Jšœ�œ�œ
˜#J˜J˜Jšžœ˜!J˜šžœ�œ�œ
�œ
˜6Jš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜2Jšœ�œ�œ
˜$Jšžœžœ
ž	œžœ
ž	œžœ˜|J˜Jšžœ˜%J˜šžœ�œ�œ
�œžœžœ
ž	œžœ
ž	œžœ
˜³
Jš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜&J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜&J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜J˜!J˜Jš
œ
™
J˜Jšœ�œ�œ˜4Jšœ�œ�œ
˜%Jšžœžœžœ˜ZJ˜Jšžœ˜'J˜šžœ�œ�œ
�œžœžœžœ
˜’
Jš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+J˜J˜Jšžœ˜.J˜šžœ�œ�œ
�œ
˜>Jš�œ˜—J˜J˜$J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*Jšž
œž
œ˜8J˜Jšžœ˜-J˜šžœ�œ�œ
�œž
œž
œ˜uJš�œ˜—J˜J˜#J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜,J˜šžœ�œ�œ
�œ
˜HJš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜"J˜Jšžœ˜,J˜šžœ�œ�œ
�œ#˜^Jš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜'J˜šžœ�œ�œ
�œ
˜;Jš�œ
˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšžœ˜J˜Jšžœ˜(J˜š
žœ�œ�œ
�œžœ
˜PJš�œ
˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'J˜J˜Jšžœ˜%J˜šžœ�œ�œ
�œ
˜:Jš�œ˜—J˜J˜ J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœ˜"J˜Jšžœ˜&J˜šžœ�œ�œ
�œžœžœ
˜]Jš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜'J˜šžœ�œ�œ
�œ
˜;Jš�œ
˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšžœ
žœ˜(J˜Jšžœ˜(J˜šžœ�œ�œ
�œžœ
žœ˜dJš�œ
˜—J˜J˜"Jš�œ˜J˜—…—&ì6´