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

SaffronAG.ThreeC4

Shoup, August 8, 1986 5:49:55 pm PDT

Bill Jackson (bj) April 27, 1987 10:46:16 pm PDT

Lucy Hederman July 17, 1987 4:35:45 pm PDT

Include [ MyBaseDecls, MyTreeDecls ];

SaffronAT: Module = Begin

AbstractType

Modularity

Top: AbstractType [ foo, DoTop ];

ModuleP: AbstractType [ foo ];

Directory: AbstractType [ foo ];

IncludeItem: AbstractType [ foo ];

Using: AbstractType [ foo ];

DefBody: AbstractType [ foo ];

DefHead: AbstractType [ foo ];

Cedar: AbstractType [ foo ];

ProgHead: AbstractType [ foo ];

Class: AbstractType [ foo ];

Interface: AbstractType [ foo ];

ModuleList: AbstractType [ foo ];

ModuleItem: AbstractType [ foo ];

Lambda: AbstractType [ foo ];

Locks: AbstractType [ foo ];

Shares: AbstractType [ foo ];

Entry: AbstractType [ foo ];

Inline: AbstractType [ foo ];

Declarations

OptSize: AbstractType [ foo ];

OptType: AbstractType [ foo ];

BindList: AbstractType [ foo ];

Uncounted: AbstractType [ foo ];

MachineDependent: AbstractType [ foo ];

Monitored: AbstractType [ foo ];

ElementList: AbstractType [ foo, MakeElementList ];

Element: AbstractType [ foo, ElementName ];

RecList: AbstractType [ foo, MakeFieldList ];

PairList: AbstractType [ foo, AddPairsToFieldList ];

PairItem: AbstractType [ foo, AddPairsToFieldList ];

TypeList: AbstractType [ foo, AddToFieldList ];

TypeItem: AbstractType [ foo, AddToFieldList ];

IdentList: AbstractType [ foo, AddNamesToFieldList ];

Tag: AbstractType [ foo ];

TagType: AbstractType [ foo ];

VariantList: AbstractType [ foo ];

VariantItem: AbstractType [ foo ];

Packed: AbstractType [ foo ];

Ordered: AbstractType [ foo ];

Base: AbstractType [ foo ];

PointerType: AbstractType [ foo ];

OptInterval: AbstractType [ foo ];

DecList: AbstractType [ foo ];

Declaration: AbstractType [ foo ];

OptDecList: AbstractType [ foo ];

DescList: AbstractType [ foo ];

Initialization: AbstractType [ foo ];

InitialValue: AbstractType [ foo ];

Scope: AbstractType [ foo ];

Ident: AbstractType [ foo, AddNamesToFieldList ];

???Binding???

OptArgs: AbstractType [ foo ];

BindItem: AbstractType [ foo ];

KeyList: AbstractType [ foo ];

KeyItem: AbstractType [ foo ];

Relation: AbstractType [ foo ];

Access: AbstractType [ foo ];

Bounds: AbstractType [ foo ];

Default: AbstractType [ foo ];

Position: AbstractType [ foo ];

OptBits: AbstractType [ foo ];

Expressions

Relop: AbstractType [ foo ];

RelationTail: AbstractType [ foo ];

ExpList: AbstractType [ foo ];

Exp: AbstractType [ foo ];

OptExp: AbstractType [ foo ];

OrderList: AbstractType [ foo ];

MultOp: AbstractType [ foo ];

AddOp: AbstractType [ foo ];

ReadOnly: AbstractType [ foo ];

CatchAny: AbstractType [ foo ];

Interval: AbstractType [ foo ];

SelectExpList: AbstractType [ foo ];

SelectExpItem: AbstractType [ foo ];

TypeId: AbstractType [ foo ];

TypeApply: AbstractType [ foo ];

Range: AbstractType [ foo ];

PrefixOp: AbstractType [ foo ];

New: AbstractType [ foo ];

Free: AbstractType [ foo ];

Cons: AbstractType [ foo ];

ListCons: AbstractType [ foo ];

Control Structure

