[Indigo]<Casaba>7.0>Saffron3.0>Sources>SaffronAG.ThreeC4!35

SaffronAG.ThreeC4

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

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

Lucy Hederman August 17, 1987 4:31:08 pm PDT

Sturgis, July 20, 1987 6:51:52 pm PDT

Last edited by: James Rauen August 25, 1988 4:39:31 pm PDT

Include [ SaffronBaseDecls, SaffronTreeDecls ];

SaffronAT: Module = Begin

Dummies to go away

foo: TreeRecursiveFunction[Tree] Returns[INT];

Functions that refer to Abstract Types

MakeUnparsedValue:

BaseFunction [ Exp ]

Returns [ Value ];

ScopePTreeVal:

BaseFunction [ Scope ]

Returns [ ScopePTree ];

ScopeVal:

BaseFunction [ ScopePTree ]

Returns [ Scope ];

ModulePVal:

BaseFunction [ModulePPTree]

Returns [ModuleP];

DefBodyPTreeVal:

BaseFunction [DefBody]

Returns [DefBodyPTree];

DefBodyVal:

BaseFunction [DefBodyPTree]

Returns [DefBody];

TypeExpPTreeVal:

BaseFunction [TypeExp]

Returns [TypeExpPTree];

TypeExpVal:

BaseFunction [TypeExpPTree]

Returns [TypeExp];

InitializationPTreeVal:

BaseFunction [Initialization]

Returns [InitializationPTree];

InitializationVal:

BaseFunction [InitializationPTree]

Returns [Initialization];

DeclarationPTreeVal:

BaseFunction [Declaration]

Returns [DeclarationPTree];

DeclarationVal:

BaseFunction [DeclarationPTree]

Returns [Declaration];

EvaluateAndTypeCheckExpression:

Applied to Exp's. Calls EvaluateExpression and then sees if the result can be coerced to targetType. If the result can be coerced, does the coercion and returns the result. If the result is not compatible, raises an error ("expected type ...") and returns a garbage instance whose type is targetType. In either case, the returned expression is guaranteed to have the type targetType.

BaseFunction [Exp, LocalContext, FieldList, CompilerState, TypeGraphNode.targetType]

Returns [Value];

CompileAndTypeCheckExpression:

Applied to Exp's. Calls CompileExpression and then sees if the result can be coerced to targetType. If the result can be coerced, does the coercion and returns the result. If the result is not compatible, raises an error ("expected type ...") and returns a garbage instance whose type is targetType. In either case, the returned expression is guaranteed to have the type targetType.

BaseFunction [Exp, ContextTree.arg, CompilerState, TypeGraphNode.targetType]

Returns [Value, ContextTree.res]

DamagedReps [ContextTree.arg];

CompileDecList:

BaseFunction [DecList, LocalContext.arg, CompilerState]

Returns [LocalContext.res]

DamagedReps [LocalContext.arg];

AbstractType

Modularity

Top: AbstractType [ DoTop ];

ModuleP: AbstractType [ MakeEnvironment ];

Directory: AbstractType [ ProcessDirectoryClause ];

IncludeItem: AbstractType [ ProcessDirectoryItem ];

Using: AbstractType [ RestrictNamedTGN ];

DefBody: AbstractType [ MakeContextTree ];

DefHead: AbstractType [GetAccessVal, BuildInterfaceTGN];

Cedar: AbstractType [IsKeywordPresent];

ProgHead: AbstractType [GetAccessVal, BuildImplementationTGN];

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 [IsKeywordPresent];

Declarations

OptSize: AbstractType [ GetExpVal ];

OptType: AbstractType [ MakeType ];

BindList: AbstractType [ foo ];

Uncounted: AbstractType [ IsKeywordPresent ];

MachineDependent: AbstractType [ IsKeywordPresent ];

Monitored: AbstractType [ IsKeywordPresent ];

ElementList: AbstractType [ MakeElementList , AddSizeDependencies, AddFirstDependencies, AddLastDependencies];

Element: AbstractType [ ElementInfo, AddSizeDependencies, AddFirstDependencies, AddLastDependencies ];

RecList: AbstractType [ MakeFieldList, AddSizeDependencies ];

PairList: AbstractType [ AddPairsToFieldList, AddSizeDependencies ];

PairItem: AbstractType [ AddPairsToFieldList, AddSizeDependencies ];

TypeList: AbstractType [ AddToFieldList, AddSizeDependencies ];

TypeItem: AbstractType [ AddToFieldList, AddSizeDependencies ];

