Coverage Report - org.apache.ojb.odmg.oql.OQLLexer
 
Classes in this File Line Coverage Branch Coverage Complexity
OQLLexer
N/A
N/A
N/A
N/A
8.848
 
 1   
 // $ANTLR 2.7.5 (20050128): "oql-ojb.g" -> "OQLLexer.java"$
 2   
 
 3   
 /* Copyright 2003-2005 The Apache Software Foundation
 4   
  *
 5   
  * Licensed under the Apache License, Version 2.0 (the "License");
 6   
  * you may not use this file except in compliance with the License.
 7   
  * You may obtain a copy of the License at
 8   
  *
 9   
  *     http://www.apache.org/licenses/LICENSE-2.0
 10   
  *
 11   
  * Unless required by applicable law or agreed to in writing, software
 12   
  * distributed under the License is distributed on an "AS IS" BASIS,
 13   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14   
  * See the License for the specific language governing permissions and
 15   
  * limitations under the License.
 16   
  */
 17   
 
 18   
 package org.apache.ojb.odmg.oql;
 19   
 
 20   
 
 21   
 import java.io.InputStream;
 22   
 import antlr.TokenStreamException;
 23   
 import antlr.TokenStreamIOException;
 24   
 import antlr.TokenStreamRecognitionException;
 25   
 import antlr.CharStreamException;
 26   
 import antlr.CharStreamIOException;
 27   
 import antlr.ANTLRException;
 28   
 import java.io.Reader;
 29   
 import java.util.Hashtable;
 30   
 import antlr.CharScanner;
 31   
 import antlr.InputBuffer;
 32   
 import antlr.ByteBuffer;
 33   
 import antlr.CharBuffer;
 34   
 import antlr.Token;
 35   
 import antlr.CommonToken;
 36   
 import antlr.RecognitionException;
 37   
 import antlr.NoViableAltForCharException;
 38   
 import antlr.MismatchedCharException;
 39   
 import antlr.TokenStream;
 40   
 import antlr.ANTLRHashString;
 41   
 import antlr.LexerSharedInputState;
 42   
 import antlr.collections.impl.BitSet;
 43   
 import antlr.SemanticException;
 44   
 
 45   
 /**
 46   
  * This OQL grammar has been derived from a OQL sample grammar from the ODMG
 47   
  * WebSite. The original grammar is copyright protected by MicroData Base
 48   
  * Systems: Copyright (c) 1999 Micro Data Base Systems, Inc. All rights
 49   
  * reserved.
 50   
  *
 51   
  * The original grammar has been modified to fit into the OJB
 52   
  * Persistence Managment System.
 53   
  *
 54   
  * Modifications done by Ch. Rath, Th. Mahler, S. Harris and many others.
 55   
  *
 56   
  * This grammar can be used to build an OQL Parser with the ANTLR Parser
 57   
  * construction set.
 58   
  * The grammar defines a Parser that translates valid OQL Strings
 59   
  * into ojb.broker.query.Query Objects. These query objects can be used
 60   
  * to perform database queries by means of the OJB PersistenceBroker.
 61   
  * @see org.apache.ojb.odmg.oql.OQLQueryImpl for implementation details.
 62   
  * @version $Id: oql-ojb.g,v 1.1 2007-08-24 22:17:36 ewestfal Exp $
 63   
  */
 64   
 public class OQLLexer extends antlr.CharScanner implements OQLLexerTokenTypes, TokenStream
 65   
  {
 66   
 public OQLLexer(InputStream in) {
 67   
         this(new ByteBuffer(in));
 68   
 }
 69   
 public OQLLexer(Reader in) {
 70   
         this(new CharBuffer(in));
 71   
 }
 72   
 public OQLLexer(InputBuffer ib) {
 73   
         this(new LexerSharedInputState(ib));
 74   
 }
 75   
 public OQLLexer(LexerSharedInputState state) {
 76   
         super(state);
 77   
         caseSensitiveLiterals = true;
 78   
         setCaseSensitive(true);
 79   
         literals = new Hashtable();
 80   
         literals.put(new ANTLRHashString("nil", this), new Integer(52));
 81   
         literals.put(new ANTLRHashString("group", this), new Integer(44));
 82   
         literals.put(new ANTLRHashString("between", this), new Integer(55));
 83   
         literals.put(new ANTLRHashString("date", this), new Integer(61));
 84   
         literals.put(new ANTLRHashString("select", this), new Integer(38));
 85   
         literals.put(new ANTLRHashString("timestamp", this), new Integer(63));
 86   
         literals.put(new ANTLRHashString("like", this), new Integer(58));
 87   
         literals.put(new ANTLRHashString("is_undefined", this), new Integer(56));
 88   
         literals.put(new ANTLRHashString("asc", this), new Integer(48));
 89   
         literals.put(new ANTLRHashString("or", this), new Integer(50));
 90   
         literals.put(new ANTLRHashString("in", this), new Integer(47));
 91   
         literals.put(new ANTLRHashString("list", this), new Integer(54));
 92   
         literals.put(new ANTLRHashString("from", this), new Integer(40));
 93   
         literals.put(new ANTLRHashString("desc", this), new Integer(49));
 94   
         literals.put(new ANTLRHashString("true", this), new Integer(59));
 95   
         literals.put(new ANTLRHashString("by", this), new Integer(43));
 96   
         literals.put(new ANTLRHashString("not", this), new Integer(53));
 97   
         literals.put(new ANTLRHashString("and", this), new Integer(51));
 98   
         literals.put(new ANTLRHashString("distinct", this), new Integer(39));
 99   
         literals.put(new ANTLRHashString("prefetch", this), new Integer(45));
 100   
         literals.put(new ANTLRHashString("false", this), new Integer(60));
 101   
         literals.put(new ANTLRHashString("time", this), new Integer(62));
 102   
         literals.put(new ANTLRHashString("order", this), new Integer(42));
 103   
         literals.put(new ANTLRHashString("where", this), new Integer(41));
 104   
         literals.put(new ANTLRHashString("exists", this), new Integer(46));
 105   
         literals.put(new ANTLRHashString("is_defined", this), new Integer(57));
 106   
 }
 107   
 
 108   
 public Token nextToken() throws TokenStreamException {
 109   
         Token theRetToken=null;
 110   
 tryAgain:
 111   
         for (;;) {
 112   
                 Token _token = null;
 113   
                 int _ttype = Token.INVALID_TYPE;
 114   
                 resetText();
 115   
                 try {   // for char stream error handling
 116   
                         try {   // for lexical error handling
 117   
                                 switch ( LA(1)) {
 118   
                                 case ')':
 119   
                                 {
 120   
                                         mTOK_RPAREN(true);
 121   
                                         theRetToken=_returnToken;
 122   
                                         break;
 123   
                                 }
 124   
                                 case '(':
 125   
                                 {
 126   
                                         mTOK_LPAREN(true);
 127   
                                         theRetToken=_returnToken;
 128   
                                         break;
 129   
                                 }
 130   
                                 case ',':
 131   
                                 {
 132   
                                         mTOK_COMMA(true);
 133   
                                         theRetToken=_returnToken;
 134   
                                         break;
 135   
                                 }
 136   
                                 case ';':
 137   
                                 {
 138   
                                         mTOK_SEMIC(true);
 139   
                                         theRetToken=_returnToken;
 140   
                                         break;
 141   
                                 }
 142   
                                 case ':':
 143   
                                 {
 144   
                                         mTOK_COLON(true);
 145   
                                         theRetToken=_returnToken;
 146   
                                         break;
 147   
                                 }
 148   
                                 case '|':
 149   
                                 {
 150   
                                         mTOK_CONCAT(true);
 151   
                                         theRetToken=_returnToken;
 152   
                                         break;
 153   
                                 }
 154   
                                 case '=':
 155   
                                 {
 156   
                                         mTOK_EQ(true);
 157   
                                         theRetToken=_returnToken;
 158   
                                         break;
 159   
                                 }
 160   
                                 case '+':
 161   
                                 {
 162   
                                         mTOK_PLUS(true);
 163   
                                         theRetToken=_returnToken;
 164   
                                         break;
 165   
                                 }
 166   
                                 case '*':
 167   
                                 {
 168   
                                         mTOK_STAR(true);
 169   
                                         theRetToken=_returnToken;
 170   
                                         break;
 171   
                                 }
 172   
                                 case '!':
 173   
                                 {
 174   
                                         mTOK_NE2(true);
 175   
                                         theRetToken=_returnToken;
 176   
                                         break;
 177   
                                 }
 178   
                                 case '[':
 179   
                                 {
 180   
                                         mTOK_LBRACK(true);
 181   
                                         theRetToken=_returnToken;
 182   
                                         break;
 183   
                                 }
 184   
                                 case ']':
 185   
                                 {
 186   
                                         mTOK_RBRACK(true);
 187   
                                         theRetToken=_returnToken;
 188   
                                         break;
 189   
                                 }
 190   
                                 case '\'':
 191   
                                 {
 192   
                                         mCharLiteral(true);
 193   
                                         theRetToken=_returnToken;
 194   
                                         break;
 195   
                                 }
 196   
                                 case '"':
 197   
                                 {
 198   
                                         mStringLiteral(true);
 199   
                                         theRetToken=_returnToken;
 200   
                                         break;
 201   
                                 }
 202   
                                 case '\t':  case '\r':  case ' ':
 203   
                                 {
 204   
                                         mWhiteSpace(true);
 205   
                                         theRetToken=_returnToken;
 206   
                                         break;
 207   
                                 }
 208   
                                 case '\n':
 209   
                                 {
 210   
                                         mNewLine(true);
 211   
                                         theRetToken=_returnToken;
 212   
                                         break;
 213   
                                 }
 214   
                                 default:
 215   
                                         if ((LA(1)=='-') && (LA(2)=='>')) {
 216   
                                                 mTOK_INDIRECT(true);
 217   
                                                 theRetToken=_returnToken;
 218   
                                         }
 219   
                                         else if ((LA(1)=='<') && (LA(2)=='=')) {
 220   
                                                 mTOK_LE(true);
 221   
                                                 theRetToken=_returnToken;
 222   
                                         }
 223   
                                         else if ((LA(1)=='>') && (LA(2)=='=')) {
 224   
                                                 mTOK_GE(true);
 225   
                                                 theRetToken=_returnToken;
 226   
                                         }
 227   
                                         else if ((LA(1)=='<') && (LA(2)=='>')) {
 228   
                                                 mTOK_NE(true);
 229   
                                                 theRetToken=_returnToken;
 230   
                                         }
 231   
                                         else if ((LA(1)=='/') && (LA(2)=='/')) {
 232   
                                                 mCommentLine(true);
 233   
                                                 theRetToken=_returnToken;
 234   
                                         }
 235   
                                         else if ((LA(1)=='/') && (LA(2)=='*')) {
 236   
                                                 mMultiLineComment(true);
 237   
                                                 theRetToken=_returnToken;
 238   
                                         }
 239   
                                         else if ((LA(1)=='.') && (true)) {
 240   
                                                 mTOK_DOT(true);
 241   
                                                 theRetToken=_returnToken;
 242   
                                         }
 243   
                                         else if ((LA(1)=='-') && (true)) {
 244   
                                                 mTOK_MINUS(true);
 245   
                                                 theRetToken=_returnToken;
 246   
                                         }
 247   
                                         else if ((LA(1)=='/') && (true)) {
 248   
                                                 mTOK_SLASH(true);
 249   
                                                 theRetToken=_returnToken;
 250   
                                         }
 251   
                                         else if ((LA(1)=='<') && (true)) {
 252   
                                                 mTOK_LT(true);
 253   
                                                 theRetToken=_returnToken;
 254   
                                         }
 255   
                                         else if ((LA(1)=='>') && (true)) {
 256   
                                                 mTOK_GT(true);
 257   
                                                 theRetToken=_returnToken;
 258   
                                         }
 259   
                                         else if ((LA(1)=='$') && (true)) {
 260   
                                                 mTOK_DOLLAR(true);
 261   
                                                 theRetToken=_returnToken;
 262   
                                         }
 263   
                                         else if ((_tokenSet_0.member(LA(1))) && (true)) {
 264   
                                                 mIdentifier(true);
 265   
                                                 theRetToken=_returnToken;
 266   
                                         }
 267   
                                         else if ((_tokenSet_1.member(LA(1))) && (true)) {
 268   
                                                 mTOK_EXACT_NUMERIC_LITERAL(true);
 269   
                                                 theRetToken=_returnToken;
 270   
                                         }
 271   
                                 else {
 272   
                                         if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
 273   
                                 else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
 274   
                                 }
 275   
                                 }
 276   
                                 if ( _returnToken==null ) continue tryAgain; // found SKIP token
 277   
                                 _ttype = _returnToken.getType();
 278   
                                 _returnToken.setType(_ttype);
 279   
                                 return _returnToken;
 280   
                         }
 281   
                         catch (RecognitionException e) {
 282   
                                 throw new TokenStreamRecognitionException(e);
 283   
                         }
 284   
                 }
 285   
                 catch (CharStreamException cse) {
 286   
                         if ( cse instanceof CharStreamIOException ) {
 287   
                                 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
 288   
                         }
 289   
                         else {
 290   
                                 throw new TokenStreamException(cse.getMessage());
 291   
                         }
 292   
                 }
 293   
         }
 294   
 }
 295   
 
 296   
         public final void mTOK_RPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 297   
                 int _ttype; Token _token=null; int _begin=text.length();
 298   
                 _ttype = TOK_RPAREN;
 299   
                 int _saveIndex;
 300   
 
 301   
                 match(')');
 302   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 303   
                         _token = makeToken(_ttype);
 304   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 305   
                 }
 306   
                 _returnToken = _token;
 307   
         }
 308   
 
 309   
         public final void mTOK_LPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 310   
                 int _ttype; Token _token=null; int _begin=text.length();
 311   
                 _ttype = TOK_LPAREN;
 312   
                 int _saveIndex;
 313   
 
 314   
                 match('(');
 315   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 316   
                         _token = makeToken(_ttype);
 317   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 318   
                 }
 319   
                 _returnToken = _token;
 320   
         }
 321   
 
 322   
         public final void mTOK_COMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 323   
                 int _ttype; Token _token=null; int _begin=text.length();
 324   
                 _ttype = TOK_COMMA;
 325   
                 int _saveIndex;
 326   
 
 327   
                 match(',');
 328   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 329   
                         _token = makeToken(_ttype);
 330   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 331   
                 }
 332   
                 _returnToken = _token;
 333   
         }
 334   
 
 335   
         public final void mTOK_SEMIC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 336   
                 int _ttype; Token _token=null; int _begin=text.length();
 337   
                 _ttype = TOK_SEMIC;
 338   
                 int _saveIndex;
 339   
 
 340   
                 match(';');
 341   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 342   
                         _token = makeToken(_ttype);
 343   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 344   
                 }
 345   
                 _returnToken = _token;
 346   
         }
 347   
 
 348   
         public final void mTOK_COLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 349   
                 int _ttype; Token _token=null; int _begin=text.length();
 350   
                 _ttype = TOK_COLON;
 351   
                 int _saveIndex;
 352   
 
 353   
                 match(':');
 354   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 355   
                         _token = makeToken(_ttype);
 356   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 357   
                 }
 358   
                 _returnToken = _token;
 359   
         }
 360   
 
 361   
         public final void mTOK_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 362   
                 int _ttype; Token _token=null; int _begin=text.length();
 363   
                 _ttype = TOK_DOT;
 364   
                 int _saveIndex;
 365   
 
 366   
                 match('.');
 367   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 368   
                         _token = makeToken(_ttype);
 369   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 370   
                 }
 371   
                 _returnToken = _token;
 372   
         }
 373   
 
 374   
         public final void mTOK_INDIRECT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 375   
                 int _ttype; Token _token=null; int _begin=text.length();
 376   
                 _ttype = TOK_INDIRECT;
 377   
                 int _saveIndex;
 378   
 
 379   
                 match('-');
 380   
                 match('>');
 381   
                 _ttype = TOK_DOT;
 382   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 383   
                         _token = makeToken(_ttype);
 384   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 385   
                 }
 386   
                 _returnToken = _token;
 387   
         }
 388   
 
 389   
         public final void mTOK_CONCAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 390   
                 int _ttype; Token _token=null; int _begin=text.length();
 391   
                 _ttype = TOK_CONCAT;
 392   
                 int _saveIndex;
 393   
 
 394   
                 match('|');
 395   
                 match('|');
 396   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 397   
                         _token = makeToken(_ttype);
 398   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 399   
                 }
 400   
                 _returnToken = _token;
 401   
         }
 402   
 
 403   
         public final void mTOK_EQ(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 404   
                 int _ttype; Token _token=null; int _begin=text.length();
 405   
                 _ttype = TOK_EQ;
 406   
                 int _saveIndex;
 407   
 
 408   
                 match('=');
 409   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 410   
                         _token = makeToken(_ttype);
 411   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 412   
                 }
 413   
                 _returnToken = _token;
 414   
         }
 415   
 
 416   
         public final void mTOK_PLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 417   
                 int _ttype; Token _token=null; int _begin=text.length();
 418   
                 _ttype = TOK_PLUS;
 419   
                 int _saveIndex;
 420   
 
 421   
                 match('+');
 422   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 423   
                         _token = makeToken(_ttype);
 424   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 425   
                 }
 426   
                 _returnToken = _token;
 427   
         }
 428   
 
 429   
         public final void mTOK_MINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 430   
                 int _ttype; Token _token=null; int _begin=text.length();
 431   
                 _ttype = TOK_MINUS;
 432   
                 int _saveIndex;
 433   
 
 434   
                 match('-');
 435   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 436   
                         _token = makeToken(_ttype);
 437   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 438   
                 }
 439   
                 _returnToken = _token;
 440   
         }
 441   
 
 442   
         public final void mTOK_SLASH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 443   
                 int _ttype; Token _token=null; int _begin=text.length();
 444   
                 _ttype = TOK_SLASH;
 445   
                 int _saveIndex;
 446   
 
 447   
                 match('/');
 448   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 449   
                         _token = makeToken(_ttype);
 450   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 451   
                 }
 452   
                 _returnToken = _token;
 453   
         }
 454   
 
 455   
         public final void mTOK_STAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 456   
                 int _ttype; Token _token=null; int _begin=text.length();
 457   
                 _ttype = TOK_STAR;
 458   
                 int _saveIndex;
 459   
 
 460   
                 match('*');
 461   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 462   
                         _token = makeToken(_ttype);
 463   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 464   
                 }
 465   
                 _returnToken = _token;
 466   
         }
 467   
 
 468   
         public final void mTOK_LE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 469   
                 int _ttype; Token _token=null; int _begin=text.length();
 470   
                 _ttype = TOK_LE;
 471   
                 int _saveIndex;
 472   
 
 473   
                 match('<');
 474   
                 match('=');
 475   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 476   
                         _token = makeToken(_ttype);
 477   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 478   
                 }
 479   
                 _returnToken = _token;
 480   
         }
 481   
 
 482   
         public final void mTOK_GE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 483   
                 int _ttype; Token _token=null; int _begin=text.length();
 484   
                 _ttype = TOK_GE;
 485   
                 int _saveIndex;
 486   
 
 487   
                 match('>');
 488   
                 match('=');
 489   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 490   
                         _token = makeToken(_ttype);
 491   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 492   
                 }
 493   
                 _returnToken = _token;
 494   
         }
 495   
 
 496   
         public final void mTOK_NE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 497   
                 int _ttype; Token _token=null; int _begin=text.length();
 498   
                 _ttype = TOK_NE;
 499   
                 int _saveIndex;
 500   
 
 501   
                 match('<');
 502   
                 match('>');
 503   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 504   
                         _token = makeToken(_ttype);
 505   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 506   
                 }
 507   
                 _returnToken = _token;
 508   
         }
 509   
 
 510   
         public final void mTOK_NE2(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 511   
                 int _ttype; Token _token=null; int _begin=text.length();
 512   
                 _ttype = TOK_NE2;
 513   
                 int _saveIndex;
 514   
 
 515   
                 match('!');
 516   
                 match('=');
 517   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 518   
                         _token = makeToken(_ttype);
 519   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 520   
                 }
 521   
                 _returnToken = _token;
 522   
         }
 523   
 
 524   
         public final void mTOK_LT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 525   
                 int _ttype; Token _token=null; int _begin=text.length();
 526   
                 _ttype = TOK_LT;
 527   
                 int _saveIndex;
 528   
 
 529   
                 match('<');
 530   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 531   
                         _token = makeToken(_ttype);
 532   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 533   
                 }
 534   
                 _returnToken = _token;
 535   
         }
 536   
 
 537   
         public final void mTOK_GT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 538   
                 int _ttype; Token _token=null; int _begin=text.length();
 539   
                 _ttype = TOK_GT;
 540   
                 int _saveIndex;
 541   
 
 542   
                 match('>');
 543   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 544   
                         _token = makeToken(_ttype);
 545   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 546   
                 }
 547   
                 _returnToken = _token;
 548   
         }
 549   
 
 550   
         public final void mTOK_LBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 551   
                 int _ttype; Token _token=null; int _begin=text.length();
 552   
                 _ttype = TOK_LBRACK;
 553   
                 int _saveIndex;
 554   
 
 555   
                 match('[');
 556   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 557   
                         _token = makeToken(_ttype);
 558   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 559   
                 }
 560   
                 _returnToken = _token;
 561   
         }
 562   
 
 563   
         public final void mTOK_RBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 564   
                 int _ttype; Token _token=null; int _begin=text.length();
 565   
                 _ttype = TOK_RBRACK;
 566   
                 int _saveIndex;
 567   
 
 568   
                 match(']');
 569   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 570   
                         _token = makeToken(_ttype);
 571   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 572   
                 }
 573   
                 _returnToken = _token;
 574   
         }
 575   
 
 576   
         public final void mTOK_DOLLAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 577   
                 int _ttype; Token _token=null; int _begin=text.length();
 578   
                 _ttype = TOK_DOLLAR;
 579   
                 int _saveIndex;
 580   
 
 581   
                 match('$');
 582   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 583   
                         _token = makeToken(_ttype);
 584   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 585   
                 }
 586   
                 _returnToken = _token;
 587   
         }
 588   
 
 589   
         protected final void mNameFirstCharacter(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 590   
                 int _ttype; Token _token=null; int _begin=text.length();
 591   
                 _ttype = NameFirstCharacter;
 592   
                 int _saveIndex;
 593   
 
 594   
                 {
 595   
                 switch ( LA(1)) {
 596   
                 case 'A':  case 'B':  case 'C':  case 'D':
 597   
                 case 'E':  case 'F':  case 'G':  case 'H':
 598   
                 case 'I':  case 'J':  case 'K':  case 'L':
 599   
                 case 'M':  case 'N':  case 'O':  case 'P':
 600   
                 case 'Q':  case 'R':  case 'S':  case 'T':
 601   
                 case 'U':  case 'V':  case 'W':  case 'X':
 602   
                 case 'Y':  case 'Z':
 603   
                 {
 604   
                         matchRange('A','Z');
 605   
                         break;
 606   
                 }
 607   
                 case 'a':  case 'b':  case 'c':  case 'd':
 608   
                 case 'e':  case 'f':  case 'g':  case 'h':
 609   
                 case 'i':  case 'j':  case 'k':  case 'l':
 610   
                 case 'm':  case 'n':  case 'o':  case 'p':
 611   
                 case 'q':  case 'r':  case 's':  case 't':
 612   
                 case 'u':  case 'v':  case 'w':  case 'x':
 613   
                 case 'y':  case 'z':
 614   
                 {
 615   
                         matchRange('a','z');
 616   
                         break;
 617   
                 }
 618   
                 case '_':
 619   
                 {
 620   
                         match('_');
 621   
                         break;
 622   
                 }
 623   
                 case '.':
 624   
                 {
 625   
                         mTOK_DOT(false);
 626   
                         break;
 627   
                 }
 628   
                 case '-':
 629   
                 {
 630   
                         mTOK_INDIRECT(false);
 631   
                         break;
 632   
                 }
 633   
                 case '$':
 634   
                 {
 635   
                         mTOK_DOLLAR(false);
 636   
                         break;
 637   
                 }
 638   
                 default:
 639   
                 {
 640   
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 641   
                 }
 642   
                 }
 643   
                 }
 644   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 645   
                         _token = makeToken(_ttype);
 646   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 647   
                 }
 648   
                 _returnToken = _token;
 649   
         }
 650   
 
 651   
         protected final void mNameCharacter(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 652   
                 int _ttype; Token _token=null; int _begin=text.length();
 653   
                 _ttype = NameCharacter;
 654   
                 int _saveIndex;
 655   
 
 656   
                 {
 657   
                 switch ( LA(1)) {
 658   
                 case '$':  case '-':  case '.':  case 'A':
 659   
                 case 'B':  case 'C':  case 'D':  case 'E':
 660   
                 case 'F':  case 'G':  case 'H':  case 'I':
 661   
                 case 'J':  case 'K':  case 'L':  case 'M':
 662   
                 case 'N':  case 'O':  case 'P':  case 'Q':
 663   
                 case 'R':  case 'S':  case 'T':  case 'U':
 664   
                 case 'V':  case 'W':  case 'X':  case 'Y':
 665   
                 case 'Z':  case '_':  case 'a':  case 'b':
 666   
                 case 'c':  case 'd':  case 'e':  case 'f':
 667   
                 case 'g':  case 'h':  case 'i':  case 'j':
 668   
                 case 'k':  case 'l':  case 'm':  case 'n':
 669   
                 case 'o':  case 'p':  case 'q':  case 'r':
 670   
                 case 's':  case 't':  case 'u':  case 'v':
 671   
                 case 'w':  case 'x':  case 'y':  case 'z':
 672   
                 {
 673   
                         mNameFirstCharacter(false);
 674   
                         break;
 675   
                 }
 676   
                 case '0':  case '1':  case '2':  case '3':
 677   
                 case '4':  case '5':  case '6':  case '7':
 678   
                 case '8':  case '9':
 679   
                 {
 680   
                         matchRange('0','9');
 681   
                         break;
 682   
                 }
 683   
                 default:
 684   
                 {
 685   
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 686   
                 }
 687   
                 }
 688   
                 }
 689   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 690   
                         _token = makeToken(_ttype);
 691   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 692   
                 }
 693   
                 _returnToken = _token;
 694   
         }
 695   
 
 696   
         public final void mIdentifier(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 697   
                 int _ttype; Token _token=null; int _begin=text.length();
 698   
                 _ttype = Identifier;
 699   
                 int _saveIndex;
 700   
 
 701   
                 mNameFirstCharacter(false);
 702   
                 {
 703   
                 _loop29:
 704   
                 do {
 705   
                         if ((_tokenSet_2.member(LA(1)))) {
 706   
                                 mNameCharacter(false);
 707   
                         }
 708   
                         else {
 709   
                                 break _loop29;
 710   
                         }
 711   
 
 712   
                 } while (true);
 713   
                 }
 714   
                 _ttype = testLiteralsTable(_ttype);
 715   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 716   
                         _token = makeToken(_ttype);
 717   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 718   
                 }
 719   
                 _returnToken = _token;
 720   
         }
 721   
 
 722   
         protected final void mTOK_UNSIGNED_INTEGER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 723   
                 int _ttype; Token _token=null; int _begin=text.length();
 724   
                 _ttype = TOK_UNSIGNED_INTEGER;
 725   
                 int _saveIndex;
 726   
 
 727   
                 matchRange('0','9');
 728   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 729   
                         _token = makeToken(_ttype);
 730   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 731   
                 }
 732   
                 _returnToken = _token;
 733   
         }
 734   
 
 735   
         protected final void mTOK_APPROXIMATE_NUMERIC_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 736   
                 int _ttype; Token _token=null; int _begin=text.length();
 737   
                 _ttype = TOK_APPROXIMATE_NUMERIC_LITERAL;
 738   
                 int _saveIndex;
 739   
 
 740   
                 match('e');
 741   
                 {
 742   
                 switch ( LA(1)) {
 743   
                 case '+':
 744   
                 {
 745   
                         match('+');
 746   
                         break;
 747   
                 }
 748   
                 case '-':
 749   
                 {
 750   
                         match('-');
 751   
                         break;
 752   
                 }
 753   
                 case '0':  case '1':  case '2':  case '3':
 754   
                 case '4':  case '5':  case '6':  case '7':
 755   
                 case '8':  case '9':
 756   
                 {
 757   
                         break;
 758   
                 }
 759   
                 default:
 760   
                 {
 761   
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 762   
                 }
 763   
                 }
 764   
                 }
 765   
                 {
 766   
                 int _cnt34=0;
 767   
                 _loop34:
 768   
                 do {
 769   
                         if (((LA(1) >= '0' && LA(1) <= '9'))) {
 770   
                                 matchRange('0','9');
 771   
                         }
 772   
                         else {
 773   
                                 if ( _cnt34>=1 ) { break _loop34; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
 774   
                         }
 775   
 
 776   
                         _cnt34++;
 777   
                 } while (true);
 778   
                 }
 779   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 780   
                         _token = makeToken(_ttype);
 781   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 782   
                 }
 783   
                 _returnToken = _token;
 784   
         }
 785   
 
 786   
         public final void mTOK_EXACT_NUMERIC_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 787   
                 int _ttype; Token _token=null; int _begin=text.length();
 788   
                 _ttype = TOK_EXACT_NUMERIC_LITERAL;
 789   
                 int _saveIndex;
 790   
 
 791   
                 switch ( LA(1)) {
 792   
                 case '.':
 793   
                 {
 794   
                         match('.');
 795   
                         {
 796   
                         int _cnt37=0;
 797   
                         _loop37:
 798   
                         do {
 799   
                                 if (((LA(1) >= '0' && LA(1) <= '9'))) {
 800   
                                         mTOK_UNSIGNED_INTEGER(false);
 801   
                                 }
 802   
                                 else {
 803   
                                         if ( _cnt37>=1 ) { break _loop37; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
 804   
                                 }
 805   
 
 806   
                                 _cnt37++;
 807   
                         } while (true);
 808   
                         }
 809   
                         _ttype = TOK_EXACT_NUMERIC_LITERAL;
 810   
                         {
 811   
                         if ((LA(1)=='e')) {
 812   
                                 mTOK_APPROXIMATE_NUMERIC_LITERAL(false);
 813   
                                 _ttype = TOK_APPROXIMATE_NUMERIC_LITERAL;
 814   
                         }
 815   
                         else {
 816   
                         }
 817   
 
 818   
                         }
 819   
                         break;
 820   
                 }
 821   
                 case '0':  case '1':  case '2':  case '3':
 822   
                 case '4':  case '5':  case '6':  case '7':
 823   
                 case '8':  case '9':
 824   
                 {
 825   
                         {
 826   
                         int _cnt40=0;
 827   
                         _loop40:
 828   
                         do {
 829   
                                 if (((LA(1) >= '0' && LA(1) <= '9'))) {
 830   
                                         mTOK_UNSIGNED_INTEGER(false);
 831   
                                 }
 832   
                                 else {
 833   
                                         if ( _cnt40>=1 ) { break _loop40; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
 834   
                                 }
 835   
 
 836   
                                 _cnt40++;
 837   
                         } while (true);
 838   
                         }
 839   
                         _ttype = TOK_UNSIGNED_INTEGER;
 840   
                         {
 841   
                         switch ( LA(1)) {
 842   
                         case '.':
 843   
                         {
 844   
                                 match('.');
 845   
                                 {
 846   
                                 _loop43:
 847   
                                 do {
 848   
                                         if (((LA(1) >= '0' && LA(1) <= '9'))) {
 849   
                                                 mTOK_UNSIGNED_INTEGER(false);
 850   
                                         }
 851   
                                         else {
 852   
                                                 break _loop43;
 853   
                                         }
 854   
 
 855   
                                 } while (true);
 856   
                                 }
 857   
                                 _ttype = TOK_EXACT_NUMERIC_LITERAL;
 858   
                                 {
 859   
                                 if ((LA(1)=='e')) {
 860   
                                         mTOK_APPROXIMATE_NUMERIC_LITERAL(false);
 861   
                                         _ttype = TOK_APPROXIMATE_NUMERIC_LITERAL;
 862   
                                 }
 863   
                                 else {
 864   
                                 }
 865   
 
 866   
                                 }
 867   
                                 break;
 868   
                         }
 869   
                         case 'e':
 870   
                         {
 871   
                                 mTOK_APPROXIMATE_NUMERIC_LITERAL(false);
 872   
                                 _ttype = TOK_APPROXIMATE_NUMERIC_LITERAL;
 873   
                                 break;
 874   
                         }
 875   
                         default:
 876   
                                 {
 877   
                                 }
 878   
                         }
 879   
                         }
 880   
                         break;
 881   
                 }
 882   
                 default:
 883   
                 {
 884   
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 885   
                 }
 886   
                 }
 887   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 888   
                         _token = makeToken(_ttype);
 889   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 890   
                 }
 891   
                 _returnToken = _token;
 892   
         }
 893   
 
 894   
         public final void mCharLiteral(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 895   
                 int _ttype; Token _token=null; int _begin=text.length();
 896   
                 _ttype = CharLiteral;
 897   
                 int _saveIndex;
 898   
 
 899   
                 _saveIndex=text.length();
 900   
                 match('\'');
 901   
                 text.setLength(_saveIndex);
 902   
                 {
 903   
                 _loop48:
 904   
                 do {
 905   
                         if ((LA(1)=='\'') && (LA(2)=='\'')) {
 906   
                                 match('\'');
 907   
                                 match('\'');
 908   
                                 text.setLength(_begin); text.append("'");
 909   
                         }
 910   
                         else if ((LA(1)=='\n')) {
 911   
                                 match('\n');
 912   
                                 newline();
 913   
                         }
 914   
                         else if ((_tokenSet_3.member(LA(1)))) {
 915   
                                 {
 916   
                                 match(_tokenSet_3);
 917   
                                 }
 918   
                         }
 919   
                         else {
 920   
                                 break _loop48;
 921   
                         }
 922   
 
 923   
                 } while (true);
 924   
                 }
 925   
                 _saveIndex=text.length();
 926   
                 match('\'');
 927   
                 text.setLength(_saveIndex);
 928   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 929   
                         _token = makeToken(_ttype);
 930   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 931   
                 }
 932   
                 _returnToken = _token;
 933   
         }
 934   
 
 935   
         public final void mStringLiteral(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 936   
                 int _ttype; Token _token=null; int _begin=text.length();
 937   
                 _ttype = StringLiteral;
 938   
                 int _saveIndex;
 939   
 
 940   
                 _saveIndex=text.length();
 941   
                 match('"');
 942   
                 text.setLength(_saveIndex);
 943   
                 {
 944   
                 _loop52:
 945   
                 do {
 946   
                         if ((LA(1)=='\\') && (LA(2)=='"')) {
 947   
                                 match('\\');
 948   
                                 match('"');
 949   
                                 text.setLength(_begin); text.append("\"");
 950   
                         }
 951   
                         else if ((_tokenSet_4.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
 952   
                                 {
 953   
                                 match(_tokenSet_4);
 954   
                                 }
 955   
                         }
 956   
                         else if ((LA(1)=='\n')) {
 957   
                                 match('\n');
 958   
                                 newline();
 959   
                         }
 960   
                         else {
 961   
                                 break _loop52;
 962   
                         }
 963   
 
 964   
                 } while (true);
 965   
                 }
 966   
                 _saveIndex=text.length();
 967   
                 match('"');
 968   
                 text.setLength(_saveIndex);
 969   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 970   
                         _token = makeToken(_ttype);
 971   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 972   
                 }
 973   
                 _returnToken = _token;
 974   
         }
 975   
 
 976   
         public final void mWhiteSpace(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 977   
                 int _ttype; Token _token=null; int _begin=text.length();
 978   
                 _ttype = WhiteSpace;
 979   
                 int _saveIndex;
 980   
 
 981   
                 {
 982   
                 switch ( LA(1)) {
 983   
                 case ' ':
 984   
                 {
 985   
                         match(' ');
 986   
                         break;
 987   
                 }
 988   
                 case '\t':
 989   
                 {
 990   
                         match('\t');
 991   
                         break;
 992   
                 }
 993   
                 case '\r':
 994   
                 {
 995   
                         match('\r');
 996   
                         break;
 997   
                 }
 998   
                 default:
 999   
                 {
 1000   
                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
 1001   
                 }
 1002   
                 }
 1003   
                 }
 1004   
                 _ttype = Token.SKIP;
 1005   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 1006   
                         _token = makeToken(_ttype);
 1007   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 1008   
                 }
 1009   
                 _returnToken = _token;
 1010   
         }
 1011   
 
 1012   
         public final void mNewLine(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 1013   
                 int _ttype; Token _token=null; int _begin=text.length();
 1014   
                 _ttype = NewLine;
 1015   
                 int _saveIndex;
 1016   
 
 1017   
                 match('\n');
 1018   
                 newline(); _ttype = Token.SKIP;
 1019   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 1020   
                         _token = makeToken(_ttype);
 1021   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 1022   
                 }
 1023   
                 _returnToken = _token;
 1024   
         }
 1025   
 
 1026   
         public final void mCommentLine(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 1027   
                 int _ttype; Token _token=null; int _begin=text.length();
 1028   
                 _ttype = CommentLine;
 1029   
                 int _saveIndex;
 1030   
 
 1031   
                 _saveIndex=text.length();
 1032   
                 match('/');
 1033   
                 text.setLength(_saveIndex);
 1034   
                 _saveIndex=text.length();
 1035   
                 match('/');
 1036   
                 text.setLength(_saveIndex);
 1037   
                 {
 1038   
                 _loop58:
 1039   
                 do {
 1040   
                         if ((_tokenSet_5.member(LA(1)))) {
 1041   
                                 _saveIndex=text.length();
 1042   
                                 matchNot('\n');
 1043   
                                 text.setLength(_saveIndex);
 1044   
                         }
 1045   
                         else {
 1046   
                                 break _loop58;
 1047   
                         }
 1048   
 
 1049   
                 } while (true);
 1050   
                 }
 1051   
                 _saveIndex=text.length();
 1052   
                 match('\n');
 1053   
                 text.setLength(_saveIndex);
 1054   
                 newline(); _ttype = Token.SKIP;
 1055   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 1056   
                         _token = makeToken(_ttype);
 1057   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 1058   
                 }
 1059   
                 _returnToken = _token;
 1060   
         }
 1061   
 
 1062   
         public final void mMultiLineComment(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
 1063   
                 int _ttype; Token _token=null; int _begin=text.length();
 1064   
                 _ttype = MultiLineComment;
 1065   
                 int _saveIndex;
 1066   
 
 1067   
                 match("/*");
 1068   
                 {
 1069   
                 _loop62:
 1070   
                 do {
 1071   
                         if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe')))&&( LA(2)!='/' )) {
 1072   
                                 match('*');
 1073   
                         }
 1074   
                         else if ((LA(1)=='\n')) {
 1075   
                                 match('\n');
 1076   
                                 newline();
 1077   
                         }
 1078   
                         else if ((_tokenSet_6.member(LA(1)))) {
 1079   
                                 {
 1080   
                                 match(_tokenSet_6);
 1081   
                                 }
 1082   
                         }
 1083   
                         else {
 1084   
                                 break _loop62;
 1085   
                         }
 1086   
 
 1087   
                 } while (true);
 1088   
                 }
 1089   
                 match("*/");
 1090   
                 _ttype = Token.SKIP;
 1091   
                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
 1092   
                         _token = makeToken(_ttype);
 1093   
                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
 1094   
                 }
 1095   
                 _returnToken = _token;
 1096   
         }
 1097   
 
 1098   
 
 1099   
         private static final long[] mk_tokenSet_0() {
 1100   
                 long[] data = new long[1025];
 1101   
                 data[0]=105621835743232L;
 1102   
                 data[1]=576460745995190270L;
 1103   
                 return data;
 1104   
         }
 1105   
         public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
 1106   
         private static final long[] mk_tokenSet_1() {
 1107   
                 long[] data = new long[1025];
 1108   
                 data[0]=288019269919178752L;
 1109   
                 return data;
 1110   
         }
 1111   
         public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
 1112   
         private static final long[] mk_tokenSet_2() {
 1113   
                 long[] data = new long[1025];
 1114   
                 data[0]=288054523010744320L;
 1115   
                 data[1]=576460745995190270L;
 1116   
                 return data;
 1117   
         }
 1118   
         public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
 1119   
         private static final long[] mk_tokenSet_3() {
 1120   
                 long[] data = new long[2048];
 1121   
                 data[0]=-549755814920L;
 1122   
                 for (int i = 1; i<=1022; i++) { data[i]=-1L; }
 1123   
                 data[1023]=9223372036854775807L;
 1124   
                 return data;
 1125   
         }
 1126   
         public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
 1127   
         private static final long[] mk_tokenSet_4() {
 1128   
                 long[] data = new long[2048];
 1129   
                 data[0]=-17179870216L;
 1130   
                 for (int i = 1; i<=1022; i++) { data[i]=-1L; }
 1131   
                 data[1023]=9223372036854775807L;
 1132   
                 return data;
 1133   
         }
 1134   
         public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
 1135   
         private static final long[] mk_tokenSet_5() {
 1136   
                 long[] data = new long[2048];
 1137   
                 data[0]=-1032L;
 1138   
                 for (int i = 1; i<=1022; i++) { data[i]=-1L; }
 1139   
                 data[1023]=9223372036854775807L;
 1140   
                 return data;
 1141   
         }
 1142   
         public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
 1143   
         private static final long[] mk_tokenSet_6() {
 1144   
                 long[] data = new long[2048];
 1145   
                 data[0]=-4398046512136L;
 1146   
                 for (int i = 1; i<=1022; i++) { data[i]=-1L; }
 1147   
                 data[1023]=9223372036854775807L;
 1148   
                 return data;
 1149   
         }
 1150   
         public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
 1151   
 
 1152   
         }
Report generated by Cobertura 1.9.4.1 on 1/12/12 5:06 PM.