Safe: AbstractType [ foo ];

TransferMode: AbstractType [ foo ];

ExitItem: AbstractType [ foo ];

SelectHead: AbstractType [ foo ];

SelectStmtList: AbstractType [ foo ];

SelectStmtItem: AbstractType [ foo ];

ForClause: AbstractType [ foo ];

ControlId: AbstractType [ foo ];

Decreasing: AbstractType [ foo ];

Transfer: AbstractType [ foo ];

SelectLabel: AbstractType [ foo ];

SelectTestList: AbstractType [ foo ];

Block: AbstractType [ foo ];

Checked: AbstractType [ foo ];

CodeList: AbstractType [ foo ];

Statement: AbstractType [ foo ];

OptStatement: AbstractType [ foo ];

StatementList: AbstractType [ foo ];

DoTest: AbstractType [ foo ];

DoExit: AbstractType [ foo ];

TransferOp: AbstractType [ foo ];

Catch: AbstractType [ foo ];

CatchCase: AbstractType [ foo ];

CatchCaseList: AbstractType [ foo ];

TypeOp: AbstractType [ foo ];

IdList: AbstractType [ foo ];

Arguments: AbstractType [ foo ];

ParameterList: AbstractType [ foo ];

TypeExp: AbstractType [ foo, MakeType ];

Num: AbstractType [ foo ];

Qualifier: AbstractType [ foo ];

SignalList: AbstractType [ foo ];

ExitList: AbstractType [ foo ];

Junk

Bound: AbstractType [ foo ]; -- ???

Junk: AbstractType [ foo ];

Subrange: AbstractType [ foo ]; -- ???

End;

SaffronAG1: Module = Begin

abstract types and productions: junk, needed to handle nonterminals that don't build anything useful

Junk: AbstractType [ foo ];

Junk: AbstractProduction [ ];

Top: AbstractType [ foo, DoTop ];

Top is used to skip down to an interseting subtree

Top.modulep: AbstractProduction [ ModuleP ];

Top.scope: AbstractProduction [ Scope ];

Top.tc: AbstractProduction [ TypeExp ];

abstract types and productions: expressions

Exp: AbstractType [ foo, MakeValue ];

Exp.sum: AbstractProduction [ Exp.left, AddOp, Exp.right ];

Exp.unarysum: AbstractProduction [ AddOp, Exp ];

Exp.product: AbstractProduction [ Exp.left, MultOp, Exp.right ];

Exp.or: AbstractProduction [ Exp.left, Exp.right ];

Exp.and: AbstractProduction [ Exp.left, Exp.right ];

Exp.not: AbstractProduction [ Exp ];

Exp.relation: AbstractProduction [ Exp, Relation ];

Exp.ifthenelse: AbstractProduction [ Exp.cond, Exp.thenpart, Exp.elsepart ];

Exp.select: AbstractProduction [ SelectHead, SelectExpList, Exp.default ];

Exp.assign: AbstractProduction [ Exp.lhs, Exp.rhs ];

Exp.multiassign: AbstractProduction [ ExpList, Exp ];

Exp.id: AbstractProduction [ id ];

Exp.num: AbstractProduction [ Num ];

Exp.string: AbstractProduction [ string ];

Exp.flnum: AbstractProduction [ flnum ];

Exp.char: AbstractProduction [ char ];

Exp.atom: AbstractProduction [ atom ];

Exp.narrow: AbstractProduction [ Exp, OptType, Catch ];

Exp.loophole: AbstractProduction [ Exp, OptType ];

Exp.apply: AbstractProduction [ Exp.rator, Exp.rand, Catch ];

Exp.qualifier: AbstractProduction [ Exp, Qualifier ];

Exp.explist: AbstractProduction [ ExpList ];

Exp.prefixop: AbstractProduction [ PrefixOp, OrderList ];

Exp.val: AbstractProduction [ OrderList ];

Exp.all: AbstractProduction [ OrderList ];

Exp.new: AbstractProduction [ New, TypeExp, Initialization, Catch ];

Exp.cons: AbstractProduction [ Cons, ExpList, Catch ];

