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

SaffronCG.ThreeC4

Shoup, August 7, 1986 4:37:43 pm PDT

Bill Jackson (bj) April 27, 1987 5:21:12 pm PDT

Lucy Hederman July 17, 1987 3:30:10 pm PDT

Include [SaffronBaseDecls, SaffronAG];

SaffronCentral: Control Module;

SaffronCG1: Module = Begin

{

"TC"

"ABS" "ALL" "AND" "ANY" "APPLY" "ARRAY"

"BASE" "BEGIN" "BROADCAST"

"CEDAR" "CHECKED" "CODE" "COMPUTED" "CONS" "CONTINUE"

"DECREASING" "DEFINITIONS" "DEPENDENT" "DESCRIPTOR" "DIRECTORY" "DO"

"ELSE" "ENABLE" "END" "ENDCASE" "ENDLOOP" "ENTRY" "ERROR" "EXIT" "EXITS" "EXPORTS"

"FINISHED" "FIRST" "FOR" "FORK" "FRAME" "FREE" "FROM"

"GO" "GOTO"

"IF" "IMPORTS" "IN" "INLINE" "INTERNAL" "ISTYPE"

"JOIN"

"LAST" "LENGTH" "LIST" "LOCKS" "LONG" "LOOP" "LOOPHOLE"

"MACHINE" "MAX" "MIN" "MOD" "MONITOR" "MONITORED"

"NARROW" "NEW" "NIL" "NOT" "NOTIFY" "NULL"

"OF" "OPEN" "OR" "ORD" "ORDERED" "OVERLAID"

"PACKED" "PAINTED" "POINTER" "PORT" "PRED" "PRIVATE" "PROC" "PROCEDURE" "PROCESS" "PROGRAM" "PUBLIC"

"READONLY" "RECORD" "REF" "REJECT" "RELATIVE" "REPEAT" "RESTART" "RESUME" "RETRY" "RETURN" "RETURNS"

"SAFE" "SELECT" "SEQUENCE" "SHARES" "SIGNAL" "SIZE" "START" "STATE" "STOP" "SUCC"

"THEN" "THROUGH" "TO" "TRANSFER" "TRASH" "TRUSTED" "TYPE"

"UNCHECKED" "UNCOUNTED" "UNSAFE" "UNTIL" "USING"

"VAL" "VAR"

"WAIT" "WHILE" "WITH"

"ZONE"

"!" "#" "(" ")" "*" "+" "," "-" "." ".." "/" ":" ";" "<" "<=" "=" "=>" ">" ">=" "@"

"[" "]" "^" "←" "{" "|" "}" "~"

} : SimpleTokens;

maingoal: NonTerminal Builds Top;

for maingoal ← top

Build top;

top: NonTerminal Builds Top;

for top.modulep ← goal

Build Top.modulep[goal];

for top.scope ← "BEGIN" scope "END"

Build Top.scope[scope];

new grammar production

for top.scope ← "TC" typeCons

Build Top.tc[typeCons];

goal: NonTerminal Builds ModuleP;

for goal.a ← module "."

Build module;

for goal.b ← module ".."

Build module;

module: NonTerminal Builds ModuleP;

for module.impl ← directory identlist cedar proghead trusted checked block

Build ModuleP.impl[directory, identlist, cedar, proghead, checked, block];

for module.def ← directory identlist cedar defhead defbody

Build ModuleP.def[directory, identlist, cedar, defhead, defbody];

directory: NonTerminal Builds Directory;

for directory.a ← "DIRECTORY" ";"

Build Directory.empty[];

for directory.b ← "DIRECTORY" includelist ";"

Build includelist;

for directory.c ← -- << empty >>

Build Directory.empty[];

includelist: NonTerminal Builds Directory;

for includelist.a ← includeitem

Build Directory.more[Directory.empty[[includeitem, includeitem)], includeitem];

for includelist.b ← includelist "," includeitem

Build Directory.more[includelist, includeitem];

includeitem: NonTerminal Builds IncludeItem;

for includeitem.a ← id ":" "FROM" string using

Build IncludeItem.fromp[id, string, using];

for includeitem.b ← id ":" "TYPE" using

Build IncludeItem.type[id, using];

for includeitem.c ← id using

Build IncludeItem.plain[id, using];

for includeitem.d ← id.local ":" "TYPE" id.global using

Build IncludeItem.typeandid[id.local, id.global, using];

using: NonTerminal Builds Using;

for using.nothing ← "USING" "[" "]"

Build Using.nothing[];

for using.restricted ← "USING" "[" idlist "]"

Build Using.restricted[idlist];

for using.unrestricted ← -- << empty >>

Build Using.unrestricted[];

defbody: NonTerminal Builds DefBody;

for defbody.a ← "BEGIN" open declist "END"

Build DefBody[open, declist];

for defbody.b ← "BEGIN" open declist ";" "END"

Build DefBody[open, declist];

for defbody.c ← "{" open declist "}"

Build DefBody[open, declist];

for defbody.d ← "{" open declist ";" "}"

Build DefBody[open, declist];

defhead: NonTerminal Builds DefHead;

for defhead ← definitions locks imports shares tilde public

Build DefHead[locks, imports, shares, public];

definitions: NonTerminal Builds Junk;

for definitions ← "DEFINITIONS"

Build Junk[];

cedar: NonTerminal Builds Cedar;

for cedar.yes ← "CEDAR"

Build Cedar.yes[];

for cedar.no ← -- << empty >>

Build Cedar.no[];

proghead: NonTerminal Builds ProgHead;

for proghead ← resident safe class arguments locks interface tilde public

Build ProgHead[safe, class, arguments, locks, interface, public];

resident: NonTerminal Builds Junk;

for resident ← -- << empty >>

Build Junk[];

class: NonTerminal Builds Class;

for class.program ← "PROGRAM"

Build Class.program[];

for class.monitor ← "MONITOR"

Build Class.monitor[];

interface: NonTerminal Builds Interface;

for interface ← imports exports shares

Build Interface[imports, exports, shares];

exports: NonTerminal Builds ModuleList;

for exports.a ← "EXPORTS"

Build ModuleList.empty[];

for exports.b ← "EXPORTS" modulelist

Build modulelist;

for exports.c ← -- << empty >>

Build ModuleList.empty[];

