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