Exp.listcons: AbstractProduction [ ListCons, ExpList ];

Exp.nil: AbstractProduction [ ];

Exp.typeop: AbstractProduction [ TypeOp, TypeExp ];

Exp.size: AbstractProduction [ TypeExp ];

Exp.size2: AbstractProduction [ TypeExp, Exp ];

Exp.istype: AbstractProduction [ Exp, TypeExp ];

Exp.address: AbstractProduction [ Exp ];

Exp.descriptor: AbstractProduction [ DescList ];

Exp.error: AbstractProduction [ ];

Exp.transfer: AbstractProduction [ TransferOp, Exp ];

Num: AbstractType [ foo ];

Num.decimal: AbstractProduction [ decimalnum ];

Num.octal: AbstractProduction [ octalnum ];

Num.hex: AbstractProduction [ hexnum ];

AddOp: AbstractType [ foo ];

AddOp.plus: AbstractProduction [ ];

AddOp.minus: AbstractProduction [ ];

MultOp: AbstractType [ foo ];

MultOp.times: AbstractProduction [ ];

MultOp.divide: AbstractProduction [ ];

MultOp.mod: AbstractProduction [ ];

SelectHead: AbstractType [ foo ];

SelectHead.plain: AbstractProduction [ Exp ];

SelectHead.discriminating: AbstractProduction [ BindItem, OptExp ];

SelectExpList: AbstractType [ foo ];

SelectExpList.empty: AbstractProduction [ ];

SelectExpList.more: AbstractProduction [ SelectExpList, SelectExpItem ];

SelectExpItem: AbstractType [ foo ];

SelectExpItem: AbstractProduction [ SelectLabel, Exp ];

SelectLabel: AbstractType [ foo ];

SelectLabel.type: AbstractProduction [ Ident, TypeExp ];

SelectLabel.test: AbstractProduction [ SelectTestList ];

SelectTestList: AbstractType [ foo ];

SelectTestList.one: AbstractProduction [ Relation ];

SelectTestList.more: AbstractProduction [ SelectTestList, Relation ];

Relation: AbstractType [ foo ];

Relation.negative: AbstractProduction [ RelationTail ];

Relation.positive: AbstractProduction [ RelationTail ];

RelationTail: AbstractType [ foo ];

RelationTail.range: AbstractProduction [ Range ];

RelationTail.relop: AbstractProduction [ Relop, Exp ]

End;

SaffronAG2: Module = Begin

Relop: AbstractType [ foo ];

Relop.eq: AbstractProduction [ ];

Relop.ne: AbstractProduction [ ];

Relop.lt: AbstractProduction [ ];

Relop.le: AbstractProduction [ ];

Relop.gt: AbstractProduction [ ];

Relop.ge: AbstractProduction [ ];

Range: AbstractType [ foo ];

Range.typeid: AbstractProduction [ TypeId ];

Range.subrange: AbstractProduction [ Subrange ];

Catch: AbstractType [ foo ];

Catch: AbstractProduction [ CatchCaseList, CatchAny ];

CatchAny: AbstractType [ foo ];

CatchAny.absent: AbstractProduction [ ];

CatchAny.present: AbstractProduction [ Statement ];

CatchCaseList: AbstractType [ foo ];

CatchCaseList.empty: AbstractProduction [ ];

CatchCaseList.more: AbstractProduction [ CatchCaseList, CatchCase ];

CatchCase: AbstractType [ foo ];

CatchCase: AbstractProduction [ SignalList, Statement ];

SignalList: AbstractType [ foo ];

SignalList.one: AbstractProduction [ Exp ];

SignalList.more: AbstractProduction [ SignalList, Exp ];

ExpList: AbstractType [ foo ];

ExpList.keylist: AbstractProduction [ KeyList ];

ExpList.orderlist: AbstractProduction [ OrderList ];

KeyList: AbstractType [ foo ];

KeyList.one: AbstractProduction [ KeyItem ];

KeyList.more: AbstractProduction [ KeyList, KeyItem ];