binditem: NonTerminal Builds BindItem;

for binditem.a ← exp

Build BindItem.unnamed[exp];

for binditem.b ← id ":" exp

Build BindItem.named[id, exp];

for binditem.c ← id "~" "~" exp

Build BindItem.named[id, exp];

caselabel: NonTerminal Builds SelectLabel;

for caselabel.type ← ident typeexp

Build SelectLabel.type[ident, typeexp];

for caselabel.test ← caselabelP

Build SelectLabel.test[caselabelP];

caselabelP: NonTerminal Builds SelectTestList;

for caselabelP.one ← casetest

Build SelectTestList.one[casetest];

for caselabelP.more ← caselabelP "," casetest

Build SelectTestList.more[caselabelP, casetest];

casetest: NonTerminal Builds Relation;

for casetest.a ← optrelation

Build optrelation;

for casetest.b ← exp

Build Relation.positive[RelationTail.relop[Relop.eq[[exp, exp)], exp]];

insert position info ???

block: NonTerminal Builds Block;

for block.a ← "BEGIN" scope exits "END"

Build Block[scope, exits];

for block.b ← "{" scope exits "}"

Build Block[scope, exits];

exits: NonTerminal Builds ExitList;

for exits.list ← "EXITS" exitlist

Build exitlist;

for exits.empty ←

Build ExitList.empty[];

public: NonTerminal Builds Access;

for public.public ← "PUBLIC"

Build Access.public[];

for public.private ← "PRIVATE"

Build Access.private[];

for public.empty ← -- << empty >>

Build Access.empty[];

End;

SaffronCG2: Module = Begin

bounds: NonTerminal Builds Bounds;

for bounds ← exp.lower ".." exp.upper

Build Bounds[Bound[exp.lower], Bound[exp.upper]];

checked: NonTerminal Builds Checked;

for checked.empty ← -- << empty >>

Build Checked.empty[];

for checked.checked ← "CHECKED"

Build Checked.checked[];

for checked.trusted ← "TRUSTED"

Build Checked.trusted[];

for checked.unchecked ← "UNCHECKED"

Build Checked.unchecked[];

default: NonTerminal Builds Default;

for default.a ← "←" defaultopt

Build defaultopt;

for default.empty ← -- << empty >>

Build Default.empty[];

positionP: NonTerminal Builds Position;

for positionP ← "(" exp optbits ")"

Build Position[exp, optbits];

optbits: NonTerminal Builds OptBits;

for optbits.present ← ":" bounds

Build OptBits.present[bounds];

for optbits.absent ← -- << empty >>

Build OptBits.absent[];

sum: NonTerminal Builds Exp;

for sum.sum ← sum addop product

Build Exp.sum[sum, addop, product];

for sum.product ← product

Build product;

product: NonTerminal Builds Exp;

for product.product ← product multop factor

Build Exp.product[product, multop, factor];

for product.factor ← factor

Build factor;

multop: NonTerminal Builds MultOp;

for multop.times ← "*"

Build MultOp.times[];

for multop.divide ← "/"

Build MultOp.divide[];

for multop.mod ← "MOD"

Build MultOp.mod[];

factor: NonTerminal Builds Exp;

for factor.unarysum ← addop primary

Build Exp.unarysum[addop, primary];

for factor.primary ← primary

Build primary;

addop: NonTerminal Builds AddOp;

for addop.plus ← "+"

Build AddOp.plus[];

for addop.minus ← "-"

Build AddOp.minus[];

readonly: NonTerminal Builds ReadOnly;

for readonly.yes ← "READONLY"

Build ReadOnly.yes[];

for readonly.no ← -- << empty >>

Build ReadOnly.no[];

catchany: NonTerminal Builds CatchAny;

for catchany ← "ANY" "=>" statement

Build CatchAny.present[statement];

interval: NonTerminal Builds Interval;

for interval.cc ← "[" bounds "]"

Build Interval.cc[bounds];

for interval.oc ← "(" bounds "]"

Build Interval.oc[bounds];

for interval.co ← "[" bounds ")"

Build Interval.co[bounds];

for interval.oo ← "(" bounds ")"

Build Interval.oo[bounds];

exp: NonTerminal Builds Exp;

for exp.ifthenelse ← "IF" exp.cond "THEN" exp.thenpart "ELSE" exp.elsepart

Build Exp.ifthenelse[exp.cond, exp.thenpart, exp.elsepart];

for exp.select ← casehead caseexplist "ENDCASE" "=>" exp

Build Exp.select[casehead, caseexplist, exp];

for exp.assign ← lhs "←" exp

Build Exp.assign[lhs, exp];

for exp.multiassign ← "[" explist "]" "←" exp

Build Exp.multiassign[explist, exp];

for exp.error ← "ERROR"

Build Exp.error[];

for exp.transfer ← transferop lhs

Build Exp.transfer[transferop, lhs];

for exp.disjunct ← disjunct

Build disjunct;

caseexplist: NonTerminal Builds SelectExpList;

for caseexplist.empty ← -- << empty >>

Build SelectExpList.empty[];

for caseexplist.b ← caseexplistP

Build caseexplistP;

for caseexplist.c ← caseexplistP ","

Build caseexplistP;

caseexplistP: NonTerminal Builds SelectExpList;

for caseexplistP.a ← caseexpitem

Build SelectExpList.more[
SelectExpList.empty[[caseexpitem, caseexpitem)],
caseexpitem
];

for caseexplistP.b ← caseexplistP "," caseexpitem

Build SelectExpList.more[caseexplistP, caseexpitem];

caseexpitem: NonTerminal Builds SelectExpItem;

for caseexpitem ← caselabel "=>" exp

Build SelectExpItem[caselabel, exp]

End;

SaffronCG3: Module = Begin

transferop: NonTerminal Builds TransferOp;

for transferop.signal ← "SIGNAL"

Build TransferOp.signal[];

for transferop.error ← "ERROR"

Build TransferOp.error[];

for transferop.start ← "START"

Build TransferOp.start[];

for transferop.join ← "JOIN"

Build TransferOp.join[];

for transferop.new ← "NEW"

Build TransferOp.new[];

for transferop.fork ← "FORK"

Build TransferOp.fork[];

disjunct: NonTerminal Builds Exp;

for disjunct.or ← disjunct "OR" conjunct

