View Javadoc
Minimize
Table

Bug Overview

linebug prioritybugbug descriptionexisting sinceauthor
384mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
1636mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
1727mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
1813mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
2348mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
2829mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
3090mediumhealth.MissingJavaDocEine komplexe Methode wurde nicht dokumentiert. 18.06.2012-10:31UNKNOWN
295mediumEmptyCatchBlockDer catch-Block ist leer, das führt dazu das auftretende Exceptions nicht behandelt bzw. angezeigt werden. Bitte Code überprüfen! Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
306mediumTODODer Code ist an dieser Stelle eventuell unfertig oder fehlerhaft. Bitte überprüfen!18.06.2012-10:31UNKNOWN
308mediumTODODer Code ist an dieser Stelle eventuell unfertig oder fehlerhaft. Bitte überprüfen!18.06.2012-10:31UNKNOWN
384mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
1674mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
1679mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
1813mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2016mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2125mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2133mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
2152mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3051mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3090mediumExcessiveMethodLengthDiese Methode ist sehr lang, ein Indiz dafür das diese Methode zu viel tut, es sollten Hilfsmethoden genutzt und Copy/Paste-Code entfernt werden. Falls dies beabsichtigt ist und der Fehler soll ignoriert werden, dann //NOBUG verwenden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3155mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3238mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3316mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3324mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3341mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3457mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN
3546mediumEmptyIfStmtLeeres if-Statement, bei Erfüllung der Bedingung wird keine Anweisung ausgeführt, dieser Code kann entfernt werden.  Details zum Fehler...18.06.2012-10:31UNKNOWN