KeyItem: AbstractType [ foo ];

KeyItem: AbstractProduction [ id, OptExp ];

OrderList: AbstractType [ foo ];

OrderList.one: AbstractProduction [ OptExp ];

OrderList.more: AbstractProduction [ OrderList, OptExp ];

OptExp: AbstractType [ foo ];

OptExp.empty: AbstractProduction [ ];

OptExp.trash: AbstractProduction [ ];

OptExp.exp: AbstractProduction [ Exp ];

OptType: AbstractType [ foo ];

OptType.absent: AbstractProduction [ ];

OptType.present: AbstractProduction [ TypeExp ];

Qualifier: AbstractType [ foo ];

Qualifier.prefixop: AbstractProduction [ PrefixOp ];

Qualifier.typeop: AbstractProduction [ TypeOp ];

Qualifier.size: AbstractProduction [ ];

Qualifier.apply: AbstractProduction [ ExpList, Catch ];

Qualifier.select: AbstractProduction [ id ];

Qualifier.indirect: AbstractProduction [ ];

PrefixOp: AbstractType [ foo ];

PrefixOp.long : AbstractProduction [ ];

PrefixOp.abs : AbstractProduction [ ];

PrefixOp.pred : AbstractProduction [ ];

PrefixOp.succ : AbstractProduction [ ];

PrefixOp.ord : AbstractProduction [ ];

PrefixOp.min : AbstractProduction [ ];

PrefixOp.max : AbstractProduction [ ];

PrefixOp.base : AbstractProduction [ ];

PrefixOp.length : AbstractProduction [ ];

TypeOp: AbstractType [ foo ];

TypeOp.code: AbstractProduction [ ];

TypeOp.first: AbstractProduction [ ];

TypeOp.last: AbstractProduction [ ];

TypeOp.nil: AbstractProduction [ ]

End;

SaffronAG3: Module = Begin

New: AbstractType [ foo ];

New.plain: AbstractProduction [ ];

New.zoned: AbstractProduction [ Exp ];

Cons: AbstractType [ foo ];

Cons.plain: AbstractProduction [ ];

Cons.zoned: AbstractProduction [ Exp ];

ListCons: AbstractType [ foo ];

ListCons.plain: AbstractProduction [ ];

ListCons.zoned: AbstractProduction [ Exp ];

DescList: AbstractType [ foo ];

DescList.explicitlength: AbstractProduction [ Exp.base, Exp.length, OptType ];

DescList.defaultlength: AbstractProduction [ Exp ];

Initialization: AbstractType [ foo, MakeValue ];

Initialization.empty: AbstractProduction [ ];

Initialization.binding: AbstractProduction [ InitialValue ];

Initialization.assignment: AbstractProduction [ InitialValue ];

InitialValue: AbstractType [ foo, MakeValue ];

InitialValue.trash: AbstractProduction [ ];

InitialValue.code: AbstractProduction [ ];

InitialValue.exp: AbstractProduction [ Exp ];

InitialValue.block: AbstractProduction [ Checked, Inline, Block ];

InitialValue.machinecode: AbstractProduction [ Checked, CodeList ];

Checked: AbstractType [ foo ];

Checked.empty: AbstractProduction [ ];

Checked.checked: AbstractProduction [ ];

Checked.trusted: AbstractProduction [ ];

Checked.unchecked: AbstractProduction [ ];

Inline: AbstractType [ foo ];

Inline.yes: AbstractProduction [ ];

Inline.no: AbstractProduction [ ];

CodeList: AbstractType [ foo ];

CodeList.one: AbstractProduction [ OrderList ];

CodeList.more: AbstractProduction [ CodeList, OrderList ];

TransferOp: AbstractType [ foo ];

TransferOp.signal: AbstractProduction [ ];

TransferOp.error: AbstractProduction [ ];

TransferOp.start: AbstractProduction [ ];

TransferOp.join: AbstractProduction [ ];

TransferOp.new: AbstractProduction [ ];

TransferOp.fork: AbstractProduction [ ];

End;

SaffronAG4: Module = Begin