Build Exp.or[disjunct, conjunct];

for disjunct.conjunct ← conjunct

Build conjunct;

conjunct: NonTerminal Builds Exp;

for conjunct.and ← conjunct "AND" negation

Build Exp.and[conjunct, negation];

for conjunct.negation ← negation

Build negation;

negation: NonTerminal Builds Exp;

for negation.a ← "~" relation

Build Exp.not[relation];

for negation.b ← "NOT" relation

Build Exp.not[relation];

for negation.relation ← relation

Build relation;

relation: NonTerminal Builds Exp;

for relation.relation ← sum optrelation

Build Exp.relation[sum, optrelation];

for relation.sum ← sum

Build sum;

catchlist: NonTerminal Builds Catch;

for catchlist.a ← catchhead catchcase

Build Catch[
CatchCaseList.more[catchhead, catchcase],
CatchAny.absent[(catchcase, catchcase]]
];

for catchlist.b ← catchhead

Build Catch[catchhead,
CatchAny.absent[(catchhead, catchhead]]
];

for catchlist.c ← catchhead catchany

Build Catch[catchhead, catchany];

for catchlist.d ← catchhead catchany ";"

Build Catch[catchhead, catchany];

catchhead: NonTerminal Builds CatchCaseList;

for catchhead.empty ← -- << empty >>

Build CatchCaseList.empty[];

for catchhead.more ← catchhead catchcase ";"

Build CatchCaseList.more[catchhead, catchcase];

ident: NonTerminal Builds Ident;

for ident.idposition ← id positionP ":"

Build Ident.idposition[id, positionP];

for ident.id ← id ":"

Build Ident.id[id];

typeop: NonTerminal Builds TypeOp;

for typeop.code ← "CODE"

Build TypeOp.code[];

for typeop.first ← "FIRST"

Build TypeOp.first[];

for typeop.last ← "LAST"

Build TypeOp.last[];

for typeop.nil ← "NIL"

Build TypeOp.nil[];

idlist: NonTerminal Builds IdList;

for idlist ← idlistP

Build idlistP;

idlistP: NonTerminal Builds IdList;

for idlistP.one ← id

Build IdList.one[id];

for idlistP.more ← id "," idlistP

Build IdList.more[id, idlistP];

arguments: NonTerminal Builds Arguments;

for arguments ← arglist returnlist

Build Arguments[arglist, returnlist];

arglist: NonTerminal Builds ParameterList;

for arglist.any ← "ANY"

Build ParameterList.any[];

for arglist.fieldlist ← fieldlist

Build fieldlist;

for arglist.empty ← -- << empty >>

Build ParameterList.empty[];

returnlist: NonTerminal Builds ParameterList;

for returnlist.any ← "RETURNS" "ANY"

Build ParameterList.any[];

for returnlist.fieldlist ← "RETURNS" fieldlist

Build fieldlist;

for returnlist.empty ← -- << empty >>

Build ParameterList.empty[];

fieldlist: NonTerminal Builds ParameterList;

for fieldlist.empty ← "[" "]"

Build ParameterList.empty[];

for fieldlist.pairlist ← "[" pairlist "]"

Build ParameterList.pairlist[pairlist];

for fieldlist.typelist ← "[" typelist "]"

Build ParameterList.typelist[typelist];

typeexp: NonTerminal Builds TypeExp;

for typeexp.a ← id

Build TypeExp.typeid[TypeId.id[id]];

for typeexp.b ← typeid

Build TypeExp.typeid[typeid];

for typeexp.c ← typecons

Build typecons;

the following nonterminal was added to handle the several varieties of numbers recognized by IO.GetCedarToken

num: NonTerminal Builds Num;

for num.decimal ← decimalnum

Build Num.decimal[decimalnum];

for num.octal ← octalnum

Build Num.octal[octalnum];

for num.hex ← hexnum

Build Num.hex[hexnum];

lhs: NonTerminal Builds Exp;

for lhs.id ← id

Build Exp.id[id];

for lhs.num ← num -- several cases here

Build Exp.num[num];

for lhs.string ← string

Build Exp.string[string];

for lhs.lnum ← lnum shouldn't be a lexical entity

Build Exp.lnum[lnum];

for lhs.flnum ← flnum

Build Exp.flnum[flnum];

for lhs.char ← char

Build Exp.char[char];

for lhs.lstring ← lstring can't recognize due to IO.GetCedarToken limitation

Build Exp.lstring[lstring];

for lhs.atom ← atom

Build Exp.atom[atom];

for lhs.narrow ← "NARROW" "[" exp opttype optcatch "]"

Build Exp.narrow[exp, opttype, optcatch];

for lhs.loophole ← "LOOPHOLE" "[" exp opttype "]"

Build Exp.loophole[exp, opttype];

for lhs.apply ← "APPLY" "[" exp.rator "," exp.rand optcatch "]"

Build Exp.apply[exp.rator, exp.rand, optcatch];

for lhs.exp ← "(" exp ")"

Build exp;

for lhs.qualifier ← lhs qualifier

Build Exp.qualifier[lhs, qualifier];

qualifier: NonTerminal Builds Qualifier;

for qualifier.prefixop ← "." prefixop

Build Qualifier.prefixop[prefixop];

for qualifier.typeop ← "." typeop

Build Qualifier.typeop[typeop];

for qualifier.size ← "." "SIZE"

Build Qualifier.size[];

for qualifier.apply ← "[" explist optcatch "]"

Build Qualifier.apply[explist, optcatch];

for qualifier.select ← "." id

Build Qualifier.select[id];

for qualifier.indirect ← "^"

Build Qualifier.indirect[];

exitlist: NonTerminal Builds ExitList;

for exitlist.empty ← -- << empty >>

Build ExitList.empty[];

for exitlist.b ← exitlistP

Build exitlistP;

for exitlist.c ← exitlistP ";"

Build exitlistP;

exitlistP: NonTerminal Builds ExitList;

for exitlistP.a ← exititem

Build ExitList.more[ExitList.empty[[exititem, exititem)], exititem];

for exitlistP.b ← exitlistP ";" exititem

Build ExitList.more[exitlistP, exititem];

exititem: NonTerminal Builds ExitItem;

for exititem ← idlist "=>" statement

Build ExitItem[idlist, statement];

optexp: NonTerminal Builds OptExp;