1   // $ANTLR 2.7.7 (20060906): "groovy.g" -> "GroovyLexer.java"$
2   
3   package org.codehaus.groovy.antlr.parser;
4   import org.codehaus.groovy.antlr.*;
5   import java.util.*;
6   import java.io.InputStream;
7   import java.io.Reader;
8   import antlr.InputBuffer;
9   import antlr.LexerSharedInputState;
10  import antlr.CommonToken;
11  import org.codehaus.groovy.GroovyBugError;
12  import antlr.TokenStreamRecognitionException;
13  
14  import java.io.InputStream;
15  import antlr.TokenStreamException;
16  import antlr.TokenStreamIOException;
17  import antlr.TokenStreamRecognitionException;
18  import antlr.CharStreamException;
19  import antlr.CharStreamIOException;
20  import antlr.ANTLRException;
21  import java.io.Reader;
22  import java.util.Hashtable;
23  import antlr.CharScanner;
24  import antlr.InputBuffer;
25  import antlr.ByteBuffer;
26  import antlr.CharBuffer;
27  import antlr.Token;
28  import antlr.CommonToken;
29  import antlr.RecognitionException;
30  import antlr.NoViableAltForCharException;
31  import antlr.MismatchedCharException;
32  import antlr.TokenStream;
33  import antlr.ANTLRHashString;
34  import antlr.LexerSharedInputState;
35  import antlr.collections.impl.BitSet;
36  import antlr.SemanticException;
37  
38  public class GroovyLexer extends antlr.CharScanner implements GroovyTokenTypes, TokenStream
39   {
40  
41      /** flag for enabling the "assert" keyword */
42      private boolean assertEnabled = true;
43      /** flag for enabling the "enum" keyword */
44      private boolean enumEnabled = true;
45      /** flag for including whitespace tokens (for IDE preparsing) */
46      private boolean whitespaceIncluded = false;
47  
48      /** Enable the "assert" keyword */
49      public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }
50      /** Query the "assert" keyword state */
51      public boolean isAssertEnabled() { return assertEnabled; }
52      /** Enable the "enum" keyword */
53      public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }
54      /** Query the "enum" keyword state */
55      public boolean isEnumEnabled() { return enumEnabled; }
56  
57      /** Include whitespace tokens.  Note that this breaks the parser.   */
58      public void setWhitespaceIncluded(boolean z) { whitespaceIncluded = z; }
59      /** Are whitespace tokens included? */
60      public boolean isWhitespaceIncluded() { return whitespaceIncluded; }
61  
62      {
63          // Initialization actions performed on construction.
64          setTabSize(1);  // get rid of special tab interpretation, for IDEs and general clarity
65      }
66  
67      /** Bumped when inside '[x]' or '(x)', reset inside '{x}'.  See ONE_NL.  */
68      protected int parenLevel = 0;
69      protected int suppressNewline = 0;  // be really mean to newlines inside strings
70      protected static final int SCS_TYPE = 3, SCS_VAL = 4, SCS_LIT = 8, SCS_LIMIT = 16;
71      protected static final int SCS_SQ_TYPE = 0, SCS_TQ_TYPE = 1, SCS_RE_TYPE = 2, SCS_DRE_TYPE = 3;
72      protected int stringCtorState = 0;  // hack string and regexp constructor boundaries
73      /** Push parenLevel here and reset whenever inside '{x}'. */
74      protected ArrayList parenLevelStack = new ArrayList();
75      protected int lastSigTokenType = EOF;  // last returned non-whitespace token
76  
77      public void setTokenObjectClass(String name) {/*ignore*/}
78  
79      protected Token makeToken(int t) {
80          GroovySourceToken tok = new GroovySourceToken(t);
81          tok.setColumn(inputState.getTokenStartColumn());
82          tok.setLine(inputState.getTokenStartLine());
83          tok.setColumnLast(inputState.getColumn());
84          tok.setLineLast(inputState.getLine());
85          return tok;
86      }
87  
88      protected void pushParenLevel() {
89          parenLevelStack.add(Integer.valueOf(parenLevel*SCS_LIMIT + stringCtorState));
90          parenLevel = 0;
91          stringCtorState = 0;
92      }
93  
94      protected void popParenLevel() {
95          int npl = parenLevelStack.size();
96          if (npl == 0)  return;
97          int i = ((Integer) parenLevelStack.remove(--npl)).intValue();
98          parenLevel      = i / SCS_LIMIT;
99          stringCtorState = i % SCS_LIMIT;
100     }
101 
102     protected void restartStringCtor(boolean expectLiteral) {
103         if (stringCtorState != 0) {
104             stringCtorState = (expectLiteral? SCS_LIT: SCS_VAL) + (stringCtorState & SCS_TYPE);
105         }
106     }
107 
108     protected boolean allowRegexpLiteral() {
109         return !isExpressionEndingToken(lastSigTokenType);
110     }
111 
112     /** Return true for an operator or punctuation which can end an expression.
113      *  Return true for keywords, identifiers, and literals.
114      *  Return true for tokens which can end expressions (right brackets, ++, --).
115      *  Return false for EOF and all other operator and punctuation tokens.
116      *  Used to suppress the recognition of /foo/ as opposed to the simple division operator '/'.
117      */
118     // Cf. 'constant' and 'balancedBrackets' rules in the grammar.)
119     protected static boolean isExpressionEndingToken(int ttype) {
120         switch (ttype) {
121         case INC:               // x++ / y
122         case DEC:               // x-- / y
123         case RPAREN:            // (x) / y
124         case RBRACK:            // f[x] / y
125         case RCURLY:            // f{x} / y
126         case STRING_LITERAL:    // "x" / y
127         case STRING_CTOR_END:   // "$x" / y
128         case NUM_INT:           // 0 / y
129         case NUM_FLOAT:         // 0f / y
130         case NUM_LONG:          // 0l / y
131         case NUM_DOUBLE:        // 0.0 / y
132         case NUM_BIG_INT:       // 0g / y
133         case NUM_BIG_DECIMAL:   // 0.0g / y
134         case IDENT:             // x / y
135         // and a bunch of keywords (all of them; no sense picking and choosing):
136         case LITERAL_as:
137         case LITERAL_assert:
138         case LITERAL_boolean:
139         case LITERAL_break:
140         case LITERAL_byte:
141         case LITERAL_case:
142         case LITERAL_catch:
143         case LITERAL_char:
144         case LITERAL_class:
145         case LITERAL_continue:
146         case LITERAL_def:
147         case LITERAL_default:
148         case LITERAL_double:
149         case LITERAL_else:
150         case LITERAL_enum:
151         case LITERAL_extends:
152         case LITERAL_false:
153         case LITERAL_finally:
154         case LITERAL_float:
155         case LITERAL_for:
156         case LITERAL_if:
157         case LITERAL_implements:
158         case LITERAL_import:
159         case LITERAL_in:
160         case LITERAL_instanceof:
161         case LITERAL_int:
162         case LITERAL_interface:
163         case LITERAL_long:
164         case LITERAL_native:
165         case LITERAL_new:
166         case LITERAL_null:
167         case LITERAL_package:
168         case LITERAL_private:
169         case LITERAL_protected:
170         case LITERAL_public:
171         case LITERAL_return:
172         case LITERAL_short:
173         case LITERAL_static:
174         case LITERAL_super:
175         case LITERAL_switch:
176         case LITERAL_synchronized:
177         case LITERAL_this:
178         case LITERAL_threadsafe:
179         case LITERAL_throw:
180         case LITERAL_throws:
181         case LITERAL_transient:
182         case LITERAL_true:
183         case LITERAL_try:
184         case LITERAL_void:
185         case LITERAL_volatile:
186         case LITERAL_while:
187             return true;
188         default:
189             return false;
190         }
191     }
192 
193     protected void newlineCheck(boolean check) throws RecognitionException {
194         if (check && suppressNewline > 0) {
195             require(suppressNewline == 0,
196                 "end of line reached within a simple string 'x' or \"x\" or /x/",
197                 "for multi-line literals, use triple quotes '''x''' or \"\"\"x\"\"\" or /x/ or $/x/$");
198             suppressNewline = 0;  // shut down any flood of errors
199         }
200         newline();
201     }
202 
203     protected boolean atValidDollarEscape() throws CharStreamException {
204         // '$' (('*')? ('{' | LETTER)) =>
205         int k = 1;
206         char lc = LA(k++);
207         if (lc != '$')  return false;
208         lc = LA(k++);
209         if (lc == '*')  lc = LA(k++);
210         return (lc == '{' || (lc != '$' && Character.isJavaIdentifierStart(lc)));
211     }
212 
213     protected boolean atDollarDollarEscape() throws CharStreamException {
214         return LA(1) == '$' && LA(2) == '$';
215     }
216 
217     protected boolean atDollarSlashEscape() throws CharStreamException {
218         return LA(1) == '$' && LA(2) == '/';
219     }
220 
221     /** This is a bit of plumbing which resumes collection of string constructor bodies,
222      *  after an embedded expression has been parsed.
223      *  Usage:  new GroovyRecognizer(new GroovyLexer(in).plumb()).
224      */
225     public TokenStream plumb() {
226         return new TokenStream() {
227             public Token nextToken() throws TokenStreamException {
228                 if (stringCtorState >= SCS_LIT) {
229                     // This goo is modeled upon the ANTLR code for nextToken:
230                     int quoteType = (stringCtorState & SCS_TYPE);
231                     stringCtorState = 0;  // get out of this mode, now
232                     resetText();
233                     try {
234                         switch (quoteType) {
235                         case SCS_SQ_TYPE:
236                             mSTRING_CTOR_END(true, /*fromStart:*/false, false); break;
237                         case SCS_TQ_TYPE:
238                             mSTRING_CTOR_END(true, /*fromStart:*/false, true); break;
239                         case SCS_RE_TYPE:
240                             mREGEXP_CTOR_END(true, /*fromStart:*/false); break;
241                         case SCS_DRE_TYPE:
242                             mDOLLAR_REGEXP_CTOR_END(true, /*fromStart:*/false); break;
243                         default:  throw new AssertionError(false);
244                         }
245                         lastSigTokenType = _returnToken.getType();
246                         return _returnToken;
247                     } catch (RecognitionException e) {
248                         throw new TokenStreamRecognitionException(e);
249                     } catch (CharStreamException cse) {
250                         if ( cse instanceof CharStreamIOException ) {
251                             throw new TokenStreamIOException(((CharStreamIOException)cse).io);
252                         }
253                         else {
254                             throw new TokenStreamException(cse.getMessage());
255                         }
256                     }
257                 }
258                 Token token = GroovyLexer.this.nextToken();
259                 int lasttype = token.getType();
260                 if (whitespaceIncluded) {
261                     switch (lasttype) {  // filter out insignificant types
262                     case WS:
263                     case ONE_NL:
264                     case SL_COMMENT:
265                     case ML_COMMENT:
266                         lasttype = lastSigTokenType;  // back up!
267                     }
268                 }
269                 lastSigTokenType = lasttype;
270                 return token;
271             }
272         };
273     }
274 
275         // stuff to adjust ANTLR's tracing machinery
276     public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceLexer
277     public void traceIn(String rname) throws CharStreamException {
278         if (!GroovyLexer.tracing)  return;
279         super.traceIn(rname);
280     }
281     public void traceOut(String rname) throws CharStreamException {
282         if (!GroovyLexer.tracing)  return;
283         if (_returnToken != null)  rname += tokenStringOf(_returnToken);
284         super.traceOut(rname);
285     }
286     private static java.util.HashMap ttypes;
287     private static String tokenStringOf(Token t) {
288         if (ttypes == null) {
289             java.util.HashMap map = new java.util.HashMap();
290             java.lang.reflect.Field[] fields = GroovyTokenTypes.class.getDeclaredFields();
291             for (int i = 0; i < fields.length; i++) {
292                 if (fields[i].getType() != int.class)  continue;
293                 try {
294                     map.put(fields[i].get(null), fields[i].getName());
295 bug overview next bug                   } catch (IllegalAccessException ee) {  HEALTH4J >>  :  EmptyCatchBlock 
296                 }
297             }
298             ttypes = map;
299         }
300         Integer tt = Integer.valueOf(t.getType());
301         Object ttn = ttypes.get(tt);
302         if (ttn == null)  ttn = "<"+tt+">";
303         return "["+ttn+",\""+t.getText()+"\"]";
304     }
305 
306 previous bug bug overview next bug       protected GroovyRecognizer parser;  // little-used link; TODO: get rid of 
307     private void require(boolean z, String problem, String solution) throws SemanticException {
308 previous bug bug overview next bug           // TODO: Direct to a common error handler, rather than through the parser. 
309         if (!z)  parser.requireFailed(problem, solution);
310     }
311 public GroovyLexer(InputStream in) {
312 	this(new ByteBuffer(in));
313 }
314 public GroovyLexer(Reader in) {
315 	this(new CharBuffer(in));
316 }
317 public GroovyLexer(InputBuffer ib) {
318 	this(new LexerSharedInputState(ib));
319 }
320 public GroovyLexer(LexerSharedInputState state) {
321 	super(state);
322 	caseSensitiveLiterals = true;
323 	setCaseSensitive(true);
324 	literals = new Hashtable();
325 	literals.put(new ANTLRHashString("byte", this), new Integer(104));
326 	literals.put(new ANTLRHashString("public", this), new Integer(114));
327 	literals.put(new ANTLRHashString("case", this), new Integer(148));
328 	literals.put(new ANTLRHashString("short", this), new Integer(106));
329 	literals.put(new ANTLRHashString("break", this), new Integer(142));
330 	literals.put(new ANTLRHashString("while", this), new Integer(137));
331 	literals.put(new ANTLRHashString("new", this), new Integer(157));
332 	literals.put(new ANTLRHashString("instanceof", this), new Integer(156));
333 	literals.put(new ANTLRHashString("implements", this), new Integer(129));
334 	literals.put(new ANTLRHashString("synchronized", this), new Integer(119));
335 	literals.put(new ANTLRHashString("const", this), new Integer(40));
336 	literals.put(new ANTLRHashString("float", this), new Integer(108));
337 	literals.put(new ANTLRHashString("package", this), new Integer(80));
338 	literals.put(new ANTLRHashString("return", this), new Integer(141));
339 	literals.put(new ANTLRHashString("throw", this), new Integer(144));
340 	literals.put(new ANTLRHashString("null", this), new Integer(158));
341 	literals.put(new ANTLRHashString("def", this), new Integer(83));
342 	literals.put(new ANTLRHashString("threadsafe", this), new Integer(118));
343 	literals.put(new ANTLRHashString("protected", this), new Integer(115));
344 	literals.put(new ANTLRHashString("class", this), new Integer(91));
345 	literals.put(new ANTLRHashString("throws", this), new Integer(128));
346 	literals.put(new ANTLRHashString("do", this), new Integer(41));
347 	literals.put(new ANTLRHashString("strictfp", this), new Integer(42));
348 	literals.put(new ANTLRHashString("super", this), new Integer(97));
349 	literals.put(new ANTLRHashString("transient", this), new Integer(116));
350 	literals.put(new ANTLRHashString("native", this), new Integer(117));
351 	literals.put(new ANTLRHashString("interface", this), new Integer(92));
352 	literals.put(new ANTLRHashString("final", this), new Integer(37));
353 	literals.put(new ANTLRHashString("if", this), new Integer(135));
354 	literals.put(new ANTLRHashString("double", this), new Integer(110));
355 	literals.put(new ANTLRHashString("volatile", this), new Integer(120));
356 	literals.put(new ANTLRHashString("as", this), new Integer(112));
357 	literals.put(new ANTLRHashString("assert", this), new Integer(145));
358 	literals.put(new ANTLRHashString("catch", this), new Integer(151));
359 	literals.put(new ANTLRHashString("try", this), new Integer(149));
360 	literals.put(new ANTLRHashString("goto", this), new Integer(39));
361 	literals.put(new ANTLRHashString("enum", this), new Integer(93));
362 	literals.put(new ANTLRHashString("int", this), new Integer(107));
363 	literals.put(new ANTLRHashString("for", this), new Integer(139));
364 	literals.put(new ANTLRHashString("extends", this), new Integer(96));
365 	literals.put(new ANTLRHashString("boolean", this), new Integer(103));
366 	literals.put(new ANTLRHashString("char", this), new Integer(105));
367 	literals.put(new ANTLRHashString("private", this), new Integer(113));
368 	literals.put(new ANTLRHashString("default", this), new Integer(127));
369 	literals.put(new ANTLRHashString("false", this), new Integer(155));
370 	literals.put(new ANTLRHashString("this", this), new Integer(130));
371 	literals.put(new ANTLRHashString("static", this), new Integer(82));
372 	literals.put(new ANTLRHashString("abstract", this), new Integer(38));
373 	literals.put(new ANTLRHashString("continue", this), new Integer(143));
374 	literals.put(new ANTLRHashString("finally", this), new Integer(150));
375 	literals.put(new ANTLRHashString("else", this), new Integer(136));
376 	literals.put(new ANTLRHashString("import", this), new Integer(81));
377 	literals.put(new ANTLRHashString("in", this), new Integer(140));
378 	literals.put(new ANTLRHashString("void", this), new Integer(102));
379 	literals.put(new ANTLRHashString("switch", this), new Integer(138));
380 	literals.put(new ANTLRHashString("true", this), new Integer(159));
381 	literals.put(new ANTLRHashString("long", this), new Integer(109));
382 }
383 
384 previous bug bug overview next bug   public Token nextToken() throws TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
385 	Token theRetToken=null;
386 tryAgain:
387 	for (;;) {
388 		Token _token = null;
389 		int _ttype = Token.INVALID_TYPE;
390 		resetText();
391 		try {   // for char stream error handling
392 			try {   // for lexical error handling
393 				switch ( LA(1)) {
394 				case '(':
395 				{
396 					mLPAREN(true);
397 					theRetToken=_returnToken;
398 					break;
399 				}
400 				case ')':
401 				{
402 					mRPAREN(true);
403 					theRetToken=_returnToken;
404 					break;
405 				}
406 				case '[':
407 				{
408 					mLBRACK(true);
409 					theRetToken=_returnToken;
410 					break;
411 				}
412 				case ']':
413 				{
414 					mRBRACK(true);
415 					theRetToken=_returnToken;
416 					break;
417 				}
418 				case '{':
419 				{
420 					mLCURLY(true);
421 					theRetToken=_returnToken;
422 					break;
423 				}
424 				case '}':
425 				{
426 					mRCURLY(true);
427 					theRetToken=_returnToken;
428 					break;
429 				}
430 				case ':':
431 				{
432 					mCOLON(true);
433 					theRetToken=_returnToken;
434 					break;
435 				}
436 				case ',':
437 				{
438 					mCOMMA(true);
439 					theRetToken=_returnToken;
440 					break;
441 				}
442 				case '~':
443 				{
444 					mBNOT(true);
445 					theRetToken=_returnToken;
446 					break;
447 				}
448 				case ';':
449 				{
450 					mSEMI(true);
451 					theRetToken=_returnToken;
452 					break;
453 				}
454 				case '\t':  case '\u000c':  case ' ':  case '\\':
455 				{
456 					mWS(true);
457 					theRetToken=_returnToken;
458 					break;
459 				}
460 				case '\n':  case '\r':
461 				{
462 					mNLS(true);
463 					theRetToken=_returnToken;
464 					break;
465 				}
466 				case '"':  case '\'':
467 				{
468 					mSTRING_LITERAL(true);
469 					theRetToken=_returnToken;
470 					break;
471 				}
472 				case '0':  case '1':  case '2':  case '3':
473 				case '4':  case '5':  case '6':  case '7':
474 				case '8':  case '9':
475 				{
476 					mNUM_INT(true);
477 					theRetToken=_returnToken;
478 					break;
479 				}
480 				case '@':
481 				{
482 					mAT(true);
483 					theRetToken=_returnToken;
484 					break;
485 				}
486 				default:
487 					if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (LA(4)=='=')) {
488 						mBSR_ASSIGN(true);
489 						theRetToken=_returnToken;
490 					}
491 					else if ((LA(1)=='<') && (LA(2)=='=') && (LA(3)=='>')) {
492 						mCOMPARE_TO(true);
493 						theRetToken=_returnToken;
494 					}
495 					else if ((LA(1)=='=') && (LA(2)=='=') && (LA(3)=='=')) {
496 						mIDENTICAL(true);
497 						theRetToken=_returnToken;
498 					}
499 					else if ((LA(1)=='!') && (LA(2)=='=') && (LA(3)=='=')) {
500 						mNOT_IDENTICAL(true);
501 						theRetToken=_returnToken;
502 					}
503 					else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='=')) {
504 						mSR_ASSIGN(true);
505 						theRetToken=_returnToken;
506 					}
507 					else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (true)) {
508 						mBSR(true);
509 						theRetToken=_returnToken;
510 					}
511 					else if ((LA(1)=='<') && (LA(2)=='<') && (LA(3)=='=')) {
512 						mSL_ASSIGN(true);
513 						theRetToken=_returnToken;
514 					}
515 					else if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='<')) {
516 						mRANGE_EXCLUSIVE(true);
517 						theRetToken=_returnToken;
518 					}
519 					else if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='.')) {
520 						mTRIPLE_DOT(true);
521 						theRetToken=_returnToken;
522 					}
523 					else if ((LA(1)=='=') && (LA(2)=='=') && (LA(3)=='~')) {
524 						mREGEX_MATCH(true);
525 						theRetToken=_returnToken;
526 					}
527 					else if ((LA(1)=='*') && (LA(2)=='*') && (LA(3)=='=')) {
528 						mSTAR_STAR_ASSIGN(true);
529 						theRetToken=_returnToken;
530 					}
531 					else if ((LA(1)=='=') && (LA(2)=='=') && (true)) {
532 						mEQUAL(true);
533 						theRetToken=_returnToken;
534 					}
535 					else if ((LA(1)=='!') && (LA(2)=='=') && (true)) {
536 						mNOT_EQUAL(true);
537 						theRetToken=_returnToken;
538 					}
539 					else if ((LA(1)=='+') && (LA(2)=='=')) {
540 						mPLUS_ASSIGN(true);
541 						theRetToken=_returnToken;
542 					}
543 					else if ((LA(1)=='+') && (LA(2)=='+')) {
544 						mINC(true);
545 						theRetToken=_returnToken;
546 					}
547 					else if ((LA(1)=='-') && (LA(2)=='=')) {
548 						mMINUS_ASSIGN(true);
549 						theRetToken=_returnToken;
550 					}
551 					else if ((LA(1)=='-') && (LA(2)=='-')) {
552 						mDEC(true);
553 						theRetToken=_returnToken;
554 					}
555 					else if ((LA(1)=='*') && (LA(2)=='=')) {
556 						mSTAR_ASSIGN(true);
557 						theRetToken=_returnToken;
558 					}
559 					else if ((LA(1)=='%') && (LA(2)=='=')) {
560 						mMOD_ASSIGN(true);
561 						theRetToken=_returnToken;
562 					}
563 					else if ((LA(1)=='>') && (LA(2)=='>') && (true)) {
564 						mSR(true);
565 						theRetToken=_returnToken;
566 					}
567 					else if ((LA(1)=='>') && (LA(2)=='=')) {
568 						mGE(true);
569 						theRetToken=_returnToken;
570 					}
571 					else if ((LA(1)=='<') && (LA(2)=='<') && (true)) {
572 						mSL(true);
573 						theRetToken=_returnToken;
574 					}
575 					else if ((LA(1)=='<') && (LA(2)=='=') && (true)) {
576 						mLE(true);
577 						theRetToken=_returnToken;
578 					}
579 					else if ((LA(1)=='^') && (LA(2)=='=')) {
580 						mBXOR_ASSIGN(true);
581 						theRetToken=_returnToken;
582 					}
583 					else if ((LA(1)=='|') && (LA(2)=='=')) {
584 						mBOR_ASSIGN(true);
585 						theRetToken=_returnToken;
586 					}
587 					else if ((LA(1)=='|') && (LA(2)=='|')) {
588 						mLOR(true);
589 						theRetToken=_returnToken;
590 					}
591 					else if ((LA(1)=='&') && (LA(2)=='=')) {
592 						mBAND_ASSIGN(true);
593 						theRetToken=_returnToken;
594 					}
595 					else if ((LA(1)=='&') && (LA(2)=='&')) {
596 						mLAND(true);
597 						theRetToken=_returnToken;
598 					}
599 					else if ((LA(1)=='.') && (LA(2)=='.') && (true)) {
600 						mRANGE_INCLUSIVE(true);
601 						theRetToken=_returnToken;
602 					}
603 					else if ((LA(1)=='*') && (LA(2)=='.')) {
604 						mSPREAD_DOT(true);
605 						theRetToken=_returnToken;
606 					}
607 					else if ((LA(1)=='?') && (LA(2)=='.')) {
608 						mOPTIONAL_DOT(true);
609 						theRetToken=_returnToken;
610 					}
611 					else if ((LA(1)=='?') && (LA(2)==':')) {
612 						mELVIS_OPERATOR(true);
613 						theRetToken=_returnToken;
614 					}
615 					else if ((LA(1)=='.') && (LA(2)=='&')) {
616 						mMEMBER_POINTER(true);
617 						theRetToken=_returnToken;
618 					}
619 					else if ((LA(1)=='=') && (LA(2)=='~')) {
620 						mREGEX_FIND(true);
621 						theRetToken=_returnToken;
622 					}
623 					else if ((LA(1)=='*') && (LA(2)=='*') && (true)) {
624 						mSTAR_STAR(true);
625 						theRetToken=_returnToken;
626 					}
627 					else if ((LA(1)=='-') && (LA(2)=='>')) {
628 						mCLOSABLE_BLOCK_OP(true);
629 						theRetToken=_returnToken;
630 					}
631 					else if ((LA(1)=='/') && (LA(2)=='/')) {
632 						mSL_COMMENT(true);
633 						theRetToken=_returnToken;
634 					}
635 					else if ((LA(1)=='/') && (LA(2)=='*')) {
636 						mML_COMMENT(true);
637 						theRetToken=_returnToken;
638 					}
639 					else if (((LA(1)=='$') && (LA(2)=='/'))&&(allowRegexpLiteral())) {
640 						mDOLLAR_REGEXP_LITERAL(true);
641 						theRetToken=_returnToken;
642 					}
643 					else if ((LA(1)=='?') && (true)) {
644 						mQUESTION(true);
645 						theRetToken=_returnToken;
646 					}
647 					else if ((LA(1)=='.') && (true)) {
648 						mDOT(true);
649 						theRetToken=_returnToken;
650 					}
651 					else if ((LA(1)=='=') && (true)) {
652 						mASSIGN(true);
653 						theRetToken=_returnToken;
654 					}
655 					else if ((LA(1)=='!') && (true)) {
656 						mLNOT(true);
657 						theRetToken=_returnToken;
658 					}
659 					else if ((LA(1)=='+') && (true)) {
660 						mPLUS(true);
661 						theRetToken=_returnToken;
662 					}
663 					else if ((LA(1)=='-') && (true)) {
664 						mMINUS(true);
665 						theRetToken=_returnToken;
666 					}
667 					else if ((LA(1)=='*') && (true)) {
668 						mSTAR(true);
669 						theRetToken=_returnToken;
670 					}
671 					else if ((LA(1)=='%') && (true)) {
672 						mMOD(true);
673 						theRetToken=_returnToken;
674 					}
675 					else if ((LA(1)=='>') && (true)) {
676 						mGT(true);
677 						theRetToken=_returnToken;
678 					}
679 					else if ((LA(1)=='<') && (true)) {
680 						mLT(true);
681 						theRetToken=_returnToken;
682 					}
683 					else if ((LA(1)=='^') && (true)) {
684 						mBXOR(true);
685 						theRetToken=_returnToken;
686 					}
687 					else if ((LA(1)=='|') && (true)) {
688 						mBOR(true);
689 						theRetToken=_returnToken;
690 					}
691 					else if ((LA(1)=='&') && (true)) {
692 						mBAND(true);
693 						theRetToken=_returnToken;
694 					}
695 					else if (((LA(1)=='#'))&&(getLine() == 1 && getColumn() == 1)) {
696 						mSH_COMMENT(true);
697 						theRetToken=_returnToken;
698 					}
699 					else if ((LA(1)=='/') && (true)) {
700 						mREGEXP_LITERAL(true);
701 						theRetToken=_returnToken;
702 					}
703 					else if ((_tokenSet_0.member(LA(1))) && (true)) {
704 						mIDENT(true);
705 						theRetToken=_returnToken;
706 					}
707 				else {
708 					if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
709 				else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
710 				}
711 				}
712 				if ( _returnToken==null ) continue tryAgain; // found SKIP token
713 				_ttype = _returnToken.getType();
714 				_returnToken.setType(_ttype);
715 				return _returnToken;
716 			}
717 			catch (RecognitionException e) {
718 				throw new TokenStreamRecognitionException(e);
719 			}
720 		}
721 		catch (CharStreamException cse) {
722 			if ( cse instanceof CharStreamIOException ) {
723 				throw new TokenStreamIOException(((CharStreamIOException)cse).io);
724 			}
725 			else {
726 				throw new TokenStreamException(cse.getMessage());
727 			}
728 		}
729 	}
730 }
731 
732 	public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
733 		int _ttype; Token _token=null; int _begin=text.length();
734 		_ttype = QUESTION;
735 		int _saveIndex;
736 		
737 		match('?');
738 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
739 			_token = makeToken(_ttype);
740 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
741 		}
742 		_returnToken = _token;
743 	}
744 	
745 	public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
746 		int _ttype; Token _token=null; int _begin=text.length();
747 		_ttype = LPAREN;
748 		int _saveIndex;
749 		
750 		match('(');
751 		if ( inputState.guessing==0 ) {
752 			++parenLevel;
753 		}
754 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
755 			_token = makeToken(_ttype);
756 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
757 		}
758 		_returnToken = _token;
759 	}
760 	
761 	public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
762 		int _ttype; Token _token=null; int _begin=text.length();
763 		_ttype = RPAREN;
764 		int _saveIndex;
765 		
766 		match(')');
767 		if ( inputState.guessing==0 ) {
768 			--parenLevel;
769 		}
770 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
771 			_token = makeToken(_ttype);
772 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
773 		}
774 		_returnToken = _token;
775 	}
776 	
777 	public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
778 		int _ttype; Token _token=null; int _begin=text.length();
779 		_ttype = LBRACK;
780 		int _saveIndex;
781 		
782 		match('[');
783 		if ( inputState.guessing==0 ) {
784 			++parenLevel;
785 		}
786 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
787 			_token = makeToken(_ttype);
788 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
789 		}
790 		_returnToken = _token;
791 	}
792 	
793 	public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
794 		int _ttype; Token _token=null; int _begin=text.length();
795 		_ttype = RBRACK;
796 		int _saveIndex;
797 		
798 		match(']');
799 		if ( inputState.guessing==0 ) {
800 			--parenLevel;
801 		}
802 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
803 			_token = makeToken(_ttype);
804 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
805 		}
806 		_returnToken = _token;
807 	}
808 	
809 	public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
810 		int _ttype; Token _token=null; int _begin=text.length();
811 		_ttype = LCURLY;
812 		int _saveIndex;
813 		
814 		match('{');
815 		if ( inputState.guessing==0 ) {
816 			pushParenLevel();
817 		}
818 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
819 			_token = makeToken(_ttype);
820 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
821 		}
822 		_returnToken = _token;
823 	}
824 	
825 	public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
826 		int _ttype; Token _token=null; int _begin=text.length();
827 		_ttype = RCURLY;
828 		int _saveIndex;
829 		
830 		match('}');
831 		if ( inputState.guessing==0 ) {
832 			popParenLevel(); if(stringCtorState!=0) restartStringCtor(true);
833 		}
834 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
835 			_token = makeToken(_ttype);
836 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
837 		}
838 		_returnToken = _token;
839 	}
840 	
841 	public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
842 		int _ttype; Token _token=null; int _begin=text.length();
843 		_ttype = COLON;
844 		int _saveIndex;
845 		
846 		match(':');
847 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
848 			_token = makeToken(_ttype);
849 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
850 		}
851 		_returnToken = _token;
852 	}
853 	
854 	public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
855 		int _ttype; Token _token=null; int _begin=text.length();
856 		_ttype = COMMA;
857 		int _saveIndex;
858 		
859 		match(',');
860 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
861 			_token = makeToken(_ttype);
862 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
863 		}
864 		_returnToken = _token;
865 	}
866 	
867 	public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
868 		int _ttype; Token _token=null; int _begin=text.length();
869 		_ttype = DOT;
870 		int _saveIndex;
871 		
872 		match('.');
873 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
874 			_token = makeToken(_ttype);
875 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
876 		}
877 		_returnToken = _token;
878 	}
879 	
880 	public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
881 		int _ttype; Token _token=null; int _begin=text.length();
882 		_ttype = ASSIGN;
883 		int _saveIndex;
884 		
885 		match('=');
886 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
887 			_token = makeToken(_ttype);
888 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
889 		}
890 		_returnToken = _token;
891 	}
892 	
893 	public final void mCOMPARE_TO(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
894 		int _ttype; Token _token=null; int _begin=text.length();
895 		_ttype = COMPARE_TO;
896 		int _saveIndex;
897 		
898 		match("<=>");
899 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
900 			_token = makeToken(_ttype);
901 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
902 		}
903 		_returnToken = _token;
904 	}
905 	
906 	public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
907 		int _ttype; Token _token=null; int _begin=text.length();
908 		_ttype = EQUAL;
909 		int _saveIndex;
910 		
911 		match("==");
912 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
913 			_token = makeToken(_ttype);
914 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
915 		}
916 		_returnToken = _token;
917 	}
918 	
919 	public final void mIDENTICAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
920 		int _ttype; Token _token=null; int _begin=text.length();
921 		_ttype = IDENTICAL;
922 		int _saveIndex;
923 		
924 		match("===");
925 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
926 			_token = makeToken(_ttype);
927 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
928 		}
929 		_returnToken = _token;
930 	}
931 	
932 	public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
933 		int _ttype; Token _token=null; int _begin=text.length();
934 		_ttype = LNOT;
935 		int _saveIndex;
936 		
937 		match('!');
938 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
939 			_token = makeToken(_ttype);
940 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
941 		}
942 		_returnToken = _token;
943 	}
944 	
945 	public final void mBNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
946 		int _ttype; Token _token=null; int _begin=text.length();
947 		_ttype = BNOT;
948 		int _saveIndex;
949 		
950 		match('~');
951 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
952 			_token = makeToken(_ttype);
953 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
954 		}
955 		_returnToken = _token;
956 	}
957 	
958 	public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
959 		int _ttype; Token _token=null; int _begin=text.length();
960 		_ttype = NOT_EQUAL;
961 		int _saveIndex;
962 		
963 		match("!=");
964 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
965 			_token = makeToken(_ttype);
966 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
967 		}
968 		_returnToken = _token;
969 	}
970 	
971 	public final void mNOT_IDENTICAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
972 		int _ttype; Token _token=null; int _begin=text.length();
973 		_ttype = NOT_IDENTICAL;
974 		int _saveIndex;
975 		
976 		match("!==");
977 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
978 			_token = makeToken(_ttype);
979 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
980 		}
981 		_returnToken = _token;
982 	}
983 	
984 	protected final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
985 		int _ttype; Token _token=null; int _begin=text.length();
986 		_ttype = DIV;
987 		int _saveIndex;
988 		
989 		match('/');
990 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
991 			_token = makeToken(_ttype);
992 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
993 		}
994 		_returnToken = _token;
995 	}
996 	
997 	protected final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
998 		int _ttype; Token _token=null; int _begin=text.length();
999 		_ttype = DIV_ASSIGN;
1000 		int _saveIndex;
1001 		
1002 		match("/=");
1003 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1004 			_token = makeToken(_ttype);
1005 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1006 		}
1007 		_returnToken = _token;
1008 	}
1009 	
1010 	public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1011 		int _ttype; Token _token=null; int _begin=text.length();
1012 		_ttype = PLUS;
1013 		int _saveIndex;
1014 		
1015 		match('+');
1016 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1017 			_token = makeToken(_ttype);
1018 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1019 		}
1020 		_returnToken = _token;
1021 	}
1022 	
1023 	public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1024 		int _ttype; Token _token=null; int _begin=text.length();
1025 		_ttype = PLUS_ASSIGN;
1026 		int _saveIndex;
1027 		
1028 		match("+=");
1029 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1030 			_token = makeToken(_ttype);
1031 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1032 		}
1033 		_returnToken = _token;
1034 	}
1035 	
1036 	public final void mINC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1037 		int _ttype; Token _token=null; int _begin=text.length();
1038 		_ttype = INC;
1039 		int _saveIndex;
1040 		
1041 		match("++");
1042 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1043 			_token = makeToken(_ttype);
1044 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1045 		}
1046 		_returnToken = _token;
1047 	}
1048 	
1049 	public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1050 		int _ttype; Token _token=null; int _begin=text.length();
1051 		_ttype = MINUS;
1052 		int _saveIndex;
1053 		
1054 		match('-');
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 mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1063 		int _ttype; Token _token=null; int _begin=text.length();
1064 		_ttype = MINUS_ASSIGN;
1065 		int _saveIndex;
1066 		
1067 		match("-=");
1068 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1069 			_token = makeToken(_ttype);
1070 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1071 		}
1072 		_returnToken = _token;
1073 	}
1074 	
1075 	public final void mDEC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1076 		int _ttype; Token _token=null; int _begin=text.length();
1077 		_ttype = DEC;
1078 		int _saveIndex;
1079 		
1080 		match("--");
1081 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1082 			_token = makeToken(_ttype);
1083 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1084 		}
1085 		_returnToken = _token;
1086 	}
1087 	
1088 	public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1089 		int _ttype; Token _token=null; int _begin=text.length();
1090 		_ttype = STAR;
1091 		int _saveIndex;
1092 		
1093 		match('*');
1094 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1095 			_token = makeToken(_ttype);
1096 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1097 		}
1098 		_returnToken = _token;
1099 	}
1100 	
1101 	public final void mSTAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1102 		int _ttype; Token _token=null; int _begin=text.length();
1103 		_ttype = STAR_ASSIGN;
1104 		int _saveIndex;
1105 		
1106 		match("*=");
1107 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1108 			_token = makeToken(_ttype);
1109 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1110 		}
1111 		_returnToken = _token;
1112 	}
1113 	
1114 	public final void mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1115 		int _ttype; Token _token=null; int _begin=text.length();
1116 		_ttype = MOD;
1117 		int _saveIndex;
1118 		
1119 		match('%');
1120 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1121 			_token = makeToken(_ttype);
1122 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1123 		}
1124 		_returnToken = _token;
1125 	}
1126 	
1127 	public final void mMOD_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1128 		int _ttype; Token _token=null; int _begin=text.length();
1129 		_ttype = MOD_ASSIGN;
1130 		int _saveIndex;
1131 		
1132 		match("%=");
1133 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1134 			_token = makeToken(_ttype);
1135 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1136 		}
1137 		_returnToken = _token;
1138 	}
1139 	
1140 	public final void mSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1141 		int _ttype; Token _token=null; int _begin=text.length();
1142 		_ttype = SR;
1143 		int _saveIndex;
1144 		
1145 		match(">>");
1146 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1147 			_token = makeToken(_ttype);
1148 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1149 		}
1150 		_returnToken = _token;
1151 	}
1152 	
1153 	public final void mSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1154 		int _ttype; Token _token=null; int _begin=text.length();
1155 		_ttype = SR_ASSIGN;
1156 		int _saveIndex;
1157 		
1158 		match(">>=");
1159 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1160 			_token = makeToken(_ttype);
1161 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1162 		}
1163 		_returnToken = _token;
1164 	}
1165 	
1166 	public final void mBSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1167 		int _ttype; Token _token=null; int _begin=text.length();
1168 		_ttype = BSR;
1169 		int _saveIndex;
1170 		
1171 		match(">>>");
1172 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1173 			_token = makeToken(_ttype);
1174 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1175 		}
1176 		_returnToken = _token;
1177 	}
1178 	
1179 	public final void mBSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1180 		int _ttype; Token _token=null; int _begin=text.length();
1181 		_ttype = BSR_ASSIGN;
1182 		int _saveIndex;
1183 		
1184 		match(">>>=");
1185 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1186 			_token = makeToken(_ttype);
1187 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1188 		}
1189 		_returnToken = _token;
1190 	}
1191 	
1192 	public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1193 		int _ttype; Token _token=null; int _begin=text.length();
1194 		_ttype = GE;
1195 		int _saveIndex;
1196 		
1197 		match(">=");
1198 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1199 			_token = makeToken(_ttype);
1200 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1201 		}
1202 		_returnToken = _token;
1203 	}
1204 	
1205 	public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1206 		int _ttype; Token _token=null; int _begin=text.length();
1207 		_ttype = GT;
1208 		int _saveIndex;
1209 		
1210 		match(">");
1211 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1212 			_token = makeToken(_ttype);
1213 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1214 		}
1215 		_returnToken = _token;
1216 	}
1217 	
1218 	public final void mSL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1219 		int _ttype; Token _token=null; int _begin=text.length();
1220 		_ttype = SL;
1221 		int _saveIndex;
1222 		
1223 		match("<<");
1224 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1225 			_token = makeToken(_ttype);
1226 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1227 		}
1228 		_returnToken = _token;
1229 	}
1230 	
1231 	public final void mSL_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1232 		int _ttype; Token _token=null; int _begin=text.length();
1233 		_ttype = SL_ASSIGN;
1234 		int _saveIndex;
1235 		
1236 		match("<<=");
1237 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1238 			_token = makeToken(_ttype);
1239 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1240 		}
1241 		_returnToken = _token;
1242 	}
1243 	
1244 	public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1245 		int _ttype; Token _token=null; int _begin=text.length();
1246 		_ttype = LE;
1247 		int _saveIndex;
1248 		
1249 		match("<=");
1250 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1251 			_token = makeToken(_ttype);
1252 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1253 		}
1254 		_returnToken = _token;
1255 	}
1256 	
1257 	public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1258 		int _ttype; Token _token=null; int _begin=text.length();
1259 		_ttype = LT;
1260 		int _saveIndex;
1261 		
1262 		match('<');
1263 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1264 			_token = makeToken(_ttype);
1265 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1266 		}
1267 		_returnToken = _token;
1268 	}
1269 	
1270 	public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1271 		int _ttype; Token _token=null; int _begin=text.length();
1272 		_ttype = BXOR;
1273 		int _saveIndex;
1274 		
1275 		match('^');
1276 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1277 			_token = makeToken(_ttype);
1278 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1279 		}
1280 		_returnToken = _token;
1281 	}
1282 	
1283 	public final void mBXOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1284 		int _ttype; Token _token=null; int _begin=text.length();
1285 		_ttype = BXOR_ASSIGN;
1286 		int _saveIndex;
1287 		
1288 		match("^=");
1289 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1290 			_token = makeToken(_ttype);
1291 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1292 		}
1293 		_returnToken = _token;
1294 	}
1295 	
1296 	public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1297 		int _ttype; Token _token=null; int _begin=text.length();
1298 		_ttype = BOR;
1299 		int _saveIndex;
1300 		
1301 		match('|');
1302 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1303 			_token = makeToken(_ttype);
1304 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1305 		}
1306 		_returnToken = _token;
1307 	}
1308 	
1309 	public final void mBOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1310 		int _ttype; Token _token=null; int _begin=text.length();
1311 		_ttype = BOR_ASSIGN;
1312 		int _saveIndex;
1313 		
1314 		match("|=");
1315 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1316 			_token = makeToken(_ttype);
1317 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1318 		}
1319 		_returnToken = _token;
1320 	}
1321 	
1322 	public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1323 		int _ttype; Token _token=null; int _begin=text.length();
1324 		_ttype = LOR;
1325 		int _saveIndex;
1326 		
1327 		match("||");
1328 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1329 			_token = makeToken(_ttype);
1330 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1331 		}
1332 		_returnToken = _token;
1333 	}
1334 	
1335 	public final void mBAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1336 		int _ttype; Token _token=null; int _begin=text.length();
1337 		_ttype = BAND;
1338 		int _saveIndex;
1339 		
1340 		match('&');
1341 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1342 			_token = makeToken(_ttype);
1343 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1344 		}
1345 		_returnToken = _token;
1346 	}
1347 	
1348 	public final void mBAND_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1349 		int _ttype; Token _token=null; int _begin=text.length();
1350 		_ttype = BAND_ASSIGN;
1351 		int _saveIndex;
1352 		
1353 		match("&=");
1354 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1355 			_token = makeToken(_ttype);
1356 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1357 		}
1358 		_returnToken = _token;
1359 	}
1360 	
1361 	public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1362 		int _ttype; Token _token=null; int _begin=text.length();
1363 		_ttype = LAND;
1364 		int _saveIndex;
1365 		
1366 		match("&&");
1367 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1368 			_token = makeToken(_ttype);
1369 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1370 		}
1371 		_returnToken = _token;
1372 	}
1373 	
1374 	public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1375 		int _ttype; Token _token=null; int _begin=text.length();
1376 		_ttype = SEMI;
1377 		int _saveIndex;
1378 		
1379 		match(';');
1380 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1381 			_token = makeToken(_ttype);
1382 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1383 		}
1384 		_returnToken = _token;
1385 	}
1386 	
1387 	protected final void mDOLLAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1388 		int _ttype; Token _token=null; int _begin=text.length();
1389 		_ttype = DOLLAR;
1390 		int _saveIndex;
1391 		
1392 		match('$');
1393 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1394 			_token = makeToken(_ttype);
1395 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1396 		}
1397 		_returnToken = _token;
1398 	}
1399 	
1400 	public final void mRANGE_INCLUSIVE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1401 		int _ttype; Token _token=null; int _begin=text.length();
1402 		_ttype = RANGE_INCLUSIVE;
1403 		int _saveIndex;
1404 		
1405 		match("..");
1406 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1407 			_token = makeToken(_ttype);
1408 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1409 		}
1410 		_returnToken = _token;
1411 	}
1412 	
1413 	public final void mRANGE_EXCLUSIVE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1414 		int _ttype; Token _token=null; int _begin=text.length();
1415 		_ttype = RANGE_EXCLUSIVE;
1416 		int _saveIndex;
1417 		
1418 		match("..<");
1419 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1420 			_token = makeToken(_ttype);
1421 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1422 		}
1423 		_returnToken = _token;
1424 	}
1425 	
1426 	public final void mTRIPLE_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1427 		int _ttype; Token _token=null; int _begin=text.length();
1428 		_ttype = TRIPLE_DOT;
1429 		int _saveIndex;
1430 		
1431 		match("...");
1432 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1433 			_token = makeToken(_ttype);
1434 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1435 		}
1436 		_returnToken = _token;
1437 	}
1438 	
1439 	public final void mSPREAD_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1440 		int _ttype; Token _token=null; int _begin=text.length();
1441 		_ttype = SPREAD_DOT;
1442 		int _saveIndex;
1443 		
1444 		match("*.");
1445 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1446 			_token = makeToken(_ttype);
1447 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1448 		}
1449 		_returnToken = _token;
1450 	}
1451 	
1452 	public final void mOPTIONAL_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1453 		int _ttype; Token _token=null; int _begin=text.length();
1454 		_ttype = OPTIONAL_DOT;
1455 		int _saveIndex;
1456 		
1457 		match("?.");
1458 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1459 			_token = makeToken(_ttype);
1460 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1461 		}
1462 		_returnToken = _token;
1463 	}
1464 	
1465 	public final void mELVIS_OPERATOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1466 		int _ttype; Token _token=null; int _begin=text.length();
1467 		_ttype = ELVIS_OPERATOR;
1468 		int _saveIndex;
1469 		
1470 		match("?:");
1471 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1472 			_token = makeToken(_ttype);
1473 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1474 		}
1475 		_returnToken = _token;
1476 	}
1477 	
1478 	public final void mMEMBER_POINTER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1479 		int _ttype; Token _token=null; int _begin=text.length();
1480 		_ttype = MEMBER_POINTER;
1481 		int _saveIndex;
1482 		
1483 		match(".&");
1484 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1485 			_token = makeToken(_ttype);
1486 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1487 		}
1488 		_returnToken = _token;
1489 	}
1490 	
1491 	public final void mREGEX_FIND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1492 		int _ttype; Token _token=null; int _begin=text.length();
1493 		_ttype = REGEX_FIND;
1494 		int _saveIndex;
1495 		
1496 		match("=~");
1497 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1498 			_token = makeToken(_ttype);
1499 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1500 		}
1501 		_returnToken = _token;
1502 	}
1503 	
1504 	public final void mREGEX_MATCH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1505 		int _ttype; Token _token=null; int _begin=text.length();
1506 		_ttype = REGEX_MATCH;
1507 		int _saveIndex;
1508 		
1509 		match("==~");
1510 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1511 			_token = makeToken(_ttype);
1512 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1513 		}
1514 		_returnToken = _token;
1515 	}
1516 	
1517 	public final void mSTAR_STAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1518 		int _ttype; Token _token=null; int _begin=text.length();
1519 		_ttype = STAR_STAR;
1520 		int _saveIndex;
1521 		
1522 		match("**");
1523 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1524 			_token = makeToken(_ttype);
1525 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1526 		}
1527 		_returnToken = _token;
1528 	}
1529 	
1530 	public final void mSTAR_STAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1531 		int _ttype; Token _token=null; int _begin=text.length();
1532 		_ttype = STAR_STAR_ASSIGN;
1533 		int _saveIndex;
1534 		
1535 		match("**=");
1536 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1537 			_token = makeToken(_ttype);
1538 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1539 		}
1540 		_returnToken = _token;
1541 	}
1542 	
1543 	public final void mCLOSABLE_BLOCK_OP(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1544 		int _ttype; Token _token=null; int _begin=text.length();
1545 		_ttype = CLOSABLE_BLOCK_OP;
1546 		int _saveIndex;
1547 		
1548 		match("->");
1549 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1550 			_token = makeToken(_ttype);
1551 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1552 		}
1553 		_returnToken = _token;
1554 	}
1555 	
1556 	public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1557 		int _ttype; Token _token=null; int _begin=text.length();
1558 		_ttype = WS;
1559 		int _saveIndex;
1560 		
1561 		{
1562 		int _cnt648=0;
1563 		_loop648:
1564 		do {
1565 			if ((LA(1)=='\\') && (LA(2)=='\n'||LA(2)=='\r') && (true) && (true)) {
1566 				match('\\');
1567 				mONE_NL(false,false);
1568 			}
1569 			else if ((LA(1)==' ') && (true) && (true) && (true)) {
1570 				match(' ');
1571 			}
1572 			else if ((LA(1)=='\t') && (true) && (true) && (true)) {
1573 				match('\t');
1574 			}
1575 			else if ((LA(1)=='\u000c') && (true) && (true) && (true)) {
1576 				match('\f');
1577 			}
1578 			else {
1579 				if ( _cnt648>=1 ) { break _loop648; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1580 			}
1581 			
1582 			_cnt648++;
1583 		} while (true);
1584 		}
1585 		if ( inputState.guessing==0 ) {
1586 			if (!whitespaceIncluded)  _ttype = Token.SKIP;
1587 		}
1588 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1589 			_token = makeToken(_ttype);
1590 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1591 		}
1592 		_returnToken = _token;
1593 	}
1594 	
1595 	protected final void mONE_NL(boolean _createToken,
1596 		boolean check
1597 	) throws RecognitionException, CharStreamException, TokenStreamException {
1598 		int _ttype; Token _token=null; int _begin=text.length();
1599 		_ttype = ONE_NL;
1600 		int _saveIndex;
1601 		
1602 		{
1603 		if ((LA(1)=='\r') && (LA(2)=='\n') && (true) && (true)) {
1604 			_saveIndex=text.length();
1605 			match("\r\n");
1606 			text.setLength(_saveIndex);
1607 		}
1608 		else if ((LA(1)=='\r') && (true) && (true) && (true)) {
1609 			_saveIndex=text.length();
1610 			match('\r');
1611 			text.setLength(_saveIndex);
1612 		}
1613 		else if ((LA(1)=='\n')) {
1614 			_saveIndex=text.length();
1615 			match('\n');
1616 			text.setLength(_saveIndex);
1617 		}
1618 		else {
1619 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1620 		}
1621 		
1622 		}
1623 		if ( inputState.guessing==0 ) {
1624 			
1625 			// update current line number for error reporting
1626 			newlineCheck(check);
1627 			
1628 		}
1629 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1630 			_token = makeToken(_ttype);
1631 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1632 		}
1633 		_returnToken = _token;
1634 	}
1635 	
1636 previous bug bug overview next bug   	public final void mNLS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
1637 		int _ttype; Token _token=null; int _begin=text.length();
1638 		_ttype = NLS;
1639 		int _saveIndex;
1640 		
1641 		mONE_NL(false,true);
1642 		{
1643 		if (((LA(1)=='\t'||LA(1)=='\n'||LA(1)=='\u000c'||LA(1)=='\r'||LA(1)==' '||LA(1)=='/'||LA(1)=='\\'))&&(!whitespaceIncluded)) {
1644 			{
1645 			int _cnt654=0;
1646 			_loop654:
1647 			do {
1648 				switch ( LA(1)) {
1649 				case '\n':  case '\r':
1650 				{
1651 					mONE_NL(false,true);
1652 					break;
1653 				}
1654 				case '\t':  case '\u000c':  case ' ':  case '\\':
1655 				{
1656 					mWS(false);
1657 					break;
1658 				}
1659 				default:
1660 					if ((LA(1)=='/') && (LA(2)=='/')) {
1661 						mSL_COMMENT(false);
1662 					}
1663 					else if ((LA(1)=='/') && (LA(2)=='*')) {
1664 						mML_COMMENT(false);
1665 					}
1666 				else {
1667 					if ( _cnt654>=1 ) { break _loop654; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1668 				}
1669 				}
1670 				_cnt654++;
1671 			} while (true);
1672 			}
1673 		}
1674 previous bug bug overview next bug   		else {  HEALTH4J >>  :  EmptyIfStmt 
1675 		}
1676 		
1677 		}
1678 		if ( inputState.guessing==0 ) {
1679 previous bug bug overview next bug   			if (whitespaceIncluded) {  HEALTH4J >>  :  EmptyIfStmt 
1680 			// keep the token as-is
1681 			} else if (parenLevel != 0) {
1682 			// when directly inside parens, all newlines are ignored here
1683 			_ttype = Token.SKIP;
1684 			} else {
1685 			// inside {...}, newlines must be explicitly matched as 'nls!'
1686 			text.setLength(_begin); text.append("<newline>");
1687 			}
1688 			
1689 		}
1690 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1691 			_token = makeToken(_ttype);
1692 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1693 		}
1694 		_returnToken = _token;
1695 	}
1696 	
1697 	public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1698 		int _ttype; Token _token=null; int _begin=text.length();
1699 		_ttype = SL_COMMENT;
1700 		int _saveIndex;
1701 		
1702 		match("//");
1703 		{
1704 		_loop658:
1705 		do {
1706 			if ((_tokenSet_1.member(LA(1))) && (true) && (true) && (true)) {
1707 				{
1708 				match(_tokenSet_1);
1709 				}
1710 			}
1711 			else {
1712 				break _loop658;
1713 			}
1714 			
1715 		} while (true);
1716 		}
1717 		if ( inputState.guessing==0 ) {
1718 			if (!whitespaceIncluded)  _ttype = Token.SKIP;
1719 		}
1720 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1721 			_token = makeToken(_ttype);
1722 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1723 		}
1724 		_returnToken = _token;
1725 	}
1726 	
1727 previous bug bug overview next bug   	public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
1728 		int _ttype; Token _token=null; int _begin=text.length();
1729 		_ttype = ML_COMMENT;
1730 		int _saveIndex;
1731 		
1732 		match("/*");
1733 		{
1734 		_loop668:
1735 		do {
1736 			boolean synPredMatched666 = false;
1737 			if (((LA(1)=='*') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))) {
1738 				int _m666 = mark();
1739 				synPredMatched666 = true;
1740 				inputState.guessing++;
1741 				try {
1742 					{
1743 					match('*');
1744 					matchNot('/');
1745 					}
1746 				}
1747 				catch (RecognitionException pe) {
1748 					synPredMatched666 = false;
1749 				}
1750 				rewind(_m666);
1751 inputState.guessing--;
1752 			}
1753 			if ( synPredMatched666 ) {
1754 				match('*');
1755 			}
1756 			else if ((LA(1)=='\n'||LA(1)=='\r')) {
1757 				mONE_NL(false,true);
1758 			}
1759 			else if ((_tokenSet_2.member(LA(1)))) {
1760 				{
1761 				match(_tokenSet_2);
1762 				}
1763 			}
1764 			else {
1765 				break _loop668;
1766 			}
1767 			
1768 		} while (true);
1769 		}
1770 		match("*/");
1771 		if ( inputState.guessing==0 ) {
1772 			if (!whitespaceIncluded)  _ttype = Token.SKIP;
1773 		}
1774 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1775 			_token = makeToken(_ttype);
1776 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1777 		}
1778 		_returnToken = _token;
1779 	}
1780 	
1781 	public final void mSH_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1782 		int _ttype; Token _token=null; int _begin=text.length();
1783 		_ttype = SH_COMMENT;
1784 		int _saveIndex;
1785 		
1786 		if (!(getLine() == 1 && getColumn() == 1))
1787 		  throw new SemanticException("getLine() == 1 && getColumn() == 1");
1788 		match("#!");
1789 		{
1790 		_loop662:
1791 		do {
1792 			if ((_tokenSet_1.member(LA(1)))) {
1793 				{
1794 				match(_tokenSet_1);
1795 				}
1796 			}
1797 			else {
1798 				break _loop662;
1799 			}
1800 			
1801 		} while (true);
1802 		}
1803 		if ( inputState.guessing==0 ) {
1804 			if (!whitespaceIncluded)  _ttype = Token.SKIP;
1805 		}
1806 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1807 			_token = makeToken(_ttype);
1808 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1809 		}
1810 		_returnToken = _token;
1811 	}
1812 	
1813 previous bug bug overview next bug   	public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
1814 		int _ttype; Token _token=null; int _begin=text.length();
1815 		_ttype = STRING_LITERAL;
1816 		int _saveIndex;
1817 		int tt=0;
1818 		
1819 		boolean synPredMatched671 = false;
1820 		if (((LA(1)=='\'') && (LA(2)=='\'') && (LA(3)=='\'') && ((LA(4) >= '\u0000' && LA(4) <= '\ufffe')))) {
1821 			int _m671 = mark();
1822 			synPredMatched671 = true;
1823 			inputState.guessing++;
1824 			try {
1825 				{
1826 				match("'''");
1827 				}
1828 			}
1829 			catch (RecognitionException pe) {
1830 				synPredMatched671 = false;
1831 			}
1832 			rewind(_m671);
1833 inputState.guessing--;
1834 		}
1835 		if ( synPredMatched671 ) {
1836 			_saveIndex=text.length();
1837 			match("'''");
1838 			text.setLength(_saveIndex);
1839 			{
1840 			_loop676:
1841 			do {
1842 				switch ( LA(1)) {
1843 				case '\\':
1844 				{
1845 					mESC(false);
1846 					break;
1847 				}
1848 				case '"':
1849 				{
1850 					match('"');
1851 					break;
1852 				}
1853 				case '$':
1854 				{
1855 					match('$');
1856 					break;
1857 				}
1858 				case '\n':  case '\r':
1859 				{
1860 					mSTRING_NL(false,true);
1861 					break;
1862 				}
1863 				default:
1864 					boolean synPredMatched675 = false;
1865 					if (((LA(1)=='\'') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && ((LA(4) >= '\u0000' && LA(4) <= '\ufffe')))) {
1866 						int _m675 = mark();
1867 						synPredMatched675 = true;
1868 						inputState.guessing++;
1869 						try {
1870 							{
1871 							match('\'');
1872 							{
1873 							if ((_tokenSet_3.member(LA(1)))) {
1874 								matchNot('\'');
1875 							}
1876 							else if ((LA(1)=='\'')) {
1877 								match('\'');
1878 								matchNot('\'');
1879 							}
1880 							else {
1881 								throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1882 							}
1883 							
1884 							}
1885 							}
1886 						}
1887 						catch (RecognitionException pe) {
1888 							synPredMatched675 = false;
1889 						}
1890 						rewind(_m675);
1891 inputState.guessing--;
1892 					}
1893 					if ( synPredMatched675 ) {
1894 						match('\'');
1895 					}
1896 					else if ((_tokenSet_4.member(LA(1)))) {
1897 						mSTRING_CH(false);
1898 					}
1899 				else {
1900 					break _loop676;
1901 				}
1902 				}
1903 			} while (true);
1904 			}
1905 			_saveIndex=text.length();
1906 			match("'''");
1907 			text.setLength(_saveIndex);
1908 		}
1909 		else {
1910 			boolean synPredMatched680 = false;
1911 			if (((LA(1)=='"') && (LA(2)=='"') && (LA(3)=='"') && ((LA(4) >= '\u0000' && LA(4) <= '\ufffe')))) {
1912 				int _m680 = mark();
1913 				synPredMatched680 = true;
1914 				inputState.guessing++;
1915 				try {
1916 					{
1917 					match("\"\"\"");
1918 					}
1919 				}
1920 				catch (RecognitionException pe) {
1921 					synPredMatched680 = false;
1922 				}
1923 				rewind(_m680);
1924 inputState.guessing--;
1925 			}
1926 			if ( synPredMatched680 ) {
1927 				_saveIndex=text.length();
1928 				match("\"\"\"");
1929 				text.setLength(_saveIndex);
1930 				tt=mSTRING_CTOR_END(false,true, /*tripleQuote:*/ true);
1931 				if ( inputState.guessing==0 ) {
1932 					_ttype = tt;
1933 				}
1934 			}
1935 			else if ((LA(1)=='\'') && (_tokenSet_1.member(LA(2))) && (true) && (true)) {
1936 				_saveIndex=text.length();
1937 				match('\'');
1938 				text.setLength(_saveIndex);
1939 				if ( inputState.guessing==0 ) {
1940 					++suppressNewline;
1941 				}
1942 				{
1943 				_loop678:
1944 				do {
1945 					switch ( LA(1)) {
1946 					case '\\':
1947 					{
1948 						mESC(false);
1949 						break;
1950 					}
1951 					case '"':
1952 					{
1953 						match('"');
1954 						break;
1955 					}
1956 					case '$':
1957 					{
1958 						match('$');
1959 						break;
1960 					}
1961 					default:
1962 						if ((_tokenSet_4.member(LA(1)))) {
1963 							mSTRING_CH(false);
1964 						}
1965 					else {
1966 						break _loop678;
1967 					}
1968 					}
1969 				} while (true);
1970 				}
1971 				if ( inputState.guessing==0 ) {
1972 					--suppressNewline;
1973 				}
1974 				_saveIndex=text.length();
1975 				match('\'');
1976 				text.setLength(_saveIndex);
1977 			}
1978 			else if ((LA(1)=='"') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
1979 				_saveIndex=text.length();
1980 				match('"');
1981 				text.setLength(_saveIndex);
1982 				if ( inputState.guessing==0 ) {
1983 					++suppressNewline;
1984 				}
1985 				tt=mSTRING_CTOR_END(false,true, /*tripleQuote:*/ false);
1986 				if ( inputState.guessing==0 ) {
1987 					_ttype = tt;
1988 				}
1989 			}
1990 			else {
1991 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1992 			}
1993 			}
1994 			if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1995 				_token = makeToken(_ttype);
1996 				_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1997 			}
1998 			_returnToken = _token;
1999 		}
2000 		
2001 	protected final void mSTRING_CH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2002 		int _ttype; Token _token=null; int _begin=text.length();
2003 		_ttype = STRING_CH;
2004 		int _saveIndex;
2005 		
2006 		{
2007 		match(_tokenSet_4);
2008 		}
2009 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2010 			_token = makeToken(_ttype);
2011 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2012 		}
2013 		_returnToken = _token;
2014 	}
2015 	
2016 previous bug bug overview next bug   	protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {  HEALTH4J >>  :  ExcessiveMethodLength 
2017 		int _ttype; Token _token=null; int _begin=text.length();
2018 		_ttype = ESC;
2019 		int _saveIndex;
2020 		
2021 		if ((LA(1)=='\\') && (LA(2)=='"'||LA(2)=='$'||LA(2)=='\''||LA(2)=='0'||LA(2)=='1'||LA(2)=='2'||LA(2)=='3'||LA(2)=='4'||LA(2)=='5'||LA(2)=='6'||LA(2)=='7'||LA(2)=='\\'||LA(2)=='b'||LA(2)=='f'||LA(2)=='n'||LA(2)=='r'||LA(2)=='t'||LA(2)=='u')) {
2022 			_saveIndex=text.length();
2023 			match('\\');
2024 			text.setLength(_saveIndex);
2025 			{
2026 			switch ( LA(1)) {
2027 			case 'n':
2028 			{
2029 				match('n');
2030 				if ( inputState.guessing==0 ) {
2031 					text.setLength(_begin); text.append("\n");
2032 				}
2033 				break;
2034 			}
2035 			case 'r':
2036 			{
2037 				match('r');
2038 				if ( inputState.guessing==0 ) {
2039 					text.setLength(_begin); text.append("\r");
2040 				}
2041 				break;
2042 			}
2043 			case 't':
2044 			{
2045 				match('t');
2046 				if ( inputState.guessing==0 ) {
2047 					text.setLength(_begin); text.append("\t");
2048 				}
2049 				break;
2050 			}
2051 			case 'b':
2052 			{
2053 				match('b');
2054 				if ( inputState.guessing==0 ) {
2055 					text.setLength(_begin); text.append("\b");
2056 				}
2057 				break;
2058 			}
2059 			case 'f':
2060 			{
2061 				match('f');
2062 				if ( inputState.guessing==0 ) {
2063 					text.setLength(_begin); text.append("\f");
2064 				}
2065 				break;
2066 			}
2067 			case '"':
2068 			{
2069 				match('"');
2070 				break;
2071 			}
2072 			case '\'':
2073 			{
2074 				match('\'');
2075 				break;
2076 			}
2077 			case '\\':
2078 			{
2079 				match('\\');
2080 				break;
2081 			}
2082 			case '$':
2083 			{
2084 				match('$');
2085 				break;
2086 			}
2087 			case 'u':
2088 			{
2089 				{
2090 				int _cnt722=0;
2091 				_loop722:
2092 				do {
2093 					if ((LA(1)=='u')) {
2094 						match('u');
2095 					}
2096 					else {
2097 						if ( _cnt722>=1 ) { break _loop722; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
2098 					}
2099 					
2100 					_cnt722++;
2101 				} while (true);
2102 				}
2103 				if ( inputState.guessing==0 ) {
2104 					text.setLength(_begin); text.append("");
2105 				}
2106 				mHEX_DIGIT(false);
2107 				mHEX_DIGIT(false);
2108 				mHEX_DIGIT(false);
2109 				mHEX_DIGIT(false);
2110 				if ( inputState.guessing==0 ) {
2111 					char ch = (char)Integer.parseInt(new String(text.getBuffer(),_begin,text.length()-_begin),16); text.setLength(_begin); text.append(ch);
2112 				}
2113 				break;
2114 			}
2115 			case '0':  case '1':  case '2':  case '3':
2116 			{
2117 				matchRange('0','3');
2118 				{
2119 				if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
2120 					matchRange('0','7');
2121 					{
2122 					if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
2123 						matchRange('0','7');
2124 					}
2125 previous bug bug overview next bug   					else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {  HEALTH4J >>  :  EmptyIfStmt 
2126 					}
2127 					else {
2128 						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2129 					}
2130 					
2131 					}
2132 				}
2133 previous bug bug overview next bug   				else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {  HEALTH4J >>  :  EmptyIfStmt 
2134 				}
2135 				else {
2136 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2137 				}
2138 				
2139 				}
2140 				if ( inputState.guessing==0 ) {
2141 					char ch = (char)Integer.parseInt(new String(text.getBuffer(),_begin,text.length()-_begin),8); text.setLength(_begin); text.append(ch);
2142 				}
2143 				break;
2144 			}
2145 			case '4':  case '5':  case '6':  case '7':
2146 			{
2147 				matchRange('4','7');
2148 				{
2149 				if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true)) {
2150 					matchRange('0','7');
2151 				}
2152 previous bug bug overview next bug   				else if (((LA(1) >= '\u0000' && LA(1) <= '\ufffe')) && (true) && (true) && (true)) {  HEALTH4J >>  :  EmptyIfStmt 
2153 				}
2154 				else {
2155 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2156 				}
2157 				
2158 				}
2159 				if ( inputState.guessing==0 ) {
2160 					char ch = (char)Integer.parseInt(new String(text.getBuffer(),_begin,text.length()-_begin),8); text.setLength(_begin); text.append(ch);
2161 				}
2162 				break;
2163 			}
2164 			default:
2165 			{
2166 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2167 			}
2168 			}
2169 			}
2170 		}
2171 		else if ((LA(1)=='\\') && (LA(2)=='\n'||LA(2)=='\r')) {
2172 			_saveIndex=text.length();
2173 			match('\\');
2174 			text.setLength(_saveIndex);
2175 			_saveIndex=text.length();
2176 			mONE_NL(false,false);
2177 			text.setLength(_saveIndex);
2178 		}
2179 		else {
2180 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2181 		}
2182 		
2183 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2184 			_token = makeToken(_ttype);
2185 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2186 		}
2187 		_returnToken = _token;
2188 	}
2189 	
2190 	protected final void mSTRING_NL(boolean _createToken,
2191 		boolean allowNewline
2192 	) throws RecognitionException, CharStreamException, TokenStreamException {
2193 		int _ttype; Token _token=null; int _begin=text.length();
2194 		_ttype = STRING_NL;
2195 		int _saveIndex;
2196 		
2197 		if ( inputState.guessing==0 ) {
2198 			if (!allowNewline) throw new MismatchedCharException('\n', '\n', true, this);
2199 		}
2200 		mONE_NL(false,false);
2201 		if ( inputState.guessing==0 ) {
2202 			text.setLength(_begin); text.append('\n');
2203 		}
2204 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2205 			_token = makeToken(_ttype);
2206 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2207 		}
2208 		_returnToken = _token;
2209 	}
2210 	
2211 	protected final int  mSTRING_CTOR_END(boolean _createToken,
2212 		boolean fromStart, boolean tripleQuote
2213 	) throws RecognitionException, CharStreamException, TokenStreamException {
2214 		int tt=STRING_CTOR_END;
2215 		int _ttype; Token _token=null; int _begin=text.length();
2216 		_ttype = STRING_CTOR_END;
2217 		int _saveIndex;
2218 		boolean dollarOK = false;
2219 		
2220 		{
2221 		_loop686:
2222 		do {
2223 			switch ( LA(1)) {
2224 			case '\\':
2225 			{
2226 				mESC(false);
2227 				break;
2228 			}
2229 			case '\'':
2230 			{
2231 				match('\'');
2232 				break;
2233 			}
2234 			case '\n':  case '\r':
2235 			{
2236 				mSTRING_NL(false,tripleQuote);
2237 				break;
2238 			}
2239 			default:
2240 				boolean synPredMatched685 = false;
2241 				if ((((LA(1)=='"') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&(tripleQuote))) {
2242 					int _m685 = mark();
2243 					synPredMatched685 = true;
2244 					inputState.guessing++;
2245 					try {
2246 						{
2247 						match('"');
2248 						{
2249 						if ((_tokenSet_5.member(LA(1)))) {
2250 							matchNot('"');
2251 						}
2252 						else if ((LA(1)=='"')) {
2253 							match('"');
2254 							matchNot('"');
2255 						}
2256 						else {
2257 							throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2258 						}
2259 						
2260 						}
2261 						}
2262 					}
2263 					catch (RecognitionException pe) {
2264 						synPredMatched685 = false;
2265 					}
2266 					rewind(_m685);
2267 inputState.guessing--;
2268 				}
2269 				if ( synPredMatched685 ) {
2270 					match('"');
2271 				}
2272 				else if ((_tokenSet_4.member(LA(1)))) {
2273 					mSTRING_CH(false);
2274 				}
2275 			else {
2276 				break _loop686;
2277 			}
2278 			}
2279 		} while (true);
2280 		}
2281 		{
2282 		switch ( LA(1)) {
2283 		case '"':
2284 		{
2285 			{
2286 			if (((LA(1)=='"') && (LA(2)=='"'))&&(  tripleQuote )) {
2287 				_saveIndex=text.length();
2288 				match("\"\"\"");
2289 				text.setLength(_saveIndex);
2290 			}
2291 			else if (((LA(1)=='"') && (true))&&( !tripleQuote )) {
2292 				_saveIndex=text.length();
2293 				match("\"");
2294 				text.setLength(_saveIndex);
2295 			}
2296 			else {
2297 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2298 			}
2299 			
2300 			}
2301 			if ( inputState.guessing==0 ) {
2302 				
2303 				if (fromStart)      tt = STRING_LITERAL;  // plain string literal!
2304 				if (!tripleQuote)   {--suppressNewline;}
2305 				// done with string constructor!
2306 				//assert(stringCtorState == 0);
2307 				
2308 			}
2309 			break;
2310 		}
2311 		case '$':
2312 		{
2313 			if ( inputState.guessing==0 ) {
2314 				dollarOK = atValidDollarEscape();
2315 			}
2316 			_saveIndex=text.length();
2317 			match('$');
2318 			text.setLength(_saveIndex);
2319 			if ( inputState.guessing==0 ) {
2320 				
2321 				require(dollarOK,
2322 				"illegal string body character after dollar sign",
2323 				"either escape a literal dollar sign \"\\$5\" or bracket the value expression \"${5}\"");
2324 				// Yes, it's a string constructor, and we've got a value part.
2325 				tt = (fromStart ? STRING_CTOR_START : STRING_CTOR_MIDDLE);
2326 				stringCtorState = SCS_VAL + (tripleQuote? SCS_TQ_TYPE: SCS_SQ_TYPE);
2327 				
2328 			}
2329 			break;
2330 		}
2331 		default:
2332 		{
2333 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2334 		}
2335 		}
2336 		}
2337 		if ( inputState.guessing==0 ) {
2338 			_ttype = tt;
2339 		}
2340 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2341 			_token = makeToken(_ttype);
2342 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2343 		}
2344 		_returnToken = _token;
2345 		return tt;
2346 	}
2347 	
2348 previous bug bug overview next bug   	public final void mREGEXP_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
2349 		int _ttype; Token _token=null; int _begin=text.length();
2350 		_ttype = REGEXP_LITERAL;
2351 		int _saveIndex;
2352 		int tt=0;
2353 		
2354 		if (((LA(1)=='/') && (_tokenSet_6.member(LA(2))) && (true) && (true))&&(allowRegexpLiteral())) {
2355 			_saveIndex=text.length();
2356 			match('/');
2357 			text.setLength(_saveIndex);
2358 			if ( inputState.guessing==0 ) {
2359 				++suppressNewline;
2360 			}
2361 			{
2362 			if (((LA(1)=='$') && (_tokenSet_7.member(LA(2))))&&(!atValidDollarEscape())) {
2363 				match('$');
2364 				tt=mREGEXP_CTOR_END(false,true);
2365 			}
2366 			else if ((_tokenSet_8.member(LA(1)))) {
2367 				mREGEXP_SYMBOL(false);
2368 				tt=mREGEXP_CTOR_END(false,true);
2369 			}
2370 			else if ((LA(1)=='$') && (true)) {
2371 				_saveIndex=text.length();
2372 				match('$');
2373 				text.setLength(_saveIndex);
2374 				if ( inputState.guessing==0 ) {
2375 					
2376 					// Yes, it's a regexp constructor, and we've got a value part.
2377 					tt = STRING_CTOR_START;
2378 					stringCtorState = SCS_VAL + SCS_RE_TYPE;
2379 					
2380 				}
2381 			}
2382 			else {
2383 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2384 			}
2385 			
2386 			}
2387 			if ( inputState.guessing==0 ) {
2388 				_ttype = tt;
2389 			}
2390 		}
2391 		else if ((LA(1)=='/') && (LA(2)=='=') && (true) && (true)) {
2392 			mDIV_ASSIGN(false);
2393 			if ( inputState.guessing==0 ) {
2394 				_ttype = DIV_ASSIGN;
2395 			}
2396 		}
2397 		else if ((LA(1)=='/') && (true)) {
2398 			mDIV(false);
2399 			if ( inputState.guessing==0 ) {
2400 				_ttype = DIV;
2401 			}
2402 		}
2403 		else {
2404 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2405 		}
2406 		
2407 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2408 			_token = makeToken(_ttype);
2409 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2410 		}
2411 		_returnToken = _token;
2412 	}
2413 	
2414 	protected final void mREGEXP_SYMBOL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2415 		int _ttype; Token _token=null; int _begin=text.length();
2416 		_ttype = REGEXP_SYMBOL;
2417 		int _saveIndex;
2418 		
2419 		{
2420 		if ((LA(1)=='\\') && (LA(2)=='/') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
2421 			match('\\');
2422 			match('/');
2423 			if ( inputState.guessing==0 ) {
2424 				text.setLength(_begin); text.append('/');
2425 			}
2426 		}
2427 		else if ((LA(1)=='\\') && (LA(2)=='\n'||LA(2)=='\r') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
2428 			_saveIndex=text.length();
2429 			match('\\');
2430 			text.setLength(_saveIndex);
2431 			_saveIndex=text.length();
2432 			mONE_NL(false,false);
2433 			text.setLength(_saveIndex);
2434 		}
2435 		else if (((LA(1)=='\\') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&( LA(2)!='/' && LA(2)!='\n' && LA(2)!='\r' )) {
2436 			match('\\');
2437 		}
2438 		else if ((_tokenSet_9.member(LA(1)))) {
2439 			{
2440 			match(_tokenSet_9);
2441 			}
2442 		}
2443 		else if ((LA(1)=='\n'||LA(1)=='\r')) {
2444 			mSTRING_NL(false,true);
2445 		}
2446 		else {
2447 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2448 		}
2449 		
2450 		}
2451 		{
2452 		_loop713:
2453 		do {
2454 			if ((LA(1)=='*')) {
2455 				match('*');
2456 			}
2457 			else {
2458 				break _loop713;
2459 			}
2460 			
2461 		} while (true);
2462 		}
2463 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2464 			_token = makeToken(_ttype);
2465 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2466 		}
2467 		_returnToken = _token;
2468 	}
2469 	
2470 	protected final int  mREGEXP_CTOR_END(boolean _createToken,
2471 		boolean fromStart
2472 	) throws RecognitionException, CharStreamException, TokenStreamException {
2473 		int tt=STRING_CTOR_END;
2474 		int _ttype; Token _token=null; int _begin=text.length();
2475 		_ttype = REGEXP_CTOR_END;
2476 		int _saveIndex;
2477 		
2478 		{
2479 		_loop697:
2480 		do {
2481 			if (((LA(1)=='$') && (_tokenSet_7.member(LA(2))))&&(!atValidDollarEscape())) {
2482 				match('$');
2483 			}
2484 			else if ((_tokenSet_8.member(LA(1)))) {
2485 				mREGEXP_SYMBOL(false);
2486 			}
2487 			else {
2488 				break _loop697;
2489 			}
2490 			
2491 		} while (true);
2492 		}
2493 		{
2494 		switch ( LA(1)) {
2495 		case '/':
2496 		{
2497 			_saveIndex=text.length();
2498 			match('/');
2499 			text.setLength(_saveIndex);
2500 			if ( inputState.guessing==0 ) {
2501 				
2502 				if (fromStart)      tt = STRING_LITERAL;  // plain regexp literal!
2503 				{--suppressNewline;}
2504 				// done with regexp constructor!
2505 				//assert(stringCtorState == 0);
2506 				
2507 			}
2508 			break;
2509 		}
2510 		case '$':
2511 		{
2512 			_saveIndex=text.length();
2513 			match('$');
2514 			text.setLength(_saveIndex);
2515 			if ( inputState.guessing==0 ) {
2516 				
2517 				// Yes, it's a regexp constructor, and we've got a value part.
2518 				tt = (fromStart ? STRING_CTOR_START : STRING_CTOR_MIDDLE);
2519 				stringCtorState = SCS_VAL + SCS_RE_TYPE;
2520 				
2521 			}
2522 			break;
2523 		}
2524 		default:
2525 		{
2526 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2527 		}
2528 		}
2529 		}
2530 		if ( inputState.guessing==0 ) {
2531 			_ttype = tt;
2532 		}
2533 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2534 			_token = makeToken(_ttype);
2535 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2536 		}
2537 		_returnToken = _token;
2538 		return tt;
2539 	}
2540 	
2541 	public final void mDOLLAR_REGEXP_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2542 		int _ttype; Token _token=null; int _begin=text.length();
2543 		_ttype = DOLLAR_REGEXP_LITERAL;
2544 		int _saveIndex;
2545 		int tt=0;
2546 		
2547 		if (!(allowRegexpLiteral()))
2548 		  throw new SemanticException("allowRegexpLiteral()");
2549 		_saveIndex=text.length();
2550 		match("$/");
2551 		text.setLength(_saveIndex);
2552 		{
2553 		if (((LA(1)=='$') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')))&&(!atValidDollarEscape())) {
2554 			match('$');
2555 			tt=mDOLLAR_REGEXP_CTOR_END(false,true);
2556 		}
2557 		else if ((_tokenSet_10.member(LA(1)))) {
2558 			mDOLLAR_REGEXP_SYMBOL(false);
2559 			tt=mDOLLAR_REGEXP_CTOR_END(false,true);
2560 		}
2561 		else if ((LA(1)=='$') && (true)) {
2562 			_saveIndex=text.length();
2563 			match('$');
2564 			text.setLength(_saveIndex);
2565 			if ( inputState.guessing==0 ) {
2566 				
2567 				// Yes, it's a regexp constructor, and we've got a value part.
2568 				tt = STRING_CTOR_START;
2569 				stringCtorState = SCS_VAL + SCS_DRE_TYPE;
2570 				
2571 			}
2572 		}
2573 		else {
2574 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2575 		}
2576 		
2577 		}
2578 		if ( inputState.guessing==0 ) {
2579 			_ttype = tt;
2580 		}
2581 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2582 			_token = makeToken(_ttype);
2583 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2584 		}
2585 		_returnToken = _token;
2586 	}
2587 	
2588 	protected final void mDOLLAR_REGEXP_SYMBOL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2589 		int _ttype; Token _token=null; int _begin=text.length();
2590 		_ttype = DOLLAR_REGEXP_SYMBOL;
2591 		int _saveIndex;
2592 		
2593 		{
2594 		switch ( LA(1)) {
2595 		case '/':
2596 		{
2597 			match('/');
2598 			break;
2599 		}
2600 		case '\n':  case '\r':
2601 		{
2602 			mSTRING_NL(false,true);
2603 			break;
2604 		}
2605 		default:
2606 			if ((LA(1)=='\\') && (LA(2)=='\n'||LA(2)=='\r') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true)) {
2607 				_saveIndex=text.length();
2608 				match('\\');
2609 				text.setLength(_saveIndex);
2610 				_saveIndex=text.length();
2611 				mONE_NL(false,false);
2612 				text.setLength(_saveIndex);
2613 			}
2614 			else if (((LA(1)=='\\') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&( LA(2)!='\n' && LA(2)!='\r' )) {
2615 				match('\\');
2616 			}
2617 			else if ((_tokenSet_11.member(LA(1)))) {
2618 				{
2619 				match(_tokenSet_11);
2620 				}
2621 			}
2622 		else {
2623 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2624 		}
2625 		}
2626 		}
2627 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2628 			_token = makeToken(_ttype);
2629 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2630 		}
2631 		_returnToken = _token;
2632 	}
2633 	
2634 	protected final int  mDOLLAR_REGEXP_CTOR_END(boolean _createToken,
2635 		boolean fromStart
2636 	) throws RecognitionException, CharStreamException, TokenStreamException {
2637 		int tt=STRING_CTOR_END;
2638 		int _ttype; Token _token=null; int _begin=text.length();
2639 		_ttype = DOLLAR_REGEXP_CTOR_END;
2640 		int _saveIndex;
2641 		
2642 		{
2643 		_loop705:
2644 		do {
2645 			boolean synPredMatched702 = false;
2646 			if (((LA(1)=='$') && (LA(2)=='/') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))) {
2647 				int _m702 = mark();
2648 				synPredMatched702 = true;
2649 				inputState.guessing++;
2650 				try {
2651 					{
2652 					match('$');
2653 					match('/');
2654 					}
2655 				}
2656 				catch (RecognitionException pe) {
2657 					synPredMatched702 = false;
2658 				}
2659 				rewind(_m702);
2660 inputState.guessing--;
2661 			}
2662 			if ( synPredMatched702 ) {
2663 				mESCAPED_SLASH(false);
2664 			}
2665 			else {
2666 				boolean synPredMatched704 = false;
2667 				if (((LA(1)=='$') && (LA(2)=='$') && ((LA(3) >= '\u0000' && LA(3) <= '\ufffe')) && (true))) {
2668 					int _m704 = mark();
2669 					synPredMatched704 = true;
2670 					inputState.guessing++;
2671 					try {
2672 						{
2673 						match('$');
2674 						match('$');
2675 						}
2676 					}
2677 					catch (RecognitionException pe) {
2678 						synPredMatched704 = false;
2679 					}
2680 					rewind(_m704);
2681 inputState.guessing--;
2682 				}
2683 				if ( synPredMatched704 ) {
2684 					mESCAPED_DOLLAR(false);
2685 				}
2686 				else if (((_tokenSet_10.member(LA(1))) && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&( !(LA(1) == '/' && LA(2) == '$') )) {
2687 					mDOLLAR_REGEXP_SYMBOL(false);
2688 				}
2689 				else if (((LA(1)=='$') && ((LA(2) >= '\u0000' && LA(2) <= '\ufffe')) && (true) && (true))&&(!atValidDollarEscape() && !atDollarSlashEscape() && !atDollarDollarEscape())) {
2690 					match('$');
2691 				}
2692 				else {
2693 					break _loop705;
2694 				}
2695 				}
2696 			} while (true);
2697 			}
2698 			{
2699 			switch ( LA(1)) {
2700 			case '/':
2701 			{
2702 				_saveIndex=text.length();
2703 				match("/$");
2704 				text.setLength(_saveIndex);
2705 				if ( inputState.guessing==0 ) {
2706 					
2707 					if (fromStart)      tt = STRING_LITERAL;  // plain regexp literal!
2708 					
2709 				}
2710 				break;
2711 			}
2712 			case '$':
2713 			{
2714 				_saveIndex=text.length();
2715 				match('$');
2716 				text.setLength(_saveIndex);
2717 				if ( inputState.guessing==0 ) {
2718 					
2719 					// Yes, it's a regexp constructor, and we've got a value part.
2720 					tt = (fromStart ? STRING_CTOR_START : STRING_CTOR_MIDDLE);
2721 					stringCtorState = SCS_VAL + SCS_DRE_TYPE;
2722 					
2723 				}
2724 				break;
2725 			}
2726 			default:
2727 			{
2728 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2729 			}
2730 			}
2731 			}
2732 			if ( inputState.guessing==0 ) {
2733 				_ttype = tt;
2734 			}
2735 			if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2736 				_token = makeToken(_ttype);
2737 				_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2738 			}
2739 			_returnToken = _token;
2740 			return tt;
2741 		}
2742 		
2743 	protected final void mESCAPED_SLASH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2744 		int _ttype; Token _token=null; int _begin=text.length();
2745 		_ttype = ESCAPED_SLASH;
2746 		int _saveIndex;
2747 		
2748 		match('$');
2749 		match('/');
2750 		if ( inputState.guessing==0 ) {
2751 			text.setLength(_begin); text.append('/');
2752 		}
2753 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2754 			_token = makeToken(_ttype);
2755 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2756 		}
2757 		_returnToken = _token;
2758 	}
2759 	
2760 	protected final void mESCAPED_DOLLAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2761 		int _ttype; Token _token=null; int _begin=text.length();
2762 		_ttype = ESCAPED_DOLLAR;
2763 		int _saveIndex;
2764 		
2765 		match('$');
2766 		match('$');
2767 		if ( inputState.guessing==0 ) {
2768 			text.setLength(_begin); text.append('$');
2769 		}
2770 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2771 			_token = makeToken(_ttype);
2772 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2773 		}
2774 		_returnToken = _token;
2775 	}
2776 	
2777 	protected final void mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2778 		int _ttype; Token _token=null; int _begin=text.length();
2779 		_ttype = HEX_DIGIT;
2780 		int _saveIndex;
2781 		
2782 		{
2783 		switch ( LA(1)) {
2784 		case '0':  case '1':  case '2':  case '3':
2785 		case '4':  case '5':  case '6':  case '7':
2786 		case '8':  case '9':
2787 		{
2788 			matchRange('0','9');
2789 			break;
2790 		}
2791 		case 'A':  case 'B':  case 'C':  case 'D':
2792 		case 'E':  case 'F':
2793 		{
2794 			matchRange('A','F');
2795 			break;
2796 		}
2797 		case 'a':  case 'b':  case 'c':  case 'd':
2798 		case 'e':  case 'f':
2799 		{
2800 			matchRange('a','f');
2801 			break;
2802 		}
2803 		default:
2804 		{
2805 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2806 		}
2807 		}
2808 		}
2809 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2810 			_token = makeToken(_ttype);
2811 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2812 		}
2813 		_returnToken = _token;
2814 	}
2815 	
2816 	protected final void mVOCAB(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2817 		int _ttype; Token _token=null; int _begin=text.length();
2818 		_ttype = VOCAB;
2819 		int _saveIndex;
2820 		
2821 		matchRange('\3','\377');
2822 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2823 			_token = makeToken(_ttype);
2824 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2825 		}
2826 		_returnToken = _token;
2827 	}
2828 	
2829 previous bug bug overview next bug   	public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc 
2830 		int _ttype; Token _token=null; int _begin=text.length();
2831 		_ttype = IDENT;
2832 		int _saveIndex;
2833 		
2834 		{
2835 		if (((_tokenSet_0.member(LA(1))) && (true) && (true) && (true))&&(stringCtorState == 0)) {
2836 			{
2837 			if ((LA(1)=='$')) {
2838 				mDOLLAR(false);
2839 			}
2840 			else if ((_tokenSet_12.member(LA(1)))) {
2841 				mLETTER(false);
2842 			}
2843 			else {
2844 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2845 			}
2846 			
2847 			}
2848 			{
2849 			_loop734:
2850 			do {
2851 				switch ( LA(1)) {
2852 				case '0':  case '1':  case '2':  case '3':
2853 				case '4':  case '5':  case '6':  case '7':
2854 				case '8':  case '9':
2855 				{
2856 					mDIGIT(false);
2857 					break;
2858 				}
2859 				case '$':
2860 				{
2861 					mDOLLAR(false);
2862 					break;
2863 				}
2864 				default:
2865 					if ((_tokenSet_12.member(LA(1)))) {
2866 						mLETTER(false);
2867 					}
2868 				else {
2869 					break _loop734;
2870 				}
2871 				}
2872 			} while (true);
2873 			}
2874 		}
2875 		else if ((_tokenSet_12.member(LA(1))) && (true) && (true) && (true)) {
2876 			mLETTER(false);
2877 			{
2878 			_loop736:
2879 			do {
2880 				if ((_tokenSet_12.member(LA(1)))) {
2881 					mLETTER(false);
2882 				}
2883 				else if (((LA(1) >= '0' && LA(1) <= '9'))) {
2884 					mDIGIT(false);
2885 				}
2886 				else {
2887 					break _loop736;
2888 				}
2889 				
2890 			} while (true);
2891 			}
2892 		}
2893 		else {
2894 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2895 		}
2896 		
2897 		}
2898 		if ( inputState.guessing==0 ) {
2899 			
2900 			if (stringCtorState != 0) {
2901 			if (LA(1) == '.' && LA(2) != '$' &&
2902 			Character.isJavaIdentifierStart(LA(2))) {
2903 			// pick up another name component before going literal again:
2904 			restartStringCtor(false);
2905 			} else {
2906 			// go back to the string
2907 			restartStringCtor(true);
2908 			}
2909 			}
2910 			int ttype = testLiteralsTable(IDENT);
2911 			// Java doesn't have the keywords 'as', 'in' or 'def so we make some allowances
2912 			// for them in package names for better integration with existing Java packages
2913 			if ((ttype == LITERAL_as || ttype == LITERAL_def || ttype == LITERAL_in) &&
2914 			(LA(1) == '.' || lastSigTokenType == DOT || lastSigTokenType == LITERAL_package)) {
2915 			ttype = IDENT;
2916 			}
2917 			if (ttype == LITERAL_static && LA(1) == '.') {
2918 			ttype = IDENT;
2919 			}
2920 			
2921 			/* The grammar allows a few keywords to follow dot.
2922 			* TODO: Reinstate this logic if we change or remove keywordPropertyNames.
2923 			if (ttype != IDENT && lastSigTokenType == DOT) {
2924 			// A few keywords can follow a dot:
2925 			switch (ttype) {
2926 			case LITERAL_this: case LITERAL_super: case LITERAL_class:
2927 			break;
2928 			default:
2929 			ttype = LITERAL_in;  // the poster child for bad dotted names
2930 			}
2931 			}
2932 			*/
2933 			_ttype = ttype;
2934 			
2935 			// check if "assert" keyword is enabled
2936 			if (assertEnabled && "assert".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
2937 			_ttype = LITERAL_assert; // set token type for the rule in the parser
2938 			}
2939 			// check if "enum" keyword is enabled
2940 			if (enumEnabled && "enum".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
2941 			_ttype = LITERAL_enum; // set token type for the rule in the parser
2942 			}
2943 			
2944 		}
2945 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2946 			_token = makeToken(_ttype);
2947 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2948 		}
2949 		_returnToken = _token;
2950 	}
2951 	
2952 	protected final void mLETTER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2953 		int _ttype; Token _token=null; int _begin=text.length();
2954 		_ttype = LETTER;
2955 		int _saveIndex;
2956 		
2957 		switch ( LA(1)) {
2958 		case 'a':  case 'b':  case 'c':  case 'd':
2959 		case 'e':  case 'f':  case 'g':  case 'h':
2960 		case 'i':  case 'j':  case 'k':  case 'l':
2961 		case 'm':  case 'n':  case 'o':  case 'p':
2962 		case 'q':  case 'r':  case 's':  case 't':
2963 		case 'u':  case 'v':  case 'w':  case 'x':
2964 		case 'y':  case 'z':
2965 		{
2966 			matchRange('a','z');
2967 			break;
2968 		}
2969 		case 'A':  case 'B':  case 'C':  case 'D':
2970 		case 'E':  case 'F':  case 'G':  case 'H':
2971 		case 'I':  case 'J':  case 'K':  case 'L':
2972 		case 'M':  case 'N':  case 'O':  case 'P':
2973 		case 'Q':  case 'R':  case 'S':  case 'T':
2974 		case 'U':  case 'V':  case 'W':  case 'X':
2975 		case 'Y':  case 'Z':
2976 		{
2977 			matchRange('A','Z');
2978 			break;
2979 		}
2980 		case '\u00c0':  case '\u00c1':  case '\u00c2':  case '\u00c3':
2981 		case '\u00c4':  case '\u00c5':  case '\u00c6':  case '\u00c7':
2982 		case '\u00c8':  case '\u00c9':  case '\u00ca':  case '\u00cb':
2983 		case '\u00cc':  case '\u00cd':  case '\u00ce':  case '\u00cf':
2984 		case '\u00d0':  case '\u00d1':  case '\u00d2':  case '\u00d3':
2985 		case '\u00d4':  case '\u00d5':  case '\u00d6':
2986 		{
2987 			matchRange('\u00C0','\u00D6');
2988 			break;
2989 		}
2990 		case '\u00d8':  case '\u00d9':  case '\u00da':  case '\u00db':
2991 		case '\u00dc':  case '\u00dd':  case '\u00de':  case '\u00df':
2992 		case '\u00e0':  case '\u00e1':  case '\u00e2':  case '\u00e3':
2993 		case '\u00e4':  case '\u00e5':  case '\u00e6':  case '\u00e7':
2994 		case '\u00e8':  case '\u00e9':  case '\u00ea':  case '\u00eb':
2995 		case '\u00ec':  case '\u00ed':  case '\u00ee':  case '\u00ef':
2996 		case '\u00f0':  case '\u00f1':  case '\u00f2':  case '\u00f3':
2997 		case '\u00f4':  case '\u00f5':  case '\u00f6':
2998 		{
2999 			matchRange('\u00D8','\u00F6');
3000 			break;
3001 		}
3002 		case '\u00f8':  case '\u00f9':  case '\u00fa':  case '\u00fb':
3003 		case '\u00fc':  case '\u00fd':  case '\u00fe':  case '\u00ff':
3004 		{
3005 			matchRange('\u00F8','\u00FF');
3006 			break;
3007 		}
3008 		case '_':
3009 		{
3010 			match('_');
3011 			break;
3012 		}
3013 		default:
3014 			if (((LA(1) >= '\u0100' && LA(1) <= '\ufffe'))) {
3015 				matchRange('\u0100','\uFFFE');
3016 			}
3017 		else {
3018 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3019 		}
3020 		}
3021 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3022 			_token = makeToken(_ttype);
3023 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3024 		}
3025 		_returnToken = _token;
3026 	}
3027 	
3028 	protected final void mDIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3029 		int _ttype; Token _token=null; int _begin=text.length();
3030 		_ttype = DIGIT;
3031 		int _saveIndex;
3032 		
3033 		matchRange('0','9');
3034 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3035 			_token = makeToken(_ttype);
3036 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3037 		}
3038 		_returnToken = _token;
3039 	}
3040 	
3041 	protected final void mDIGITS_WITH_UNDERSCORE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3042 		int _ttype; Token _token=null; int _begin=text.length();
3043 		_ttype = DIGITS_WITH_UNDERSCORE;
3044 		int _saveIndex;
3045 		
3046 		mDIGIT(false);
3047 		{
3048 		if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9'||LA(1)=='_')) {
3049 			mDIGITS_WITH_UNDERSCORE_OPT(false);
3050 		}
3051 previous bug bug overview next bug   		else {  HEALTH4J >>  :  EmptyIfStmt 
3052 		}
3053 		
3054 		}
3055 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3056 			_token = makeToken(_ttype);
3057 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3058 		}
3059 		_returnToken = _token;
3060 	}
3061 	
3062 	protected final void mDIGITS_WITH_UNDERSCORE_OPT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3063 		int _ttype; Token _token=null; int _begin=text.length();
3064 		_ttype = DIGITS_WITH_UNDERSCORE_OPT;
3065 		int _saveIndex;
3066 		
3067 		{
3068 		_loop743:
3069 		do {
3070 			if (((LA(1) >= '0' && LA(1) <= '9')) && (LA(2)=='0'||LA(2)=='1'||LA(2)=='2'||LA(2)=='3'||LA(2)=='4'||LA(2)=='5'||LA(2)=='6'||LA(2)=='7'||LA(2)=='8'||LA(2)=='9'||LA(2)=='_')) {
3071 				mDIGIT(false);
3072 			}
3073 			else if ((LA(1)=='_')) {
3074 				match('_');
3075 			}
3076 			else {
3077 				break _loop743;
3078 			}
3079 			
3080 		} while (true);
3081 		}
3082 		mDIGIT(false);
3083 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3084 			_token = makeToken(_ttype);
3085 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3086 		}
3087 		_returnToken = _token;
3088 	}
3089 	
3090 previous bug bug overview next bug   	public final void mNUM_INT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {  HEALTH4J >>  :  health.MissingJavaDoc  ExcessiveMethodLength 
3091 		int _ttype; Token _token=null; int _begin=text.length();
3092 		_ttype = NUM_INT;
3093 		int _saveIndex;
3094 		Token e=null;
3095 		Token f2=null;
3096 		Token g2=null;
3097 		Token f3=null;
3098 		Token g3=null;
3099 		Token f4=null;
3100 		boolean isDecimal=false; Token t=null;
3101 		
3102 		{
3103 		switch ( LA(1)) {
3104 		case '0':
3105 		{
3106 			match('0');
3107 			if ( inputState.guessing==0 ) {
3108 				isDecimal = true;
3109 			}
3110 			{
3111 			switch ( LA(1)) {
3112 			case 'X':  case 'x':
3113 			{
3114 				{
3115 				switch ( LA(1)) {
3116 				case 'x':
3117 				{
3118 					match('x');
3119 					break;
3120 				}
3121 				case 'X':
3122 				{
3123 					match('X');
3124 					break;
3125 				}
3126 				default:
3127 				{
3128 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3129 				}
3130 				}
3131 				}
3132 				if ( inputState.guessing==0 ) {
3133 					isDecimal = false;
3134 				}
3135 				mHEX_DIGIT(false);
3136 				{
3137 				if ((_tokenSet_13.member(LA(1))) && (true) && (true) && (true)) {
3138 					{
3139 					_loop750:
3140 					do {
3141 						if ((_tokenSet_14.member(LA(1))) && (_tokenSet_13.member(LA(2))) && (true) && (true)) {
3142 							mHEX_DIGIT(false);
3143 						}
3144 						else if ((LA(1)=='_')) {
3145 							match('_');
3146 						}
3147 						else {
3148 							break _loop750;
3149 						}
3150 						
3151 					} while (true);
3152 					}
3153 					mHEX_DIGIT(false);
3154 				}
3155 previous bug bug overview next bug   				else {  HEALTH4J >>  :  EmptyIfStmt 
3156 				}
3157 				
3158 				}
3159 				break;
3160 			}
3161 			case 'B':  case 'b':
3162 			{
3163 				{
3164 				switch ( LA(1)) {
3165 				case 'b':
3166 				{
3167 					match('b');
3168 					break;
3169 				}
3170 				case 'B':
3171 				{
3172 					match('B');
3173 					break;
3174 				}
3175 				default:
3176 				{
3177 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3178 				}
3179 				}
3180 				}
3181 				{
3182 				switch ( LA(1)) {
3183 				case '0':
3184 				{
3185 					match('0');
3186 					break;
3187 				}
3188 				case '1':
3189 				{
3190 					match('1');
3191 					break;
3192 				}
3193 				default:
3194 				{
3195 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3196 				}
3197 				}
3198 				}
3199 				{
3200 				if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='_')) {
3201 					{
3202 					_loop755:
3203 					do {
3204 						if ((LA(1)=='0') && (LA(2)=='0'||LA(2)=='1'||LA(2)=='_')) {
3205 							match('0');
3206 						}
3207 						else if ((LA(1)=='1') && (LA(2)=='0'||LA(2)=='1'||LA(2)=='_')) {
3208 							match('1');
3209 						}
3210 						else if ((LA(1)=='_')) {
3211 							match('_');
3212 						}
3213 						else {
3214 							break _loop755;
3215 						}
3216 						
3217 					} while (true);
3218 					}
3219 					{
3220 					switch ( LA(1)) {
3221 					case '0':
3222 					{
3223 						match('0');
3224 						break;
3225 					}
3226 					case '1':
3227 					{
3228 						match('1');
3229 						break;
3230 					}
3231 					default:
3232 					{
3233 						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3234 					}
3235 					}
3236 					}
3237 				}
3238 previous bug bug overview next bug   				else {  HEALTH4J >>  :  EmptyIfStmt 
3239 				}
3240 				
3241 				}
3242 				if ( inputState.guessing==0 ) {
3243 					isDecimal = false;
3244 				}
3245 				break;
3246 			}
3247 			default:
3248 				boolean synPredMatched759 = false;
3249 				if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
3250 					int _m759 = mark();
3251 					synPredMatched759 = true;
3252 					inputState.guessing++;
3253 					try {
3254 						{
3255 						mDIGITS_WITH_UNDERSCORE(false);
3256 						{
3257 						switch ( LA(1)) {
3258 						case '.':
3259 						{
3260 							match('.');
3261 							mDIGITS_WITH_UNDERSCORE(false);
3262 							break;
3263 						}
3264 						case 'E':  case 'e':
3265 						{
3266 							mEXPONENT(false);
3267 							break;
3268 						}
3269 						case 'D':  case 'F':  case 'd':  case 'f':
3270 						{
3271 							mFLOAT_SUFFIX(false);
3272 							break;
3273 						}
3274 						default:
3275 						{
3276 							throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3277 						}
3278 						}
3279 						}
3280 						}
3281 					}
3282 					catch (RecognitionException pe) {
3283 						synPredMatched759 = false;
3284 					}
3285 					rewind(_m759);
3286 inputState.guessing--;
3287 				}
3288 				if ( synPredMatched759 ) {
3289 					mDIGITS_WITH_UNDERSCORE(false);
3290 				}
3291 				else if (((LA(1) >= '0' && LA(1) <= '7')) && (true) && (true) && (true)) {
3292 					{
3293 					matchRange('0','7');
3294 					}
3295 					{
3296 					if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='_')) {
3297 						{
3298 						_loop763:
3299 						do {
3300 							if (((LA(1) >= '0' && LA(1) <= '7')) && (LA(2)=='0'||LA(2)=='1'||LA(2)=='2'||LA(2)=='3'||LA(2)=='4'||LA(2)=='5'||LA(2)=='6'||LA(2)=='7'||LA(2)=='_')) {
3301 								matchRange('0','7');
3302 							}
3303 							else if ((LA(1)=='_')) {
3304 								match('_');
3305 							}
3306 							else {
3307 								break _loop763;
3308 							}
3309 							
3310 						} while (true);
3311 						}
3312 						{
3313 						matchRange('0','7');
3314 						}
3315 					}
3316 previous bug bug overview next bug   					else {  HEALTH4J >>  :  EmptyIfStmt 
3317 					}
3318 					
3319 					}
3320 					if ( inputState.guessing==0 ) {
3321 						isDecimal = false;
3322 					}
3323 				}
3324 previous bug bug overview next bug   				else {  HEALTH4J >>  :  EmptyIfStmt 
3325 				}
3326 			}
3327 			}
3328 			break;
3329 		}
3330 		case '1':  case '2':  case '3':  case '4':
3331 		case '5':  case '6':  case '7':  case '8':
3332 		case '9':
3333 		{
3334 			{
3335 			matchRange('1','9');
3336 			}
3337 			{
3338 			if ((LA(1)=='0'||LA(1)=='1'||LA(1)=='2'||LA(1)=='3'||LA(1)=='4'||LA(1)=='5'||LA(1)=='6'||LA(1)=='7'||LA(1)=='8'||LA(1)=='9'||LA(1)=='_')) {
3339 				mDIGITS_WITH_UNDERSCORE_OPT(false);
3340 			}
3341 previous bug bug overview next bug   			else {  HEALTH4J >>  :  EmptyIfStmt 
3342 			}
3343 			
3344 			}
3345 			if ( inputState.guessing==0 ) {
3346 				isDecimal=true;
3347 			}
3348 			break;
3349 		}
3350 		default:
3351 		{
3352 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3353 		}
3354 		}
3355 		}
3356 		{
3357 		switch ( LA(1)) {
3358 		case 'L':  case 'l':
3359 		{
3360 			{
3361 			switch ( LA(1)) {
3362 			case 'l':
3363 			{
3364 				match('l');
3365 				break;
3366 			}
3367 			case 'L':
3368 			{
3369 				match('L');
3370 				break;
3371 			}
3372 			default:
3373 			{
3374 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3375 			}
3376 			}
3377 			}
3378 			if ( inputState.guessing==0 ) {
3379 				_ttype = NUM_LONG;
3380 			}
3381 			break;
3382 		}
3383 		case 'I':  case 'i':
3384 		{
3385 			{
3386 			switch ( LA(1)) {
3387 			case 'i':
3388 			{
3389 				match('i');
3390 				break;
3391 			}
3392 			case 'I':
3393 			{
3394 				match('I');
3395 				break;
3396 			}
3397 			default:
3398 			{
3399 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3400 			}
3401 			}
3402 			}
3403 			if ( inputState.guessing==0 ) {
3404 				_ttype = NUM_INT;
3405 			}
3406 			break;
3407 		}
3408 		case 'G':  case 'g':
3409 		{
3410 			mBIG_SUFFIX(false);
3411 			if ( inputState.guessing==0 ) {
3412 				_ttype = NUM_BIG_INT;
3413 			}
3414 			break;
3415 		}
3416 		default:
3417 			boolean synPredMatched772 = false;
3418 			if ((((LA(1)=='.'||LA(1)=='D'||LA(1)=='E'||LA(1)=='F'||LA(1)=='d'||LA(1)=='e'||LA(1)=='f'))&&(isDecimal))) {
3419 				int _m772 = mark();
3420 				synPredMatched772 = true;
3421 				inputState.guessing++;
3422 				try {
3423 					{
3424 					if ((_tokenSet_15.member(LA(1)))) {
3425 						matchNot('.');
3426 					}
3427 					else if ((LA(1)=='.')) {
3428 						match('.');
3429 						{
3430 						matchRange('0','9');
3431 						}
3432 					}
3433 					else {
3434 						throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3435 					}
3436 					
3437 					}
3438 				}
3439 				catch (RecognitionException pe) {
3440 					synPredMatched772 = false;
3441 				}
3442 				rewind(_m772);
3443 inputState.guessing--;
3444 			}
3445 			if ( synPredMatched772 ) {
3446 				{
3447 				switch ( LA(1)) {
3448 				case '.':
3449 				{
3450 					match('.');
3451 					mDIGITS_WITH_UNDERSCORE(false);
3452 					{
3453 					if ((LA(1)=='E'||LA(1)=='e')) {
3454 						mEXPONENT(true);
3455 						e=_returnToken;
3456 					}
3457 previous bug bug overview next bug   					else {  HEALTH4J >>  :  EmptyIfStmt 
3458 					}
3459 					
3460 					}
3461 					{
3462 					switch ( LA(1)) {
3463 					case 'D':  case 'F':  case 'd':  case 'f':
3464 					{
3465 						mFLOAT_SUFFIX(true);
3466 						f2=_returnToken;
3467 						if ( inputState.guessing==0 ) {
3468 							t=f2;
3469 						}
3470 						break;
3471 					}
3472 					case 'G':  case 'g':
3473 					{
3474 						mBIG_SUFFIX(true);
3475 						g2=_returnToken;
3476 						if ( inputState.guessing==0 ) {
3477 							t=g2;
3478 						}
3479 						break;
3480 					}
3481 					default:
3482 						{
3483 						}
3484 					}
3485 					}
3486 					break;
3487 				}
3488 				case 'E':  case 'e':
3489 				{
3490 					mEXPONENT(false);
3491 					{
3492 					switch ( LA(1)) {
3493 					case 'D':  case 'F':  case 'd':  case 'f':
3494 					{
3495 						mFLOAT_SUFFIX(true);
3496 						f3=_returnToken;
3497 						if ( inputState.guessing==0 ) {
3498 							t=f3;
3499 						}
3500 						break;
3501 					}
3502 					case 'G':  case 'g':
3503 					{
3504 						mBIG_SUFFIX(true);
3505 						g3=_returnToken;
3506 						if ( inputState.guessing==0 ) {
3507 							t=g3;
3508 						}
3509 						break;
3510 					}
3511 					default:
3512 						{
3513 						}
3514 					}
3515 					}
3516 					break;
3517 				}
3518 				case 'D':  case 'F':  case 'd':  case 'f':
3519 				{
3520 					mFLOAT_SUFFIX(true);
3521 					f4=_returnToken;
3522 					if ( inputState.guessing==0 ) {
3523 						t=f4;
3524 					}
3525 					break;
3526 				}
3527 				default:
3528 				{
3529 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3530 				}
3531 				}
3532 				}
3533 				if ( inputState.guessing==0 ) {
3534 					
3535 					String txt = (t == null ? "" : t.getText().toUpperCase());
3536 					if (txt.indexOf('F') >= 0) {
3537 					_ttype = NUM_FLOAT;
3538 					} else if (txt.indexOf('G') >= 0) {
3539 					_ttype = NUM_BIG_DECIMAL;
3540 					} else {
3541 					_ttype = NUM_DOUBLE; // assume double
3542 					}
3543 					
3544 				}
3545 			}
3546 previous bug bug overview   			else {  HEALTH4J >>  :  EmptyIfStmt 
3547 			}
3548 		}
3549 		}
3550 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3551 			_token = makeToken(_ttype);
3552 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3553 		}
3554 		_returnToken = _token;
3555 	}
3556 	
3557 	protected final void mEXPONENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3558 		int _ttype; Token _token=null; int _begin=text.length();
3559 		_ttype = EXPONENT;
3560 		int _saveIndex;
3561 		
3562 		{
3563 		switch ( LA(1)) {
3564 		case 'e':
3565 		{
3566 			match('e');
3567 			break;
3568 		}
3569 		case 'E':
3570 		{
3571 			match('E');
3572 			break;
3573 		}
3574 		default:
3575 		{
3576 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3577 		}
3578 		}
3579 		}
3580 		{
3581 		switch ( LA(1)) {
3582 		case '+':
3583 		{
3584 			match('+');
3585 			break;
3586 		}
3587 		case '-':
3588 		{
3589 			match('-');
3590 			break;
3591 		}
3592 		case '0':  case '1':  case '2':  case '3':
3593 		case '4':  case '5':  case '6':  case '7':
3594 		case '8':  case '9':  case '_':
3595 		{
3596 			break;
3597 		}
3598 		default:
3599 		{
3600 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3601 		}
3602 		}
3603 		}
3604 		{
3605 		_loop782:
3606 		do {
3607 			if (((LA(1) >= '0' && LA(1) <= '9')) && (LA(2)=='0'||LA(2)=='1'||LA(2)=='2'||LA(2)=='3'||LA(2)=='4'||LA(2)=='5'||LA(2)=='6'||LA(2)=='7'||LA(2)=='8'||LA(2)=='9'||LA(2)=='_')) {
3608 				matchRange('0','9');
3609 			}
3610 			else if ((LA(1)=='_')) {
3611 				match('_');
3612 			}
3613 			else {
3614 				break _loop782;
3615 			}
3616 			
3617 		} while (true);
3618 		}
3619 		{
3620 		matchRange('0','9');
3621 		}
3622 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3623 			_token = makeToken(_ttype);
3624 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3625 		}
3626 		_returnToken = _token;
3627 	}
3628 	
3629 	protected final void mFLOAT_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3630 		int _ttype; Token _token=null; int _begin=text.length();
3631 		_ttype = FLOAT_SUFFIX;
3632 		int _saveIndex;
3633 		
3634 		switch ( LA(1)) {
3635 		case 'f':
3636 		{
3637 			match('f');
3638 			break;
3639 		}
3640 		case 'F':
3641 		{
3642 			match('F');
3643 			break;
3644 		}
3645 		case 'd':
3646 		{
3647 			match('d');
3648 			break;
3649 		}
3650 		case 'D':
3651 		{
3652 			match('D');
3653 			break;
3654 		}
3655 		default:
3656 		{
3657 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3658 		}
3659 		}
3660 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3661 			_token = makeToken(_ttype);
3662 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3663 		}
3664 		_returnToken = _token;
3665 	}
3666 	
3667 	protected final void mBIG_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3668 		int _ttype; Token _token=null; int _begin=text.length();
3669 		_ttype = BIG_SUFFIX;
3670 		int _saveIndex;
3671 		
3672 		switch ( LA(1)) {
3673 		case 'g':
3674 		{
3675 			match('g');
3676 			break;
3677 		}
3678 		case 'G':
3679 		{
3680 			match('G');
3681 			break;
3682 		}
3683 		default:
3684 		{
3685 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
3686 		}
3687 		}
3688 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3689 			_token = makeToken(_ttype);
3690 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3691 		}
3692 		_returnToken = _token;
3693 	}
3694 	
3695 	public final void mAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
3696 		int _ttype; Token _token=null; int _begin=text.length();
3697 		_ttype = AT;
3698 		int _saveIndex;
3699 		
3700 		match('@');
3701 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
3702 			_token = makeToken(_ttype);
3703 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
3704 		}
3705 		_returnToken = _token;
3706 	}
3707 	
3708 	
3709 	private static final long[] mk_tokenSet_0() {
3710 		long[] data = new long[2560];
3711 		data[0]=68719476736L;
3712 		data[1]=576460745995190270L;
3713 		data[3]=-36028797027352577L;
3714 		for (int i = 4; i<=1022; i++) { data[i]=-1L; }
3715 		data[1023]=9223372036854775807L;
3716 		return data;
3717 	}
3718 	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
3719 	private static final long[] mk_tokenSet_1() {
3720 		long[] data = new long[2048];
3721 		data[0]=-9217L;
3722 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
3723 		data[1023]=9223372036854775807L;
3724 		return data;
3725 	}
3726 	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
3727 	private static final long[] mk_tokenSet_2() {
3728 		long[] data = new long[2048];
3729 		data[0]=-4398046520321L;
3730 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
3731 		data[1023]=9223372036854775807L;
3732 		return data;
3733 	}
3734 	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
3735 	private static final long[] mk_tokenSet_3() {
3736 		long[] data = new long[2048];
3737 		data[0]=-549755813889L;
3738 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
3739 		return data;
3740 	}
3741 	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
3742 	private static final long[] mk_tokenSet_4() {
3743 		long[] data = new long[2048];
3744 		data[0]=-635655169025L;
3745 		data[1]=-268435457L;
3746 		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
3747 		data[1023]=9223372036854775807L;
3748 		return data;
3749 	}
3750 	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
3751 	private static final long[] mk_tokenSet_5() {
3752 		long[] data = new long[2048];
3753 		data[0]=-17179869185L;
3754 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
3755 		return data;
3756 	}
3757 	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
3758 	private static final long[] mk_tokenSet_6() {
3759 		long[] data = new long[2048];
3760 		data[0]=-145135534866433L;
3761 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
3762 		data[1023]=9223372036854775807L;
3763 		return data;
3764 	}
3765 	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
3766 	private static final long[] mk_tokenSet_7() {
3767 		long[] data = new long[2048];
3768 		data[0]=-4398046511105L;
3769 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
3770 		data[1023]=9223372036854775807L;
3771 		return data;
3772 	}
3773 	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
3774 	private static final long[] mk_tokenSet_8() {
3775 		long[] data = new long[2048];
3776 		data[0]=-145204254343169L;
3777 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
3778 		data[1023]=9223372036854775807L;
3779 		return data;
3780 	}
3781 	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
3782 	private static final long[] mk_tokenSet_9() {
3783 		long[] data = new long[2048];
3784 		data[0]=-145204254352385L;
3785 		data[1]=-268435457L;
3786 		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
3787 		data[1023]=9223372036854775807L;
3788 		return data;
3789 	}
3790 	public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
3791 	private static final long[] mk_tokenSet_10() {
3792 		long[] data = new long[2048];
3793 		data[0]=-68719476737L;
3794 		for (int i = 1; i<=1022; i++) { data[i]=-1L; }
3795 		data[1023]=9223372036854775807L;
3796 		return data;
3797 	}
3798 	public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
3799 	private static final long[] mk_tokenSet_11() {
3800 		long[] data = new long[2048];
3801 		data[0]=-140806207841281L;
3802 		data[1]=-268435457L;
3803 		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
3804 		data[1023]=9223372036854775807L;
3805 		return data;
3806 	}
3807 	public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
3808 	private static final long[] mk_tokenSet_12() {
3809 		long[] data = new long[2560];
3810 		data[1]=576460745995190270L;
3811 		data[3]=-36028797027352577L;
3812 		for (int i = 4; i<=1022; i++) { data[i]=-1L; }
3813 		data[1023]=9223372036854775807L;
3814 		return data;
3815 	}
3816 	public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
3817 	private static final long[] mk_tokenSet_13() {
3818 		long[] data = new long[1025];
3819 		data[0]=287948901175001088L;
3820 		data[1]=543313363070L;
3821 		return data;
3822 	}
3823 	public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
3824 	private static final long[] mk_tokenSet_14() {
3825 		long[] data = new long[1025];
3826 		data[0]=287948901175001088L;
3827 		data[1]=541165879422L;
3828 		return data;
3829 	}
3830 	public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
3831 	private static final long[] mk_tokenSet_15() {
3832 		long[] data = new long[2048];
3833 		data[0]=-70368744177665L;
3834 		for (int i = 1; i<=1023; i++) { data[i]=-1L; }
3835 		return data;
3836 	}
3837 	public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
3838 	
3839 	}