SaffronNoops.ThreeC4
Copyright Ó 1987 by Xerox Corporation. All rights reserved.
Shoup, August 8, 1986 5:32:07 pm PDT
Bill Jackson (bj) April 28, 1987 0:26:13 am PDT
Sturgis, July 20, 1987 7:05:44 pm PDT
Lucy Hederman July 21, 1987 5:05:01 pm PDT
Include [SaffronAG, SaffronBaseDecls];
NoopMethods1: Module = Begin
Junk: AbstractType [ foo ];
for Junk: AbstractProduction [ ]
let foo[tree] ←
0
;
Exp: AbstractType [ foo ];
for Exp.sum: AbstractProduction [ Exp.left, AddOp, Exp.right ]
let foo[tree] ←
0
;
for Exp.unarysum: AbstractProduction [ AddOp, Exp ]
let foo[tree] ←
0
;
for Exp.product: AbstractProduction [ Exp.left, MultOp, Exp.right ]
let foo[tree] ←
0
;
for Exp.or: AbstractProduction [ Exp.left, Exp.right ]
let foo[tree] ←
0
;
for Exp.and: AbstractProduction [ Exp.left, Exp.right ]
let foo[tree] ←
0
;
for Exp.not: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for Exp.relation: AbstractProduction [ Exp, Relation ]
let foo[tree] ←
0
;
for Exp.ifthenelse: AbstractProduction [ Exp.cond, Exp.thenpart, Exp.elsepart ]
let foo[tree] ←
0
;
for Exp.select: AbstractProduction [ SelectHead, SelectExpList, Exp.default ]
let foo[tree] ←
0
;
for Exp.assign: AbstractProduction [ Exp.lhs, Exp.rhs ]
let foo[tree] ←
0
;
for Exp.multiassign: AbstractProduction [ ExpList, Exp ]
let foo[tree] ←
0
;
for Exp.id: AbstractProduction [ Id ]
let foo[tree] ←
0
;
for Exp.num: AbstractProduction [ Num ]
let foo[tree] ←
0
;
for Exp.string: AbstractProduction [ String ]
let foo[tree] ←
0
;
for Exp.flnum: AbstractProduction [ Flnum ]
let foo[tree] ←
0
;
for Exp.char: AbstractProduction [ Char ]
let foo[tree] ←
0
;
for Exp.atom: AbstractProduction [ Atom ]
let foo[tree] ←
0
;
for Exp.narrow: AbstractProduction [ Exp, OptType, Catch ]
let foo[tree] ←
0
;
for Exp.loophole: AbstractProduction [ Exp, OptType ]
let foo[tree] ←
0
;
for Exp.apply: AbstractProduction [ Exp.rator, Exp.rand, Catch ]
let foo[tree] ←
0
;
for Exp.qualifier: AbstractProduction [ Exp, Qualifier ]
let foo[tree] ←
0
;
for Exp.explist: AbstractProduction [ ExpList ]
let foo[tree] ←
0
;
for Exp.prefixop: AbstractProduction [ PrefixOp, OrderList ]
let foo[tree] ←
0
;
for Exp.val: AbstractProduction [ OrderList ]
let foo[tree] ←
0
;
for Exp.all: AbstractProduction [ OrderList ]
let foo[tree] ←
0
;
for Exp.new: AbstractProduction [ New, TypeExp, Initialization, Catch ]
let foo[tree] ←
0
;
for Exp.cons: AbstractProduction [ Cons, ExpList, Catch ]
let foo[tree] ←
0
;
for Exp.listcons: AbstractProduction [ ListCons, ExpList ]
let foo[tree] ←
0
;
for Exp.nil: AbstractProduction [ ]
let foo[tree] ←
0
;
for Exp.typeop: AbstractProduction [ TypeOp, TypeExp ]
let foo[tree] ←
0
;
for Exp.size: AbstractProduction [ TypeExp ]
let foo[tree] ←
0
;
for Exp.size2: AbstractProduction [ TypeExp, Exp ]
let foo[tree] ←
0
;
for Exp.istype: AbstractProduction [ Exp, TypeExp ]
let foo[tree] ←
0
;
for Exp.address: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for Exp.descriptor: AbstractProduction [ DescList ]
let foo[tree] ←
0
;
for Exp.error: AbstractProduction [ ]
let foo[tree] ←
0
;
for Exp.transfer: AbstractProduction [ TransferOp, Exp ]
let foo[tree] ←
0
;
Num: AbstractType [ foo ];
for Num.decimal: AbstractProduction [ Decimalnum ]
let foo[tree] ←
0
;
for Num.octal: AbstractProduction [ Octalnum ]
let foo[tree] ←
0
;
for Num.hex: AbstractProduction [ Hexnum ]
let foo[tree] ←
0
;
AddOp: AbstractType [ foo ];
for AddOp.plus: AbstractProduction [ ]
let foo[tree] ←
0
;
for AddOp.minus: AbstractProduction [ ]
let foo[tree] ←
0
;
MultOp: AbstractType [ foo ];
for MultOp.times: AbstractProduction [ ]
let foo[tree] ←
0
;
for MultOp.divide: AbstractProduction [ ]
let foo[tree] ←
0
;
for MultOp.mod: AbstractProduction [ ]
let foo[tree] ←
0
;
SelectHead: AbstractType [ foo ];
for SelectHead.plain: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for SelectHead.discriminating: AbstractProduction [ BindItem, OptExp ]
let foo[tree] ←
0
;
SelectExpList: AbstractType [ foo ];
for SelectExpList.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for SelectExpList.more: AbstractProduction [ SelectExpList, SelectExpItem ]
let foo[tree] ←
0
;
SelectExpItem: AbstractType [ foo ];
for SelectExpItem: AbstractProduction [ SelectLabel, Exp ]
let foo[tree] ←
0
;
SelectLabel: AbstractType [ foo ];
for SelectLabel.type: AbstractProduction [ Ident, TypeExp ]
let foo[tree] ←
0
;
for SelectLabel.test: AbstractProduction [ SelectTestList ]
let foo[tree] ←
0
;
SelectTestList: AbstractType [ foo ];
for SelectTestList.one: AbstractProduction [ Relation ]
let foo[tree] ←
0
;
for SelectTestList.more: AbstractProduction [ SelectTestList, Relation ]
let foo[tree] ←
0
;
End;
NoopMethods2: Module = Begin
Relation: AbstractType [ foo ];
for Relation.negative: AbstractProduction [ RelationTail ]
let foo[tree] ←
0
;
for Relation.positive: AbstractProduction [ RelationTail ]
let foo[tree] ←
0
;
RelationTail: AbstractType [ foo ];
for RelationTail.range: AbstractProduction [ Range ]
let foo[tree] ←
0
;
for RelationTail.relop: AbstractProduction [ Relop, Exp ]
let foo[tree] ←
0
;
Relop: AbstractType [ foo ];
for Relop.eq: AbstractProduction [ ]
let foo[tree] ←
0
;
for Relop.ne: AbstractProduction [ ]
let foo[tree] ←
0
;
for Relop.lt: AbstractProduction [ ]
let foo[tree] ←
0
;
for Relop.le: AbstractProduction [ ]
let foo[tree] ←
0
;
for Relop.gt: AbstractProduction [ ]
let foo[tree] ←
0
;
for Relop.ge: AbstractProduction [ ]
let foo[tree] ←
0
;
Range: AbstractType [ foo ];
for Range.typeid: AbstractProduction [ TypeId ]
let foo[tree] ←
0
;
for Range.subrange: AbstractProduction [ Subrange ]
let foo[tree] ←
0
;
Catch: AbstractType [ foo ];
for Catch: AbstractProduction [ CatchCaseList, CatchAny ]
let foo[tree] ←
0
;
CatchAny: AbstractType [ foo ];
for CatchAny.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for CatchAny.present: AbstractProduction [ Statement ]
let foo[tree] ←
0
;
CatchCaseList: AbstractType [ foo ];
for CatchCaseList.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for CatchCaseList.more: AbstractProduction [ CatchCaseList, CatchCase ]
let foo[tree] ←
0
;
CatchCase: AbstractType [ foo ];
for CatchCase: AbstractProduction [ SignalList, Statement ]
let foo[tree] ←
0
;
SignalList: AbstractType [ foo ];
for SignalList.one: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for SignalList.more: AbstractProduction [ SignalList, Exp ]
let foo[tree] ←
0
;
ExpList: AbstractType [ foo ];
for ExpList.keylist: AbstractProduction [ KeyList ]
let foo[tree] ←
0
;
for ExpList.orderlist: AbstractProduction [ OrderList ]
let foo[tree] ←
0
;
KeyList: AbstractType [ foo ];
for KeyList.one: AbstractProduction [ KeyItem ]
let foo[tree] ←
0
;
for KeyList.more: AbstractProduction [ KeyList, KeyItem ]
let foo[tree] ←
0
;
KeyItem: AbstractType [ foo ];
for KeyItem: AbstractProduction [ Id, OptExp ]
let foo[tree] ←
0
;
OrderList: AbstractType [ foo ];
for OrderList.one: AbstractProduction [ OptExp ]
let foo[tree] ←
0
;
for OrderList.more: AbstractProduction [ OrderList, OptExp ]
let foo[tree] ←
0
;
OptExp: AbstractType [ foo ];
for OptExp.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for OptExp.trash: AbstractProduction [ ]
let foo[tree] ←
0
;
for OptExp.exp: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
OptType: AbstractType [ foo ];
for OptType.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for OptType.present: AbstractProduction [ TypeExp ]
let foo[tree] ←
0
;
Qualifier: AbstractType [ foo ];
for Qualifier.prefixop: AbstractProduction [ PrefixOp ]
let foo[tree] ←
0
;
for Qualifier.typeop: AbstractProduction [ TypeOp ]
let foo[tree] ←
0
;
for Qualifier.size: AbstractProduction [ ]
let foo[tree] ←
0
;
for Qualifier.apply: AbstractProduction [ ExpList, Catch ]
let foo[tree] ←
0
;
for Qualifier.select: AbstractProduction [ Id ]
let foo[tree] ←
0
;
for Qualifier.indirect: AbstractProduction [ ]
let foo[tree] ←
0
;
PrefixOp: AbstractType [ foo ];
for PrefixOp.long : AbstractProduction [ ]
let foo[tree] ←
0
;
for PrefixOp.abs : AbstractProduction [ ]
let foo[tree] ←
0
;
for PrefixOp.pred : AbstractProduction [ ]
let foo[tree] ←
0
;
for PrefixOp.succ : AbstractProduction [ ]
let foo[tree] ←
0
;
for PrefixOp.ord : AbstractProduction [ ]
let foo[tree] ←
0
;
for PrefixOp.min : AbstractProduction [ ]
let foo[tree] ←
0
;
for PrefixOp.max : AbstractProduction [ ]
let foo[tree] ←
0
;
for PrefixOp.base : AbstractProduction [ ]
let foo[tree] ←
0
;
for PrefixOp.length : AbstractProduction [ ]
let foo[tree] ←
0
;
TypeOp: AbstractType [ foo ];
for TypeOp.code: AbstractProduction [ ]
let foo[tree] ←
0
;
for TypeOp.first: AbstractProduction [ ]
let foo[tree] ←
0
;
for TypeOp.last: AbstractProduction [ ]
let foo[tree] ←
0
;
for TypeOp.nil: AbstractProduction [ ]
let foo[tree] ←
0
;
End;
NoopMethods3: Module = Begin
New: AbstractType [ foo ];
for New.plain: AbstractProduction [ ]
let foo[tree] ←
0
;
for New.zoned: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
Cons: AbstractType [ foo ];
for Cons.plain: AbstractProduction [ ]
let foo[tree] ←
0
;
for Cons.zoned: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
ListCons: AbstractType [ foo ];
for ListCons.plain: AbstractProduction [ ]
let foo[tree] ←
0
;
for ListCons.zoned: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
DescList: AbstractType [ foo ];
for DescList.explicitlength: AbstractProduction [ Exp.base, Exp.length, OptType ]
let foo[tree] ←
0
;
for DescList.defaultlength: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
Initialization: AbstractType [ foo ];
for Initialization.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for Initialization.binding: AbstractProduction [ InitialValue ]
let foo[tree] ←
0
;
for Initialization.assignment: AbstractProduction [ InitialValue ]
let foo[tree] ←
0
;
InitialValue: AbstractType [ foo ];
for InitialValue.trash: AbstractProduction [ ]
let foo[tree] ←
0
;
for InitialValue.code: AbstractProduction [ ]
let foo[tree] ←
0
;
for InitialValue.exp: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for InitialValue.block: AbstractProduction [ Checked, Inline, Block ]
let foo[tree] ←
0
;
for InitialValue.machinecode: AbstractProduction [ Checked, CodeList ]
let foo[tree] ←
0
;
Checked: AbstractType [ foo ];
for Checked.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for Checked.checked: AbstractProduction [ ]
let foo[tree] ←
0
;
for Checked.trusted: AbstractProduction [ ]
let foo[tree] ←
0
;
for Checked.unchecked: AbstractProduction [ ]
let foo[tree] ←
0
;
Inline: AbstractType [ foo ];
for Inline.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Inline.no: AbstractProduction [ ]
let foo[tree] ←
0
;
CodeList: AbstractType [ foo ];
for CodeList.one: AbstractProduction [ OrderList ]
let foo[tree] ←
0
;
for CodeList.more: AbstractProduction [ CodeList, OrderList ]
let foo[tree] ←
0
;
TransferOp: AbstractType [ foo ];
for TransferOp.signal: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferOp.error: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferOp.start: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferOp.join: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferOp.new: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferOp.fork: AbstractProduction [ ]
let foo[tree] ←
0
;
End;
NoopMethods4: Module = Begin
Statement: AbstractType [ foo ];
for Statement.ifthen: AbstractProduction [ Exp, Statement ]
let foo[tree] ←
0
;
for Statement.ifthenelse: AbstractProduction [ Exp, Statement.thenpart, Statement.elsepart ]
let foo[tree] ←
0
;
for Statement.select: AbstractProduction [ SelectHead, SelectStmtList, OptStatement ]
let foo[tree] ←
0
;
for Statement.exp: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for Statement.assign: AbstractProduction [ Exp.lhs, Exp.rhs ]
let foo[tree] ←
0
;
for Statement.multiassign: AbstractProduction [ ExpList, Exp ]
let foo[tree] ←
0
;
for Statement.block: AbstractProduction [ Checked, Block ]
let foo[tree] ←
0
;
for Statement.loopcontrol: AbstractProduction [ ForClause, DoTest, Scope, DoExit ]
let foo[tree] ←
0
;
for Statement.exit: AbstractProduction [ ]
let foo[tree] ←
0
;
for Statement.loop: AbstractProduction [ ]
let foo[tree] ←
0
;
for Statement.goto: AbstractProduction [ Id ]
let foo[tree] ←
0
;
for Statement.return: AbstractProduction [ OptArgs ]
let foo[tree] ←
0
;
for Statement.transfer: AbstractProduction [ Transfer, Exp ]
let foo[tree] ←
0
;
for Statement.free: AbstractProduction [ Free, Exp, Catch ]
let foo[tree] ←
0
;
for Statement.wait: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for Statement.error: AbstractProduction [ ]
let foo[tree] ←
0
;
for Statement.stop: AbstractProduction [ ]
let foo[tree] ←
0
;
for Statement.null: AbstractProduction [ ]
let foo[tree] ←
0
;
for Statement.resume: AbstractProduction [ OptArgs ]
let foo[tree] ←
0
;
for Statement.reject: AbstractProduction [ ]
let foo[tree] ←
0
;
for Statement.continue: AbstractProduction [ ]
let foo[tree] ←
0
;
for Statement.retry: AbstractProduction [ ]
let foo[tree] ←
0
;
for Statement.getstate: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for Statement.setstate: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
OptStatement: AbstractType [ foo ];
for OptStatement.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for OptStatement.present: AbstractProduction [ Statement ]
let foo[tree] ←
0
;
SelectStmtList: AbstractType [ foo ];
for SelectStmtList.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for SelectStmtList.more: AbstractProduction [ SelectStmtList, SelectStmtItem ]
let foo[tree] ←
0
;
SelectStmtItem: AbstractType [ foo ];
for SelectStmtItem: AbstractProduction [ SelectLabel, Statement ]
let foo[tree] ←
0
;
Block: AbstractType [ foo ];
for Block: AbstractProduction [ Scope, ExitList ]
let foo[tree] ←
0
;
Scope: AbstractType [ foo ];
for Scope: AbstractProduction [ BindList, Catch, OptDecList, StatementList ]
let foo[tree] ←
0
;
End;
NoopMethods5: Module = Begin
OptDecList: AbstractType [ foo ];
for OptDecList.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for OptDecList.present: AbstractProduction [ DecList ]
let foo[tree] ←
0
;
StatementList: AbstractType [ foo ];
for StatementList.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for StatementList.more: AbstractProduction [ StatementList, Statement ]
let foo[tree] ←
0
;
DecList: AbstractType [ foo ];
for DecList.one: AbstractProduction [ Declaration ]
let foo[tree] ←
0
;
for DecList.many: AbstractProduction [ DecList.head, DecList.tail ]
let foo[tree] ←
0
;
Declaration: AbstractType [ foo ];
for Declaration.value: AbstractProduction [ IdentList, Access, Entry, ReadOnly, TypeExp, Initialization ]
let foo[tree] ←
0
;
for Declaration.type: AbstractProduction [ IdentList, Access.id, Access.type, TypeExp, Default ]
let foo[tree] ←
0
;
for Declaration.opaquetype: AbstractProduction [ IdentList, Access, OptSize ]
let foo[tree] ←
0
;
OptSize: AbstractType [ foo ];
for OptSize.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for OptSize.present: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
Entry: AbstractType [ foo ];
for Entry.entry: AbstractProduction [ ]
let foo[tree] ←
0
;
for Entry.internal: AbstractProduction [ ]
let foo[tree] ←
0
;
for Entry.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
ExitList: AbstractType [ foo ];
for ExitList.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for ExitList.more: AbstractProduction [ ExitList, ExitItem ]
let foo[tree] ←
0
;
ExitItem: AbstractType [ foo ];
for ExitItem: AbstractProduction [ IdList, Statement ]
let foo[tree] ←
0
;
BindList: AbstractType [ foo ];
for BindList.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for BindList.more: AbstractProduction [ BindList, BindItem ]
let foo[tree] ←
0
;
BindItem: AbstractType [ foo ];
for BindItem.named: AbstractProduction [ Id, Exp ]
let foo[tree] ←
0
;
for BindItem.unnamed: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
ForClause: AbstractType [ foo ];
for ForClause.assignation: AbstractProduction [ ControlId, Exp.initial, Exp.next ]
let foo[tree] ←
0
;
for ForClause.iteration: AbstractProduction [ ControlId, Decreasing, Range ]
let foo[tree] ←
0
;
for ForClause.repetition: AbstractProduction [ Range ]
let foo[tree] ←
0
;
for ForClause.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
ControlId: AbstractType [ foo ];
for ControlId.new: AbstractProduction [ Ident, TypeExp ]
let foo[tree] ←
0
;
for ControlId.old: AbstractProduction [ Id ]
let foo[tree] ←
0
;
Decreasing: AbstractType [ foo ];
for Decreasing.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Decreasing.no: AbstractProduction [ ]
let foo[tree] ←
0
;
DoTest: AbstractType [ foo ];
for DoTest.until: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for DoTest.while: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for DoTest.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
DoExit: AbstractType [ foo ];
for DoExit: AbstractProduction [ ExitList, OptStatement ]
let foo[tree] ←
0
;
OptArgs: AbstractType [ foo ];
for OptArgs.explist: AbstractProduction [ ExpList ]
let foo[tree] ←
0
;
for OptArgs.exp: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for OptArgs.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
Transfer: AbstractType [ foo ];
for Transfer.signal: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.error: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.returnwitherror: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.start: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.restart: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.join: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.notify: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.broadcast: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.transferwith: AbstractProduction [ ]
let foo[tree] ←
0
;
for Transfer.returnwith: AbstractProduction [ ]
let foo[tree] ←
0
;
Free: AbstractType [ foo ];
for Free.plain: AbstractProduction [ ]
let foo[tree] ←
0
;
for Free.zoned: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
End;
NoopMethods6: Module = Begin
TypeId: AbstractType [ foo ];
for TypeId.id: AbstractProduction [ Id ]
let foo[tree] ←
0
;
for TypeId.qualifier: AbstractProduction [ TypeId, Id ]
let foo[tree] ←
0
;
Subrange: AbstractType [ foo ];
for Subrange.named: AbstractProduction [ TypeId, Interval ]
let foo[tree] ←
0
;
for Subrange.unnamed: AbstractProduction [ Interval ]
let foo[tree] ←
0
;
Interval: AbstractType [ foo ];
for Interval.cc: AbstractProduction [ Bounds ]
let foo[tree] ←
0
;
for Interval.co: AbstractProduction [ Bounds ]
let foo[tree] ←
0
;
for Interval.oc: AbstractProduction [ Bounds ]
let foo[tree] ←
0
;
for Interval.oo: AbstractProduction [ Bounds ]
let foo[tree] ←
0
;
Bounds: AbstractType [ foo ];
for Bounds: AbstractProduction [ Bound.lower, Bound.upper ]
let foo[tree] ←
0
;
Bound: AbstractType [ foo ];
for Bound: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
MachineDependent: AbstractType [ foo ];
for MachineDependent.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for MachineDependent.no: AbstractProduction [ ]
let foo[tree] ←
0
;
Monitored: AbstractType [ foo ];
for Monitored.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Monitored.no: AbstractProduction [ ]
let foo[tree] ←
0
;
End;
NoopMethods7: Module = Begin
Access: AbstractType [ foo ];
for Access.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for Access.public: AbstractProduction [ ]
let foo[tree] ←
0
;
for Access.private: AbstractProduction [ ]
let foo[tree] ←
0
;
Default: AbstractType [ foo ];
for Default.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for Default.gets: AbstractProduction [ ]
let foo[tree] ←
0
;
for Default.getsexp: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
for Default.getstrash: AbstractProduction [ ]
let foo[tree] ←
0
;
for Default.getsexportrash: AbstractProduction [ Exp ]
let foo[tree] ←
0
;
Position: AbstractType [ foo ];
for Position: AbstractProduction [ Exp, OptBits ]
let foo[tree] ←
0
;
OptBits: AbstractType [ foo ];
for OptBits.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for OptBits.present: AbstractProduction [ Bounds ]
let foo[tree] ←
0
;
Tag: AbstractType [ foo ];
for Tag.ident: AbstractProduction [ Ident, Access, TagType ]
let foo[tree] ←
0
;
for Tag.computed: AbstractProduction [ TagType ]
let foo[tree] ←
0
;
for Tag.overlaid: AbstractProduction [ TagType ]
let foo[tree] ←
0
;
TagType: AbstractType [ foo ];
for TagType.star: AbstractProduction [ ]
let foo[tree] ←
0
;
for TagType.typeexp: AbstractProduction [ TypeExp ]
let foo[tree] ←
0
;
VariantList: AbstractType [ foo ];
for VariantList.one: AbstractProduction [ VariantItem ]
let foo[tree] ←
0
;
for VariantList.more: AbstractProduction [ VariantList, VariantItem ]
let foo[tree] ←
0
;
VariantItem: AbstractType [ foo ];
for VariantItem: AbstractProduction [ IdList, RecList ]
let foo[tree] ←
0
;
Packed: AbstractType [ foo ];
for Packed.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Packed.no: AbstractProduction [ ]
let foo[tree] ←
0
;
End;
NoopMethods8: Module = Begin
IdList: AbstractType [ foo ];
for IdList.one: AbstractProduction [ Id ]
let foo[tree] ←
0
;
for IdList.more: AbstractProduction [ Id, IdList ]
let foo[tree] ←
0
;
Ordered: AbstractType [ foo ];
for Ordered.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Ordered.no: AbstractProduction [ ]
let foo[tree] ←
0
;
Base: AbstractType [ foo ];
for Base.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Base.no: AbstractProduction [ ]
let foo[tree] ←
0
;
PointerType: AbstractType [ foo ];
for PointerType.unspecified: AbstractProduction [ OptInterval ]
let foo[tree] ←
0
;
for PointerType.specified: AbstractProduction [ OptInterval, ReadOnly, TypeExp ]
let foo[tree] ←
0
;
OptInterval: AbstractType [ foo ];
for OptInterval.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for OptInterval.present: AbstractProduction [ Interval ]
let foo[tree] ←
0
;
ReadOnly: AbstractType [ foo ];
for ReadOnly.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for ReadOnly.no: AbstractProduction [ ]
let foo[tree] ←
0
;
Safe: AbstractType [ foo ];
for Safe.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for Safe.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Safe.no: AbstractProduction [ ]
let foo[tree] ←
0
;
TransferMode: AbstractType [ foo ];
for TransferMode.proc: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferMode.port: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferMode.signal: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferMode.error: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferMode.process: AbstractProduction [ ]
let foo[tree] ←
0
;
for TransferMode.program: AbstractProduction [ ]
let foo[tree] ←
0
;
Arguments: AbstractType [ foo ];
for Arguments: AbstractProduction [ ParameterList.input, ParameterList.output ]
let foo[tree] ←
0
;
ParameterList: AbstractType [ foo ];
for ParameterList.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for ParameterList.any: AbstractProduction [ ]
let foo[tree] ←
0
;
for ParameterList.pairlist: AbstractProduction [ PairList ]
let foo[tree] ←
0
;
for ParameterList.typelist: AbstractProduction [ TypeList ]
let foo[tree] ←
0
;
Uncounted: AbstractType [ foo ];
for Uncounted.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Uncounted.no: AbstractProduction [ ]
let foo[tree] ←
0
;
TypeApply: AbstractType [ foo ];
for TypeApply.one: AbstractProduction [ TypeId, Exp ]
let foo[tree] ←
0
;
for TypeApply.morelengths: AbstractProduction [ TypeApply, Exp ]
let foo[tree] ←
0
;
for TypeApply.moreids: AbstractProduction [ TypeApply, Id ]
let foo[tree] ←
0
;
End;
NoopMethods9: Module = Begin
ModuleP: AbstractType [ foo ];
for ModuleP.impl: AbstractProduction [ Directory, IdentList, Cedar, ProgHead, Checked, Block ]
let foo[tree] ←
0
;
for ModuleP.def: AbstractProduction [ Directory, IdentList, Cedar, DefHead, DefBody ]
let foo[tree] ←
0
;
Directory: AbstractType [ foo ];
for Directory.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for Directory.more: AbstractProduction [ Directory, IncludeItem ]
let foo[tree] ←
0
;
IncludeItem: AbstractType [ foo ];
for IncludeItem.fromp: AbstractProduction [ Id, String, Using ]
let foo[tree] ←
0
;
for IncludeItem.type: AbstractProduction [ Id, Using ]
let foo[tree] ←
0
;
for IncludeItem.plain: AbstractProduction [ Id, Using ]
let foo[tree] ←
0
;
for IncludeItem.typeandid: AbstractProduction [ Id.local, Id.global, Using ]
let foo[tree] ←
0
;
Using: AbstractType [ foo ];
for Using.restricted: AbstractProduction [ IdList ]
let foo[tree] ←
0
;
for Using.nothing: AbstractProduction [ ]
let foo[tree] ←
0
;
for Using.unrestricted: AbstractProduction [ ]
let foo[tree] ←
0
;
DefBody: AbstractType [ foo ];
for DefBody: AbstractProduction [ BindList, DecList ]
let foo[tree] ←
0
;
DefHead: AbstractType [ foo ];
for DefHead: AbstractProduction [ Locks, ModuleList, Shares, Access ]
let foo[tree] ←
0
;
Cedar: AbstractType [ foo ];
for Cedar.yes: AbstractProduction [ ]
let foo[tree] ←
0
;
for Cedar.no: AbstractProduction [ ]
let foo[tree] ←
0
;
ProgHead: AbstractType [ foo ];
for ProgHead: AbstractProduction [ Safe, Class, Arguments, Locks, Interface, Access ]
let foo[tree] ←
0
;
Class: AbstractType [ foo ];
for Class.program: AbstractProduction [ ]
let foo[tree] ←
0
;
for Class.monitor: AbstractProduction [ ]
let foo[tree] ←
0
;
Interface: AbstractType [ foo ];
for Interface: AbstractProduction [ ModuleList.imports, ModuleList.exports, Shares ]
let foo[tree] ←
0
;
ModuleList: AbstractType [ foo ];
for ModuleList.empty: AbstractProduction [ ]
let foo[tree] ←
0
;
for ModuleList.more: AbstractProduction [ ModuleList, ModuleItem ]
let foo[tree] ←
0
;
ModuleItem: AbstractType [ foo ];
for ModuleItem.one: AbstractProduction [ Id ]
let foo[tree] ←
0
;
for ModuleItem.two: AbstractProduction [ Id.record, Id.type ]
let foo[tree] ←
0
;
Shares: AbstractType [ foo ];
for Shares.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for Shares.present: AbstractProduction [ IdList ]
let foo[tree] ←
0
;
Locks: AbstractType [ foo ];
for Locks.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for Locks.present: AbstractProduction [ Exp, Lambda ]
let foo[tree] ←
0
;
Lambda: AbstractType [ foo ];
for Lambda.absent: AbstractProduction [ ]
let foo[tree] ←
0
;
for Lambda.present: AbstractProduction [ Ident, TypeExp ]
let foo[tree] ←
0
;
End.
eof...