for optexp.trash ← trash

Build OptExp.trash[];

for optexp.exp ← exp

Build OptExp.exp[exp];

for optexp.empty ← -- << empty >>

Build OptExp.empty[];

catchcase: NonTerminal Builds CatchCase;

for catchcase ← lhslist "=>" statement

Build CatchCase[lhslist, statement];

lhslist: NonTerminal Builds SignalList;

for lhslist.one ← lhs

Build SignalList.one[lhs];

for lhslist.more ← lhslist "," lhs

Build SignalList.more[lhslist, lhs];

initialization: NonTerminal Builds Initialization;

for initialization.empty ← -- << empty >>

Build Initialization.empty[];

for initialization.assignment ← "←" initvalue

Build Initialization.assignment[initvalue];

for initialization.binding ← tilde initvalue

Build Initialization.binding[initvalue];

initvalue: NonTerminal Builds InitialValue;

for initvalue.block ← procaccess trusted checked inline block

Build InitialValue.block[checked, inline, block];

for initvalue.code ← "CODE"

Build InitialValue.code[];

for initvalue.c ← procaccess trusted checked

"MACHINE" "CODE" "BEGIN" codelist "END"

Build InitialValue.machinecode[checked, codelist];

for initvalue.d ← procaccess trusted checked

"MACHINE" "CODE" "{" codelist "}"

Build InitialValue.machinecode[checked, codelist];

for initvalue.trash ← trash

Build InitialValue.trash[];

for initvalue.exp ← exp

Build InitialValue.exp[exp];

procaccess: NonTerminal Builds Junk;

for procaccess ← -- << empty >>

Build Junk[];

inline: NonTerminal Builds Inline;

for inline.yes ← "INLINE"

Build Inline.yes[];

for inline.no ← -- << empty >>

Build Inline.no[];

codelist: NonTerminal Builds CodeList;

for codelist.one ← orderlist

Build CodeList.one[orderlist];

for codelist.more ← codelist ";" orderlist

Build CodeList.more[codelist, orderlist]

End;

SaffronCG4: Module = Begin

range: NonTerminal Builds Range;

for range.a ← id

Build Range.typeid[TypeId.id[id]];

for range.b ← id interval

Build Range.subrange[Subrange.named[TypeId.id[id], interval]];

for range.c ← typeid interval

Build Range.subrange[Subrange.named[typeid, interval]];

for range.d ← interval

Build Range.subrange[Subrange.unnamed[interval]];

for range.e ← typeid

Build Range.typeid[typeid];

trash: NonTerminal Builds Junk;

for trash.trash ← "TRASH"

Build Junk[];

for trash.null ← "NULL"

Build Junk[];

defaultopt: NonTerminal Builds Default;

for defaultopt.getstrash ← trash

Build Default.getstrash[];

for defaultopt.getsexportrash ← exp "|" trash

Build Default.getsexportrash[exp];

for defaultopt.gets ← -- << empty >>

Build Default.gets[];

for defaultopt.getsexp ← exp

Build Default.getsexp[exp];

orderlist: NonTerminal Builds OrderList;

for orderlist.one ← optexp

Build OrderList.one[optexp];

for orderlist.more ← orderlist "," optexp

Build OrderList.more[orderlist, optexp];

trusted: NonTerminal Builds Junk;

for trusted ← -- << empty >>

Build Junk[];

optrelation: NonTerminal Builds Relation;

for optrelation.negative ← "NOT" relationtail

Build Relation.negative[relationtail];

for optrelation.positive ← relationtail

Build Relation.positive[relationtail];

relationtail: NonTerminal Builds RelationTail;

for relationtail.range ← "IN" range

Build RelationTail.range[range];

for relationtail.relop ← relop sum

Build RelationTail.relop[relop, sum];

relop: NonTerminal Builds Relop;

for relop.eq ← "=" Build Relop.eq[];

for relop.ne ← "#" Build Relop.ne[];

for relop.lt ← "<" Build Relop.lt[];

for relop.le ← "<=" Build Relop.le[];

for relop.gt ← ">" Build Relop.gt[];

for relop.ge ← ">=" Build Relop.ge[];

shares: NonTerminal Builds Shares;

for shares.present ← "SHARES" idlist

Build Shares.present[idlist];

for shares.absent ← -- << empty >>

Build Shares.absent[];

statement: NonTerminal Builds Statement;

for statement.ifthen ← "IF" exp "THEN" statement

Build Statement.ifthen[exp, statement];

for statement.ifthenelse ← "IF" exp "THEN" balstmt "ELSE" statement

Build Statement.ifthenelse[exp, balstmt, statement];

for statement.select ← casehead casestmtlist "ENDCASE" "=>" statement

Build Statement.select[casehead, casestmtlist, OptStatement.present[statement]];

for statement.basicstmt ← basicstmt

Build basicstmt;

balstmt: NonTerminal Builds Statement;

for balstmt.ifthenelse ← "IF" exp "THEN" balstmt.thenpart "ELSE" balstmt.elsepart

Build Statement.ifthenelse[exp, balstmt.thenpart, balstmt.elsepart];

for balstmt.select ← casehead casestmtlist "ENDCASE" "=>" balstmt

Build Statement.select[casehead, casestmtlist, OptStatement.present[balstmt]];

for balstmt.basicstmt ← basicstmt

Build basicstmt;

basicstmt: NonTerminal Builds Statement;

for basicstmt.exp ← lhs

Build Statement.exp[lhs];

for basicstmt.assign ← lhs "←" exp

Build Statement.assign[lhs, exp];

for basicstmt.multiassign ← "[" explist "]" "←" exp

Build Statement.multiassign[explist, exp];

for basicstmt.block ← trusted checked block

Build Statement.block[checked, block];

for basicstmt.select ← casehead casestmtlist "ENDCASE"

Build Statement.select[casehead, casestmtlist,
OptStatement.absent[(casestmtlist, casestmtlist]]];

for basicstmt.loopcontrol ← forclause dotest "DO" scope doexit "ENDLOOP"

Build Statement.loopcontrol[forclause, dotest, scope, doexit];

for basicstmt.exit ← "EXIT"

Build Statement.exit[];

for basicstmt.loop ← "LOOP"

Build Statement.loop[];

for basicstmt.i ← "GOTO" id

