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