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.