Build Statement.goto[id];

for basicstmt.j ← "GO" "TO" id

Build Statement.goto[id];

for basicstmt.return ← "RETURN" optargs

Build Statement.return[optargs];

for basicstmt.transfer ← transfer lhs

Build Statement.transfer[transfer, lhs];

for basicstmt.free ← free "[" exp optcatch "]"

Build Statement.free[free, exp, optcatch];

for basicstmt.wait ← "WAIT" lhs

Build Statement.wait[lhs];

for basicstmt.error ← "ERROR"

Build Statement.error[];

for basicstmt.stop ← "STOP"

Build Statement.stop[];

for basicstmt.null ← "NULL"

Build Statement.null[];

for basicstmt.resume ← "RESUME" optargs

Build Statement.resume[optargs];

for basicstmt.reject ← "REJECT"

Build Statement.reject[];

for basicstmt.continue ← "CONTINUE"

Build Statement.continue[];

for basicstmt.retry ← "RETRY"

Build Statement.retry[];

for basicstmt.getstate ← lhs "←" "STATE"

Build Statement.getstate[lhs];

for basicstmt.setstate ← "STATE" "←" exp

Build Statement.setstate[exp];

forclause: NonTerminal Builds ForClause;

for forclause.assignation ← "FOR" controlid "←" exp.initial "," exp.next

Build ForClause.assignation[controlid, exp.initial, exp.next];

for forclause.iteration ← "FOR" controlid direction "IN" range

Build ForClause.iteration[controlid, direction, range];

for forclause.repetition ← "THROUGH" range

Build ForClause.repetition[range];

for forclause.empty ← -- << empty >>

Build ForClause.empty[];

controlid: NonTerminal Builds ControlId;

for controlid.new ← ident typeexp

Build ControlId.new[ident, typeexp];

for controlid.old ← id

Build ControlId.old[id];

direction: NonTerminal Builds Decreasing;

for direction.yes ← "DECREASING"

Build Decreasing.yes[];

for direction.no ← -- << empty >>

Build Decreasing.no[];

doexit: NonTerminal Builds DoExit;

for doexit.a ← -- << empty >>

Build DoExit[ExitList.empty[], OptStatement.absent[]];

for doexit.b ← "REPEAT" exitlist

Build DoExit[exitlist, OptStatement.absent[(exitlist, exitlist]]];

for doexit.c ← "REPEAT" exitlist "FINISHED" "=>" statement

Build DoExit[exitlist, OptStatement.present[statement]];

for doexit.d ← "REPEAT" exitlist "FINISHED" "=>" statement ";"

Build DoExit[exitlist, OptStatement.present[statement]];

transfer: NonTerminal Builds Transfer;

for transfer.signal ← "SIGNAL"

Build Transfer.signal[];

for transfer.error ← "ERROR"

Build Transfer.error[];

for transfer.returnwitherror ← "RETURN" "WITH" "ERROR"

Build Transfer.returnwitherror[];

for transfer.start ← "START"

Build Transfer.start[];

for transfer.restart ← "RESTART"

Build Transfer.restart[];

for transfer.join ← "JOIN"

Build Transfer.join[];

for transfer.notify ← "NOTIFY"

Build Transfer.notify[];

for transfer.broadcast ← "BROADCAST"

Build Transfer.broadcast[];

for transfer.transferwith ← "TRANSFER" "WITH"

Build Transfer.transferwith[];

for transfer.returnwith ← "RETURN" "WITH"

Build Transfer.returnwith[]

End;

SaffronCG5: Module = Begin

dotest: NonTerminal Builds DoTest;

for dotest.until ← "UNTIL" exp

Build DoTest.until[exp];

for dotest.while ← "WHILE" exp

Build DoTest.while[exp];

for dotest.empty ← -- << empty >>

Build DoTest.empty[];

optargs: NonTerminal Builds OptArgs;

for optargs.explist ← "[" explist "]"

Build OptArgs.explist[explist];

for optargs.empty ← -- << empty >>

Build OptArgs.empty[];

for optargs.exp ← lhs

Build OptArgs.exp[lhs];

free: NonTerminal Builds Free;

for free.plain ← "FREE"

Build Free.plain[];

for free.zoned ← lhs "." "FREE"

Build Free.zoned[lhs];

casestmtlist: NonTerminal Builds SelectStmtList;

for casestmtlist.empty ← -- << empty >>

Build SelectStmtList.empty[];

for casestmtlist.b ← casestmtlistP

Build casestmtlistP;

for casestmtlist.c ← casestmtlistP ";"

Build casestmtlistP;

casestmtlistP: NonTerminal Builds SelectStmtList;

for casestmtlistP.a ← casestmtitem

Build SelectStmtList.more[
SelectStmtList.empty[[casestmtitem, casestmtitem)],
casestmtitem];

for casestmtlistP.b ← casestmtlistP ";" casestmtitem

Build SelectStmtList.more[casestmtlistP, casestmtitem];

casestmtitem: NonTerminal Builds SelectStmtItem;

for casestmtitem ← caselabel "=>" statement

Build SelectStmtItem[caselabel, statement];

declist: NonTerminal Builds DecList;

for declist.one ← declaration

Build DecList.one[declaration];

for declist.many ← declist ";" declaration

Build DecList.many[declist, DecList.one[declaration]];

declaration: NonTerminal Builds Declaration;

for declaration.value ← identlist public entry readonly typeexp initialization

Build Declaration.value[identlist, public, entry, readonly, typeexp, initialization];

for declaration.type ← identlist public.id "TYPE" tilde public.type typeexp default

Build Declaration.type[identlist, public.id, public.type, typeexp, default];

for declaration.opaquetype ← identlist public "TYPE" optsize

Build Declaration.opaquetype[identlist, public, optsize];

entry: NonTerminal Builds Entry;

for entry.entry ← "ENTRY"

Build Entry.entry[];

for entry.internal ← "INTERNAL"

Build Entry.internal[];

for entry.empty ← -- << empty >>

Build Entry.empty[];

optsize: NonTerminal Builds OptSize;

for optsize.present ← "[" exp "]"

Build OptSize.present[exp];

for optsize.absent ← -- << empty >>

Build OptSize.absent[];

primary: NonTerminal Builds Exp;

for primary.explist ← "[" explist "]"

Build Exp.explist[explist];

