*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, WRITE-ON,
  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,MAXWDCK,SAVEBIT,REPARSESW, TERMPAR, CREATE-IDIOM.
RESERVED ROUTINES (4) =
  STARTAT, NELEMRT, IMMEDIATE, ELEMOF, 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>
                   _ PRESENT : <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])]) /
           SAVE SWITCH IS ON _ (SAVEBIT[3]) /
           SAVE SWITCH IS OFF _ (NOT[(SAVEBIT[3])]) /
           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)])])/
           END WORD OF NODE IS GREATER THAN MAXWORD _ (MAXWDCK[1]) /
           END WORD OF NODE IS LESS THAN MAXWORD _ (MAXWDCK[2])/
           END WORD OF NODE IS LESS THAN OR EQUAL TO MAXWORD
             _ (MAXWDCK[3])/
           END WORD OF NODE IS GREATER THAN OR EQUAL TO MAXWORD
             _ (MAXWDCK[4])/
           END WORD OF NODE IS EQUAL TO MAXWORD_ (MAXWDCK[5]).
*               EQUIV-MATCH USING (<*REG>/<*NAME>)1 OF <EQINARG>2
*                   INTO <EQOTARG>3 SETTING LOGIC SWITCH <EQLSN>4
*                   _ (EQUIVMATCH[(#1,#2,#3,#4)])/
<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>)]) )/
               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)]) /
           TERMINATE PARSING _ (TERMPAR)/
           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 SAVE SWITCH  _ (SAVEBIT[1]) /
           CLEAR SAVE SWITCH  _ (SAVEBIT[2])/
           SET NON-LOCAL SWITCH  <*INTEGER> _ (SETGLOBSW[<INTEGER>])/
           CLEAR NON-LOCAL SWITCH <*INTEGER> _ (CLEARGLOBSW[<INTEGER>])/
           CREATEIDIOM WITH DEFINITION OF <*REG>1 _ (CREATE-IDIOM[#1]) .
<EQINARG> ::= <*REG>1 (<EQREG>)*2 _ #1:#2.
<EQOTARG> ::= <*REG>1 (<EQREG>)*2 _ #1:#2.
<EQREG> ::= ',' <*REG> _ <REG>.
<WHERE>    ::= UP _ (UPONE) / DOWN _ (DOWN) /
               LEFT _ (LEFT) / RIGHT _ (RIGHT) /
               TO (<NODEWORD> / <*REG> _ (LOOK[<REG>]) /
                   CURRENT WORD _ (WORDL) / PRECEDING WORD _ (PREVL) /
                   NEXT WORD _ (NEXTL) ) .
<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 ( <*TEXT> /
                       IDENTIFICATION _ 1 /
                       SENTEXT _ 8 /
                       NODE NAME _ 2 /
                       LIST ELEMENT _ 2 /
                       LIST _ 9 /
                       WORD _ 2 /
                       DRAW TREE _ 13 /
                       WORDS SUBSUMED _ 3 /
                       PARSE-TREE DISPLAY  _ 12 /
                       END OF LINE _ 4 /
                       PARSE TREE (WITH WORD FORMS _ 7 / <*NULL> _ 5) /
                       SOURCE _ 6      )1 _ (WRITE[#1]) .
<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>.
<NATTRBL>  ::= <ATNODE> (','  <ATNODE>)*.
<ATNODE>   ::= (<*ATTRIBUTE>/<*TEXT>/<*NODE>)1
                   [':' '(' <NATTRBL> ')']2 _ (#1[#2])/
               '(' <NATTRBL> ')' _ (<NATTRBL>).
*     S Y N T A X   O F   W O R D   D I C T I O N A R Y
*
<WDCANSENT>   ::= <CSFDEFN>.
<WDWORDSENT>   ::= <WORDDEFN> / <WDLIST> .
<WORDDEFN> ::= <WORD> ['^' _ .DERIV] [<WDATTRBL>]1 '.'
                   _ (<WORD> [NHEAD] #1) .END.(6) /
               <WORD> ['^' _ .DERIV] '(' <*NAME> ')' '.'
                   _ (<WORD> [NHEAD] <NAME>) .END.(8).
<WORD>     ::= <*TEXT> (<IDIOM-WORD>)* _ <TEXT>.
<IDIOM-WORD>::='_' <*TEXT> _ <TEXT> .IDIOM.
<WDATTRBL>  ::= (<WDATNODE> / <WDSPATNODE>) (',' (<WDATNODE>/<WDSPATNODE>))*.
<WDATNODE>   ::= (<*ATTRIBUTE>/<*TEXT>/<*NODE>)1
                   [':' ((<*LINO>)/'(' <WDATTRBL> ')')]2 _ (#1[#2])/
               '(' <WDATTRBL> ')' _ (<WDATTRBL>).
<WDSPATNODE>   ::= (<*ATTRIBUTE>/<*TEXT>/<*NODE>)1
                   ':' '(' <*LINO>2 ',' <WDATTRBL> ')' 
                _ (#1[#2:<WDATTRBL>])/
               '(' <WDATTRBL> ')' _ (<WDATTRBL>).
<WDLIST>   ::= <*LINO> '=' <WDATTRBL> '.'
                   _ (<LINO> [NHEAD] <WDATTRBL>) .END.(7).
<CSFDEFN>  ::= '(' <*NAME> ')' '=' <WDATTRBL> '.'
                   _ (<NAME> [NHEAD] <WDATTRBL>) .END.(9).
*CLOSE()
