lexer.java

一个类似于openJMS分布在ObjectWeb之下的JMS消息中间件。

   *
   * @param number  the number of characters to be read again.
   *                This number must not be greater than yylength()!
   */
  private void yypushback(int number)  {
    if ( number > yylength() )
      yy_ScanError(YY_PUSHBACK_2BIG);

    yy_markedPos -= number;
  }


  /**
   * Contains user EOF-code, which will be executed exactly once,
   * when the end of file is reached
   */
  private void yy_do_eof() throws java.io.IOException {
    if (!yy_eof_done) {
      yy_eof_done = true;
      yyclose();
    }
  }


  /**
   * Resumes scanning until the next regular expression is matched,
   * the end of input is encountered or an I/O-Error occurs.
   *
   * @return      the next token
   * @exception   IOException  if any I/O-Error occurs
   */
  public java_cup.runtime.Symbol next_token() throws java.io.IOException {
    int yy_input;
    int yy_action;


    while (true) {

      boolean yy_r = false;
      for (yy_currentPos = yy_startRead; yy_currentPos < yy_markedPos;
                                                      yy_currentPos++) {
        switch (yy_buffer[yy_currentPos]) {
        case '\u000B':
        case '\u000C':
        case '\u0085':
        case '\u2028':
        case '\u2029':
          yyline++;
          yycolumn = 0;
          yy_r = false;
          break;
        case '\r':
          yyline++;
          yycolumn = 0;
          yy_r = true;
          break;
        case '\n':
          if (yy_r)
            yy_r = false;
          else {
            yyline++;
            yycolumn = 0;
          }
          break;
        default:
          yy_r = false;
          yycolumn++;
        }
      }

      if (yy_r) {
        if ( yy_advance() == '\n' ) yyline--;
        if ( !yy_atEOF ) yy_currentPos--;
      }

      yy_action = -1;

      yy_currentPos = yy_startRead = yy_markedPos;

      yy_state = yy_lexical_state;


      yy_forAction: {
        while (true) {

          yy_input = yy_advance();

          if ( yy_input == YYEOF ) break yy_forAction;

          int yy_next = yytrans[ yy_rowMap[yy_state] + yycmap[yy_input] ];
          if (yy_next == -1) break yy_forAction;
          yy_state = yy_next;

          int yy_attributes = YY_ATTRIBUTE[yy_state];
          if ( (yy_attributes & 1) > 0 ) {
            yy_action = yy_state; 
            yy_markedPos = yy_currentPos; 
            if ( (yy_attributes & 8) > 0 ) break yy_forAction;
          }

        }
      }


      switch (yy_action) {

        case 0: 
        case 70: 
        case 71: 
          {  return symbol(sym.STRING, new String(yytext())); }
        case 144: break;
        case 118: 
          {  return symbol(sym.NOTBETWEEN);  }
        case 145: break;
        case 101: 
          {  return symbol(sym.BETWEEN);  }
        case 146: break;
        case 96: 
          {  return symbol(sym.ESCAPE);  }
        case 147: break;
        case 30: 
        case 39: 
        case 62: 
        case 136: 
        case 138: 
        case 139: 
        case 140: 
        case 141: 
        case 142: 
          {  return symbol(sym.DOUBLE, new Double(yytext()));  }
        case 148: break;
        case 29: 
        case 34: 
        case 35: 
        case 36: 
        case 60: 
        case 61: 
        case 76: 
        case 77: 
        case 87: 
        case 88: 
        case 93: 
        case 94: 
        case 99: 
        case 100: 
        case 104: 
        case 105: 
        case 108: 
        case 109: 
        case 112: 
        case 113: 
        case 116: 
        case 117: 
        case 120: 
        case 121: 
        case 123: 
        case 124: 
        case 126: 
        case 127: 
        case 129: 
        case 130: 
        case 132: 
        case 133: 
        case 135: 
          {  return symbol(sym.INT, new Integer((int) parseLong(yytext(),8)));  }
        case 149: break;
        case 25: 
          {  return symbol(sym.COMMA);  }
        case 150: break;
        case 24: 
          {  return symbol(sym.GT);  }
        case 151: break;
        case 23: 
          {  return symbol(sym.LT);  }
        case 152: break;
        case 22: 
          {  return symbol(sym.EQ);  }
        case 153: break;
        case 21: 
          {  return symbol(sym.RPAREN);  }
        case 154: break;
        case 20: 
          {  return symbol(sym.LPAREN);  }
        case 155: break;
        case 19: 
          {  return symbol(sym.DIVIDE);  }
        case 156: break;
        case 1: 
        case 10: 
        case 15: 
        case 16: 
          {  throw new Error("Illegal character <"+yytext()+"> at line "+yyline+", column "+yycolumn);  }
        case 157: break;
        case 2: 
        case 3: 
          {  /* just skip what was found, do nothing */  }
        case 158: break;
        case 4: 
        case 5: 
          {  return symbol(sym.INT, new Integer(yytext()));  }
        case 159: break;
        case 6: 
        case 7: 
        case 8: 
        case 9: 
        case 11: 
        case 13: 
        case 14: 
        case 26: 
        case 27: 
        case 28: 
        case 41: 
        case 42: 
        case 43: 
        case 44: 
        case 45: 
        case 46: 
        case 52: 
        case 53: 
        case 64: 
        case 65: 
        case 66: 
        case 67: 
        case 68: 
        case 72: 
        case 79: 
        case 80: 
        case 89: 
        case 90: 
        case 95: 
          {  return symbol(sym.ID, new String(yytext()));  }
        case 160: break;
        case 12: 
          {  return symbol(sym.MINUS);  }
        case 161: break;
        case 17: 
          {  return symbol(sym.PLUS);  }
        case 162: break;
        case 18: 
          {  return symbol(sym.TIMES);  }
        case 163: break;
        case 31: 
          {  if ((yytext().substring(0,yylength()-1)).equals((Long.MIN_VALUE+"").substring(1,yylength())))
                              return symbol(sym.MIN_LONG, new Long(Long.MIN_VALUE));
                            return symbol(sym.LONG, new Long(yytext().substring(0,yylength()-1))); 
                           }
        case 164: break;
        case 32: 
          {  return symbol(sym.SHORT, new Short(yytext().substring(0,yylength()-1)));  }
        case 165: break;
        case 37: 
          {  return symbol(sym.FLOAT, new Float(yytext()));  }
        case 166: break;
        case 38: 
          {  return symbol(sym.DOUBLE, new Double(yytext().substring(0,yylength()-1)));  }
        case 167: break;
        case 49: 
          {  return symbol(sym.LE);  }
        case 168: break;
        case 50: 
          {  return symbol(sym.NEQ);  }
        case 169: break;
        case 51: 
          {  return symbol(sym.GE);  }
        case 170: break;
        case 54: 
          {  return symbol(sym.OR);  }
        case 171: break;
        case 55: 
          {  return symbol(sym.IS);  }
        case 172: break;
        case 56: 
          {  return symbol(sym.IN);  }
        case 173: break;
        case 57: 
          {  return symbol(sym.LONG, new Long(parseLong(yytext().substring(0,yylength()-1),8)));  }
        case 174: break;
        case 58: 
        case 59: 
        case 75: 
        case 86: 
        case 92: 
        case 98: 
        case 103: 
        case 107: 
        case 111: 
          {  return symbol(sym.INT, new Integer((int) parseLong(yytext().substring(2),16)));  }
        case 175: break;
        case 69: 
          {  return symbol(sym.AND);  }
        case 176: break;
        case 73: 
          {  return symbol(sym.NOT);  }
        case 177: break;
        case 74: 
          {  return symbol(sym.LONG, new Long(parseLong(yytext().substring(2,yylength()-1),16)));  }
        case 178: break;
        case 78: 
          {  return symbol(sym.LIKE);  }
        case 179: break;
        case 81: 
          {  return symbol(sym.BOOLEAN, new Boolean(yytext()));  }
        case 180: break;
        case 84: 
          {  return symbol(sym.NULL);  }
        case 181: break;
        default: 
          if (yy_input == YYEOF && yy_startRead == yy_currentPos) {
            yy_atEOF = true;
            yy_do_eof();
              { return new java_cup.runtime.Symbol(sym.EOF); }
          } 
          else {
            yy_ScanError(YY_NO_MATCH);
          }
      }
    }
  }


}