for primary.prefixop ← prefixop "[" orderlist "]"

Build Exp.prefixop[prefixop, orderlist];

for primary.val ← "VAL" "[" orderlist "]"

Build Exp.val[orderlist];

for primary.all ← "ALL" "[" orderlist "]"

Build Exp.all[orderlist];

for primary.new ← new "[" typeexp initialization optcatch "]"

Build Exp.new[new, typeexp, initialization, optcatch];

for primary.cons ← cons "[" explist optcatch "]"

Build Exp.cons[cons, explist, optcatch];

for primary.listcons ← listcons "[" explist "]"

Build Exp.listcons[listcons, explist];

for primary.nil ← "NIL"

Build Exp.nil[];

for primary.typeop ← typeop "[" typeexp "]"

Build Exp.typeop[typeop, typeexp];

for primary.size ← "SIZE" "[" typeexp "]"

Build Exp.size[typeexp];

for primary.size2 ← "SIZE" "[" typeexp "," exp "]"

Build Exp.size2[typeexp, exp];

for primary.istype ← "ISTYPE" "[" exp "," typeexp "]"

Build Exp.istype[exp, typeexp];

for primary.address ← "@" lhs

Build Exp.address[lhs];

for primary.descriptor ← "DESCRIPTOR" "[" desclist "]"

Build Exp.descriptor[desclist];

for primary.lhs ← lhs

Build lhs;

new: NonTerminal Builds New;

for new.plain ← "NEW"

Build New.plain[];

for new.zoned ← lhs "." "NEW"

Build New.zoned[lhs];

cons: NonTerminal Builds Cons;

for cons.plain ← "CONS"

Build Cons.plain[];

for cons.zoned ← lhs "." "CONS"

Build Cons.zoned[lhs];

listcons: NonTerminal Builds ListCons;

for listcons.plain ← "LIST"

Build ListCons.plain[];

for listcons.zoned ← lhs "." "LIST"

Build ListCons.zoned[lhs];

desclist: NonTerminal Builds DescList;

for desclist.explicit ← exp.base "," exp.length opttype

Build DescList.explicitlength[exp.base, exp.length, opttype];

for desclist.default ← exp

Build DescList.defaultlength[exp];

optcatch: NonTerminal Builds Catch;

for optcatch.catchlist ← "!" catchlist

Build catchlist;

for optcatch.empty ← -- << empty >>

Build Catch[CatchCaseList.empty[], CatchAny.absent[]];

identlist: NonTerminal Builds IdentList;

for identlist ← identlistP

Build identlistP;

identlistP: NonTerminal Builds IdentList;

for identlistP.a ← id ":"

Build IdentList.one[Ident.id[id]];

for identlistP.b ← id positionP ":"

Build IdentList.one[Ident.idposition[id, positionP]];

for identlistP.c ← id "," identlistP

Build IdentList.many[IdentList.one[Ident.id[id]], identlistP];

for identlistP.d ← id positionP "," identlistP

Build IdentList.many[IdentList.one[Ident.idposition[id, positionP]], identlistP];

prefixop: NonTerminal Builds PrefixOp;

for prefixop.long ← "LONG"

Build PrefixOp.long[];

for prefixop.abs ← "ABS"

Build PrefixOp.abs[];

for prefixop.pred ← "PRED"

Build PrefixOp.pred[];

for prefixop.succ ← "SUCC"

Build PrefixOp.succ[];

for prefixop.ord ← "ORD"

Build PrefixOp.ord[];

for prefixop.min ← "MIN"

Build PrefixOp.min[];

for prefixop.max ← "MAX"

Build PrefixOp.max[];

for prefixop.base ← "BASE"

Build PrefixOp.base[];

for prefixop.length ← "LENGTH"

Build PrefixOp.length[]

End;

SaffronCG6: Module = Begin

typecons: NonTerminal Builds TypeExp;

for typecons.a ← interval

Build TypeExp.subrange[Subrange.unnamed[interval]];

for typecons.b ← id interval

Build TypeExp.subrange[Subrange.named[TypeId.id[id], interval]];

for typecons.c ← typeid interval

Build TypeExp.subrange[Subrange.named[typeid, interval]];

for typecons.enum ← dependent "{" elementlist "}"

Build TypeExp.enum[dependent, elementlist];

for typecons.record ← dependent monitored "RECORD" reclist

Build TypeExp.record[dependent, monitored, reclist];

for typecons.pointer ← ordered base pointertype

Build TypeExp.pointer[ordered, base, pointertype];

for typecons.var ← "VAR" typeexp

Build TypeExp.var[typeexp];

for typecons.ref ← "REF" readonly typeexp

Build TypeExp.ref[readonly, typeexp];

for typecons.refany ← "REF" readonly "ANY"

Build TypeExp.refany[readonly];

for typecons.refunspecified ← "REF"

Build TypeExp.refunspecified[];

for typecons.list ← "LIST" "OF" readonly typeexp

Build TypeExp.list[readonly, typeexp];

for typecons.array ← packed "ARRAY" indextype "OF" typeexp

Build TypeExp.array[packed, indextype, typeexp];

for typecons.descriptor ← "DESCRIPTOR" "FOR" readonly typeexp

Build TypeExp.descriptor[readonly, typeexp];

for typecons.transfer ← safe transfermode arguments

Build TypeExp.transfer[safe, transfermode, arguments];

for typecons.o ← id "RELATIVE" typeexp

Build TypeExp.relative[TypeId.id[id], typeexp];

for typecons.p ← typeid "RELATIVE" typeexp

Build TypeExp.relative[typeid, typeexp];

for typecons.zone ← heap "ZONE"

Build TypeExp.zone[heap];

for typecons.long ← "LONG" typeexp

Build TypeExp.long[typeexp];

for typecons.frame ← "FRAME" "[" id "]"

Build TypeExp.frame[id];

for typecons.t ← id "PAINTED" typeexp

Build TypeExp.painted[TypeId.id[id], typeexp];

for typecons.u ← typeid "PAINTED" typeexp

Build TypeExp.painted[typeid, typeexp];

for typecons.typeapply ← typeappl

Build TypeExp.typeapply[typeappl];

dependent: NonTerminal Builds MachineDependent;

for dependent.yes ← "MACHINE" "DEPENDENT"

