lexparse.cup

java语法解释器生成器

                ;
                

rules         ::=  rules:rlist rule:r
                   {: rlist.addElement(r); RESULT = rlist; :}
                |  rules:rlist1 LESSTHAN states:states MORETHAN LBRACE rules:rlist2 RBRACE
                   {: 
                     Enumeration rs = rlist2.elements();
                     while ( rs.hasMoreElements() ) {
                       Integer elem = (Integer) rs.nextElement();
                       // might be null for error case of "rule"
                       if (elem != null) { 
                         regExps.addStates( elem.intValue(), states );
                       }
                       rlist1.addElement( elem );
                     }                       
                     RESULT = rlist1;
                   :}
                |  LESSTHAN states:states MORETHAN LBRACE rules:rlist RBRACE
                   {: 
                     Enumeration rs = rlist.elements();
                     while ( rs.hasMoreElements() ) {
                       Integer elem = (Integer) rs.nextElement();
                       // might be null for error case of "rule"
                       if (elem != null) { 
                         regExps.addStates( elem.intValue(), states );
                       }
                     }                       
                     RESULT = rlist;
                   :}
                |  rule:r
                   {: RESULT = new Vector(); RESULT.addElement(r); :}
                ;  

rule          ::=  statesOPT:s hatOPT:bol series:r actions:a
                   {: RESULT = new Integer(regExps.insert(rleft, s, r, a, bol, null)); :}
                |  statesOPT:s hatOPT:bol series:r lookahead:l act:a
                   {: RESULT = new Integer(regExps.insert(rleft, s, r, a, bol, l)); :}
                |  statesOPT:s hatOPT:bol series:r lookahead:l NOACTION:a
                   {: syntaxError(ErrorMessages.LOOKAHEAD_NEEDS_ACTION, aleft, aright+1); :}
                |  statesOPT:s EOFRULE ACTION:a
                   {: RESULT = new Integer(regExps.insert(s, a)); :}
                |  error                
                ;

lookahead     ::=  DOLLAR
                   {: RESULT = makeNL(); :}
                |  LOOKAHEAD series:r
                   {: RESULT = r; :}
                |  LOOKAHEAD series:s DOLLAR
                   {: RESULT = new RegExp2(sym.CONCAT, s, makeNL()); :}
                ;

act           ::=  REGEXPEND ACTION:a
                   {: RESULT = a; :}
				;

actions       ::=  act:a
                   {: RESULT = a; :}
                |  NOACTION
                ;

                
statesOPT     ::=  LESSTHAN states:list MORETHAN          
                   {: RESULT = list; :}
                |  /* empty */
                   {: RESULT = new Vector(); :}                   
                ;
                
states        ::=  IDENT:id COMMA states:list
                   {:
                     stateNumber = scanner.states.getNumber( id );
                     if ( stateNumber != null )
                       list.addElement( stateNumber ); 
                     else {
                       throw new ScannerException(scanner.file, ErrorMessages.LEXSTATE_UNDECL, 
                                                  idleft, idright);
                     }
                     RESULT = list;
                   :}                
                |  IDENT:id
                   {:
                     Vector list = new Vector();
                     stateNumber = scanner.states.getNumber( id );
                     if ( stateNumber != null )
                       list.addElement( stateNumber ); 
                     else {
                       throw new ScannerException(scanner.file, ErrorMessages.LEXSTATE_UNDECL, 
                                                  idleft, idright);
                     }
                     RESULT = list;
                   :}
                 | IDENT COMMA:c
                   {: syntaxError(ErrorMessages.REGEXP_EXPECTED, cleft, cright+1); :}
                ;
                
hatOPT        ::=  HAT 
                   {: // assumption: there is no upper case for \n
                      charClasses.makeClass('\n', false); 
                      RESULT = new Boolean(true); :}
                |  /* empty */ 
                   {: RESULT = new Boolean(false); :}
                ;
                
series        ::= series:r1 BAR concs:r2
                  {: RESULT = new RegExp2(sym.BAR, r1, r2); :}                 
                | concs:r
                  {: RESULT = r; :} 
                | BAR:b
                  {: syntaxError(ErrorMessages.REGEXP_EXPECTED, bleft, bright); :}
                ;
               