abstract types and expressions: statements

Statement: AbstractType [ foo ];

Statement.ifthen: AbstractProduction [ Exp, Statement ];

Statement.ifthenelse: AbstractProduction [ Exp, Statement.thenpart, Statement.elsepart ];

Statement.select: AbstractProduction [ SelectHead, SelectStmtList, OptStatement ];

Statement.exp: AbstractProduction [ Exp ];

Statement.assign: AbstractProduction [ Exp.lhs, Exp.rhs ];

Statement.multiassign: AbstractProduction [ ExpList, Exp ];

Statement.block: AbstractProduction [ Checked, Block ];

Statement.loopcontrol: AbstractProduction [ ForClause, DoTest, Scope, DoExit ];

Statement.exit: AbstractProduction [ ];

Statement.loop: AbstractProduction [ ];

Statement.goto: AbstractProduction [ id ];

Statement.return: AbstractProduction [ OptArgs ];

Statement.transfer: AbstractProduction [ Transfer, Exp ];

Statement.free: AbstractProduction [ Free, Exp, Catch ];

Statement.wait: AbstractProduction [ Exp ];

Statement.error: AbstractProduction [ ];

Statement.stop: AbstractProduction [ ];

Statement.null: AbstractProduction [ ];

Statement.resume: AbstractProduction [ OptArgs ];

Statement.reject: AbstractProduction [ ];

Statement.continue: AbstractProduction [ ];

Statement.retry: AbstractProduction [ ];

Statement.getstate: AbstractProduction [ Exp ];

Statement.setstate: AbstractProduction [ Exp ];

OptStatement: AbstractType [ foo ];

OptStatement.absent: AbstractProduction [ ];

OptStatement.present: AbstractProduction [ Statement ];

SelectStmtList: AbstractType [ foo ];

SelectStmtList.empty: AbstractProduction [ ];

SelectStmtList.more: AbstractProduction [ SelectStmtList, SelectStmtItem ];

SelectStmtItem: AbstractType [ foo ];

SelectStmtItem: AbstractProduction [ SelectLabel, Statement ];

Block: AbstractType [ foo ];

Block: AbstractProduction [ Scope, ExitList ];

Scope: AbstractType [ foo, NewScope ];

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

OptDecList: AbstractType [ foo, PreprocessDecls, ProcessDecls ];

OptDecList.absent: AbstractProduction [ ];

OptDecList.present: AbstractProduction [ DecList ];

StatementList: AbstractType [ foo ];

StatementList.empty: AbstractProduction [ ];

StatementList.more: AbstractProduction [ StatementList, Statement ]

End;

SaffronAG5: Module = Begin

DecList: AbstractType [ foo, PreprocessDecls, ProcessDecls ];

DecList.one: AbstractProduction [ Declaration ];

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

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

Declaration.value: AbstractProduction [ IdentList, Access, Entry, ReadOnly, TypeExp, Initialization ];

Declaration.type: AbstractProduction [ IdentList, Access.id, Access.type, TypeExp, Default ];

Declaration.opaquetype: AbstractProduction [ IdentList, Access, OptSize ];

OptSize: AbstractType [ foo ];

OptSize.absent: AbstractProduction [ ];

OptSize.present: AbstractProduction [ Exp ];

Entry: AbstractType [ foo ];

Entry.entry: AbstractProduction [ ];

Entry.internal: AbstractProduction [ ];

Entry.empty: AbstractProduction [ ];

ExitList: AbstractType [ foo ];

ExitList.empty: AbstractProduction [ ];

ExitList.more: AbstractProduction [ ExitList, ExitItem ];

ExitItem: AbstractType [ foo ];

ExitItem: AbstractProduction [ IdList, Statement ];

BindList: AbstractType [ foo ];

BindList.empty: AbstractProduction [ ];

BindList.more: AbstractProduction [ BindList, BindItem ];

BindItem: AbstractType [ foo ];

BindItem.named: AbstractProduction [ id, Exp ];

BindItem.unnamed: AbstractProduction [ Exp ];

