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