IdentList: AbstractType [ AddNamesToFieldList, MakeNameSequence, AddNamesToSequence, AddValueDeclarationToFieldList, AddTypeDeclarationToFieldList, MakeCodeToStoreTOSInVariousLocalFrameSlots ];

IdentList: AbstractType [ AddNamesToFieldList, PutNewTypeNamesInLocalContext, PutNewVariableNamesInLocalContext, RecAddArcsfromLVTGNtoTGN, RecAddArcsFromLocalNameToInstance, MakeNameSequence, AddNamesToSequence ];

Tag: AbstractType [ MakeVariantFlavor, MakeTagType, GetSequenceTagInfo, AddSizeDependencies ];

TagType: AbstractType [ MakeTagType, AddSizeDependencies ];

VariantList: AbstractType [ MakeUnionList, AddVariantsToUnionList, MakeStarTagType, AddVariantNamesToEnumTypeTGN, AddSizeDependencies ];

VariantItem: AbstractType [ AddVariantsToUnionList, AddVariantNamesToEnumTypeTGN, AddSizeDependencies ];

Packed: AbstractType [ IsKeywordPresent ];

Ordered: AbstractType [ IsKeywordPresent ];

Base: AbstractType [ IsKeywordPresent ];

PointerType: AbstractType [ GetPointerTypeInfo ];

OptInterval: AbstractType [ GetBoundsVal ];

DecList: AbstractType [ UpdateLocalContext, AddDeclarationsToFieldList, HangContextsFromContextTree, Compile];

DecList: AbstractType [ UpdateLocalContext, PutNewNamesInLocalContext, FillInLocalContext, HangContextsFromContextTree];

Declaration: AbstractType [ AddDeclarationToFieldList, HangContextsFromContextTree, Compile];

Declaration: AbstractType [ PutNewNamesInLocalContext, FillInLocalContext, HangContextsFromContextTree];

OptDecList: AbstractType [ UpdateLocalContext, HangContextsFromContextTree , AddDeclarationsToFieldList, Compile];

DescList: AbstractType [ foo ];

Initialization: AbstractType [GetInitialValue, InitializationIsEmpty, InitializationIsBinding, InitializationIsAssignment, CompileInitialization, AddValueDependencies];

InitialValue: AbstractType [GetInitialValue, CompileInitialization, AddValueDependencies];

Scope: AbstractType [ CompileScope ];

Ident: AbstractType [ AddNamesToFieldList, GetIdentInfo, AddNamesToSequence, AddValueDeclarationToFieldList, AddTypeDeclarationToFieldList, MakeCodeToStoreTOSInVariousLocalFrameSlots ];

Ident: AbstractType [ AddNamesToFieldList , PutNewTypeNamesInLocalContext, PutNewVariableNamesInLocalContext, RecAddArcsfromLVTGNtoTGN, RecAddArcsFromLocalNameToInstance, GetIdentInfo, AddNamesToSequence ];

???Binding???

OptArgs: AbstractType [ foo ];

BindItem: AbstractType [ foo ];

KeyList: AbstractType [ foo ];

KeyItem: AbstractType [ foo ];

Relation: AbstractType [ foo ];

Access: AbstractType [ GetAccessVal ];

Bounds: AbstractType [ GetLowerAndUpper, AddFirstDependencies, AddLastDependencies, AddSizeDependencies];

Default: AbstractType [ GetDefaultExpVal ];

Position: AbstractType [ GetPositionVal ];

OptBits: AbstractType [ GetBoundsVal ];

Expressions

Relop: AbstractType [GetRelationOp];

RelationTail: AbstractType [ foo ];

ExpList: AbstractType [ foo ];

Exp: AbstractType [IdVal, CompileExpression, AddValueDependencies, CompileLValue, EvaluateExpression];

OptExp: AbstractType [ foo ];

OrderList: AbstractType [ foo ];

MultOp: AbstractType [IsTimes, IsDivide, IsMod];

AddOp: AbstractType [IsPlus, IsMinus];

ReadOnly: AbstractType [ IsKeywordPresent ];

CatchAny: AbstractType [ foo ];

Interval: AbstractType [ GetBoundsVal, AddFirstDependencies, AddLastDependencies, AddSizeDependencies, CompileSizeOfTypeExpression, CompileFirstOfTypeExpression, CompileLastOfTypeExpression, EvaluateSizeOfTypeExpression, EvaluateFirstOfTypeExpression, EvaluateLastOfTypeExpression];

SelectExpList: AbstractType [ foo ];

SelectExpItem: AbstractType [ foo ];