ForClause: AbstractType [ foo ];

ForClause.assignation: AbstractProduction [ ControlId, Exp.initial, Exp.next ];

ForClause.iteration: AbstractProduction [ ControlId, Decreasing, Range ];

ForClause.repetition: AbstractProduction [ Range ];

ForClause.empty: AbstractProduction [ ];

ControlId: AbstractType [ foo ];

ControlId.new: AbstractProduction [ Ident, TypeExp ];

ControlId.old: AbstractProduction [ id ];

Decreasing: AbstractType [ foo ];

Decreasing.yes: AbstractProduction [ ];

Decreasing.no: AbstractProduction [ ];

DoTest: AbstractType [ foo ];

DoTest.until: AbstractProduction [ Exp ];

DoTest.while: AbstractProduction [ Exp ];

DoTest.empty: AbstractProduction [ ];

DoExit: AbstractType [ foo ];

DoExit: AbstractProduction [ ExitList, OptStatement ];

OptArgs: AbstractType [ foo ];

OptArgs.explist: AbstractProduction [ ExpList ];

OptArgs.exp: AbstractProduction [ Exp ];

OptArgs.empty: AbstractProduction [ ];

Transfer: AbstractType [ foo ];

Transfer.signal: AbstractProduction [ ];

Transfer.error: AbstractProduction [ ];

Transfer.returnwitherror: AbstractProduction [ ];

Transfer.start: AbstractProduction [ ];

Transfer.restart: AbstractProduction [ ];

Transfer.join: AbstractProduction [ ];

Transfer.notify: AbstractProduction [ ];

Transfer.broadcast: AbstractProduction [ ];

Transfer.transferwith: AbstractProduction [ ];

Transfer.returnwith: AbstractProduction [ ];

Free: AbstractType [ foo ];

Free.plain: AbstractProduction [ ];

Free.zoned: AbstractProduction [ Exp ]

End;

SaffronAG6: Module = Begin

abstract types and productions: type expressions

TypeExp: AbstractType [ foo, MakeType ];

TypeExp.typeid: AbstractProduction [ TypeId ];

TypeExp.subrange: AbstractProduction [ Subrange ];

TypeExp.enum: AbstractProduction [ MachineDependent, ElementList ];

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

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

TypeExp.var: AbstractProduction [ TypeExp ];

TypeExp.ref: AbstractProduction [ ReadOnly, TypeExp ];

TypeExp.refany: AbstractProduction [ ReadOnly ];

TypeExp.refunspecified: AbstractProduction [ ];

TypeExp.list: AbstractProduction [ ReadOnly, TypeExp ];

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

TypeExp.descriptor: AbstractProduction [ ReadOnly, TypeExp ];

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

TypeExp.relative: AbstractProduction [ TypeId, TypeExp ];

TypeExp.zone: AbstractProduction [ Uncounted ];

TypeExp.long: AbstractProduction [ TypeExp ];

TypeExp.frame: AbstractProduction [ id ];

TypeExp.painted: AbstractProduction [ TypeId, TypeExp ];

TypeExp.typeapply: AbstractProduction [ TypeApply ];

TypeExp.union: AbstractProduction [ Tag, VariantList ];

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

TypeId: AbstractType [ foo, MakeType ];

TypeId.id: AbstractProduction [ id ];

TypeId.qualifier: AbstractProduction [ TypeId, id ];

Subrange: AbstractType [ foo, MakeType ];

Subrange.named: AbstractProduction [ TypeId, Interval ];

Subrange.unnamed: AbstractProduction [ Interval ];

Interval: AbstractType [ foo, MakeTypeInterval ];

Interval.cc: AbstractProduction [ Bounds ];

Interval.co: AbstractProduction [ Bounds ];

Interval.oc: AbstractProduction [ Bounds ];

Interval.oo: AbstractProduction [ Bounds ];

Bounds: AbstractType [ foo, MakeTypeBounds ];

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

Bound: AbstractType [ foo, MakeTypeBound ];

Bound: AbstractProduction [ Exp ];

MachineDependent: AbstractType [ foo ];

