*COMPILE()
*OBJSW=T
*LKED()
*BNF
*     R E S E R V E D   S Y M B O L S
*
RESERVED ATOMICS (2) = MAT, SPWORD, SCOPEWORD.
RESERVED OPERATORS (3) =
  UPONE, DOWN, LEFT, RIGHT, UPTRN, DNTRN, VALUE, PRESENT, NELEM,
  AND, OR, NOT, IMPLY, ITER, ITERF, ITERT, ITERFT,
  CANDO, EXEC, EXECUTE, TRUE,
  RARE, REP, SEGMENT, REPARSE, PARSE, MINWD,
  INTERSECTOP, INTERSECTCHK, UNIONOP, COMPLEMENTOP,
  LOOK, STORE, IS,ATTRB, EDIT, TEXTX, ASSIGN, ERASE, HASATT, EMPTY,
  COMMONAT, GENER, STACK, WRITE, GENSYM,
  CREATE, COPY, BUILDDOWN, BUILDRIGHT, BUILDUP, REPLACE, INSERTAFTER,
  INSERTBEFORE, TRANSFORM, CLASS, BUILDWORD,  DEACTIVATE,
  WORDL, PREVL, NEXTL, FRSTL, LASTL, NWORD, NODENAME,
  HEAD, SUCCESSORS, PREFIX, LOOKATLIST, LOOKATSYMBOL, MEMBER,
  TESTFORNIL, IDENTICAL, SETLOGSW, CLEARLOGSW, TESTLOGSW, TOGLOGSW,
  SUFFIX, SUFFIXUNIQ, PREFIXUNIQ, SETGLOBSW, CLEARGLOBSW, TESTGLOBSW,
  EQUIVMATCH,REPARSESW, CREATE-IDIOM, EVERY-NODE .
RESERVED ROUTINES (4) =
  STARTAT, NELEMRT, IMMEDIATE, INITIALRT, SUBSUMERT,
  LOOKAHEAD, $RARE, $REP.
RESERVED ATTRIBUTES (5) = ANYTHING, ROUTINE.
RESERVED TYPES (7) = ATOM.
RESERVED ORDINAL1 (31) = FIRST.
RESERVED ORDINAL2 (47) = SECOND.
RESERVED ORDINAL3 (63) = THIRD.
*     S Y N T A X   O F   B N F
*
<DEFINITION>::='<' <*NAME> '>' ':' ':' '=' <DEFINER> '.'
                   _ (<NAME> [NHEAD] <DEFINER>) .END.(1) /
               '<' <*NAME> '>' '*' 'R' ':' ':' '=' <DEFINER> '.'
                   _ (<NAME> [NHEAD], (
                   1= (NIL [UNNHEAD] <DEFINER>),
                   2= (NIL [UNNHEAD], (NULL), (*1,*2) [($REP)]))
                                                 , (NULL)) .END.(1) /
               '<' <*NAME> '>' 'R' '*' ':' ':' '=' <DEFINER> '.'
                   _ (<NAME> [NHEAD], (NULL), (
                   3= (NIL [UNNHEAD] <DEFINER>),
                   4= (NIL [UNNHEAD], (NULL), (*3,*4) [($REP)])))
                                                           .END.(1).