Build MachineDependent.yes[];

for dependent.no ← -- << empty >>

Build MachineDependent.no[];

monitored: NonTerminal Builds Monitored;

for monitored.yes ← "MONITORED"

Build Monitored.yes[];

for monitored.no ← -- << empty >>

Build Monitored.no[];

ordered: NonTerminal Builds Ordered;

for ordered.yes ← "ORDERED"

Build Ordered.yes[];

for ordered.no ← -- << empty >>

Build Ordered.no[];

base: NonTerminal Builds Base;

for base.yes ← "BASE"

Build Base.yes[];

for base.no ← -- << empty >>

Build Base.no[];

pointertype: NonTerminal Builds PointerType;

for pointertype.unspecified ← pointerprefix

Build PointerType.unspecified[pointerprefix];

for pointertype.specified ← pointerprefix "TO" readonly typeexp

Build PointerType.specified[pointerprefix, readonly, typeexp];

pointerprefix: NonTerminal Builds OptInterval;

for pointerprefix.absent ← "POINTER"

Build OptInterval.absent[];

for pointerprefix.present ← "POINTER" interval

Build OptInterval.present[interval];

indextype: NonTerminal Builds OptType;

for indextype.present ← typeexp

Build OptType.present[typeexp];

for indextype.absent ← -- << empty >>

Build OptType.absent[];

transfermode: NonTerminal Builds TransferMode;

for transfermode.a ← "PROCEDURE"

Build TransferMode.proc[];

for transfermode.b ← "PROC"

Build TransferMode.proc[];

for transfermode.port ← "PORT"

Build TransferMode.port[];

for transfermode.signal ← "SIGNAL"

Build TransferMode.signal[];

for transfermode.error ← "ERROR"

Build TransferMode.error[];

for transfermode.process ← "PROCESS"

Build TransferMode.process[];

for transfermode.program ← "PROGRAM"

Build TransferMode.program[];

elementlist: NonTerminal Builds ElementList;

for elementlist.empty ← -- << empty >>

Build ElementList.empty[];

for elementlist.b ← elementlistP

Build elementlistP;

elementlistP: NonTerminal Builds ElementList;

for elementlistP.a ← element

Build ElementList.more[ElementList.empty[[element, element)], element];

for elementlistP.b ← elementlistP "," element

Build ElementList.more[elementlistP, element];

element: NonTerminal Builds Element;

for element.idwithrep ← id "(" exp ")"

Build Element.idwithrep[id, exp];

for element.anon ← "(" exp ")"

Build Element.anonymousrep[exp];

for element.id ← id

Build Element.id[id];

heap: NonTerminal Builds Uncounted;

for heap.yes ← "UNCOUNTED"

Build Uncounted.yes[];

for heap.no ← -- << empty >>

Build Uncounted.no[];

typeappl: NonTerminal Builds TypeApply;

for typeappl.a ← typeappl "." id

Build TypeApply.moreids[typeappl, id];

for typeappl.b ← id lengthP

Build TypeApply.one[TypeId.id[id], lengthP];

for typeappl.c ← typeid lengthP

Build TypeApply.one[typeid, lengthP];

for typeappl.d ← typeappl lengthP

Build TypeApply.morelengths[typeappl, lengthP];

lengthP: NonTerminal Builds Exp;

for lengthP ← "[" exp "]"

Build exp;

reclist: NonTerminal Builds RecList;

for reclist.a ← "[" "]"

Build RecList.empty[];

for reclist.b ← "NULL"

Build RecList.empty[];

for reclist.c ← "[" pairlist "]"

Build RecList.pairlist[pairlist];

for reclist.d ← "[" typelist "]"

Build RecList.typelist[typelist];

for reclist.e ← "[" pairlist "," variantpair "]"

Build RecList.pairlist[PairList.many[pairlist, PairList.one[variantpair]]];

for reclist.f ← "[" variantpart default "]"

Build RecList.typelist[TypeList.one[TypeItem[variantpart, default]]];

for reclist.g ← "[" variantpair "]"

Build RecList.pairlist[PairList.one[variantpair]];

variantpair: NonTerminal Builds PairItem;

for variantpair ← identlist public variantpart default

Build PairItem[identlist, public, variantpart, default];

variantpart: NonTerminal Builds TypeExp;

for variantpart.a ← "SELECT" vcasehead "FROM" variantlist "ENDCASE"

Build TypeExp.union[vcasehead, variantlist];

for variantpart.b ← "SELECT" vcasehead "FROM" variantlist "," "ENDCASE"

Build TypeExp.union[vcasehead, variantlist];

for variantpart.c ← packed "SEQUENCE" vcasehead "OF" typeexp

Build TypeExp.sequence[packed, vcasehead, typeexp];

vcasehead: NonTerminal Builds Tag;

for vcasehead.ident ← ident public tagtype

Build Tag.ident[ident, public, tagtype];

for vcasehead.computed ← "COMPUTED" tagtype

Build Tag.computed[tagtype];

for vcasehead.overlaid ← "OVERLAID" tagtype

Build Tag.overlaid[tagtype];

tagtype: NonTerminal Builds TagType;

for tagtype.star ← "*"

Build TagType.star[];

for tagtype.typeexp ← typeexp

Build TagType.typeexp[typeexp];

variantlist: NonTerminal Builds VariantList;

for variantlist.one ← variantitem

Build VariantList.one[variantitem];

for variantlist.more ← variantlist "," variantitem

Build VariantList.more[variantlist, variantitem];

variantitem: NonTerminal Builds VariantItem;

for variantitem ← idlist "=>" reclist

Build VariantItem[idlist, reclist];

packed: NonTerminal Builds Packed;

for packed.yes ← "PACKED"

Build Packed.yes[];

for packed.no ← -- << empty >>

Build Packed.no[];

imports: NonTerminal Builds ModuleList;

for imports.a ← "IMPORTS"

Build ModuleList.empty[];

for imports.b ← "IMPORTS" modulelist

Build modulelist;

for imports.c ← -- << empty >>

Build ModuleList.empty[];

opttype: NonTerminal Builds OptType;

for opttype.present ← "," typeexp

Build OptType.present[typeexp];

for opttype.absent ← -- << empty >>

Build OptType.absent[]

End;

SaffronCG7: Module = Begin

typelist: NonTerminal Builds TypeList;