MachineDependent.yes: AbstractProduction [ ];

MachineDependent.no: AbstractProduction [ ];

Monitored: AbstractType [ foo ];

Monitored.yes: AbstractProduction [ ];

Monitored.no: AbstractProduction [ ];

ElementList: AbstractType [ foo, MakeEltList ];

ElementList.empty: AbstractProduction [ ];

ElementList.more: AbstractProduction [ ElementList, Element ];

Element: AbstractType [ foo, InsertElement ];

Element.id: AbstractProduction [ id ];

Element.idwithrep: AbstractProduction [ id, Exp ];

Element.anonymousrep: AbstractProduction [ Exp ];

RecList: AbstractType [ foo, MakeFieldList ];

RecList.empty: AbstractProduction [ ];

RecList.pairlist: AbstractProduction [ PairList ];

RecList.typelist: AbstractProduction [ TypeList ];

PairList: AbstractType [ foo, MakeNamedFieldList ];

PairList.one: AbstractProduction [ PairItem ];

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

PairItem: AbstractType [ foo, MakeNamedFieldList ];

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

TypeList: AbstractType [ foo, MakeUnnamedFieldList ];

TypeList.one: AbstractProduction [ TypeItem ];

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

TypeItem: AbstractType [ foo, MakeUnnamedFieldList ];

TypeItem: AbstractProduction [ TypeExp, Default ]

End;

SaffronAG7: Module = Begin

Access: AbstractType [ foo ];

Access.empty: AbstractProduction [ ];

Access.public: AbstractProduction [ ];

Access.private: AbstractProduction [ ];

Default: AbstractType [ foo ];

Default.empty: AbstractProduction [ ];

Default.gets: AbstractProduction [ ];

Default.getsexp: AbstractProduction [ Exp ];

Default.getstrash: AbstractProduction [ ];

Default.getsexportrash: AbstractProduction [ Exp ];

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

Ident.id: AbstractProduction [ id ];

Ident.idposition: AbstractProduction [ id, Position ];

Position: AbstractType [ foo ];

Position: AbstractProduction [ Exp, OptBits ];

OptBits: AbstractType [ foo ];

OptBits.absent: AbstractProduction [ ];

OptBits.present: AbstractProduction [ Bounds ];

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

IdentList.one: AbstractProduction [ Ident ];

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

Tag: AbstractType [ foo ];

Tag.ident: AbstractProduction [ Ident, Access, TagType ];

Tag.computed: AbstractProduction [ TagType ];

Tag.overlaid: AbstractProduction [ TagType ];

TagType: AbstractType [ foo ];

TagType.star: AbstractProduction [ ];

TagType.typeexp: AbstractProduction [ TypeExp ];

VariantList: AbstractType [ foo ];

VariantList.one: AbstractProduction [ VariantItem ];

VariantList.more: AbstractProduction [ VariantList, VariantItem ];

VariantItem: AbstractType [ foo ];

VariantItem: AbstractProduction [ IdList, RecList ];

Packed: AbstractType [ foo ];

Packed.yes: AbstractProduction [ ];

Packed.no: AbstractProduction [ ]

End;

SaffronAG8: Module = Begin

IdList: AbstractType [ foo ];

IdList.one: AbstractProduction [ id ];

IdList.more: AbstractProduction [ id, IdList ];

Ordered: AbstractType [ foo ];

Ordered.yes: AbstractProduction [ ];

Ordered.no: AbstractProduction [ ];

Base: AbstractType [ foo ];

Base.yes: AbstractProduction [ ];

Base.no: AbstractProduction [ ];

PointerType: AbstractType [ foo ];

PointerType.unspecified: AbstractProduction [ OptInterval ];

PointerType.specified: AbstractProduction [ OptInterval, ReadOnly, TypeExp ];

OptInterval: AbstractType [ foo ];

OptInterval.absent: AbstractProduction [ ];

OptInterval.present: AbstractProduction [ Interval ];

ReadOnly: AbstractType [ foo ];

ReadOnly.yes: AbstractProduction [ ];