TypeId: AbstractType [ MakeType, LookupTypeId, AddSizeDependencies, AddFirstDependencies, AddLastDependencies, CompileSizeOfTypeExpression, CompileFirstOfTypeExpression, CompileLastOfTypeExpression, EvaluateSizeOfTypeExpression, EvaluateFirstOfTypeExpression, EvaluateLastOfTypeExpression ];

TypeApply: AbstractType [ MakeType ];

Range: AbstractType [ foo ];

PrefixOp: AbstractType [ foo ];

New: AbstractType [ foo ];

Free: AbstractType [ foo ];

Cons: AbstractType [ foo ];

ListCons: AbstractType [ foo ];

Control Structure

Safe: AbstractType [ IsKeywordPresent ];

TransferMode: AbstractType [ MakeTransferMode ];

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 [ HangContextsFromContextTree, MakeContextTree, CompileFrameBlock, Compile, InternalCompileBlock ];

Checked: AbstractType [foo];

CodeList: AbstractType [ foo ];

Statement: AbstractType [ HangContextsFromContextTree, Compile ];

OptStatement: AbstractType [ foo ];

StatementList: AbstractType [ HangContextsFromContextTree, Compile ];

DoTest: AbstractType [ foo ];

DoExit: AbstractType [ foo ];

TransferOp: AbstractType [ foo ];

Catch: AbstractType [ foo ];

CatchCase: AbstractType [ foo ];

CatchCaseList: AbstractType [ foo ];

TypeOp: AbstractType [TypeOpIsCode, TypeOpIsFirst, TypeOpIsLast, TypeOpIsNil];

IdList: AbstractType [ AddNamesToUnionList , AddVariantNamesToEnumTypeTGN, AddIdsToRestrictionList];

Arguments: AbstractType [ MakeArgumentLists ];

ParameterList: AbstractType [ MakeFieldList ];

TypeExp: AbstractType [ MakeType, AddSizeDependencies, AddFirstDependencies, AddLastDependencies, CompileSizeOfTypeExpression, CompileFirstOfTypeExpression, CompileLastOfTypeExpression, EvaluateSizeOfTypeExpression, EvaluateFirstOfTypeExpression, EvaluateLastOfTypeExpression ];

Num: AbstractType [IntegerValueFromLiteral];

Qualifier: AbstractType [CompileQualifiedExpression];

SignalList: AbstractType [ foo ];

ExitList: AbstractType [ foo ];

Junk

Junk: AbstractType [ foo ];

Subrange: AbstractType [ MakeType, AddFirstDependencies, AddLastDependencies, AddSizeDependencies, CompileSizeOfTypeExpression, CompileFirstOfTypeExpression, CompileLastOfTypeExpression, EvaluateSizeOfTypeExpression, EvaluateFirstOfTypeExpression, EvaluateLastOfTypeExpression ]; -- ???

End;

SaffronAG1a: Module = Begin

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

Junk: AbstractType [ foo ];

Junk: AbstractProduction [ ];

Top: AbstractType [ DoTop, Explore ];

Top is used to skip down to an interseting subtree

Top.modulep: AbstractProduction [ ModuleP ];

abstract types and productions: expressions

Exp: AbstractType [ IdVal ];

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

End;

SaffronAG1b: Module = Begin

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

Exp.bits2: AbstractProduction [ TypeExp, Exp ];

Exp.bytes: AbstractProduction [ TypeExp ];

Exp.bytes2: AbstractProduction [ TypeExp, Exp ];

Exp.units: AbstractProduction [ TypeExp ];

Exp.units2: AbstractProduction [ TypeExp, Exp ];

Exp.words: AbstractProduction [ TypeExp ];

Exp.words2: 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 [];

End;

SaffronAG2: Module = Begin

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

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 [ MakeType ];

OptType.absent: AbstractProduction [ ];

OptType.present: AbstractProduction [ TypeExp ]

End;

SaffronAG3: Module = Begin

Qualifier: AbstractType [ foo ];

Qualifier.prefixop: AbstractProduction [ PrefixOp ];

Qualifier.typeop: AbstractProduction [ TypeOp ];

Qualifier.size: AbstractProduction [ ];

Qualifier.bits: AbstractProduction [ ];

Qualifier.bytes: AbstractProduction [ ];

Qualifier.units: AbstractProduction [ ];

Qualifier.words: 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 [ ];

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

Initialization.empty: AbstractProduction [ ];

Initialization.binding: AbstractProduction [ InitialValue ];

Initialization.assignment: AbstractProduction [ InitialValue ];

InitialValue: AbstractType [ foo ];

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 [ HangContextsFromContextTree ];

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 [ HangContextsFromContextTree ];

Block: AbstractProduction [ Scope, ExitList ];

