SaffronCentral.OneCasaba

Begin

{ "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;

top: NonTerminal;

goal: NonTerminal;

module: NonTerminal;

directory: NonTerminal;

includelist: NonTerminal;

includeitem: NonTerminal;

using: NonTerminal;

defbody: NonTerminal;

defhead: NonTerminal;

definitions: NonTerminal;

cedar: NonTerminal;

proghead: NonTerminal;

resident: NonTerminal;

class: NonTerminal;

interface: NonTerminal;

exports: NonTerminal;

binditem: NonTerminal;

caselabel: NonTerminal;

caselabelP: NonTerminal;

casetest: NonTerminal;

block: NonTerminal;

exits: NonTerminal;

public: NonTerminal;

bounds: NonTerminal;

checked: NonTerminal;

default: NonTerminal;

positionP: NonTerminal;

optbits: NonTerminal;

sum: NonTerminal;

product: NonTerminal;

multop: NonTerminal;

factor: NonTerminal;

addop: NonTerminal;

readonly: NonTerminal;

catchany: NonTerminal;

interval: NonTerminal;

exp: NonTerminal;

caseexplist: NonTerminal;

caseexplistP: NonTerminal;

caseexpitem: NonTerminal;

transferop: NonTerminal;

disjunct: NonTerminal;

conjunct: NonTerminal;

negation: NonTerminal;

relation: NonTerminal;

catchlist: NonTerminal;

catchhead: NonTerminal;

ident: NonTerminal;

typeop: NonTerminal;

idlist: NonTerminal;

idlistP: NonTerminal;

arguments: NonTerminal;

arglist: NonTerminal;

returnlist: NonTerminal;

fieldlist: NonTerminal;

typeexp: NonTerminal;

num: NonTerminal;

lhs: NonTerminal;

qualifier: NonTerminal;

exitlist: NonTerminal;

exitlistP: NonTerminal;

exititem: NonTerminal;

optexp: NonTerminal;

catchcase: NonTerminal;

lhslist: NonTerminal;

initialization: NonTerminal;

initvalue: NonTerminal;

procaccess: NonTerminal;

inline: NonTerminal;

codelist: NonTerminal;

range: NonTerminal;

trash: NonTerminal;

defaultopt: NonTerminal;

orderlist: NonTerminal;

trusted: NonTerminal;

optrelation: NonTerminal;

relationtail: NonTerminal;

relop: NonTerminal;

shares: NonTerminal;

statement: NonTerminal;

balstmt: NonTerminal;

basicstmt: NonTerminal;

forclause: NonTerminal;

controlid: NonTerminal;

direction: NonTerminal;

doexit: NonTerminal;

transfer: NonTerminal;

dotest: NonTerminal;

optargs: NonTerminal;

free: NonTerminal;

casestmtlist: NonTerminal;

casestmtlistP: NonTerminal;

casestmtitem: NonTerminal;

declist: NonTerminal;

declaration: NonTerminal;

entry: NonTerminal;

optsize: NonTerminal;

primary: NonTerminal;

new: NonTerminal;

cons: NonTerminal;

listcons: NonTerminal;

desclist: NonTerminal;

optcatch: NonTerminal;

identlist: NonTerminal;

identlistP: NonTerminal;

prefixop: NonTerminal;

typecons: NonTerminal;

dependent: NonTerminal;

monitored: NonTerminal;

ordered: NonTerminal;

base: NonTerminal;

pointertype: NonTerminal;

pointerprefix: NonTerminal;

indextype: NonTerminal;

transfermode: NonTerminal;

elementlist: NonTerminal;

elementlistP: NonTerminal;

element: NonTerminal;

heap: NonTerminal;

typeappl: NonTerminal;

lengthP: NonTerminal;

reclist: NonTerminal;

variantpair: NonTerminal;

variantpart: NonTerminal;

vcasehead: NonTerminal;

tagtype: NonTerminal;

variantlist: NonTerminal;

variantitem: NonTerminal;

packed: NonTerminal;

imports: NonTerminal;

opttype: NonTerminal;

typelist: NonTerminal;

modulelist: NonTerminal;

moduleitem: NonTerminal;

tilde: NonTerminal;

pairlist: NonTerminal;

pairitem: NonTerminal;

typeid: NonTerminal;

typeidP: NonTerminal;

explist: NonTerminal;

keylist: NonTerminal;

keyitem: NonTerminal;

locks: NonTerminal;

lambda: NonTerminal;

open: NonTerminal;

bindlist: NonTerminal;

casehead: NonTerminal;

scope: NonTerminal;

enables: NonTerminal;

statementlist: NonTerminal;

statementlistP: NonTerminal;

safe: NonTerminal;

decimalnum: GenericToken = "tokenDECIMAL" ;

octalnum: GenericToken = "tokenOCTAL" ;

hexnum: GenericToken = "tokenHEX" ;

id: GenericToken = "tokenID" ;

string: GenericToken = "tokenROPE" ;

flnum: GenericToken = "tokenREAL" ;

char: GenericToken = "tokenCHAR" ;

atom: GenericToken = "tokenATOM" ;

maingoal ← top ;

top.modulep ← goal ;

top.scope ← "BEGIN" scope "END" ;

goal.a ← module "." ;

goal.b ← module ".." ;

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

module.def ← directory identlist cedar defhead defbody ;

directory.a ← "DIRECTORY" ";" ;

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

directory.c ← ;

includelist.a ← includeitem ;

includelist.b ← includelist "," includeitem ;

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

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

includeitem.c ← id using ;

includeitem.d ← id ":" "TYPE" id using ;

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

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

using.unrestricted ← ;

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

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

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

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

defhead ← definitions locks imports shares tilde public ;

definitions ← "DEFINITIONS" ;

cedar.yes ← "CEDAR" ;

cedar.no ← ;

proghead ← resident safe class arguments locks interface tilde public ;

resident ← ;

class.program ← "PROGRAM" ;

class.monitor ← "MONITOR" ;

interface ← imports exports shares ;

exports.a ← "EXPORTS" ;

exports.b ← "EXPORTS" modulelist ;

exports.c ← ;

binditem.a ← exp ;

binditem.b ← id ":" exp ;

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

caselabel.type ← ident typeexp ;

caselabel.test ← caselabelP ;

caselabelP.one ← casetest ;

caselabelP.more ← caselabelP "," casetest ;

casetest.a ← optrelation ;

casetest.b ← exp ;

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

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

exits.list ← "EXITS" exitlist ;

exits.empty ← ;

public.public ← "PUBLIC" ;

public.private ← "PRIVATE" ;

public.empty ← ;

bounds ← exp ".." exp ;

checked.empty ← ;

checked.checked ← "CHECKED" ;

checked.trusted ← "TRUSTED" ;

checked.unchecked ← "UNCHECKED" ;

default.a ← "←" defaultopt ;

default.empty ← ;

positionP ← "(" exp optbits ")" ;

optbits.present ← ":" bounds ;

optbits.absent ← ;

sum.sum ← sum addop product ;

sum.product ← product ;

product.product ← product multop factor ;

product.factor ← factor ;

multop.times ← "*" ;

multop.divide ← "/" ;

multop.mod ← "MOD" ;

factor.unarysum ← addop primary ;

factor.primary ← primary ;

addop.plus ← "+" ;

addop.minus ← "-" ;

readonly.yes ← "READONLY" ;

readonly.no ← ;

catchany ← "ANY" "=>" statement ;

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

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

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

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

exp.ifthenelse ← "IF" exp "THEN" exp "ELSE" exp ;

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

exp.assign ← lhs "←" exp ;

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

exp.error ← "ERROR" ;

exp.transfer ← transferop lhs ;

exp.disjunct ← disjunct ;

caseexplist.empty ← ;

caseexplist.b ← caseexplistP ;

caseexplist.c ← caseexplistP "," ;

caseexplistP.a ← caseexpitem ;

caseexplistP.b ← caseexplistP "," caseexpitem ;

caseexpitem ← caselabel "=>" exp ;

transferop.signal ← "SIGNAL" ;

transferop.error ← "ERROR" ;

transferop.start ← "START" ;

transferop.join ← "JOIN" ;

transferop.new ← "NEW" ;

transferop.fork ← "FORK" ;

disjunct.or ← disjunct "OR" conjunct ;

disjunct.conjunct ← conjunct ;

conjunct.and ← conjunct "AND" negation ;

conjunct.negation ← negation ;

negation.a ← "~" relation ;

negation.b ← "NOT" relation ;

negation.relation ← relation ;

relation.relation ← sum optrelation ;

relation.sum ← sum ;

catchlist.a ← catchhead catchcase ;

catchlist.b ← catchhead ;

catchlist.c ← catchhead catchany ;

catchlist.d ← catchhead catchany ";" ;

catchhead.empty ← ;

catchhead.more ← catchhead catchcase ";" ;

ident.idposition ← id positionP ":" ;

ident.id ← id ":" ;

typeop.code ← "CODE" ;

typeop.first ← "FIRST" ;

typeop.last ← "LAST" ;

typeop.nil ← "NIL" ;

idlist ← idlistP ;

idlistP.one ← id ;

idlistP.more ← id "," idlistP ;

arguments ← arglist returnlist ;

arglist.any ← "ANY" ;

arglist.fieldlist ← fieldlist ;

arglist.empty ← ;

returnlist.any ← "RETURNS" "ANY" ;

returnlist.fieldlist ← "RETURNS" fieldlist ;

returnlist.empty ← ;

fieldlist.empty ← "[" "]" ;

fieldlist.pairlist ← "[" pairlist "]" ;

fieldlist.typelist ← "[" typelist "]" ;

typeexp.a ← id ;

typeexp.b ← typeid ;

typeexp.c ← typecons ;

num.decimal ← decimalnum ;

num.octal ← octalnum ;

num.hex ← hexnum ;

lhs.id ← id ;

lhs.num ← num ;

lhs.string ← string ;

lhs.flnum ← flnum ;

lhs.char ← char ;

lhs.atom ← atom ;

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

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

lhs.apply ← "APPLY" "[" exp "," exp optcatch "]" ;

lhs.exp ← "(" exp ")" ;

lhs.qualifier ← lhs qualifier ;

qualifier.prefixop ← "." prefixop ;

qualifier.typeop ← "." typeop ;

qualifier.size ← "." "SIZE" ;

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

qualifier.select ← "." id ;

qualifier.indirect ← "^" ;

exitlist.empty ← ;

exitlist.b ← exitlistP ;

exitlist.c ← exitlistP ";" ;

exitlistP.a ← exititem ;

exitlistP.b ← exitlistP ";" exititem ;

exititem ← idlist "=>" statement ;

optexp.trash ← trash ;

optexp.exp ← exp ;

optexp.empty ← ;

catchcase ← lhslist "=>" statement ;

lhslist.one ← lhs ;

lhslist.more ← lhslist "," lhs ;

initialization.empty ← ;

initialization.assignment ← "←" initvalue ;

initialization.binding ← tilde initvalue ;

initvalue.block ← procaccess trusted checked inline block ;

initvalue.code ← "CODE" ;

initvalue.c ← procaccess trusted checked "MACHINE" "CODE" "BEGIN" codelist "END" ;

initvalue.d ← procaccess trusted checked "MACHINE" "CODE" "{" codelist "}" ;

initvalue.trash ← trash ;

initvalue.exp ← exp ;

procaccess ← ;

inline.yes ← "INLINE" ;

inline.no ← ;

codelist.one ← orderlist ;

codelist.more ← codelist ";" orderlist ;

range.a ← id ;

range.b ← id interval ;

range.c ← typeid interval ;

range.d ← interval ;

range.e ← typeid ;

trash.trash ← "TRASH" ;

trash.null ← "NULL" ;

defaultopt.getstrash ← trash ;

defaultopt.getsexportrash ← exp "|" trash ;

defaultopt.gets ← ;

defaultopt.getsexp ← exp ;

orderlist.one ← optexp ;

orderlist.more ← orderlist "," optexp ;

trusted ← ;

optrelation.negative ← "NOT" relationtail ;

optrelation.positive ← relationtail ;

relationtail.range ← "IN" range ;

relationtail.relop ← relop sum ;

relop.eq ← "=" ;

relop.ne ← "#" ;

relop.lt ← "<" ;

relop.le ← "<=" ;

relop.gt ← ">" ;

relop.ge ← ">=" ;

shares.present ← "SHARES" idlist ;

shares.absent ← ;

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

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

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

statement.basicstmt ← basicstmt ;

balstmt.ifthenelse ← "IF" exp "THEN" balstmt "ELSE" balstmt ;

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

balstmt.basicstmt ← basicstmt ;

basicstmt.exp ← lhs ;

basicstmt.assign ← lhs "←" exp ;

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

basicstmt.block ← trusted checked block ;

basicstmt.select ← casehead casestmtlist "ENDCASE" ;

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

basicstmt.exit ← "EXIT" ;

basicstmt.loop ← "LOOP" ;

basicstmt.i ← "GOTO" id ;

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

basicstmt.return ← "RETURN" optargs ;

basicstmt.transfer ← transfer lhs ;

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

basicstmt.wait ← "WAIT" lhs ;

basicstmt.error ← "ERROR" ;

basicstmt.stop ← "STOP" ;

basicstmt.null ← "NULL" ;

basicstmt.resume ← "RESUME" optargs ;

basicstmt.reject ← "REJECT" ;

basicstmt.continue ← "CONTINUE" ;

basicstmt.retry ← "RETRY" ;

basicstmt.getstate ← lhs "←" "STATE" ;

basicstmt.setstate ← "STATE" "←" exp ;

forclause.assignation ← "FOR" controlid "←" exp "," exp ;

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

forclause.repetition ← "THROUGH" range ;

forclause.empty ← ;

controlid.new ← ident typeexp ;

controlid.old ← id ;

direction.yes ← "DECREASING" ;

direction.no ← ;

doexit.a ← ;

doexit.b ← "REPEAT" exitlist ;

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

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

transfer.signal ← "SIGNAL" ;

transfer.error ← "ERROR" ;

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

transfer.start ← "START" ;

transfer.restart ← "RESTART" ;

transfer.join ← "JOIN" ;

transfer.notify ← "NOTIFY" ;

transfer.broadcast ← "BROADCAST" ;

transfer.transferwith ← "TRANSFER" "WITH" ;

transfer.returnwith ← "RETURN" "WITH" ;

dotest.until ← "UNTIL" exp ;

dotest.while ← "WHILE" exp ;

dotest.empty ← ;

optargs.explist ← "[" explist "]" ;

optargs.empty ← ;

optargs.exp ← lhs ;

free.plain ← "FREE" ;

free.zoned ← lhs "." "FREE" ;

casestmtlist.empty ← ;

casestmtlist.b ← casestmtlistP ;

casestmtlist.c ← casestmtlistP ";" ;

casestmtlistP.a ← casestmtitem ;

casestmtlistP.b ← casestmtlistP ";" casestmtitem ;

casestmtitem ← caselabel "=>" statement ;

declist.one ← declaration ;

declist.many ← declist ";" declaration ;

declaration.value ← identlist public entry readonly typeexp initialization ;

declaration.type ← identlist public "TYPE" tilde public typeexp default ;

declaration.opaquetype ← identlist public "TYPE" optsize ;

entry.entry ← "ENTRY" ;

entry.internal ← "INTERNAL" ;

entry.empty ← ;

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

optsize.absent ← ;

primary.explist ← "[" explist "]" ;

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

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

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

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

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

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

primary.nil ← "NIL" ;

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

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

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

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

primary.address ← "@" lhs ;

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

primary.lhs ← lhs ;

new.plain ← "NEW" ;

new.zoned ← lhs "." "NEW" ;

cons.plain ← "CONS" ;

cons.zoned ← lhs "." "CONS" ;

listcons.plain ← "LIST" ;

listcons.zoned ← lhs "." "LIST" ;

desclist.explicit ← exp "," exp opttype ;

desclist.default ← exp ;

optcatch.catchlist ← "!" catchlist ;

optcatch.empty ← ;

identlist ← identlistP ;

identlistP.a ← id ":" ;

identlistP.b ← id positionP ":" ;

identlistP.c ← id "," identlistP ;

identlistP.d ← id positionP "," identlistP ;

prefixop.long ← "LONG" ;

prefixop.abs ← "ABS" ;

prefixop.pred ← "PRED" ;

prefixop.succ ← "SUCC" ;

prefixop.ord ← "ORD" ;

prefixop.min ← "MIN" ;

prefixop.max ← "MAX" ;

prefixop.base ← "BASE" ;

prefixop.length ← "LENGTH" ;

typecons.a ← interval ;

typecons.b ← id interval ;

typecons.c ← typeid interval ;

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

typecons.record ← dependent monitored "RECORD" reclist ;

typecons.pointer ← ordered base pointertype ;

typecons.var ← "VAR" typeexp ;

typecons.ref ← "REF" readonly typeexp ;

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

typecons.refunspecified ← "REF" ;

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

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

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

typecons.transfer ← safe transfermode arguments ;

typecons.o ← id "RELATIVE" typeexp ;

typecons.p ← typeid "RELATIVE" typeexp ;

typecons.zone ← heap "ZONE" ;

typecons.long ← "LONG" typeexp ;

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

typecons.t ← id "PAINTED" typeexp ;

typecons.u ← typeid "PAINTED" typeexp ;

typecons.typeapply ← typeappl ;

dependent.yes ← "MACHINE" "DEPENDENT" ;

dependent.no ← ;

monitored.yes ← "MONITORED" ;

monitored.no ← ;

ordered.yes ← "ORDERED" ;

ordered.no ← ;

base.yes ← "BASE" ;

base.no ← ;

pointertype.unspecified ← pointerprefix ;

pointertype.specified ← pointerprefix "TO" readonly typeexp ;

pointerprefix.absent ← "POINTER" ;

pointerprefix.present ← "POINTER" interval ;

indextype.present ← typeexp ;

indextype.absent ← ;

transfermode.a ← "PROCEDURE" ;

transfermode.b ← "PROC" ;

transfermode.port ← "PORT" ;

transfermode.signal ← "SIGNAL" ;

transfermode.error ← "ERROR" ;

transfermode.process ← "PROCESS" ;

transfermode.program ← "PROGRAM" ;

elementlist.empty ← ;

elementlist.b ← elementlistP ;

elementlistP.a ← element ;

elementlistP.b ← elementlistP "," element ;

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

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

element.id ← id ;

heap.yes ← "UNCOUNTED" ;

heap.no ← ;

typeappl.a ← typeappl "." id ;

typeappl.b ← id lengthP ;

typeappl.c ← typeid lengthP ;

typeappl.d ← typeappl lengthP ;

lengthP ← "[" exp "]" ;

reclist.a ← "[" "]" ;

reclist.b ← "NULL" ;

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

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

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

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

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

variantpair ← identlist public variantpart default ;

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

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

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

vcasehead.ident ← ident public tagtype ;

vcasehead.computed ← "COMPUTED" tagtype ;

vcasehead.overlaid ← "OVERLAID" tagtype ;

tagtype.star ← "*" ;

tagtype.typeexp ← typeexp ;

variantlist.one ← variantitem ;

variantlist.more ← variantlist "," variantitem ;

variantitem ← idlist "=>" reclist ;

packed.yes ← "PACKED" ;

packed.no ← ;

imports.a ← "IMPORTS" ;

imports.b ← "IMPORTS" modulelist ;

imports.c ← ;

opttype.present ← "," typeexp ;

opttype.absent ← ;

typelist.a ← typecons default ;

typelist.b ← typeid default ;

typelist.c ← id ;

typelist.d ← id "←" defaultopt ;

typelist.e ← typecons default "," typelist ;

typelist.f ← typeid default "," typelist ;

typelist.g ← id "," typelist ;

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

modulelist.a ← moduleitem ;

modulelist.b ← modulelist "," moduleitem ;

moduleitem.one ← id ;

moduleitem.two ← id ":" id ;

tilde.a ← "~" ;

tilde.b ← "=" ;

pairlist.one ← pairitem ;

pairlist.many ← pairlist "," pairitem ;

pairitem ← identlist public typeexp default ;

typeid.a ← id id ;

typeid.b ← id typeid ;

typeid.c ← typeidP ;

typeidP.a ← id "." id ;

typeidP.b ← typeidP "." id ;

explist.orderlist ← orderlist ;

explist.keylist ← keylist ;

keylist.one ← keyitem ;

keylist.more ← keylist "," keyitem ;

keyitem.a ← id "~" optexp ;

keyitem.b ← id ":" optexp ;

locks.present ← "LOCKS" primary lambda ;

locks.absent ← ;

lambda.present ← "USING" ident typeexp ;

lambda.absent ← ;

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

open.empty ← ;

bindlist.item ← binditem ;

bindlist.list ← bindlist "," binditem ;

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

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

scope.a ← open enables statementlist ;

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

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

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

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

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

enables.e ← ;

statementlist.empty ← ;

statementlist.b ← statementlistP ;

statementlist.c ← statementlistP ";" ;

statementlistP.a ← statement ;

statementlistP.b ← statementlistP ";" statement ;

safe.empty ← ;

safe.no ← "UNSAFE" ;

safe.yes ← "SAFE" ;

End.