ReadOnly.no: AbstractProduction [ ];

Safe: AbstractType [ foo ];

Safe.empty: AbstractProduction [ ];

Safe.yes: AbstractProduction [ ];

Safe.no: AbstractProduction [ ];

TransferMode: AbstractType [ foo ];

TransferMode.proc: AbstractProduction [ ];

TransferMode.port: AbstractProduction [ ];

TransferMode.signal: AbstractProduction [ ];

TransferMode.error: AbstractProduction [ ];

TransferMode.process: AbstractProduction [ ];

TransferMode.program: AbstractProduction [ ];

Arguments: AbstractType [ foo ];

Arguments: AbstractProduction [ ParameterList.input, ParameterList.output ];

ParameterList: AbstractType [ foo ];

ParameterList.empty: AbstractProduction [ ];

ParameterList.any: AbstractProduction [ ];

ParameterList.pairlist: AbstractProduction [ PairList ];

ParameterList.typelist: AbstractProduction [ TypeList ];

Uncounted: AbstractType [ foo ];

Uncounted.yes: AbstractProduction [ ];

Uncounted.no: AbstractProduction [ ];

TypeApply: AbstractType [ foo ];

TypeApply.one: AbstractProduction [ TypeId, Exp ];

TypeApply.morelengths: AbstractProduction [ TypeApply, Exp ];

TypeApply.moreids: AbstractProduction [ TypeApply, id ]

End;

SaffronAG9: Module = Begin

abstract types and productions: modules

ModuleP: AbstractType [ foo ];

ModuleP.impl: AbstractProduction [ Directory, IdentList, Cedar, ProgHead, Checked, Block ];

ModuleP.def: AbstractProduction [ Directory, IdentList, Cedar, DefHead, DefBody ];

Directory: AbstractType [ foo ];

Directory.empty: AbstractProduction [ ];

Directory.more: AbstractProduction [ Directory, IncludeItem ];

IncludeItem: AbstractType [ foo ];

IncludeItem.fromp: AbstractProduction [ id, string, Using ];

IncludeItem.type: AbstractProduction [ id, Using ];

IncludeItem.plain: AbstractProduction [ id, Using ];

IncludeItem.typeandid: AbstractProduction [ id.local, id.global, Using ];

Using: AbstractType [ foo ];

Using.restricted: AbstractProduction [ IdList ];

Using.nothing: AbstractProduction [ ];

Using.unrestricted: AbstractProduction [ ];

DefBody: AbstractType [ foo ];

DefBody: AbstractProduction [ BindList, DecList ];

DefHead: AbstractType [ foo ];

DefHead: AbstractProduction [ Locks, ModuleList, Shares, Access ];

Cedar: AbstractType [ foo ];

Cedar.yes: AbstractProduction [ ];

Cedar.no: AbstractProduction [ ];

ProgHead: AbstractType [ foo ];

ProgHead: AbstractProduction [ Safe, Class, Arguments, Locks, Interface, Access ];

Class: AbstractType [ foo ];

Class.program: AbstractProduction [ ];

Class.monitor: AbstractProduction [ ];

Interface: AbstractType [ foo ];

Interface: AbstractProduction [ ModuleList.imports, ModuleList.exports, Shares ];

ModuleList: AbstractType [ foo ];

ModuleList.empty: AbstractProduction [ ];

ModuleList.more: AbstractProduction [ ModuleList, ModuleItem ];

ModuleItem: AbstractType [ foo ];

ModuleItem.one: AbstractProduction [ id ];

ModuleItem.two: AbstractProduction [ id.record, id.type ];

Shares: AbstractType [ foo ];

Shares.absent: AbstractProduction [ ];

Shares.present: AbstractProduction [ IdList ];

Locks: AbstractType [ foo ];

Locks.absent: AbstractProduction [ ];

Locks.present: AbstractProduction [ Exp, Lambda ];

Lambda: AbstractType [ foo ];

Lambda.absent: AbstractProduction [ ];

Lambda.present: AbstractProduction [ Ident, TypeExp ]

End.

eof...