concs         ::= concs:r1 nregexp:r2
                  {: RESULT = new RegExp2(sym.CONCAT, r1, r2); :} 
                | nregexp:r
                  {: RESULT = r; :}
                ;

nregexp       ::= regexp:r
                  {: RESULT = r; :}
                | BANG nregexp:r
                  {: RESULT = new RegExp1(sym.BANG, r); :}
                | TILDE nregexp:r
                  {: RESULT = new RegExp1(sym.TILDE, r); :}
                ;

regexp        ::=  regexp:r STAR
                   {: RESULT = new RegExp1(sym.STAR, r); :}
                |  regexp:r PLUS
                   {: RESULT = new RegExp1(sym.PLUS, r); :}
                |  regexp:r QUESTION
                   {: RESULT = new RegExp1(sym.QUESTION, r); :}
                |  regexp:r REPEAT:n RBRACE:b
                   {: RESULT = makeRepeat(r, n.intValue(), n.intValue(), bleft, bright); :}
                |  regexp:r REPEAT:n1 REPEAT:n2 RBRACE
                   {: RESULT = makeRepeat(r, n1.intValue(), n2.intValue(), n1left, n2right); :}
                |  OPENBRACKET series:r CLOSEBRACKET
                   {: RESULT = r; :}
                |  MACROUSE:ident
                   {: 
                      if ( !scanner.macroDefinition ) {
                        if ( ! macros.markUsed(ident) ) 
                          throw new ScannerException(scanner.file, ErrorMessages.MACRO_UNDECL, 
                                                     identleft, identright);
                      }
                      RESULT = new RegExp1(sym.MACROUSE, ident); 
                   :}
                |  charclass:c
                   {: RESULT = c; :}
                |  preclass:list
                   {:
                     try {
                       // assumption [correct?]: preclasses are already closed under case
                       charClasses.makeClass(list, false);
                     }
                     catch (CharClassException e) {
                       syntaxError(ErrorMessages.CHARSET_2_SMALL, listleft);
                     }
                     RESULT = new RegExp1(sym.CCLASS, list);
                   :}
                |  STRING:str
                   {: 
                     try {
                       if ( scanner.caseless ) {
                         charClasses.makeClass(str, true);
                         RESULT = new RegExp1(sym.STRING_I, str);
                       }
                       else {
                         charClasses.makeClass(str, false);
                         RESULT = new RegExp1(sym.STRING, str); 
                       }
                     }
                     catch (CharClassException e) {
                       syntaxError(ErrorMessages.CS2SMALL_STRING, strleft, strright);
                     }

                   :}
                |  POINT
                   {: 
                      Vector any = new Vector();
                      any.addElement(new Interval('\n','\n'));
                      // assumption: there is no upper case for \n
                      charClasses.makeClass('\n', false);
                      RESULT = new RegExp1(sym.CCLASSNOT, any); 
                   :}
                |  CHAR:c
                   {: 
                     try {
                       if ( scanner.caseless ) {
                         charClasses.makeClass(c.charValue(), true);
                         RESULT = new RegExp1(sym.CHAR_I, c);
                       }
                       else {
                         charClasses.makeClass(c.charValue(), false);
                         RESULT = new RegExp1(sym.CHAR, c); 
                       }
                     }
                     catch (CharClassException e) {
                       syntaxError(ErrorMessages.CS2SMALL_CHAR, cleft, cright);
                     }
                   :}
                ;