Scope: AbstractType [ MakeContextTree, MakeContextTree1 ];

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

OptDecList: AbstractType [ UpdateLocalContext, HangContextsFromContextTree ];

OptDecList.absent: AbstractProduction [ ];

OptDecList.present: AbstractProduction [ DecList ];

StatementList: AbstractType [ HangContextsFromContextTree ];

StatementList.empty: AbstractProduction [ ];

StatementList.more: AbstractProduction [ StatementList, Statement ]

End;

SaffronAG5: Module = Begin

DecList: AbstractType [ UpdateLocalContext, PutNewNamesInLocalContext, FillInLocalContext, HangContextsFromContextTree];

DecList.one: AbstractProduction [ Declaration ];

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

Declaration: AbstractType [ PutNewNamesInLocalContext, FillInLocalContext, HangContextsFromContextTree ];

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 [ GetExpVal ];

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 [ MakeBindListContextTreeWithScope, MakeBindListContextTreeWithDefBody, UpdateLocalContext ];

BindList.empty: AbstractProduction [ ];

BindList.more: AbstractProduction [ BindList, BindItem ];

BindItem: AbstractType [ UpdateLocalContext ];

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;

SaffronAG6a: Module = Begin

abstract types and productions: type expressions

TypeExp: AbstractType [ 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 ];

End;

SaffronAG6b: Module = Begin

TypeId: AbstractType [ MakeType, LookupTypeId ];

TypeId.id: AbstractProduction [ Id ];

TypeId.qualifier: AbstractProduction [ TypeId, Id ];

Subrange: AbstractType [ MakeType ];

Subrange.named: AbstractProduction [ TypeId, Interval ];

Subrange.unnamed: AbstractProduction [ Interval ];

Interval: AbstractType [ GetBoundsVal ];

Interval.cc: AbstractProduction [ Bounds ];

Interval.co: AbstractProduction [ Bounds ];

Interval.oc: AbstractProduction [ Bounds ];

Interval.oo: AbstractProduction [ Bounds ];

Bounds: AbstractType [ GetLowerAndUpper ];

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

End;

SaffronAG6c: Module = Begin

MachineDependent: AbstractType [ IsKeywordPresent ];

MachineDependent.yes: AbstractProduction [ ];

MachineDependent.no: AbstractProduction [ ];

Monitored: AbstractType [ IsKeywordPresent ];

Monitored.yes: AbstractProduction [ ];

Monitored.no: AbstractProduction [ ];

ElementList: AbstractType [ MakeElementList ];

ElementList.empty: AbstractProduction [ ];

ElementList.more: AbstractProduction [ ElementList, Element ];

Element: AbstractType [ ElementInfo ];

Element.id: AbstractProduction [ Id ];

Element.idwithrep: AbstractProduction [ Id, Exp ];

Element.anonymousrep: AbstractProduction [ Exp ];

RecList: AbstractType [ MakeFieldList ];

RecList.empty: AbstractProduction [ ];

RecList.pairlist: AbstractProduction [ PairList ];

RecList.typelist: AbstractProduction [ TypeList ];

PairList: AbstractType [AddPairsToFieldList ];

PairList.one: AbstractProduction [ PairItem ];

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

PairItem: AbstractType [ AddPairsToFieldList ];

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

TypeList: AbstractType [ AddToFieldList ];

TypeList.one: AbstractProduction [ TypeItem ];

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

TypeItem: AbstractType [ AddToFieldList ];

TypeItem: AbstractProduction [ TypeExp, Default ]

End;

SaffronAG7a: Module = Begin

Access: AbstractType [ GetAccessVal ];

Access.empty: AbstractProduction [ ];

Access.public: AbstractProduction [ ];

Access.private: AbstractProduction [ ];

Default: AbstractType [ GetDefaultExpVal ];

Default.empty: AbstractProduction [ ];

Default.gets: AbstractProduction [ ];

Default.getsexp: AbstractProduction [ Exp ];

Default.getstrash: AbstractProduction [ ];

Default.getsexportrash: AbstractProduction [ Exp ];

Ident: AbstractType [ AddNamesToFieldList, PutNewTypeNamesInLocalContext, RecAddArcsfromLVTGNtoTGN, GetIdentInfo, AddNamesToSequence ];

Ident.id: AbstractProduction [ Id ];

Ident.idposition: AbstractProduction [ Id, Position ];

Position: AbstractType [ GetPositionVal ];

Position: AbstractProduction [ Exp, OptBits ];

OptBits: AbstractType [ GetBoundsVal ];

OptBits.absent: AbstractProduction [ ];

