
    <<SaffronCG.ThreeC4>>
        <<Copyright Ó 1986, 1987 by Xerox Corporation.  All rights reserved.>>
        <<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>>
        <<Sturgis, July 20, 1987 6:02:22 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.tc    _ "TC" typeexp 
                Build    Top.tc[typeexp];

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