[Indigo]<Casaba>7.0>Saffron2Lucy>MyNoops.ThreeC4!1

SaffronNoopMethods.ThreeC4

Shoup, August 8, 1986 5:32:07 pm PDT

Bill Jackson (bj) April 28, 1987 0:26:13 am PDT

Include [SaffronAG, SaffronTreeBucket, SaffronBaseDecls];

NoopMethods1: Module = Begin

Junk: AbstractType [ foo ];

for Junk: AbstractProduction [ ]

let foo[tree] ←

0

;

Top: AbstractType [ foo, DoTop ];

for Top.modulep: AbstractProduction [ ModuleP ]

let DoTop[tree] ←

False[]

let foo[tree] ←

0

;

for Top.scope: AbstractProduction [ Scope ]

let foo[tree] ←

0

;

Exp: AbstractType [ foo, MakeValue ];

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, MakeValue ];

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, MakeValue ];

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, NewScope ];

for Scope: AbstractProduction [ BindList, Catch, OptDecList, StatementList ]

let foo[tree] ←

0

;

End;

NoopMethods5: Module = Begin

OptDecList: AbstractType [ foo, PreprocessDecls, ProcessDecls ];

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, PreprocessDecls, ProcessDecls ];

for DecList.one: AbstractProduction [ Declaration ]

let foo[tree] ←

0

;

for DecList.many: AbstractProduction [ DecList.head, DecList.tail ]

let foo[tree] ←

0

;

Declaration: AbstractType [ foo, PreprocessDecls, ProcessDecls, ProcessOneDecl ];

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

TypeExp: AbstractType [ foo, MakeType ];

for TypeExp.typeid: AbstractProduction [ TypeId ]

let foo[tree] ←

0

;

for TypeExp.subrange: AbstractProduction [ Subrange ]

let foo[tree] ←

0

;

for TypeExp.enum: AbstractProduction [ MachineDependent, ElementList ]

let foo[tree] ←

0

;

for TypeExp.record: AbstractProduction [ MachineDependent, Monitored, RecList ]

let foo[tree] ←

0

;

for TypeExp.pointer: AbstractProduction [ Ordered, Base, PointerType ]

let foo[tree] ←

0

;

for TypeExp.var: AbstractProduction [ TypeExp ]

let foo[tree] ←

0

;

for TypeExp.ref: AbstractProduction [ ReadOnly, TypeExp ]

let foo[tree] ←

0

;

for TypeExp.refany: AbstractProduction [ ReadOnly ]

let foo[tree] ←

0

;

for TypeExp.refunspecified: AbstractProduction [ ]

let foo[tree] ←

0

;

for TypeExp.list: AbstractProduction [ ReadOnly, TypeExp ]

let foo[tree] ←

0

;

for TypeExp.array: AbstractProduction [ Packed, OptType, TypeExp ]

let foo[tree] ←

0

;

for TypeExp.descriptor: AbstractProduction [ ReadOnly, TypeExp ]

let foo[tree] ←

0

;

for TypeExp.transfer: AbstractProduction [ Safe, TransferMode, Arguments ]

let foo[tree] ←

0

;

for TypeExp.relative: AbstractProduction [ TypeId, TypeExp ]

let foo[tree] ←

0

;

for TypeExp.zone: AbstractProduction [ Uncounted ]

let foo[tree] ←

0

;

for TypeExp.long: AbstractProduction [ TypeExp ]

let foo[tree] ←

0

;

for TypeExp.frame: AbstractProduction [ id ]

let foo[tree] ←

0

;

for TypeExp.painted: AbstractProduction [ TypeId, TypeExp ]

let foo[tree] ←

0

;

for TypeExp.typeapply: AbstractProduction [ TypeApply ]

let foo[tree] ←

0

;

for TypeExp.union: AbstractProduction [ Tag, VariantList ]

let foo[tree] ←

0

;

for TypeExp.sequence: AbstractProduction [ Packed, Tag, TypeExp ]

let foo[tree] ←

0

;

TypeId: AbstractType [ foo, MakeType ];

for TypeId.id: AbstractProduction [ id ]

let foo[tree] ←

0

;

for TypeId.qualifier: AbstractProduction [ TypeId, id ]

let foo[tree] ←

0

;

Subrange: AbstractType [ foo, MakeType ];

for Subrange.named: AbstractProduction [ TypeId, Interval ]

let foo[tree] ←

0

;

for Subrange.unnamed: AbstractProduction [ Interval ]

let foo[tree] ←

0

;

Interval: AbstractType [ foo, MakeTypeInterval ];

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, MakeTypeBounds ];

for Bounds: AbstractProduction [ Bound.lower, Bound.upper ]

let foo[tree] ←

0

;

Bound: AbstractType [ foo, MakeTypeBound ];

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

;

ElementList: AbstractType [ foo, MakeEltList ];

for ElementList.empty: AbstractProduction [ ]

let foo[tree] ←

0

;

for ElementList.more: AbstractProduction [ ElementList, Element ]

let foo[tree] ←

0

;

Element: AbstractType [ foo, InsertElement ];

for Element.id: AbstractProduction [ id ]

let foo[tree] ←

0

;

for Element.idwithrep: AbstractProduction [ id, Exp ]

let foo[tree] ←

0

;

for Element.anonymousrep: AbstractProduction [ Exp ]

let foo[tree] ←

0

;

RecList: AbstractType [ foo, MakeFieldList ];

for RecList.empty: AbstractProduction [ ]

let foo[tree] ←

0

;

for RecList.pairlist: AbstractProduction [ PairList ]

let foo[tree] ←

0

;

for RecList.typelist: AbstractProduction [ TypeList ]

let foo[tree] ←

0

;

PairList: AbstractType [ foo, MakeNamedFieldList ];

for PairList.one: AbstractProduction [ PairItem ]

let foo[tree] ←

0

;

for PairList.many: AbstractProduction [ PairList.head, PairList.tail ]

let foo[tree] ←

0

;

PairItem: AbstractType [ foo, MakeNamedFieldList ];

for PairItem: AbstractProduction [ IdentList, Access, TypeExp, Default ]

let foo[tree] ←

0

;

TypeList: AbstractType [ foo, MakeUnnamedFieldList ];

for TypeList.one: AbstractProduction [ TypeItem ]

let foo[tree] ←

0

;

for TypeList.many: AbstractProduction [ TypeList.head, TypeList.tail ]

let foo[tree] ←

0

;

TypeItem: AbstractType [ foo, MakeUnnamedFieldList ];

for TypeItem: AbstractProduction [ TypeExp, Default ]

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

;

Ident: AbstractType [ foo, InsertDescriptor, ReplaceDescriptor, AddToNamedFieldList, ProcessDecls ];

for Ident.id: AbstractProduction [ id ]

let foo[tree] ←

0

;

for Ident.idposition: AbstractProduction [ id, Position ]

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

;

IdentList: AbstractType [ foo, ProcessDecls, InsertDescriptor, ReplaceDescriptor, AddToNamedFieldList ];

for IdentList.one: AbstractProduction [ Ident ]

let foo[tree] ←

0

;

for IdentList.many: AbstractProduction [ IdentList.head, IdentList.tail ]

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...