OptBits.present: AbstractProduction [ Bounds ];

End;

SaffronAG7b: Module = Begin

IdentList: AbstractType [ AddNamesToFieldList, PutNewTypeNamesInLocalContext, RecAddArcsfromLVTGNtoTGN, MakeNameSequence, AddNamesToSequence ];

IdentList.one: AbstractProduction [ Ident ];

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

Tag: AbstractType [ MakeVariantFlavor, MakeTagType, GetSequenceTagInfo ];

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

Tag.computed: AbstractProduction [ TagType ];

Tag.overlaid: AbstractProduction [ TagType ];

TagType: AbstractType [ MakeTagType ];

TagType.star: AbstractProduction [ ];

TagType.typeexp: AbstractProduction [ TypeExp ];

VariantList: AbstractType [ MakeUnionList, AddVariantsToUnionList, MakeStarTagType, AddVariantNamesToEnumTypeTGN ];

VariantList.one: AbstractProduction [ VariantItem ];

VariantList.more: AbstractProduction [ VariantList, VariantItem ];

VariantItem: AbstractType [ AddVariantsToUnionList, AddVariantNamesToEnumTypeTGN ];

VariantItem: AbstractProduction [ IdList, RecList ];

Packed: AbstractType [ IsKeywordPresent ];

Packed.yes: AbstractProduction [ ];

Packed.no: AbstractProduction [ ]

End;

SaffronAG8: Module = Begin

IdList: AbstractType [ AddNamesToUnionList, AddVariantNamesToEnumTypeTGN, AddIdsToInterfaceTGN ];

IdList.one: AbstractProduction [ Id ];

IdList.more: AbstractProduction [ Id, IdList ];

Ordered: AbstractType [ IsKeywordPresent ];

Ordered.yes: AbstractProduction [ ];

Ordered.no: AbstractProduction [ ];

Base: AbstractType [ IsKeywordPresent ];

Base.yes: AbstractProduction [ ];

Base.no: AbstractProduction [ ];

PointerType: AbstractType [ GetPointerTypeInfo ];

PointerType.unspecified: AbstractProduction [ OptInterval ];

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

OptInterval: AbstractType [ GetBoundsVal ];

OptInterval.absent: AbstractProduction [ ];

OptInterval.present: AbstractProduction [ Interval ];

ReadOnly: AbstractType [ IsKeywordPresent ];

ReadOnly.yes: AbstractProduction [ ];

ReadOnly.no: AbstractProduction [ ];

Safe: AbstractType [ IsKeywordPresent ];

Safe.empty: AbstractProduction [ ];

Safe.yes: AbstractProduction [ ];

Safe.no: AbstractProduction [ ];

TransferMode: AbstractType [ MakeTransferMode ];

TransferMode.proc: AbstractProduction [ ];

TransferMode.port: AbstractProduction [ ];

TransferMode.signal: AbstractProduction [ ];

TransferMode.error: AbstractProduction [ ];

TransferMode.process: AbstractProduction [ ];

TransferMode.program: AbstractProduction [ ];

Arguments: AbstractType [ MakeArgumentLists ];

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

ParameterList: AbstractType [ MakeFieldList ];

ParameterList.empty: AbstractProduction [ ];

ParameterList.any: AbstractProduction [ ];

ParameterList.pairlist: AbstractProduction [ PairList ];

ParameterList.typelist: AbstractProduction [ TypeList ];

Uncounted: AbstractType [ IsKeywordPresent ];

Uncounted.yes: AbstractProduction [ ];

Uncounted.no: AbstractProduction [ ];

TypeApply: AbstractType [ MakeType ];

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 [ MakeEnvironment, Explore ];

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

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

Directory: AbstractType [ ProcessDirectoryClause , ExploreDirectoryClause];

Directory.empty: AbstractProduction [ ];

Directory.more: AbstractProduction [ Directory, IncludeItem ];

IncludeItem: AbstractType [ ProcessDirectoryClause, ExploreDirectoryClause ];

IncludeItem: AbstractProduction [Id.local, IdOrString, Id.moduleName, Using];

IdOrString: AbstractType [RopeFromIdOrString];

IdOrString.id: AbstractProduction [Id];

IdOrString.string: AbstractProduction [String];

IncludeItem: AbstractType [ ProcessDirectoryClause, ExploreDirectoryClause ];

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 [ MakeInterfaceTGN ];

Using.restricted: AbstractProduction [ IdList ];

Using.nothing: AbstractProduction [ ];

Using.unrestricted: AbstractProduction [ ];

DefBody: AbstractType [ MakeContextTree, MakeContextTree1 ];

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