Include [SaffronAG, SaffronTreeDecls, SaffronBaseDecls];

SaffronValueDependencies: Module = Begin

for Initialization.empty: AbstractProduction []
let AddValueDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
;

for Initialization.binding: AbstractProduction [InitialValue]
let AddValueDependencies[tree, dg, dgn] _ AddValueDependencies[InitialValue, dg, dgn]
;

for Initialization.assignment: AbstractProduction [InitialValue]
let AddValueDependencies[tree, dg, dgn] _ AddRuntimeDependency[dg, dgn]
;

for InitialValue.trash: AbstractProduction []
let AddValueDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
;

for InitialValue.code: AbstractProduction []
let AddValueDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
;

for InitialValue.exp: AbstractProduction [Exp]
let AddValueDependencies[tree, dg, dgn] _ AddValueDependencies[Exp, dg, dgn]
;

for InitialValue.block: AbstractProduction [Checked, Inline, Block]
let AddValueDependencies[tree, dg, dgn] _ 
if IsKeywordPresent[Inline]
then (FakeDamageDependencyGraph[dg]
where err _ Error["AddValueDependencies not yet implemented for inline block"]
)
else FakeDamageDependencyGraph[dg]
;

for InitialValue.machinecode: AbstractProduction [Checked, CodeList]
let AddValueDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
;