charclass     ::=  OPENCLASS CLOSECLASS
                   {: 
                     RESULT = new RegExp1(sym.CCLASS,null);
                   :}
                |  OPENCLASS classcontent:list CLOSECLASS:close
                   {: 
                     try {
                       charClasses.makeClass(list, Options.jlex && scanner.caseless);
                     }
                     catch (CharClassException e) {
                       syntaxError(ErrorMessages.CHARSET_2_SMALL, closeleft, closeright);
                     }
                     RESULT = new RegExp1(sym.CCLASS,list);
                   :}
                |  OPENCLASS HAT CLOSECLASS:close
                   {: 
                     Vector list = new Vector();
                     list.addElement(new Interval((char)0,CharClasses.maxChar));
                     try {
                       charClasses.makeClass(list, false);
                     }
                     catch (CharClassException e) {
                       syntaxError(ErrorMessages.CHARSET_2_SMALL, closeleft, closeright);
                     }
                     RESULT = new RegExp1(sym.CCLASS,list);
                   :}
                |  OPENCLASS HAT classcontent:list CLOSECLASS:close
                   {: 
                     try {
                       charClasses.makeClassNot(list, Options.jlex && scanner.caseless);
                     }
                     catch (CharClassException e) {
                       syntaxError(ErrorMessages.CHARSET_2_SMALL, closeleft, closeright);
                     }
                     RESULT = new RegExp1(sym.CCLASSNOT,list);
                   :}
                | OPENCLASS DASH classcontent:list CLOSECLASS:close
                   {: 
                     try {
                       list.addElement(new Interval('-','-'));
                       charClasses.makeClass(list, Options.jlex && scanner.caseless);
                     }
                     catch (CharClassException e) {
                       syntaxError(ErrorMessages.CHARSET_2_SMALL, closeleft, closeright);
                     }
                     RESULT = new RegExp1(sym.CCLASS,list);
                   :}
                |  OPENCLASS HAT DASH classcontent:list CLOSECLASS:close
                   {: 
                     try {
                       list.addElement(new Interval('-','-'));
                       charClasses.makeClassNot(list, Options.jlex && scanner.caseless);
                     }
                     catch (CharClassException e) {
                       syntaxError(ErrorMessages.CHARSET_2_SMALL, closeleft, closeright);
                     }
                     RESULT = new RegExp1(sym.CCLASSNOT,list);
                   :}
                ;

classcontent  ::=  classcontent:list classcontentelem:elem
                   {:
                     list.addElement(elem);
                     RESULT = list;
                   :}
                |  classcontentelem:elem
                   {:
                     Vector list = new Vector();
                     list.addElement(elem);
                     RESULT = list;
                   :}
                |  classcontent:list preclass:plist
                   {:
                     for (Enumeration e = plist.elements(); e.hasMoreElements();)
                       list.addElement(e.nextElement());
                     RESULT = list;
                   :}
                |  preclass:list 
                   {: RESULT = list; :}
                |  classcontent:list STRING:s
                   {: 
                      for (int i = 0; i < s.length(); i++)
                        list.addElement(new Interval(s.charAt(i),s.charAt(i)));
                      RESULT = list;
                   :}
                |  STRING:s
                   {: 
                      RESULT = new Vector();
                      for (int i = 0; i < s.length(); i++)
                        RESULT.addElement(new Interval(s.charAt(i),s.charAt(i)));
                   :}
                |  classcontent:list MACROUSE:ident
                   {: 
                     syntaxError(ErrorMessages.CHARCLASS_MACRO, identleft, identright);
                   :}
                |  MACROUSE:ident
                   {: 
                     syntaxError(ErrorMessages.CHARCLASS_MACRO, identleft, identright);
                   :}
                ;

classcontentelem ::= CHAR:c1 DASH CHAR:c2
                     {: RESULT = new Interval(c1.charValue(), c2.charValue()); :}
                   | CHAR:c
                     {: RESULT = new Interval(c.charValue(), c.charValue()); :}
                   ;
                   
preclass ::= JLETTERCLASS
             {: RESULT = makePreClass(sym.JLETTERCLASS); :}
           | JLETTERDIGITCLASS 
             {: RESULT = makePreClass(sym.JLETTERDIGITCLASS); :}
           | LETTERCLASS
             {: RESULT = makePreClass(sym.LETTERCLASS); :}
           | DIGITCLASS
             {: RESULT = makePreClass(sym.DIGITCLASS); :}
           | UPPERCLASS
             {: RESULT = makePreClass(sym.UPPERCLASS); :}
           | LOWERCLASS
             {: RESULT = makePreClass(sym.LOWERCLASS); :}
           ;