<DEFINER>  ::= <OPTION> ('/' <OPTION>)*.
<OPTION>   ::= ['-'_($RARE)]1 <ELEMENT>2 (<ELEMENT>)*3 _ (#2:#3 [#1]).
<ELEMENT>  ::= '<' <*NAME> '>' _ <NAME> .TYP.(1) /
               '<' '*' <*NAME> '>' _ <NAME> .TYP.(2) /
               '(' <DEFINER> ')' _ (NIL [UNNHEAD] <DEFINER>) /
               '[' <DEFINER> ']' _ (NIL [UNNHEAD] <DEFINER>:((NULL))) /
               <*NAME> _ <NAME> .TXT /
               <*TEXT> _ <TEXT> /
               <*TEXT> '_' <*TEXT>1 (<IDNODLIT>)*2 _ (<TEXT>:#1:#2).
<IDNODLIT> ::= '_' <*TEXT> _ <TEXT> .
*     S Y N T A X   O F   L I S T S
*
<LIST>     ::= <TYPE-LIST> / <ATTRIBUTE-LIST> / <GLOBAL-LIST> /
               <GENERAL-LIST>.
<TYPE-LIST>::= TYPE <*NAME> '=' <*NODE>1 (',' <*NODE>)*2 '.'
                   _ (<NAME> [NHEAD] #1:#2) .END.(5).
<ATTRIBUTE-LIST> ::= ATTRIBUTE '=' <ATT-LIST-ELEM>1 (',' <ATT-LIST-ELEM>
                   )*2 '.' _ (ATTRIBUTE [NHEAD] #1:#2) .END.(5).
<ATT-LIST-ELEM> ::= <*ATTRIBUTE> / <*NAME> _ <NAME> .TYP.(5).
<GLOBAL-LIST> ::= GLOBAL '=' <GLOB-LIST-ELEM>1 (',' <GLOB-LIST-ELEM>)*2
                   '.' _ (GLOBAL [NHEAD] #1:#2) .END.(5).
<GLOB-LIST-ELEM> ::= <*ADDRESS> _ <ADDRESS> .TYP.(16).
<GENERAL-LIST> ::= LIST <*NAME> '=' <LIST-ELEM-SEQ> '.'
                   _ (<NAME> [NHEAD] <LIST-ELEM-SEQ>) .END.(5).
<LIST-ELEM-SEQ> ::= <LIST-ELEM> (',' <LIST-ELEM>)*.
<LIST-ELEM>::= (<*ATTRIBUTE> / <*TEXT> / <*NODE>)1
                   [':' '(' <LIST-ELEM-SEQ> ')']2 _ (#1[#2]) /
               '(' <LIST-ELEM-SEQ> ')' _ (<LIST-ELEM-SEQ>).
*     S y n t a x   o f   R o u t i n e s,
*                         R e s t r i c t i o n s, and
*                         T r a n s f o r m a t i o n S
*
<RLSENT>   ::= <ROUTINEDEF> / <RESTRICTION> / <ADDRSENT> / <WORDRESTR>.
<RESTRICTION>::= <*NAME> '=' <HOUSING> <RESTRSENT> '.'
                   _ (<NAME> [NHEAD] <HOUSING>:<RESTRSENT>) .END.(2).
<ROUTINEDEF>::=ROUTINE <*NAME> ['(' <REGLIST> ')']1
                   [LOCAL '(' <REGLIST> ')']2 '=' <RESTRSENT> '.'
                   _ (<NAME> [NHEAD], ROUTINE, #1, #2): <RESTRSENT>
                     .END.(4).
<REGLIST>  ::= <*REG>1 (',' <*REG>)*2 _ #1:#2.
<ADDRSENT> ::= <*ADDRESS> '=' <RESTRSENT> '.'
                   _ (<ADDRESS> [NHEAD] <RESTRSENT>) .END.(3).
<WORDRESTR> ::= <*NAME> '=' <RESTRSENT> '.'
                   _ (<NAME> [NHEAD] <RESTRSENT>) .END.(10).
<HOUSING>  ::= <INDEF> (<AFTERL>/<REOPT>/<*NULL>_(0))1 ':'
                   _ (NIL [(<INDEF>,#1)]) .
<INDEF>    ::= IN <DEFTYP>1 (',' <DEFTYP>)*2 _ #1:#2.
<DEFTYP>   ::= <*DEF> / <*TYPE> / '(' ')' <*DEF> _ (<DEF> [1]).
<AFTERL>   ::= AFTER ( <*NODE> _ (4,<NODE>) / <*NTH> ELEMENT _ (2,<NTH>)
                      / (OPTION/OPTIONS) <OPTIONLIST> _ 3:<OPTIONLIST>).
<REOPT>    ::= RE [OPTION/OPTIONS] <OPTIONLIST> _ 1:<OPTIONLIST>.
<OPTIONLIST>::= <*NODE>1 (',' <*NODE>)*2 _ #1:#2 /
                <*INTEGER>1 (',' <*INTEGER>)*2 _ #1:#2.
<RESTRSENT>::= <RTESTLIST> (';' <RTESTLIST>)*.
<RTESTLIST>::= <RTEST> ( (WHERE/WHEREAS/WHILE) <RTEST> )*.
<RTEST>    ::= ( (IN/AT) <NSUBJ> [ ',' ] )* <RTEST1>.
<RTEST1>   ::= <SENTENCE> /
               <*ADDRESS> IS TRUE _ (EXEC [<ADDRESS>]) /
               <*ADDRESS> IS FALSE _ (NOT [<ADDRESS>]) /
               [IT IS] NOT [CASE THAT] <RT> _ (NOT [<RT>]) /
               IF <RT>1 [','] ['@'_1]3 THEN <RT>2 [ELSE <RT> _ (<RT>)]4
                   _ (IMPLY[(#1[#3],#2):#4])/
               EITHER <RT>1 [','] OR <RT>2 _ (OR[(#1,#2)]) /
               BOTH <RT>1 [','] ['@'_1]3 AND <RT>2 _ (AND[(#1[#3],#2)])/
               NEITHER <RT>1 NOR <RT>2 _ (NOT[(OR[(#1,#2)])]) /
               ONE OF <TESTSEQ> _ (OR[<TESTSEQ>]) /
               ALL OF <TESTSEQ> _ (AND[<TESTSEQ>]) /
               NONE OF <TESTSEQ> _ (NOT[(OR[<TESTSEQ>])]).
<RT>       ::= <*ADDRESS> [IS TRUE/ARE TRUE] / <RTESTLIST>.
<TESTSEQ>  ::= (<ADDRESS-COMMA>)* <*ADDRESS> [IS TRUE / ARE TRUE].
<ADDRESS-COMMA>::= <*ADDRESS> ',' ['@'_1]1 _ (<ADDRESS>[#1]) .
<SENTENCE> ::= <RSUBJ> <PREDICATE> / <MONOSENT> / <COMMAND>/<TRANSFORM>.
*          RSUBJ:  SUBJECT OF RESTRICTION LANGUAGE SENTENCE
*                  OPTIONS ARE GROUPED ACCORDING TO WHETHER THEY LEAVE
*                  THE RESTRICTION LOOKING AT A NODE (OF THE PARSE
*                  TREE), A LIST ELEMENT, OR A SENTENCE WORD:
*             NODESUBJ  -- LOOKS AT A NODE OF THE PARSE TREE
*             LISTSUBJ  -- LOOKS AT A LIST ELEMENT
*             NODEWORD  )- LOOKS AT A SENTENCE WORD
*             SENTWORD  )
*             XSUBJ     -- MAY LOOK AT A NODE, LIST ELEMENT, OR WORD
*                  NOTE THAT -ROUTINE- IS MADE THE LAST OPTION, SINCE
*                  ANY UNCLASSIFIED NAME WILL BE ACCEPTED AS A ROUTINE.
<RSUBJ>    ::= <NODESUBJ> /
               <LISTSUBJ> /
               <NODEWORD> <REGST> /
               <SENTWORD> <REGST> /
               <XSUBJ>.
<NODESUBJ> ::= <*NODE> <REGST> [OF <NSUBJ>]1
                   _ #1:(EXECUTE[(STARTAT[((<NODE>))])]):<REGST> /
               VALUE <REGST> [OF <NSUBJ>]1 _ #1:VALUE:<REGST> /
               <*NTH> ELEMENT <REGST> [OF <NSUBJ>]1
                   _ #1 : (EXECUTE[(PRESENT-ELEMENT)], NELEM[<NTH>],
                     EXECUTE[(NELEMRT)]) : <REGST> /
               <*NTH> <*NODE> <REGST> [OF <NSUBJ>]1
                   _ #1 : (EXECUTE[(PRESENT-ELEMENT)],
                           NELEM[(<NTH>[(<NODE>)])],
                           EXECUTE[(NELEMRT)]) : <REGST>.
<LISTSUBJ> ::= HEAD <REGST> [OF <LSUBJ>]1 _ #1 : HEAD : <REGST> /
               SUCCESSORS <REGST> [OF <LSUBJ>]1
                   _ #1 : SUCCESSORS : <REGST> /
               ATTRIBUTE-LIST <REGST> [OF <LSUBJ>]1
                   _ #1 : ATTRB : <REGST> /
               NAME <REGST> OF <NSUBJ> _ <NSUBJ> : NODENAME : <REGST> /
               LIST <*TYPE> _ (LOOKATLIST[<TYPE>]) /
               SYMBOL (<*NODE>/<*ATTRIBUTE>)1 _ (LOOKATSYMBOL[#1]) /
               NIL _ (LOOKATSYMBOL).
<NODEWORD> ::= WORD (PRECEDING _ (FRSTL,PREVL)/
                     STARTING  _ (FRSTL)      /
                     ENDING    _ (LASTL,PREVL)/
                     FOLLOWING _ (LASTL)      ) PRESENT NODE.
<SENTWORD> ::= CURRENT WORD _ (WORDL) /
               PRECEDING WORD _ (WORDL,PREVL) /
               NEXT WORD _ (WORDL,NEXTL).
<XSUBJ>    ::= <*REG> _ (LOOK[<REG>]) /
               (PRESENT-ELEMENT- / PRESENT-STRING- / IT-) <REGST>
                   _  <REGST> /
               <ROUTINE> [<*NODE>_((<NODE>)) / <*TYPE>_(<TYPE>) /
                   '(' <ARGLIST> ')']1 <REGST> [OF <NSUBJ>]2
                   _ #2:(EXECUTE[(<ROUTINE> [#1])]):<REGST> .
<ROUTINE>  ::= <*NAME> _ <NAME> .TYP.(4).
<REGST>    ::= <*REG> _ (STORE [<REG>]) / <*NULL>.
*          LSUBJ:  SUBJECTS WHICH MAY LOOK AT A LIST ELEMENT
<LSUBJ>    ::= <LISTSUBJ> / <XSUBJ>.
*          NSUBJ:  SUBJECTS WHICH MAY LOOK AT A NODE
<NSUBJ>    ::= <NODESUBJ> / <XSUBJ>.
<PREDICATE>::= IS <BEPRED> <REGST> /
               IS NOT <BEPRED> _ (NOT [<BEPRED>]) /
               HAS <HAVEPRED> <REGST> /
               DOES NOT HAVE <HAVEPRED> _ (NOT [<HAVEPRED>]) /
               EXISTS /
               IS OCCURRING (IN/AS) <OCCPRED> <REGST> /
               IS NOT OCCURRING (IN/AS) <OCCPRED> _ (NOT [<OCCPRED>]) /
               DOES NOT OCCUR (IN/AS) <OCCPRED> _ (NOT [<OCCPRED>]) /
               SUBSUMES <SUBPRED> /
               DOES NOT SUBSUME <SUBPRED> _ (NOT [<SUBPRED>]).
<BEPRED>   ::= <ATOM-ATT> / <ATTRB> /
               <*DEF>1 (OR <*DEF>)*2 _ (IS[#1:#2]) /
               <*REG> _ (IS[<REG>]) /
               IDENTICAL TO <*REG> _ (IDENTICAL [<REG>]) /
               <TEXT-LIST> /
               OF TYPE <*TYPE> _ (IS[<TYPE>]) /
               EMPTY _ (EMPTY) /
               NIL _ (TESTFORNIL) /
               C-REDUNDANT _ (EXECUTE[(C-REDUNDANT)]) /
               ELEMENT OF <OR-NODE> _ (EXECUTE[(ELEMOF[(<OR-NODE>)])])/
               CORE OF <OR-NODE> _ (EXECUTE[(IMMEDIATE[(<OR-NODE>)])]) /
               STRING INITIAL _ (EXECUTE[(INITIALRT)]) .
<HAVEPRED> ::= VALUE <OR-NODE> _ (VALUE,IS[<OR-NODE>]) /
               ATTRIBUTE <ATT> /
               NODE ATTRIBUTE <*ATTRIBUTE> _ (HASATT[<ATTRIBUTE>]) /
               MEMBER <ATTRB-LIST> _ (MEMBER[<ATTRB-LIST>]) /
               ATTRIBUTE-LIST _ ATTRB /
               <ROUTINE> [<OR-NODE> _ (<OR-NODE>)]1
                   _ (EXECUTE[(<ROUTINE>[#1])]).
<OCCPRED>  ::= <OR-NODE> _ (EXECUTE[(IMMEDIATE[(<OR-NODE>)])]).
<SUBPRED>  ::= (<ATOM-ATT>/<TEXT-LIST>)1 _ (EXECUTE[(SUBSUMERT[(#1)])]).
<OR-NODE>  ::= <*NODE>1 (OR <*NODE>)*2 _ #1:#2 / <*TYPE>.
<ATOM-ATT> ::= <ATOM-LIST> [':' <ATT>]1 _ (IS[<ATOM-LIST>]):#1.
<ATT>      ::= <ATTRB-LIST> [':' <ATT>]1 _ (ATTRB[<ATTRB-LIST>]):#1.
<ATTRB>    ::= <*ATTRIBUTE>1 (OR <*ATTRIBUTE>)*2 [':' <ATT>]3
                   _ (ATTRB[#1:#2]):#3.
<ATOM-LIST>::= <*ATOM>1 (OR <*ATOM>)*2 _ #1:#2.
<ATTRB-LIST>::=<*REG>/ (<*ATTRIBUTE>/<*TEXT>/<*NODE>)1
                   (OR (<*ATTRIBUTE>/<*TEXT>/<*NODE>))*2 _ #1:#2 /
               <*TYPE>.
<TEXT-LIST>::= <TEXTTEST> /
               <XTEXT>1 OR <XTEXT>2 (OR <XTEXT>)*3 _ (OR[#1:#2:#3]).
<TEXTTEST> ::= <*TEXT> (<IDTEXT>)*1 _ (TEXTX[<TEXT>:#1]) .
<IDTEXT> ::= '_' <*TEXT>  _ <TEXT> .
<XTEXT>    ::= <TEXTTEST> _ (<TEXTTEST>).
<MONOSENT> ::= RARE SWITCH IS (ON _ (RARE) / OFF _ (NOT[(RARE)])) /
           REP SWITCH IS (ON _ (REP) / OFF _ (NOT[(REP)])) /
           REPARSE SWITCH IS (ON _ (REPARSESW) /
                     OFF _ (NOT[(REPARSESW)])) /
           NON-LOCAL SWITCH <*INTEGER>1 IS ON
               _ (TESTGLOBSW[#1]) /
           NON-LOCAL SWITCH <*INTEGER>1 IS OFF
               _ (NOT[(TESTGLOBSW[#1])]) /
           SEGMENT SWITCH IS (ON _ (SEGMENT) /
              OFF _ (NOT[(SEGMENT)])) /
           REPARSE _ (REPARSE[0]) /
           REPARSE WITH NEXT SEGMENT _ (REPARSE[1]) /
           REPARSE WITH PREVIOUS SEGMENT _ (REPARSE[2]) /
           PARSE HAS BEEN OBTAINED _ (PARSE) /
           THERE IS (<ATOM-ATT>/<TEXT-LIST>)1
               AHEAD _ (EXECUTE [(LOOKAHEAD[(#1)])]) /
           THERE ARE AT LEAST <*INTEGER> WORDS AHEAD
               _ (NWORD[<INTEGER>]) /
           EDIT BY <*ADDRESS> _ (EDIT [<ADDRESS>]) /
           ASSIGN [PRESENT (ELEMENT/STRING)] NODE ATTRIBUTE
                  <*ATTRIBUTE>
                  [WITH VALUE <NSUBJ>_(CANDO [<NSUBJ>:(STORE[X0])])]1
                  _ #1 : (ASSIGN[<ATTRIBUTE>]) /
           ERASE NODE ATTRIBUTE <*ATTRIBUTE> _ (ERASE[<ATTRIBUTE>])/
           THIS IS MIN WORD _ (MINWD) /
           LISTS <NSUBJ>1 AND <NSUBJ>2 HAVE COMMON ATTRIBUTE
                _ (COMMONAT[(#1,#2)]) /
           LISTS <NSUBJ>1 AND <NSUBJ>2 HAVE NO COMMON ATTRIBUTE
                _ (NOT[(COMMONAT[(#1,#2)])]).
<COMMAND> ::= GO <WHERE> /
              <*REG> ':' '=' <RSUBJ> _ <RSUBJ> : (STORE[<REG>]) /
              PREFIX <*REG>1 [':' <*REG>]2 TO <*REG>3
                 _(LOOK[#3], PREFIX[(#1[#2])], STORE[#3]) /
              PREFIX UNIQUELY <*REG>1 [':' <*REG>]2 TO <*REG>3
                  _(LOOK[#3], PREFIXUNIQ[(#1[#2])], STORE[#3]) /
              SUFFIX <*REG>1 [':' <*REG>]2 TO <*REG>3
                  _(LOOK[#3], SUFFIX[(#1[#2])], STORE[#3]) /
              SUFFIX UNIQUELY <*REG>1 [':' <*REG>]2 TO <*REG>3
                  _(LOOK[#3], SUFFIXUNIQ[(#1[#2])], STORE[#3]) /
              DESCEND TO <ROUTARG>1 [PASSING THROUGH <ROUTARG>]2
               [NOT PASSING THROUGH <ROUTARG>]3 _ (DNTRN[(#1,#2,#3)])/
              ASCEND TO <ROUTARG>1 [PASSING THROUGH <ROUTARG>]2
               [NOT PASSING THROUGH <ROUTARG>]3 _ (UPTRN[(#1,#2,#3)])/
              STACK _ (STACK) /
              STORE IN <*REG> _ (STORE [<REG>]) /
              <ITERATOR> /
              <WRITE-CMD> /
              TRUE _ (TRUE) / FALSE _ (NOT[(TRUE)]) /
              GENERATE OPTION SPANNING <*REG>1 TO <*REG>2
                  _ (GENER[(#1,#2)]) /
              GENERATE SYMBOL _ (GENSYM) /
              <DO-CMD> /
              VERIFY <RT> _ (CANDO [<RT>]) /
              TEST FOR(<ROUTARG> _ (IS[<ROUTARG>]) /
                     <*ATTRIBUTE> _ (IS[(<ATTRIBUTE>)]) )/
              EQUIV-MATCH USING (<*REG>/<*NAME>)1 OF ATT-LISTS <EQIN-REGS>2
                  INTO <EQOUT-REGS>3 [WITH REJECTION SET (<*REG>/<*NAME>)]4
                  _ (EQUIVMATCH[(#1,#2,#3,#4)])/
              INTERSECT <*REG>1 WITH <*REG>2 INTO <*REG>3
                 _ (INTERSECTOP[(#1,#2,#3)])/
              INTERSECT <*REG>1 WITH <*REG>2
                 _ (INTERSECTOP[(#1,#2)])/
              INTERSECT-CHK <*REG>1 WITH <*REG>2
                 _ (INTERSECTCHK[(#1,#2)])/
              UNION <*REG>1 WITH <*REG>2 INTO <*REG>3
                 _ (UNIONOP[(#1,#2,#3)])/
              COMPLEMENT <*REG>1 WITH <*REG>2 INTO <*REG>3
                 _ (COMPLEMENTOP[(#1,#2,#3)]) /
           FOR EVERY NODE DO <*ADDRESS> _ (EVERY-NODE[<ADDRESS>])/
           SET LOGIC SWITCH <*INTEGER> _ (SETLOGSW[<INTEGER>])/
           CLEAR LOGIC SWITCH <*INTEGER> _ (CLEARLOGSW[<INTEGER>])/
           CLEAR LOGIC (SWITCH/SWITCHES) ALL _ (CLEARLOGSWALL)/
           TOGGLE LOGIC SWITCH <*INTEGER> _ (TOGLOGSW[<INTEGER>])/
           TEST LOGIC SWITCH <*INTEGER> _ (TESTLOGSW[<INTEGER>])/
           SET NON-LOCAL SWITCH  <*INTEGER> _ (SETGLOBSW[<INTEGER>])/
           CLEAR NON-LOCAL SWITCH <*INTEGER> _ (CLEARGLOBSW[<INTEGER>])/
           CREATEIDIOM WITH DEFINITION OF <*REG>1 _ (CREATE-IDIOM[#1]) .
<WHERE>    ::= UP _ (UPONE) / DOWN _ (DOWN) /
               LEFT _ (LEFT) / RIGHT _ (RIGHT) /
               TO (<NODEWORD> / <*REG> _ (LOOK[<REG>]) /
                   CURRENT WORD _ (WORDL) / PRECEDING WORD _ (PREVL) /
                   NEXT WORD _ (NEXTL) ) .
<EQIN-REGS> ::= (<*REG>)*1 _ #1 .
<EQOUT-REGS> ::= (<*REG>)*1 _ #1 .
<ITERATOR> ::= ITERATE <RT> _ (ITER [(<RT>)]) /
               ITERATE <RT>1 UNTIL <RT>2 SUCCEEDS _ (ITER[(#1,#2)]) /
               ITERATE <RT>1 UNTIL <RT>2 FAILS _ (ITERF[(#1,#2)]) /
               ITERATET <RT>1 UNTIL <RT>2 SUCCEEDS _ (ITERT[(#1,#2)]) /
               ITERATET <RT>1 UNTIL <RT>2 FAILS _ (ITERFT[(#1,#2)]) .
<DO-CMD>   ::= DO (<*ADDRESS> / <*REG>)1 _ (EXEC[#1]) /
               DO <ROUTINE> [ '(' <ARGLIST> ')' ]1
                   _ (EXECUTE[(<ROUTINE>[#1])]) .
<ARGLIST>  ::= <ARG> (',' <ARG>)*.
<ARG>      ::= <ROUTARG> _ (<ROUTARG>).
<WRITE-CMD>::= WRITE ON (DIAG _ 1/INFO _ 2/STD _ 3)1
                      (<*TEXT> /
                       IDENTIFICATION _ 1 /
                       NODE NAME _ 2 /
                       LIST ELEMENT _ 2 /
                       WORD _ 2 /
                       WORDS SUBSUMED _ 3 /
                       END OF LINE _ 4 /
                       SENTEXT _ 5 /
                       LIST _ 6 /
                       PARSE TREE (WITH WORD FORMS _ 7 / <*NULL> _ 8) /
                       PARSE SUBTREE  _ 9 )2
                        _ (WRITE[(#1,#2)]) .
<ROUTARG>  ::= <*NODE>1 (OR <*NODE>)*2 _ #1:#2 / [TYPE] <*TYPE> /
               <*REG>.
<TRANSFORM>::= TRANSFORM <NSUBJ> _ <NSUBJ> : TRANSFORM /
               DEACTIVATE _ (DEACTIVATE) /
               REPLACE <NSUBJ> BY <STRUCTURE>
                   _ <STRUCTURE> : <NSUBJ> : REPLACE /
               DELETE <NSUBJ> _ <NSUBJ> : REPLACE /
               BEFORE <NSUBJ> INSERT <STRUCTURE>
                   _ <STRUCTURE> : <NSUBJ> : INSERTBEFORE /
               AFTER <NSUBJ> INSERT <STRUCTURE>
                   _ <STRUCTURE> : <NSUBJ> : INSERTAFTER .
<STRUCTURE>::= <ITEM> (<FOLLOWING-ITEM>)*.
<CHILDREN> ::= '(' <STRUCTURE> ')' _ <STRUCTURE> : BUILDUP .
<ITEM>     ::= '<' <*NODE> '>' <REGST> <WATT> [<CHILDREN>]1
                   _ (CANDO[ (CREATE[<NODE>]):<REGST>]):BUILDDOWN:
                   <WATT>:#1 /
               <*TEXT> <REGST>
                   _ (CANDO[ (CREATE[<TEXT>]):<REGST> ]):BUILDDOWN /
               <CLASS-SPEC> _ <CLASS-SPEC> : BUILDDOWN /
               <NSUBJ> <CREGST> <CHILDREN> _ (CANDO [<NSUBJ> : COPY :
                   <CREGST> ]) : BUILDDOWN : <CHILDREN> /
               <NSUBJ> <CREGST> _ (CANDO [ <NSUBJ> : (COPY[1]) :
                   <CREGST> ]) : BUILDDOWN /
               ALL ELEMENTS OF <NSUBJ> _ (CANDO [<NSUBJ>:VALUE:(CANDO[(
                   COPY[1])],BUILDDOWN,ITERFT [((CANDO[(COPY[1],
                   BUILDRIGHT)]), (RIGHT))])]).
<FOLLOWING-ITEM> ::= '+' (
               '<' <*NODE> '>' <REGST> <WATT> [<CHILDREN>]1
                   _ (CANDO[ (CREATE[<NODE>]):<REGST> ]):BUILDRIGHT:
                   <WATT>:#1 /
               <*TEXT> <REGST>
                   _ (CANDO[ (CREATE[<TEXT>]):<REGST> ]):BUILDRIGHT /
               <CLASS-SPEC> _ <CLASS-SPEC> : BUILDRIGHT /
               <NSUBJ> <CREGST> <CHILDREN> _ (CANDO [<NSUBJ> : COPY :
                   <CREGST> ]) : BUILDRIGHT : <CHILDREN> /
               <NSUBJ> <CREGST> _ (CANDO [ <NSUBJ> : (COPY[1]) :
                   <CREGST> ]) : BUILDRIGHT /
               ALL ELEMENTS OF <NSUBJ> _ (CANDO [ <NSUBJ> : VALUE :
                   (ITERF [((CANDO [(COPY[1],BUILDRIGHT)] ),
                            (RIGHT))] )] ) ).
<CREGST>   ::= ',' <*REG> _ (STORE [<REG>]) / <*NULL>.
<CLASS-SPEC>::=
               CLASS <*ATOM> ':' '(' <ATTRIBS>1 (',' <ATTRIBS>)*2
               ')' OF <NSUBJ> <CREGST>
                 _ (CANDO [<NSUBJ> : (CLASS[(<ATOM>[#1:#2 ])])
               : <CREGST>]) /
               CLASS  <*ATOM> ':' <*REG>  OF <NSUBJ> <CREGST>
                  _ (CANDO [<NSUBJ> : (CLASS [(<ATOM> [ <REG>])])
               : <CREGST>]) /
               CLASS <*ATOM> OF <NSUBJ> <CREGST>
                   _ (CANDO [<NSUBJ> : (CLASS[<ATOM>]) : <CREGST>]).
   <ATTRIBS>   ::= <*ATTRIBUTE>1
                      ':' '(' <*ATTRIBUTE>2
                                        (',' <*ATTRIBUTE>)*3 ')'
                   _ (#1[#2:#3]) /
                   <*ATTRIBUTE> _ <ATTRIBUTE> .
<WATT>     ::= '=' (<*NAME> _ <NAME> .TXT / <*TEXT>)1
                   [':' '(' <NATTRBL> ')']2
                   ['^' '(' <NATTRBL> ')']3
                   _ (BUILDWORD [(#1[#2]):#3] ) / <*NULL>.
*
*     S Y N T A X   O F   W O R D   D I C T I O N A R Y
*
<WDWORDSENT>   ::= <WORDDEFN> / <WDLIST> .
<WORDDEFN> ::= <WORD> [<NATTRBL>]1 '.'
                   _ (<WORD> [NHEAD] #1) .END.(6) /
               <WORD> '(' <*NAME> ')' '.'
                   _ (<WORD> [NHEAD] <NAME>) .END.(8).
<WORD>     ::= (<*NAME>/<*TEXT>)1 (<IDIOM-WORD>)* ['^' _ .DERIV]_#1.
<IDIOM-WORD>::='_' (<*NAME>/<*TEXT>)1 _ #1 .IDIOM.
<NATTRBL>  ::= <ATNODE> (',' <ATNODE>)*.
<ATNODE>   ::= (<*ATTRIBUTE>/<*TEXT>/<*NODE>)1
                   [':' (<*LINO>/'(' <NATTRBL> ')')]2 _ (#1[#2])/
               '(' <NATTRBL> ')' _ (<NATTRBL>).
<WDLIST>   ::= <*LINO> '=' <NATTRBL> '.'
                   _ (<LINO> [NHEAD] <NATTRBL>) .END.(7).
<WDCANSENT>  ::= '(' <*NAME> ')' '=' <NATTRBL> '.'
                   _ (<NAME> [NHEAD] <NATTRBL>) .END.(9).
*CLOSE()