for Exp.sum:	AbstractProduction [ Exp.left, AddOp, Exp.right ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddValueDependencies[Exp.right, dg1, dgn]
where dg1 _ AddValueDependencies[Exp.left, dg, dgn];

for Exp.unarysum:	AbstractProduction [ AddOp, Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ AddValueDependencies[Exp, dg, dgn];

for Exp.product:	AbstractProduction [ Exp.left, MultOp, Exp.right ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddValueDependencies[Exp.right, dg1, dgn]
where dg1 _ AddValueDependencies[Exp.left, dg, dgn];

for Exp.or:	AbstractProduction [ Exp.left, Exp.right ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddValueDependencies[Exp.right, dg1, dgn]
where dg1 _ AddValueDependencies[Exp.left, dg, dgn];

for Exp.and:	AbstractProduction [ Exp.left, Exp.right ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddValueDependencies[Exp.right, dg1, dgn]
where dg1 _ AddValueDependencies[Exp.left, dg, dgn];

for Exp.not:	AbstractProduction [ Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ AddValueDependencies[Exp, dg, dgn];

for Exp.relation:	AbstractProduction [ Exp, Relation ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ AddValueDependencies[Exp, dg, dgn];

for Exp.ifthenelse:	AbstractProduction [ Exp.cond, Exp.thenpart, Exp.elsepart ]
let AddValueDependencies[tree, dg, dgn] _ dg3
where dg3 _ AddValueDependencies[Exp.elsepart, dg2, dgn]
where dg2 _ AddValueDependencies[Exp.thenpart, dg1, dgn]
where dg1 _ AddValueDependencies[Exp.cond, dg, dgn];

for Exp.select:	AbstractProduction [ SelectHead, SelectExpList, Exp.default ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.select"];

for Exp.assign:	AbstractProduction [ Exp.lhs, Exp.rhs ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ AddRuntimeDependency[dg, dgn];

for Exp.multiassign:	AbstractProduction [ ExpList, Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ AddRuntimeDependency[dg, dgn];

for Exp.id:	AbstractProduction [ Id ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ AddValueDependency[dg, dgn, Id];

for Exp.num:	AbstractProduction [ Num ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg];

for Exp.string:	AbstractProduction [ String ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg];

for Exp.flnum:	AbstractProduction [ Flnum ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg];

for Exp.char:	AbstractProduction [ Char ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg];

for Exp.atom:	AbstractProduction [ Atom ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg];

for Exp.narrow:	AbstractProduction [ Exp, OptType, Catch ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.narrow"];

for Exp.loophole:	AbstractProduction [ Exp, OptType ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.loophole"];

for Exp.apply:	AbstractProduction [ Exp.rator, Exp.rand, Catch ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.apply"];

for Exp.qualifier:	AbstractProduction [ Exp, Qualifier ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.qualifier"];

for Exp.explist:	AbstractProduction [ ExpList ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.explist"];

for Exp.prefixop:	AbstractProduction [ PrefixOp, OrderList ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.prefixop"];

for Exp.val:	AbstractProduction [ OrderList ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.val"];

for Exp.all:	AbstractProduction [ OrderList ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.all"];

for Exp.new:	AbstractProduction [ New, TypeExp, Initialization, Catch ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.new"];

for Exp.cons:	AbstractProduction [ Cons, ExpList, Catch ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.cons"];

for Exp.listcons:	AbstractProduction [ ListCons, ExpList ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.listcons"];

for Exp.nil:	AbstractProduction [  ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg];

for Exp.typeop:	AbstractProduction [ TypeOp, TypeExp ]
let AddValueDependencies[tree, dg, dgn] _ 
if TypeOpIsCode[TypeOp] then (
FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.typeop"]
)
else if TypeOpIsFirst[TypeOp] then AddFirstDependencies[TypeExp, dg, dgn]
else if TypeOpIsLast[TypeOp] then AddLastDependencies[TypeExp, dg, dgn]
else if TypeOpIsNil[TypeOp] then FakeDamageDependencyGraph[dg]
else (
FakeDamageDependencyGraph[dg]
where err _ Error["in AddValueDependencies for Exp.typeop"]
)
;

for Exp.size:	AbstractProduction [ TypeExp ]
let AddValueDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];

for Exp.size2:	AbstractProduction [ TypeExp, Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[TypeExp, dg1, dgn]
where dg1 _ AddValueDependencies[Exp, dg, dgn];

for Exp.bits:	AbstractProduction [ TypeExp ]
let AddValueDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];

for Exp.bits2:	AbstractProduction [ TypeExp, Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[TypeExp, dg1, dgn]
where dg1 _ AddValueDependencies[Exp, dg, dgn];

for Exp.bytes:	AbstractProduction [ TypeExp ]
let AddValueDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];

for Exp.bytes2:	AbstractProduction [ TypeExp, Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[TypeExp, dg1, dgn]
where dg1 _ AddValueDependencies[Exp, dg, dgn];

for Exp.units:	AbstractProduction [ TypeExp ]
let AddValueDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];

for Exp.units2:	AbstractProduction [ TypeExp, Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[TypeExp, dg1, dgn]
where dg1 _ AddValueDependencies[Exp, dg, dgn];

for Exp.words:	AbstractProduction [ TypeExp ]
let AddValueDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];

for Exp.words2:	AbstractProduction [ TypeExp, Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[TypeExp, dg1, dgn]
where dg1 _ AddValueDependencies[Exp, dg, dgn];

for Exp.istype:	AbstractProduction [ Exp, TypeExp ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.istype"];

for Exp.address:	AbstractProduction [ Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.address"];

for Exp.descriptor:	AbstractProduction [ DescList ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.descriptor"];

for Exp.error:	AbstractProduction [  ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.error"];

for Exp.transfer:	AbstractProduction [ TransferOp, Exp ]
let AddValueDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for Exp.transfer"];

End;

SaffronTypeDependencies: Module = Begin

for TypeExp.record:	AbstractProduction [ MachineDependent, Monitored, RecList ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on record types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on record types"]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[RecList, dg, dgn];

for TypeExp.union:	AbstractProduction [ Tag, VariantList ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on union types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on union types"]
let AddSizeDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[Tag, dg1, dgn]
where dg1 _ AddSizeDependencies[VariantList, dg, dgn];

for TypeExp.sequence:	AbstractProduction [ Packed, Tag, TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on sequence types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on sequence types"]
let AddSizeDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[Tag, dg1, dgn]
where dg1 _ AddSizeDependencies[TypeExp, dg, dgn];

for TypeExp.enum:	AbstractProduction [ MachineDependent, ElementList ]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[ElementList, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[ElementList, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[ElementList, dg, dgn];

for TypeExp.ref:	AbstractProduction [ ReadOnly, TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on REF types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on REF types"]
let AddSizeDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg];

for TypeExp.refany:	AbstractProduction [ ReadOnly ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on REF ANY"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on REF ANY"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.refany"];

for TypeExp.refunspecified:	AbstractProduction [ ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on REF UNSPECIFIED"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on REF UNSPECIFIED"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.refunspecified"];

for TypeExp.typeid:	AbstractProduction [ TypeId ]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[TypeId, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[TypeId, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeId, dg, dgn];

for TypeExp.subrange:	AbstractProduction [ Subrange ]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[Subrange, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[Subrange, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[Subrange, dg, dgn];

for TypeExp.pointer:	AbstractProduction [ Ordered, Base, PointerType ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on pointer types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on pointer types"]
let AddSizeDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg];

for TypeExp.var:	AbstractProduction [ TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on VAR types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on VAR types"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.var"];

for TypeExp.list:	AbstractProduction [ ReadOnly, TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on LIST types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on LIST types"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.list"];

for TypeExp.array:	AbstractProduction [ Packed, OptType, TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on ARRAY types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on ARRAY types"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.array"];

for TypeExp.descriptor:	AbstractProduction [ ReadOnly, TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on descriptor types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on descriptor types"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.descriptor"];

for TypeExp.transfer:	AbstractProduction [ Safe, TransferMode, Arguments ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on transfer types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on transfer types"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.transfer"];

for TypeExp.relative:	AbstractProduction [ TypeId, TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on relative types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on relative types"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.relative"];

for TypeExp.zone:	AbstractProduction [ Uncounted ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on zone types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on zone types"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.zone"];

for TypeExp.long:	AbstractProduction [ TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[TypeExp, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[TypeExp, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];

for TypeExp.frame:	AbstractProduction [ Id ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["FIRST is not a valid operation on frame types"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["LAST is not a valid operation on frame types"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.frame"];

for TypeExp.painted:	AbstractProduction [ TypeId, TypeExp ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.painted"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.painted"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.painted"];

for TypeExp.typeapply:	AbstractProduction [ TypeApply ]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.typeapply"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.typeapply"]
let AddSizeDependencies[tree, dg, dgn] _ dg1
where dg1 _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeExp.typeapply"];


for RecList.empty: AbstractProduction []
let AddSizeDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg];

for RecList.pairlist: AbstractProduction [PairList]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[PairList, dg, dgn];

for RecList.typelist: AbstractProduction [TypeList]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeList, dg, dgn];


for PairList.one: AbstractProduction [PairItem]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[PairItem, dg, dgn];

for PairList.many: AbstractProduction [PairList.head, PairList.tail]
let AddSizeDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[PairList.tail, dg1, dgn]
where dg1 _ AddSizeDependencies[PairList.head, dg, dgn];


for TypeList.one: AbstractProduction [TypeItem]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeItem, dg, dgn];

for TypeList.many: AbstractProduction [TypeList.head, TypeList.tail]
let AddSizeDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[TypeList.tail, dg1, dgn]
where dg1 _ AddSizeDependencies[TypeList.head, dg, dgn];


for PairItem: AbstractProduction [IdentList, Access, TypeExp, Default]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];


for TypeItem: AbstractProduction [TypeExp, Default]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];


for Tag.ident: AbstractProduction [Ident, Access, TagType]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TagType, dg, dgn];

for Tag.computed: AbstractProduction [TagType]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TagType, dg, dgn];

for Tag.overlaid: AbstractProduction [TagType]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TagType, dg, dgn];


for TagType.star: AbstractProduction []
let AddSizeDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg];

for TagType.typeexp: AbstractProduction [TypeExp]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[TypeExp, dg, dgn];


for VariantList.one: AbstractProduction [VariantItem]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[VariantItem, dg, dgn];

for VariantList.more: AbstractProduction [VariantList, VariantItem]
let AddSizeDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[VariantList, dg1, dgn]
where dg1 _ AddSizeDependencies[VariantItem, dg, dgn];

for VariantItem: AbstractProduction [IdList, RecList]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[RecList, dg, dgn];


for ElementList.empty: AbstractProduction []
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
let AddSizeDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg];

for ElementList.more: AbstractProduction [ElementList, Element]
let AddFirstDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddFirstDependencies[ElementList, dg1, dgn]
where dg1 _ AddFirstDependencies[Element, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddLastDependencies[ElementList, dg1, dgn]
where dg1 _ AddLastDependencies[Element, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddSizeDependencies[ElementList, dg1, dgn]
where dg1 _ AddSizeDependencies[Element, dg, dgn];

for Element.id: AbstractProduction [Id]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
let AddSizeDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg];

for Element.idwithrep: AbstractProduction [Id, Exp]
let AddFirstDependencies[tree, dg, dgn] _ AddValueDependencies[Exp, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddValueDependencies[Exp, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddValueDependencies[Exp, dg, dgn];

for Element.anonymousrep: AbstractProduction [Exp]
let AddFirstDependencies[tree, dg, dgn] _ AddValueDependencies[Exp, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddValueDependencies[Exp, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddValueDependencies[Exp, dg, dgn];

for TypeId.id: AbstractProduction [Id]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependency[dg, dgn, Id]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependency[dg, dgn, Id]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependency[dg, dgn, Id];

for TypeId.qualifier: AbstractProduction [TypeId, Id]
let AddFirstDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeId.qualifier"]
let AddLastDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeId.qualifier"]
let AddSizeDependencies[tree, dg, dgn] _ FakeDamageDependencyGraph[dg]
where err _ Error["Dependency analysis not implemented for TypeId.qualifier"];


for Subrange.named: AbstractProduction [TypeId, Interval]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[Interval, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[Interval, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[Interval, dg, dgn];
for Subrange.unnamed: AbstractProduction [Interval]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[Interval, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[Interval, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[Interval, dg, dgn];
for Interval.cc: AbstractProduction [Bounds]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[Bounds, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[Bounds, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[Bounds, dg, dgn];

for Interval.co: AbstractProduction [Bounds]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[Bounds, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[Bounds, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[Bounds, dg, dgn];

for Interval.oc: AbstractProduction [Bounds]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[Bounds, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[Bounds, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[Bounds, dg, dgn];

for Interval.oo: AbstractProduction [Bounds]
let AddFirstDependencies[tree, dg, dgn] _ AddFirstDependencies[Bounds, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddLastDependencies[Bounds, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ AddSizeDependencies[Bounds, dg, dgn];


for Bounds: AbstractProduction [Exp.lower, Exp.upper]
let AddFirstDependencies[tree, dg, dgn] _ AddValueDependencies[Exp.lower, dg, dgn]
let AddLastDependencies[tree, dg, dgn] _ AddValueDependencies[Exp.upper, dg, dgn]
let AddSizeDependencies[tree, dg, dgn] _ dg2
where dg2 _ AddValueDependencies[Exp.upper, dg1, dgn]
where dg1 _ AddValueDependencies[Exp.lower, dg, dgn];


End.
€SaffronDependencyGraphMethods.ThreeC4
James Rauen, July 31, 1988 7:49:40 pm PDT
Last edited by: James Rauen August 23, 1988 9:05:07 pm PDT

is this true?  or can the code list contain variables (I wouldn't think so...).  Inquiring minds want to know.
what the hell is CODE[TypeExp]???
in documentation, p'raps give an example, such as this one, and explain what it means....
the first, last, and size of an enumeration depend on these values!!!
the first, last, and size of an enumeration depend on these values!!!
Size of a subrange doesn't depend on the type, just the number of elements.

Size of a subrange doesn't depend on the type, just the number of elements.

Κ’˜™%J™)Icode™:—J™JšΠizœ1˜8J˜šΟnœœ˜(J˜šœ
žœœ˜/JšœD˜GJ˜
J˜—šœ
žœœ˜=JšœR˜UJ˜
J˜—šœ
žœœ˜@JšœD˜GJ˜
J˜—šœ
žœœ˜-JšœD˜GJ˜
J˜—šœ
žœœ˜,JšœD˜GJ˜
J˜—šœ
žœœ˜.JšœI˜LJ˜
J˜—šœ
žœœ˜Cšœ'˜*šœ˜šœ˜#JšœI˜NJ˜
—Jšœ˜"——J˜
J˜—šœ
žœœ˜DJšœD˜GJ™nJ˜
J˜J˜—˜J˜—J˜J˜
codetabšœ
žœœ˜>šœ*˜-Lšœ0˜5Lšœ/˜4L˜——šœ
žœœ˜3šœ*˜-Lšœ*˜/L˜——šœ
žœœ ˜Cšœ*˜-Lšœ0˜5Lšœ/˜4L˜——šœ
žœœ˜6šœ*˜-Lšœ0˜5Lšœ/˜4L˜——šœ
žœœ˜7šœ*˜-Lšœ0˜5Lšœ/˜4L˜——šœ
žœœ˜'šœ*˜-Lšœ*˜/L˜——šœ
žœœ˜6šœ*˜-Lšœ*˜/L˜——šœ
žœœ)˜Ošœ*˜-Lšœ3˜8Lšœ3˜8Lšœ/˜4L˜——šœ
ž
œœ+˜Mšœ*˜-Lšœ$˜)LšœC˜HL˜——šœ
ž
œœ˜7šœ*˜-Lšœ%˜*L˜——šœ
žœœ˜8šœ*˜-Lšœ%˜*L˜——šœ
žœœ˜%šœ*˜-Lšœ'˜,L˜——šœ
žœœ˜'šœ*˜-Lšœ%˜*L˜——šœ
ž
œœ˜-šœ*˜-Lšœ%˜*L˜——šœ
ž	œœ
˜+šœ*˜-Lšœ%˜*L˜——šœ
žœœ	˜)šœ*˜-Lšœ%˜*L˜——šœ
žœœ	˜)šœ*˜-Lšœ%˜*L˜——šœ
ž
œœ˜:šœ*˜-Lšœ$˜)LšœC˜HL˜——šœ
žœœ˜5šœ*˜-Lšœ$˜)LšœE˜JL˜——šœ
ž	œœ˜@šœ*˜-Lšœ$˜)LšœB˜GL˜——šœ
ž
œœ˜8šœ*˜-Lšœ$˜)LšœF˜KL˜——šœ
žœœ˜/šœ*˜-Lšœ$˜)LšœD˜IL˜——šœ
žœœ˜<šœ*˜-Lšœ$˜)LšœE˜JL˜——šœ
žœœ˜-šœ*˜-Lšœ$˜)Lšœ@˜EL˜——šœ
žœœ˜-šœ*˜-Lšœ$˜)Lšœ@˜EL˜——šœ
žœœ(˜Gšœ*˜-Lšœ$˜)Lšœ@˜EL˜——šœ
žœœ˜9šœ*˜-Lšœ$˜)LšœA˜FL˜——šœ
žœœ˜:šœ*˜-Lšœ$˜)LšœE˜JL˜——šœ
žœœ˜$šœ*˜-Lšœ%˜*L˜——šœ
ž
œœ˜6šœ'˜*šœœ˜Lš
œ˜LšœB˜GLš
œ
˜
—L™!Lšœ
œœ'˜ILšœ
œœ&˜GLšœ
œœ˜>šœ˜Lš
œ˜Lšœ6˜;Lš
œ
˜
——˜
L˜——šœ
žœœ˜,šœM˜PL˜——šœ
ž	œœ˜2šœ*˜-Lš
œ2˜2Lš
œ/˜/—L˜—šœ
žœœ˜,LšœM˜PL˜—šœ
ž	œœ˜2šœ*˜-Lš
œ2˜2Lš
œ/˜/—L˜—šœ
ž	œœ˜-LšœM˜PL˜—šœ
ž
œœ˜3šœ*˜-Lš
œ2˜2Lš
œ/˜/—L˜—šœ
ž	œœ˜-LšœM˜PL˜—šœ
ž
œœ˜3šœ*˜-Lš
œ2˜2Lš
œ/˜/—L˜—šœ
ž	œœ˜-LšœM˜PL˜—šœ
ž
œœ˜3šœ*˜-Lš
œ2˜2Lš
œ/˜/—L˜—šœ
ž
œœ˜3šœ*˜-Lšœ$˜)LšœC˜HL˜——šœ
žœœ˜+šœ*˜-Lšœ$˜)LšœD˜IL˜——šœ
žœœ
˜3šœ*˜-Lšœ$˜)LšœG˜LL˜——šœ
ž	œœ˜&šœ*˜-Lšœ$˜)LšœB˜GL˜——šœ
žœœ˜8šœ*˜-Lšœ$˜)LšœE˜JL˜——Lšœ
˜L˜—šžœœ˜'L˜šœ
žœœ)˜O˜GL˜C—˜FL˜B—šœL˜OL˜——šœ
ž
œœ˜:˜GL˜B—˜FL˜A—šœ)˜,Lšœ)˜.Lšœ1˜6L˜——L™Yšœ
žœœ˜A˜GLšœ5žœ˜E—˜FLšœ4žœ˜D—šœ)˜,Lšœ)˜.Lšœ-˜2L˜——šœ
žœœ"˜FLš
œT˜TLš
œR˜RšœP˜SL˜——šœ
žœœ˜9˜GLš
œ@˜@—˜FLš
œ?˜?—šœD˜GL˜——šœ
žœœ
˜3˜GLš
œ>˜>—˜FLš
œ=˜=—šœ)˜,Lšœ$˜)LšœG˜LL˜——šœ
žœœ˜2˜GLš
œF˜F—˜FLš
œE˜E—šœ)˜,Lšœ$˜)LšœO˜TL˜——šœ
žœœ˜1L˜OL˜MLšœK˜NL˜—šœ
žœœ
˜5Lš
œQ˜QLš
œO˜OLš
œP˜PL˜—šœ
žœœ˜F˜GLš
œD˜D—˜FLš
œC˜C—šœD˜GL˜——šœ
žœœ˜/˜GLš
œ@˜@—˜FLš
œ?˜?—šœ)˜,Lšœ$˜)LšœD˜IL˜——šœ
žœœ˜:˜GLš
œA˜A—˜FLš
œ@˜@—šœ)˜,Lšœ$˜)LšœE˜JL˜——šœ
ž
œœ˜B˜GLš
œB˜B—˜FLš
œA˜A—šœ)˜,Lšœ$˜)LšœF˜KL˜——šœ
žœœ˜@˜GLš
œG˜G—˜FLš
œF˜F—šœ)˜,Lšœ$˜)LšœK˜PL˜——šœ
žœœ"˜J˜GLš
œE˜E—˜FLš
œD˜D—šœ)˜,Lšœ$˜)LšœI˜NL˜——šœ
žœœ˜<˜GLš
œE˜E—˜FLš
œD˜D—šœ)˜,Lšœ$˜)LšœI˜NL˜——šœ
žœœ˜2˜GLš
œA˜A—˜FLš
œ@˜@—šœ)˜,Lšœ$˜)LšœE˜JL˜——šœ
žœœ˜0L˜PL˜NšœL˜OL˜——šœ
ž
œœ˜,˜GLš
œB˜B—˜FLš
œA˜A—šœ)˜,Lšœ$˜)LšœF˜KL˜——šœ
žœœ˜;˜GLš
œL˜L—˜FLš
œL˜L—šœ)˜,Lšœ$˜)LšœH˜ML˜——šœ
žœœ˜7˜GLš
œN˜N—˜FLš
œN˜N—šœ)˜,Lšœ$˜)LšœJ˜OL˜——L˜šœ
ž
œœ˜(LšœD˜GL˜—šœ
žœœ˜3LšœM˜PL˜—šœ
žΠbnœœ˜3LšœM˜PL˜—L˜šœ
žœœ˜/LšœM˜PL˜—šœ
ž	Ÿœœ˜Dšœ)˜,Lšœ3˜8Lšœ3˜8——L˜L˜šœ
žœœ˜/LšœM˜PL˜—šœ
ž	Ÿœœ˜Dšœ)˜,Lšœ3˜8Lšœ3˜8L˜—L˜—šœ
žœœ&˜FLšœL˜OL˜L˜—šœ
žœœ˜3LšœL˜OL˜L˜—šœ
ž	œœ˜:LšœL˜OL˜—šœ
žŸœœ
˜.LšœL˜OL˜—šœ
žŸœœ
˜.LšœL˜OL˜—L˜šœ
žœœ˜'LšœD˜GL˜—šœ
Ÿœœ
˜1LšœL˜OL˜—L˜šœ
Ÿœœ˜5LšœP˜SL˜—šœ
Ÿœœ˜Cšœ)˜,Lšœ1˜6Lšœ1˜6L˜——šœ
žœœ˜5LšœL˜OL˜L˜—šœ
žœœ˜,LšœD˜GLšœC˜FLšœD˜GL˜—šœ
žŸœœ˜?šœ*˜-Lšœ2˜7Lšœ-˜2—šœ)˜,Lšœ1˜6Lšœ,˜1—šœ)˜,Lšœ1˜6Lšœ-˜2—L˜—šœ
Ÿ
œœ˜'LšœD˜GLšœC˜FLšœD˜GL˜—šœ
Ÿœœ
˜3LšœI˜LLšœH˜KLšœI˜LL™EL˜—šœ
Ÿœœ˜2LšœI˜LLšœH˜KLšœI˜LL™EL˜—šœ
ž	œœ˜&LšœF˜ILšœD˜GLšœE˜HL˜—šœ
žŸ	œœ
˜5šœD˜GLšœ=Οb	œ˜M—šœC˜FLšœ= 	œ˜M—šœC˜FLšœ= 	œ˜N——L˜L˜šœ
žœœ˜9LšœN˜QLšœL˜OLšœM˜PL™KL™—šœ
žœœ˜3LšœN˜QLšœL˜OLšœM˜PL™KL™—šœ
žœœ	˜,LšœL˜OLšœJ˜MLšœK˜NL˜—šœ
žœœ	˜,LšœL˜OLšœJ˜MLšœK˜NL˜—šœ
žœœ	˜,LšœL˜OLšœJ˜MLšœK˜NL˜—šœ
žœœ	˜,LšœL˜OLšœJ˜MLšœK˜NL˜—L˜šœ
žœœ˜5LšœO˜RLšœN˜Qšœ)˜,Lšœ0˜5Lšœ0˜5—L˜—L˜Lšœ
˜——…—g²~ψ