for typelist.a ← typecons default

Build TypeList.one[TypeItem[
typecons, default]];

for typelist.b ← typeid default

Build TypeList.one[TypeItem[
TypeExp.typeid[typeid], default]];

for typelist.c ← id

Build TypeList.one[TypeItem[
TypeExp.typeid[TypeId.id[id]], Default.empty[(id,id]]]];

for typelist.d ← id "←" defaultopt

Build TypeList.one[TypeItem[
TypeExp.typeid[TypeId.id[id]], defaultopt]];

for typelist.e ← typecons default "," typelist

Build TypeList.many[TypeList.one[TypeItem[
typecons, default]], typelist];

for typelist.f ← typeid default "," typelist

Build TypeList.many[TypeList.one[TypeItem[
TypeExp.typeid[typeid], default]], typelist];

for typelist.g ← id "," typelist

Build TypeList.many[TypeList.one[TypeItem[
TypeExp.typeid[TypeId.id[id]], Default.empty[(id,id]]]], typelist];

for typelist.h ← id "←" defaultopt "," typelist

Build TypeList.many[TypeList.one[TypeItem[
TypeExp.typeid[TypeId.id[id]], defaultopt]], typelist];

modulelist: NonTerminal Builds ModuleList;

for modulelist.a ← moduleitem

Build ModuleList.more[ModuleList.empty[[moduleitem, moduleitem)], moduleitem];

for modulelist.b ← modulelist "," moduleitem

Build ModuleList.more[modulelist, moduleitem];

moduleitem: NonTerminal Builds ModuleItem;

for moduleitem.one ← id

Build ModuleItem.one[id];

for moduleitem.two ← id.record ":" id.type

Build ModuleItem.two[id.record, id.type];

tilde: NonTerminal Builds Junk;

for tilde.a ← "~"

Build Junk[];

for tilde.b ← "="

Build Junk[];

pairlist: NonTerminal Builds PairList;

for pairlist.one ← pairitem

Build PairList.one[pairitem];

for pairlist.many ← pairlist "," pairitem

Build PairList.many[pairlist, PairList.one[pairitem]];

pairitem: NonTerminal Builds PairItem;

for pairitem ← identlist public typeexp default

Build PairItem[identlist, public, typeexp, default];

typeid: NonTerminal Builds TypeId;

for typeid.a ← id.a id.b

Build TypeId.qualifier[TypeId.id[id.b], id.a];

for typeid.b ← id typeid

Build TypeId.qualifier[typeid, id];

for typeid.c ← typeidP

Build typeidP;

typeidP: NonTerminal Builds TypeId;

for typeidP.a ← id.a "." id.b

Build TypeId.qualifier[TypeId.id[id.a], id.b];

for typeidP.b ← typeidP "." id

Build TypeId.qualifier[typeidP, id];

explist: NonTerminal Builds ExpList;

for explist.orderlist ← orderlist

Build ExpList.orderlist[orderlist];

for explist.keylist ← keylist

Build ExpList.keylist[keylist];

keylist: NonTerminal Builds KeyList;

for keylist.one ← keyitem

Build KeyList.one[keyitem];

for keylist.more ← keylist "," keyitem

Build KeyList.more[keylist, keyitem];

keyitem: NonTerminal Builds KeyItem;

for keyitem.a ← id "~" optexp

Build KeyItem[id, optexp];

for keyitem.b ← id ":" optexp

Build KeyItem[id, optexp];

locks: NonTerminal Builds Locks;

for locks.present ← "LOCKS" primary lambda

Build Locks.present[primary, lambda];

for locks.absent ← -- << empty >>

Build Locks.absent[];

lambda: NonTerminal Builds Lambda;

for lambda.present ← "USING" ident typeexp

Build Lambda.present[ident, typeexp];

for lambda.absent ← -- << empty >>

Build Lambda.absent[];

open: NonTerminal Builds BindList;

for open.bindlist ← "OPEN" bindlist ";"

Build bindlist;

for open.empty ← -- << empty >>

Build BindList.empty[];

bindlist: NonTerminal Builds BindList;

for bindlist.item ← binditem

Build BindList.more[BindList.empty[[binditem, binditem)], binditem];

for bindlist.list ← bindlist "," binditem

Build BindList.more[bindlist, binditem];

casehead: NonTerminal Builds SelectHead;

for casehead.plain ← "SELECT" exp "FROM"

Build SelectHead.plain[exp];

for casehead.discrim ← "WITH" binditem "SELECT" optexp "FROM"

Build SelectHead.discriminating[binditem, optexp];

scope: NonTerminal Builds Scope;

for scope.a ← open enables statementlist

Build Scope[open, enables, OptDecList.absent[[statementlist, statementlist)], statementlist];

for scope.b ← open enables declist ";" statementlist

Build Scope[open, enables, OptDecList.present[declist], statementlist];

enables: NonTerminal Builds Catch;

for enables.a ← "ENABLE" catchcase ";"

Build Catch[
CatchCaseList.more[CatchCaseList.empty[[catchcase, catchcase)], catchcase], CatchAny.absent[(catchcase, catchcase]
]];

for enables.b ← "ENABLE" catchany ";"

Build Catch[CatchCaseList.empty[[catchany, catchany)], catchany];

for enables.c ← "ENABLE" "BEGIN" catchlist "END" ";"

Build catchlist;

for enables.d ← "ENABLE" "{" catchlist "}" ";"

Build catchlist;

for enables.e ← -- << empty >>

Build Catch[CatchCaseList.empty[], CatchAny.absent[]];

statementlist: NonTerminal Builds StatementList;

for statementlist.empty ← -- << empty >>

Build StatementList.empty[];

for statementlist.b ← statementlistP

Build statementlistP;

for statementlist.c ← statementlistP ";"

Build statementlistP;

statementlistP: NonTerminal Builds StatementList;

for statementlistP.a ← statement

Build StatementList.more[StatementList.empty[[statement, statement)], statement];

for statementlistP.b ← statementlistP ";" statement

Build StatementList.more[statementlistP, statement];

safe: NonTerminal Builds Safe;

for safe.empty ← -- << empty >>

Build Safe.empty[];

for safe.no ← "UNSAFE"

Build Safe.no[];

for safe.yes ← "SAFE"

Build Safe.yes[]

End.

eof...