[Indigo]<Casaba>7.0>Saffron2.0>Methods>SaffronNoops.ThreeC4!17

SaffronNoops.ThreeC4

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 August 17, 1987 3:49:34 pm PDT

Include [SaffronAG, SaffronBaseDecls];

NoopMethods1: Module = Begin

Junk: AbstractType [ foo ];

for Junk: AbstractProduction [ ]

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

;

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.bits: AbstractProduction [ ]

let foo[tree] ←

0

;

for Qualifier.bytes: AbstractProduction [ ]

let foo[tree] ←

0

;

for Qualifier.units: AbstractProduction [ ]

let foo[tree] ←

0

;

for Qualifier.words: 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

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

;

End;

NoopMethods5: Module = Begin

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

;

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

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