1
2
3 package org.codehaus.groovy.antlr.java;
4 import org.codehaus.groovy.antlr.*;
5 import org.codehaus.groovy.antlr.parser.*;
6 import java.util.*;
7 import java.io.InputStream;
8 import java.io.Reader;
9 import antlr.InputBuffer;
10 import antlr.LexerSharedInputState;
11
12 import java.io.InputStream;
13 import antlr.TokenStreamException;
14 import antlr.TokenStreamIOException;
15 import antlr.TokenStreamRecognitionException;
16 import antlr.CharStreamException;
17 import antlr.CharStreamIOException;
18 import antlr.ANTLRException;
19 import java.io.Reader;
20 import java.util.Hashtable;
21 import antlr.CharScanner;
22 import antlr.InputBuffer;
23 import antlr.ByteBuffer;
24 import antlr.CharBuffer;
25 import antlr.Token;
26 import antlr.CommonToken;
27 import antlr.RecognitionException;
28 import antlr.NoViableAltForCharException;
29 import antlr.MismatchedCharException;
30 import antlr.TokenStream;
31 import antlr.ANTLRHashString;
32 import antlr.LexerSharedInputState;
33 import antlr.collections.impl.BitSet;
34 import antlr.SemanticException;
35
36 public class JavaLexer extends antlr.CharScanner implements JavaTokenTypes, TokenStream
37 {
38
39 protected static final int SCS_TYPE = 3, SCS_VAL = 4, SCS_LIT = 8, SCS_LIMIT = 16;
40 protected static final int SCS_SQ_TYPE = 0, SCS_TQ_TYPE = 1, SCS_RE_TYPE = 2;
41 protected int stringCtorState = 0;
42 protected int lastSigTokenType = EOF;
43
44 /*** flag for enabling the "assert" keyword */
45 private boolean assertEnabled = true;
46 /*** flag for enabling the "enum" keyword */
47 private boolean enumEnabled = true;
48 /*** flag for including whitespace tokens (for IDE preparsing) */
49 private boolean whitespaceIncluded = false;
50
51 /*** Enable the "assert" keyword */
52 public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }
53 /*** Query the "assert" keyword state */
54 public boolean isAssertEnabled() { return assertEnabled; }
55 /*** Enable the "enum" keyword */
56 public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }
57 /*** Query the "enum" keyword state */
58 public boolean isEnumEnabled() { return enumEnabled; }
59
60 /*** This is a bit of plumbing which resumes collection of string constructor bodies,
61 * after an embedded expression has been parsed.
62 * Usage: new JavaRecognizer(new JavaLexer(in).plumb()).
63 */
64 public TokenStream plumb() {
65 return new TokenStream() {
66 public Token nextToken() throws TokenStreamException {
67 if (stringCtorState >= SCS_LIT) {
68
69 int quoteType = (stringCtorState & SCS_TYPE);
70 stringCtorState = 0;
71 resetText();
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87 /* catch (RecognitionException e) {
88 throw new TokenStreamRecognitionException(e);
89 }*/
90
91
92
93
94
95
96
97 }
98 Token token = JavaLexer.this.nextToken();
99 int lasttype = token.getType();
100 if (whitespaceIncluded) {
101 switch (lasttype) {
102 case WS:
103 case SL_COMMENT:
104 case ML_COMMENT:
105 lasttype = lastSigTokenType;
106 }
107 }
108 lastSigTokenType = lasttype;
109 return token;
110 }
111 };
112 }
113
114 protected JavaRecognizer parser;
115 public JavaLexer(InputStream in) {
116 this(new ByteBuffer(in));
117 }
118 public JavaLexer(Reader in) {
119 this(new CharBuffer(in));
120 }
121 public JavaLexer(InputBuffer ib) {
122 this(new LexerSharedInputState(ib));
123 }
124 public JavaLexer(LexerSharedInputState state) {
125 super(state);
126 caseSensitiveLiterals = true;
127 setCaseSensitive(true);
128 literals = new Hashtable();
129 literals.put(new ANTLRHashString("byte", this), new Integer(79));
130 literals.put(new ANTLRHashString("public", this), new Integer(88));
131 literals.put(new ANTLRHashString("case", this), new Integer(121));
132 literals.put(new ANTLRHashString("short", this), new Integer(81));
133 literals.put(new ANTLRHashString("break", this), new Integer(114));
134 literals.put(new ANTLRHashString("while", this), new Integer(113));
135 literals.put(new ANTLRHashString("new", this), new Integer(157));
136 literals.put(new ANTLRHashString("instanceof", this), new Integer(144));
137 literals.put(new ANTLRHashString("implements", this), new Integer(106));
138 literals.put(new ANTLRHashString("synchronized", this), new Integer(93));
139 literals.put(new ANTLRHashString("float", this), new Integer(83));
140 literals.put(new ANTLRHashString("package", this), new Integer(61));
141 literals.put(new ANTLRHashString("return", this), new Integer(116));
142 literals.put(new ANTLRHashString("throw", this), new Integer(118));
143 literals.put(new ANTLRHashString("null", this), new Integer(156));
144 literals.put(new ANTLRHashString("threadsafe", this), new Integer(92));
145 literals.put(new ANTLRHashString("protected", this), new Integer(89));
146 literals.put(new ANTLRHashString("class", this), new Integer(101));
147 literals.put(new ANTLRHashString("throws", this), new Integer(108));
148 literals.put(new ANTLRHashString("strictfp", this), new Integer(40));
149 literals.put(new ANTLRHashString("super", this), new Integer(71));
150 literals.put(new ANTLRHashString("transient", this), new Integer(90));
151 literals.put(new ANTLRHashString("native", this), new Integer(91));
152 literals.put(new ANTLRHashString("interface", this), new Integer(102));
153 literals.put(new ANTLRHashString("final", this), new Integer(38));
154 literals.put(new ANTLRHashString("if", this), new Integer(111));
155 literals.put(new ANTLRHashString("double", this), new Integer(85));
156 literals.put(new ANTLRHashString("volatile", this), new Integer(94));
157 literals.put(new ANTLRHashString("assert", this), new Integer(119));
158 literals.put(new ANTLRHashString("catch", this), new Integer(124));
159 literals.put(new ANTLRHashString("try", this), new Integer(122));
160 literals.put(new ANTLRHashString("enum", this), new Integer(103));
161 literals.put(new ANTLRHashString("int", this), new Integer(82));
162 literals.put(new ANTLRHashString("for", this), new Integer(120));
163 literals.put(new ANTLRHashString("extends", this), new Integer(70));
164 literals.put(new ANTLRHashString("boolean", this), new Integer(78));
165 literals.put(new ANTLRHashString("char", this), new Integer(80));
166 literals.put(new ANTLRHashString("private", this), new Integer(87));
167 literals.put(new ANTLRHashString("default", this), new Integer(105));
168 literals.put(new ANTLRHashString("false", this), new Integer(155));
169 literals.put(new ANTLRHashString("this", this), new Integer(107));
170 literals.put(new ANTLRHashString("static", this), new Integer(64));
171 literals.put(new ANTLRHashString("abstract", this), new Integer(39));
172 literals.put(new ANTLRHashString("continue", this), new Integer(115));
173 literals.put(new ANTLRHashString("finally", this), new Integer(123));
174 literals.put(new ANTLRHashString("else", this), new Integer(112));
175 literals.put(new ANTLRHashString("import", this), new Integer(63));
176 literals.put(new ANTLRHashString("void", this), new Integer(77));
177 literals.put(new ANTLRHashString("switch", this), new Integer(117));
178 literals.put(new ANTLRHashString("true", this), new Integer(154));
179 literals.put(new ANTLRHashString("long", this), new Integer(84));
180 }
181
182 public Token nextToken() throws TokenStreamException {
183 Token theRetToken=null;
184 tryAgain:
185 for (;;) {
186 Token _token = null;
187 int _ttype = Token.INVALID_TYPE;
188 resetText();
189 try {
190 try {
191 switch ( LA(1)) {
192 case '?':
193 {
194 mQUESTION(true);
195 theRetToken=_returnToken;
196 break;
197 }
198 case '(':
199 {
200 mLPAREN(true);
201 theRetToken=_returnToken;
202 break;
203 }
204 case ')':
205 {
206 mRPAREN(true);
207 theRetToken=_returnToken;
208 break;
209 }
210 case '[':
211 {
212 mLBRACK(true);
213 theRetToken=_returnToken;
214 break;
215 }
216 case ']':
217 {
218 mRBRACK(true);
219 theRetToken=_returnToken;
220 break;
221 }
222 case '{':
223 {
224 mLCURLY(true);
225 theRetToken=_returnToken;
226 break;
227 }
228 case '}':
229 {
230 mRCURLY(true);
231 theRetToken=_returnToken;
232 break;
233 }
234 case ':':
235 {
236 mCOLON(true);
237 theRetToken=_returnToken;
238 break;
239 }
240 case ',':
241 {
242 mCOMMA(true);
243 theRetToken=_returnToken;
244 break;
245 }
246 case '~':
247 {
248 mBNOT(true);
249 theRetToken=_returnToken;
250 break;
251 }
252 case ';':
253 {
254 mSEMI(true);
255 theRetToken=_returnToken;
256 break;
257 }
258 case '\t': case '\n': case '\u000c': case '\r':
259 case ' ':
260 {
261 mWS(true);
262 theRetToken=_returnToken;
263 break;
264 }
265 case '"': case '\'':
266 {
267 mSTRING_LITERAL(true);
268 theRetToken=_returnToken;
269 break;
270 }
271 case '$': case 'A': case 'B': case 'C':
272 case 'D': case 'E': case 'F': case 'G':
273 case 'H': case 'I': case 'J': case 'K':
274 case 'L': case 'M': case 'N': case 'O':
275 case 'P': case 'Q': case 'R': case 'S':
276 case 'T': case 'U': case 'V': case 'W':
277 case 'X': case 'Y': case 'Z': case '_':
278 case 'a': case 'b': case 'c': case 'd':
279 case 'e': case 'f': case 'g': case 'h':
280 case 'i': case 'j': case 'k': case 'l':
281 case 'm': case 'n': case 'o': case 'p':
282 case 'q': case 'r': case 's': case 't':
283 case 'u': case 'v': case 'w': case 'x':
284 case 'y': case 'z':
285 {
286 mIDENT(true);
287 theRetToken=_returnToken;
288 break;
289 }
290 case '.': case '0': case '1': case '2':
291 case '3': case '4': case '5': case '6':
292 case '7': case '8': case '9':
293 {
294 mNUM_INT(true);
295 theRetToken=_returnToken;
296 break;
297 }
298 case '@':
299 {
300 mAT(true);
301 theRetToken=_returnToken;
302 break;
303 }
304 default:
305 if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (LA(4)=='=')) {
306 mBSR_ASSIGN(true);
307 theRetToken=_returnToken;
308 }
309 else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='=')) {
310 mSR_ASSIGN(true);
311 theRetToken=_returnToken;
312 }
313 else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (true)) {
314 mBSR(true);
315 theRetToken=_returnToken;
316 }
317 else if ((LA(1)=='<') && (LA(2)=='<') && (LA(3)=='=')) {
318 mSL_ASSIGN(true);
319 theRetToken=_returnToken;
320 }
321 else if ((LA(1)=='=') && (LA(2)=='=')) {
322 mEQUAL(true);
323 theRetToken=_returnToken;
324 }
325 else if ((LA(1)=='!') && (LA(2)=='=')) {
326 mNOT_EQUAL(true);
327 theRetToken=_returnToken;
328 }
329 else if ((LA(1)=='/') && (LA(2)=='=')) {
330 mDIV_ASSIGN(true);
331 theRetToken=_returnToken;
332 }
333 else if ((LA(1)=='+') && (LA(2)=='=')) {
334 mPLUS_ASSIGN(true);
335 theRetToken=_returnToken;
336 }
337 else if ((LA(1)=='+') && (LA(2)=='+')) {
338 mINC(true);
339 theRetToken=_returnToken;
340 }
341 else if ((LA(1)=='-') && (LA(2)=='=')) {
342 mMINUS_ASSIGN(true);
343 theRetToken=_returnToken;
344 }
345 else if ((LA(1)=='-') && (LA(2)=='-')) {
346 mDEC(true);
347 theRetToken=_returnToken;
348 }
349 else if ((LA(1)=='*') && (LA(2)=='=')) {
350 mSTAR_ASSIGN(true);
351 theRetToken=_returnToken;
352 }
353 else if ((LA(1)=='%') && (LA(2)=='=')) {
354 mMOD_ASSIGN(true);
355 theRetToken=_returnToken;
356 }
357 else if ((LA(1)=='>') && (LA(2)=='>') && (true)) {
358 mSR(true);
359 theRetToken=_returnToken;
360 }
361 else if ((LA(1)=='>') && (LA(2)=='=')) {
362 mGE(true);
363 theRetToken=_returnToken;
364 }
365 else if ((LA(1)=='<') && (LA(2)=='<') && (true)) {
366 mSL(true);
367 theRetToken=_returnToken;
368 }
369 else if ((LA(1)=='<') && (LA(2)=='=')) {
370 mLE(true);
371 theRetToken=_returnToken;
372 }
373 else if ((LA(1)=='^') && (LA(2)=='=')) {
374 mBXOR_ASSIGN(true);
375 theRetToken=_returnToken;
376 }
377 else if ((LA(1)=='|') && (LA(2)=='=')) {
378 mBOR_ASSIGN(true);
379 theRetToken=_returnToken;
380 }
381 else if ((LA(1)=='|') && (LA(2)=='|')) {
382 mLOR(true);
383 theRetToken=_returnToken;
384 }
385 else if ((LA(1)=='&') && (LA(2)=='=')) {
386 mBAND_ASSIGN(true);
387 theRetToken=_returnToken;
388 }
389 else if ((LA(1)=='&') && (LA(2)=='&')) {
390 mLAND(true);
391 theRetToken=_returnToken;
392 }
393 else if ((LA(1)=='/') && (LA(2)=='/')) {
394 mSL_COMMENT(true);
395 theRetToken=_returnToken;
396 }
397 else if ((LA(1)=='/') && (LA(2)=='*')) {
398 mML_COMMENT(true);
399 theRetToken=_returnToken;
400 }
401 else if ((LA(1)=='=') && (true)) {
402 mASSIGN(true);
403 theRetToken=_returnToken;
404 }
405 else if ((LA(1)=='!') && (true)) {
406 mLNOT(true);
407 theRetToken=_returnToken;
408 }
409 else if ((LA(1)=='/') && (true)) {
410 mDIV(true);
411 theRetToken=_returnToken;
412 }
413 else if ((LA(1)=='+') && (true)) {
414 mPLUS(true);
415 theRetToken=_returnToken;
416 }
417 else if ((LA(1)=='-') && (true)) {
418 mMINUS(true);
419 theRetToken=_returnToken;
420 }
421 else if ((LA(1)=='*') && (true)) {
422 mSTAR(true);
423 theRetToken=_returnToken;
424 }
425 else if ((LA(1)=='%') && (true)) {
426 mMOD(true);
427 theRetToken=_returnToken;
428 }
429 else if ((LA(1)=='>') && (true)) {
430 mGT(true);
431 theRetToken=_returnToken;
432 }
433 else if ((LA(1)=='<') && (true)) {
434 mLT(true);
435 theRetToken=_returnToken;
436 }
437 else if ((LA(1)=='^') && (true)) {
438 mBXOR(true);
439 theRetToken=_returnToken;
440 }
441 else if ((LA(1)=='|') && (true)) {
442 mBOR(true);
443 theRetToken=_returnToken;
444 }
445 else if ((LA(1)=='&') && (true)) {
446 mBAND(true);
447 theRetToken=_returnToken;
448 }
449 else {
450 if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
451 else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
452 }
453 }
454 if ( _returnToken==null ) continue tryAgain;
455 _ttype = _returnToken.getType();
456 _returnToken.setType(_ttype);
457 return _returnToken;
458 }
459 catch (RecognitionException e) {
460 throw new TokenStreamRecognitionException(e);
461 }
462 }
463 catch (CharStreamException cse) {
464 if ( cse instanceof CharStreamIOException ) {
465 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
466 }
467 else {
468 throw new TokenStreamException(cse.getMessage());
469 }
470 }
471 }
472 }
473
474 public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
475 int _ttype; Token _token=null; int _begin=text.length();
476 _ttype = QUESTION;
477 int _saveIndex;
478
479 match('?');
480 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
481 _token = makeToken(_ttype);
482 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
483 }
484 _returnToken = _token;
485 }
486
487 public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
488 int _ttype; Token _token=null; int _begin=text.length();
489 _ttype = LPAREN;
490 int _saveIndex;
491
492 match('(');
493 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
494 _token = makeToken(_ttype);
495 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
496 }
497 _returnToken = _token;
498 }
499
500 public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
501 int _ttype; Token _token=null; int _begin=text.length();
502 _ttype = RPAREN;
503 int _saveIndex;
504
505 match(')');
506 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
507 _token = makeToken(_ttype);
508 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
509 }
510 _returnToken = _token;
511 }
512
513 public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
514 int _ttype; Token _token=null; int _begin=text.length();
515 _ttype = LBRACK;
516 int _saveIndex;
517
518 match('[');
519 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
520 _token = makeToken(_ttype);
521 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
522 }
523 _returnToken = _token;
524 }
525
526 public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
527 int _ttype; Token _token=null; int _begin=text.length();
528 _ttype = RBRACK;
529 int _saveIndex;
530
531 match(']');
532 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
533 _token = makeToken(_ttype);
534 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
535 }
536 _returnToken = _token;
537 }
538
539 public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
540 int _ttype; Token _token=null; int _begin=text.length();
541 _ttype = LCURLY;
542 int _saveIndex;
543
544 match('{');
545 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
546 _token = makeToken(_ttype);
547 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
548 }
549 _returnToken = _token;
550 }
551
552 public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
553 int _ttype; Token _token=null; int _begin=text.length();
554 _ttype = RCURLY;
555 int _saveIndex;
556
557 match('}');
558 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
559 _token = makeToken(_ttype);
560 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
561 }
562 _returnToken = _token;
563 }
564
565 public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
566 int _ttype; Token _token=null; int _begin=text.length();
567 _ttype = COLON;
568 int _saveIndex;
569
570 match(':');
571 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
572 _token = makeToken(_ttype);
573 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
574 }
575 _returnToken = _token;
576 }
577
578 public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
579 int _ttype; Token _token=null; int _begin=text.length();
580 _ttype = COMMA;
581 int _saveIndex;
582
583 match(',');
584 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
585 _token = makeToken(_ttype);
586 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
587 }
588 _returnToken = _token;
589 }
590
591 public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
592 int _ttype; Token _token=null; int _begin=text.length();
593 _ttype = ASSIGN;
594 int _saveIndex;
595
596 match('=');
597 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
598 _token = makeToken(_ttype);
599 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
600 }
601 _returnToken = _token;
602 }
603
604 public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
605 int _ttype; Token _token=null; int _begin=text.length();
606 _ttype = EQUAL;
607 int _saveIndex;
608
609 match("==");
610 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
611 _token = makeToken(_ttype);
612 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
613 }
614 _returnToken = _token;
615 }
616
617 public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
618 int _ttype; Token _token=null; int _begin=text.length();
619 _ttype = LNOT;
620 int _saveIndex;
621
622 match('!');
623 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
624 _token = makeToken(_ttype);
625 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
626 }
627 _returnToken = _token;
628 }
629
630 public final void mBNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
631 int _ttype; Token _token=null; int _begin=text.length();
632 _ttype = BNOT;
633 int _saveIndex;
634
635 match('~');
636 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
637 _token = makeToken(_ttype);
638 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
639 }
640 _returnToken = _token;
641 }
642
643 public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
644 int _ttype; Token _token=null; int _begin=text.length();
645 _ttype = NOT_EQUAL;
646 int _saveIndex;
647
648 match("!=");
649 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
650 _token = makeToken(_ttype);
651 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
652 }
653 _returnToken = _token;
654 }
655
656 public final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
657 int _ttype; Token _token=null; int _begin=text.length();
658 _ttype = DIV;
659 int _saveIndex;
660
661 match('/');
662 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
663 _token = makeToken(_ttype);
664 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
665 }
666 _returnToken = _token;
667 }
668
669 public final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
670 int _ttype; Token _token=null; int _begin=text.length();
671 _ttype = DIV_ASSIGN;
672 int _saveIndex;
673
674 match("/=");
675 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
676 _token = makeToken(_ttype);
677 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
678 }
679 _returnToken = _token;
680 }
681
682 public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
683 int _ttype; Token _token=null; int _begin=text.length();
684 _ttype = PLUS;
685 int _saveIndex;
686
687 match('+');
688 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
689 _token = makeToken(_ttype);
690 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
691 }
692 _returnToken = _token;
693 }
694
695 public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
696 int _ttype; Token _token=null; int _begin=text.length();
697 _ttype = PLUS_ASSIGN;
698 int _saveIndex;
699
700 match("+=");
701 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
702 _token = makeToken(_ttype);
703 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
704 }
705 _returnToken = _token;
706 }
707
708 public final void mINC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
709 int _ttype; Token _token=null; int _begin=text.length();
710 _ttype = INC;
711 int _saveIndex;
712
713 match("++");
714 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
715 _token = makeToken(_ttype);
716 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
717 }
718 _returnToken = _token;
719 }
720
721 public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
722 int _ttype; Token _token=null; int _begin=text.length();
723 _ttype = MINUS;
724 int _saveIndex;
725
726 match('-');
727 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
728 _token = makeToken(_ttype);
729 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
730 }
731 _returnToken = _token;
732 }
733
734 public final void mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
735 int _ttype; Token _token=null; int _begin=text.length();
736 _ttype = MINUS_ASSIGN;
737 int _saveIndex;
738
739 match("-=");
740 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
741 _token = makeToken(_ttype);
742 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
743 }
744 _returnToken = _token;
745 }
746
747 public final void mDEC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
748 int _ttype; Token _token=null; int _begin=text.length();
749 _ttype = DEC;
750 int _saveIndex;
751
752 match("--");
753 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
754 _token = makeToken(_ttype);
755 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
756 }
757 _returnToken = _token;
758 }
759
760 public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
761 int _ttype; Token _token=null; int _begin=text.length();
762 _ttype = STAR;
763 int _saveIndex;
764
765 match('*');
766 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
767 _token = makeToken(_ttype);
768 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
769 }
770 _returnToken = _token;
771 }
772
773 public final void mSTAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
774 int _ttype; Token _token=null; int _begin=text.length();
775 _ttype = STAR_ASSIGN;
776 int _saveIndex;
777
778 match("*=");
779 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
780 _token = makeToken(_ttype);
781 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
782 }
783 _returnToken = _token;
784 }
785
786 public final void mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
787 int _ttype; Token _token=null; int _begin=text.length();
788 _ttype = MOD;
789 int _saveIndex;
790
791 match('%');
792 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
793 _token = makeToken(_ttype);
794 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
795 }
796 _returnToken = _token;
797 }
798
799 public final void mMOD_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
800 int _ttype; Token _token=null; int _begin=text.length();
801 _ttype = MOD_ASSIGN;
802 int _saveIndex;
803
804 match("%=");
805 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
806 _token = makeToken(_ttype);
807 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
808 }
809 _returnToken = _token;
810 }
811
812 public final void mSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
813 int _ttype; Token _token=null; int _begin=text.length();
814 _ttype = SR;
815 int _saveIndex;
816
817 match(">>");
818 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
819 _token = makeToken(_ttype);
820 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
821 }
822 _returnToken = _token;
823 }
824
825 public final void mSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
826 int _ttype; Token _token=null; int _begin=text.length();
827 _ttype = SR_ASSIGN;
828 int _saveIndex;
829
830 match(">>=");
831 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
832 _token = makeToken(_ttype);
833 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
834 }
835 _returnToken = _token;
836 }
837
838 public final void mBSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
839 int _ttype; Token _token=null; int _begin=text.length();
840 _ttype = BSR;
841 int _saveIndex;
842
843 match(">>>");
844 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
845 _token = makeToken(_ttype);
846 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
847 }
848 _returnToken = _token;
849 }
850
851 public final void mBSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
852 int _ttype; Token _token=null; int _begin=text.length();
853 _ttype = BSR_ASSIGN;
854 int _saveIndex;
855
856 match(">>>=");
857 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
858 _token = makeToken(_ttype);
859 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
860 }
861 _returnToken = _token;
862 }
863
864 public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
865 int _ttype; Token _token=null; int _begin=text.length();
866 _ttype = GE;
867 int _saveIndex;
868
869 match(">=");
870 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
871 _token = makeToken(_ttype);
872 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
873 }
874 _returnToken = _token;
875 }
876
877 public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
878 int _ttype; Token _token=null; int _begin=text.length();
879 _ttype = GT;
880 int _saveIndex;
881
882 match(">");
883 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
884 _token = makeToken(_ttype);
885 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
886 }
887 _returnToken = _token;
888 }
889
890 public final void mSL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
891 int _ttype; Token _token=null; int _begin=text.length();
892 _ttype = SL;
893 int _saveIndex;
894
895 match("<<");
896 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
897 _token = makeToken(_ttype);
898 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
899 }
900 _returnToken = _token;
901 }
902
903 public final void mSL_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
904 int _ttype; Token _token=null; int _begin=text.length();
905 _ttype = SL_ASSIGN;
906 int _saveIndex;
907
908 match("<<=");
909 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
910 _token = makeToken(_ttype);
911 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
912 }
913 _returnToken = _token;
914 }
915
916 public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
917 int _ttype; Token _token=null; int _begin=text.length();
918 _ttype = LE;
919 int _saveIndex;
920
921 match("<=");
922 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
923 _token = makeToken(_ttype);
924 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
925 }
926 _returnToken = _token;
927 }
928
929 public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
930 int _ttype; Token _token=null; int _begin=text.length();
931 _ttype = LT;
932 int _saveIndex;
933
934 match('<');
935 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
936 _token = makeToken(_ttype);
937 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
938 }
939 _returnToken = _token;
940 }
941
942 public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
943 int _ttype; Token _token=null; int _begin=text.length();
944 _ttype = BXOR;
945 int _saveIndex;
946
947 match('^');
948 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
949 _token = makeToken(_ttype);
950 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
951 }
952 _returnToken = _token;
953 }
954
955 public final void mBXOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
956 int _ttype; Token _token=null; int _begin=text.length();
957 _ttype = BXOR_ASSIGN;
958 int _saveIndex;
959
960 match("^=");
961 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
962 _token = makeToken(_ttype);
963 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
964 }
965 _returnToken = _token;
966 }
967
968 public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
969 int _ttype; Token _token=null; int _begin=text.length();
970 _ttype = BOR;
971 int _saveIndex;
972
973 match('|');
974 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
975 _token = makeToken(_ttype);
976 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
977 }
978 _returnToken = _token;
979 }
980
981 public final void mBOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
982 int _ttype; Token _token=null; int _begin=text.length();
983 _ttype = BOR_ASSIGN;
984 int _saveIndex;
985
986 match("|=");
987 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
988 _token = makeToken(_ttype);
989 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
990 }
991 _returnToken = _token;
992 }
993
994 public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
995 int _ttype; Token _token=null; int _begin=text.length();
996 _ttype = LOR;
997 int _saveIndex;
998
999 match("||");
1000 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1001 _token = makeToken(_ttype);
1002 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1003 }
1004 _returnToken = _token;
1005 }
1006
1007 public final void mBAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1008 int _ttype; Token _token=null; int _begin=text.length();
1009 _ttype = BAND;
1010 int _saveIndex;
1011
1012 match('&');
1013 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1014 _token = makeToken(_ttype);
1015 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1016 }
1017 _returnToken = _token;
1018 }
1019
1020 public final void mBAND_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1021 int _ttype; Token _token=null; int _begin=text.length();
1022 _ttype = BAND_ASSIGN;
1023 int _saveIndex;
1024
1025 match("&=");
1026 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1027 _token = makeToken(_ttype);
1028 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1029 }
1030 _returnToken = _token;
1031 }
1032
1033 public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1034 int _ttype; Token _token=null; int _begin=text.length();
1035 _ttype = LAND;
1036 int _saveIndex;
1037
1038 match("&&");
1039 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1040 _token = makeToken(_ttype);
1041 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1042 }
1043 _returnToken = _token;
1044 }
1045
1046 public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1047 int _ttype; Token _token=null; int _begin=text.length();
1048 _ttype = SEMI;
1049 int _saveIndex;
1050
1051 match(';');
1052 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1053 _token = makeToken(_ttype);
1054 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1055 }
1056 _returnToken = _token;
1057 }
1058
1059 public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1060 int _ttype; Token _token=null; int _begin=text.length();
1061 _ttype = WS;
1062 int _saveIndex;
1063
1064 {
1065 int _cnt363=0;
1066 _loop363:
1067 do {
1068 switch ( LA(1)) {
1069 case ' ':
1070 {
1071 match(' ');
1072 break;
1073 }
1074 case '\t':
1075 {
1076 match('\t');
1077 break;
1078 }
1079 case '\u000c':
1080 {
1081 match('\f');
1082 break;
1083 }
1084 case '\n': case '\r':
1085 {
1086 {
1087 if ((LA(1)=='\r') && (LA(2)=='\n') && (true) && (true)) {
1088 match("\r\n");
1089 }
1090 else if ((LA(1)=='\r') && (true) && (true) && (true)) {
1091 match('\r');
1092 }
1093 else if ((LA(1)=='\n')) {
1094 match('\n');
1095 }
1096 else {
1097 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1098 }
1099
1100 }
1101 if ( inputState.guessing==0 ) {
1102 newline();
1103 }
1104 break;
1105 }
1106 default:
1107 {
1108 if ( _cnt363>=1 ) { break _loop363; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1109 }
1110 }
1111 _cnt363++;
1112 } while (true);
1113 }
1114 if ( inputState.guessing==0 ) {
1115 _ttype = Token.SKIP;
1116 }
1117 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1118 _token = makeToken(_ttype);
1119 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1120 }
1121 _returnToken = _token;
1122 }
1123
1124 public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1125 int _ttype; Token _token=null; int _begin=text.length();
1126 _ttype = SL_COMMENT;
1127 int _saveIndex;
1128
1129 match("//");
1130 {
1131 _loop367:
1132 do {
1133 if ((_tokenSet_0.member(LA(1)))) {
1134 {
1135 match(_tokenSet_0);
1136 }
1137 }
1138 else {
1139 break _loop367;
1140 }
1141
1142 } while (true);
1143 }
1144 {
1145 switch ( LA(1)) {
1146 case '\n':
1147 {
1148 match('\n');
1149 break;
1150 }
1151 case '\r':
1152 {
1153 match('\r');
1154 {
1155 if ((LA(1)=='\n')) {
1156 match('\n');
1157 }
1158 else {
1159 }
1160
1161 }
1162 break;
1163 }
1164 default:
1165 {
1166 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1167 }
1168 }
1169 }
1170 if ( inputState.guessing==0 ) {
1171 _ttype = Token.SKIP; newline();
1172 }
1173 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1174 _token = makeToken(_ttype);
1175 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1176 }
1177 _returnToken = _token;
1178 }
1179
1180 public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1181 int _ttype; Token _token=null; int _begin=text.length();
1182 _ttype = ML_COMMENT;
1183 int _saveIndex;
1184
1185 match("/*");
1186 {
1187 _loop373:
1188 do {
1189 if ((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')) && ((LA(4) >= '\u0003' && LA(4) <= '\uffff'))) {
1190 match('\r');
1191 match('\n');
1192 if ( inputState.guessing==0 ) {
1193 newline();
1194 }
1195 }
1196 else if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')))&&( LA(2)!='/' )) {
1197 match('*');
1198 }
1199 else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')) && (true)) {
1200 match('\r');
1201 if ( inputState.guessing==0 ) {
1202 newline();
1203 }
1204 }
1205 else if ((LA(1)=='\n')) {
1206 match('\n');
1207 if ( inputState.guessing==0 ) {
1208 newline();
1209 }
1210 }
1211 else if ((_tokenSet_1.member(LA(1)))) {
1212 {
1213 match(_tokenSet_1);
1214 }
1215 }
1216 else {
1217 break _loop373;
1218 }
1219
1220 } while (true);
1221 }
1222 match("*/");
1223 if ( inputState.guessing==0 ) {
1224 _ttype = Token.SKIP;
1225 }
1226 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1227 _token = makeToken(_ttype);
1228 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1229 }
1230 _returnToken = _token;
1231 }
1232
1233 public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1234 int _ttype; Token _token=null; int _begin=text.length();
1235 _ttype = STRING_LITERAL;
1236 int _saveIndex;
1237
1238 switch ( LA(1)) {
1239 case '"':
1240 {
1241 match('"');
1242 {
1243 _loop377:
1244 do {
1245 if ((LA(1)=='//')) {
1246 mESC(false);
1247 }
1248 else if ((_tokenSet_2.member(LA(1)))) {
1249 {
1250 match(_tokenSet_2);
1251 }
1252 }
1253 else {
1254 break _loop377;
1255 }
1256
1257 } while (true);
1258 }
1259 match('"');
1260 break;
1261 }
1262 case '\'':
1263 {
1264 match('\'');
1265 {
1266 if ((LA(1)=='//')) {
1267 mESC(false);
1268 }
1269 else if ((_tokenSet_3.member(LA(1)))) {
1270 {
1271 match(_tokenSet_3);
1272 }
1273 }
1274 else {
1275 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1276 }
1277
1278 }
1279 match('\'');
1280 break;
1281 }
1282 default:
1283 {
1284 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1285 }
1286 }
1287 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1288 _token = makeToken(_ttype);
1289 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1290 }
1291 _returnToken = _token;
1292 }
1293
1294 protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1295 int _ttype; Token _token=null; int _begin=text.length();
1296 _ttype = ESC;
1297 int _saveIndex;
1298
1299 match('//');
1300 {
1301 switch ( LA(1)) {
1302 case 'n':
1303 {
1304 match('n');
1305 break;
1306 }
1307 case 'r':
1308 {
1309 match('r');
1310 break;
1311 }
1312 case 't':
1313 {
1314 match('t');
1315 break;
1316 }
1317 case 'b':
1318 {
1319 match('b');
1320 break;
1321 }
1322 case 'f':
1323 {
1324 match('f');
1325 break;
1326 }
1327 case '"':
1328 {
1329 match('"');
1330 break;
1331 }
1332 case '\'':
1333 {
1334 match('\'');
1335 break;
1336 }
1337 case '//':
1338 {
1339 match('//');
1340 break;
1341 }
1342 case 'u':
1343 {
1344 {
1345 int _cnt383=0;
1346 _loop383:
1347 do {
1348 if ((LA(1)=='u')) {
1349 match('u');
1350 }
1351 else {
1352 if ( _cnt383>=1 ) { break _loop383; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1353 }
1354
1355 _cnt383++;
1356 } while (true);
1357 }
1358 mHEX_DIGIT(false);
1359 mHEX_DIGIT(false);
1360 mHEX_DIGIT(false);
1361 mHEX_DIGIT(false);
1362 break;
1363 }
1364 case '0': case '1': case '2': case '3':
1365 {
1366 matchRange('0','3');
1367 {
1368 if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
1369 matchRange('0','7');
1370 {
1371 if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
1372 matchRange('0','7');
1373 }
1374 else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
1375 }
1376 else {
1377 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1378 }
1379
1380 }
1381 }
1382 else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
1383 }
1384 else {
1385 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1386 }
1387
1388 }
1389 break;
1390 }
1391 case '4': case '5': case '6': case '7':
1392 {
1393 matchRange('4','7');
1394 {
1395 if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
1396 matchRange('0','7');
1397 }
1398 else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
1399 }
1400 else {
1401 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1402 }
1403
1404 }
1405 break;
1406 }
1407 default:
1408 {
1409 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1410 }
1411 }
1412 }
1413 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1414 _token = makeToken(_ttype);
1415 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1416 }
1417 _returnToken = _token;
1418 }
1419
1420 protected final void mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1421 int _ttype; Token _token=null; int _begin=text.length();
1422 _ttype = HEX_DIGIT;
1423 int _saveIndex;
1424
1425 {
1426 switch ( LA(1)) {
1427 case '0': case '1': case '2': case '3':
1428 case '4': case '5': case '6': case '7':
1429 case '8': case '9':
1430 {
1431 matchRange('0','9');
1432 break;
1433 }
1434 case 'A': case 'B': case 'C': case 'D':
1435 case 'E': case 'F':
1436 {
1437 matchRange('A','F');
1438 break;
1439 }
1440 case 'a': case 'b': case 'c': case 'd':
1441 case 'e': case 'f':
1442 {
1443 matchRange('a','f');
1444 break;
1445 }
1446 default:
1447 {
1448 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1449 }
1450 }
1451 }
1452 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1453 _token = makeToken(_ttype);
1454 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1455 }
1456 _returnToken = _token;
1457 }
1458
1459 protected final void mVOCAB(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1460 int _ttype; Token _token=null; int _begin=text.length();
1461 _ttype = VOCAB;
1462 int _saveIndex;
1463
1464 matchRange('\3','\377');
1465 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1466 _token = makeToken(_ttype);
1467 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1468 }
1469 _returnToken = _token;
1470 }
1471
1472 public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1473 int _ttype; Token _token=null; int _begin=text.length();
1474 _ttype = IDENT;
1475 int _saveIndex;
1476
1477 {
1478 switch ( LA(1)) {
1479 case 'a': case 'b': case 'c': case 'd':
1480 case 'e': case 'f': case 'g': case 'h':
1481 case 'i': case 'j': case 'k': case 'l':
1482 case 'm': case 'n': case 'o': case 'p':
1483 case 'q': case 'r': case 's': case 't':
1484 case 'u': case 'v': case 'w': case 'x':
1485 case 'y': case 'z':
1486 {
1487 matchRange('a','z');
1488 break;
1489 }
1490 case 'A': case 'B': case 'C': case 'D':
1491 case 'E': case 'F': case 'G': case 'H':
1492 case 'I': case 'J': case 'K': case 'L':
1493 case 'M': case 'N': case 'O': case 'P':
1494 case 'Q': case 'R': case 'S': case 'T':
1495 case 'U': case 'V': case 'W': case 'X':
1496 case 'Y': case 'Z':
1497 {
1498 matchRange('A','Z');
1499 break;
1500 }
1501 case '_':
1502 {
1503 match('_');
1504 break;
1505 }
1506 case '$':
1507 {
1508 match('$');
1509 break;
1510 }
1511 default:
1512 {
1513 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1514 }
1515 }
1516 }
1517 {
1518 _loop393:
1519 do {
1520 switch ( LA(1)) {
1521 case 'a': case 'b': case 'c': case 'd':
1522 case 'e': case 'f': case 'g': case 'h':
1523 case 'i': case 'j': case 'k': case 'l':
1524 case 'm': case 'n': case 'o': case 'p':
1525 case 'q': case 'r': case 's': case 't':
1526 case 'u': case 'v': case 'w': case 'x':
1527 case 'y': case 'z':
1528 {
1529 matchRange('a','z');
1530 break;
1531 }
1532 case 'A': case 'B': case 'C': case 'D':
1533 case 'E': case 'F': case 'G': case 'H':
1534 case 'I': case 'J': case 'K': case 'L':
1535 case 'M': case 'N': case 'O': case 'P':
1536 case 'Q': case 'R': case 'S': case 'T':
1537 case 'U': case 'V': case 'W': case 'X':
1538 case 'Y': case 'Z':
1539 {
1540 matchRange('A','Z');
1541 break;
1542 }
1543 case '_':
1544 {
1545 match('_');
1546 break;
1547 }
1548 case '0': case '1': case '2': case '3':
1549 case '4': case '5': case '6': case '7':
1550 case '8': case '9':
1551 {
1552 matchRange('0','9');
1553 break;
1554 }
1555 case '$':
1556 {
1557 match('$');
1558 break;
1559 }
1560 default:
1561 {
1562 break _loop393;
1563 }
1564 }
1565 } while (true);
1566 }
1567 if ( inputState.guessing==0 ) {
1568
1569
1570 if (assertEnabled && "assert".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
1571 _ttype = LITERAL_assert;
1572 }
1573
1574 if (enumEnabled && "enum".equals(new String(text.getBuffer(),_begin,text.length()-_begin))) {
1575 _ttype = LITERAL_enum;
1576 }
1577
1578 }
1579 _ttype = testLiteralsTable(_ttype);
1580 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1581 _token = makeToken(_ttype);
1582 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1583 }
1584 _returnToken = _token;
1585 }
1586
1587 public final void mNUM_INT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1588 int _ttype; Token _token=null; int _begin=text.length();
1589 _ttype = NUM_INT;
1590 int _saveIndex;
1591 Token f1=null;
1592 Token f2=null;
1593 Token f3=null;
1594 Token f4=null;
1595 boolean isDecimal=false; Token t=null;
1596
1597 switch ( LA(1)) {
1598 case '.':
1599 {
1600 match('.');
1601 if ( inputState.guessing==0 ) {
1602 _ttype = DOT;
1603 }
1604 {
1605 switch ( LA(1)) {
1606 case '0': case '1': case '2': case '3':
1607 case '4': case '5': case '6': case '7':
1608 case '8': case '9':
1609 {
1610 {
1611 {
1612 int _cnt398=0;
1613 _loop398:
1614 do {
1615 if (((LA(1) >= '0' && LA(1) <= '9'))) {
1616 matchRange('0','9');
1617 }
1618 else {
1619 if ( _cnt398>=1 ) { break _loop398; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1620 }
1621
1622 _cnt398++;
1623 } while (true);
1624 }
1625 {
1626 if ((LA(1)=='E'||LA(1)=='e')) {
1627 mEXPONENT(false);
1628 }
1629 else {
1630 }
1631
1632 }
1633 {
1634 if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
1635 mFLOAT_SUFFIX(true);
1636 f1=_returnToken;
1637 if ( inputState.guessing==0 ) {
1638 t=f1;
1639 }
1640 }
1641 else {
1642 }
1643
1644 }
1645 if ( inputState.guessing==0 ) {
1646
1647 if (t != null && t.getText().toUpperCase().indexOf('F')>=0) {
1648 _ttype = NUM_FLOAT;
1649 }
1650 else {
1651 _ttype = NUM_DOUBLE;
1652 }
1653
1654 }
1655 }
1656 break;
1657 }
1658 case '.':
1659 {
1660 {
1661 match("..");
1662 if ( inputState.guessing==0 ) {
1663 _ttype = TRIPLE_DOT;
1664 }
1665 }
1666 break;
1667 }
1668 default:
1669 {
1670 }
1671 }
1672 }
1673 break;
1674 }
1675 case '0': case '1': case '2': case '3':
1676 case '4': case '5': case '6': case '7':
1677 case '8': case '9':
1678 {
1679 {
1680 switch ( LA(1)) {
1681 case '0':
1682 {
1683 match('0');
1684 if ( inputState.guessing==0 ) {
1685 isDecimal = true;
1686 }
1687 {
1688 if ((LA(1)=='X'||LA(1)=='x')) {
1689 {
1690 switch ( LA(1)) {
1691 case 'x':
1692 {
1693 match('x');
1694 break;
1695 }
1696 case 'X':
1697 {
1698 match('X');
1699 break;
1700 }
1701 default:
1702 {
1703 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1704 }
1705 }
1706 }
1707 {
1708 int _cnt406=0;
1709 _loop406:
1710 do {
1711 if ((_tokenSet_4.member(LA(1))) && (true) && (true) && (true)) {
1712 mHEX_DIGIT(false);
1713 }
1714 else {
1715 if ( _cnt406>=1 ) { break _loop406; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1716 }
1717
1718 _cnt406++;
1719 } while (true);
1720 }
1721 }
1722 else {
1723 boolean synPredMatched411 = false;
1724 if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
1725 int _m411 = mark();
1726 synPredMatched411 = true;
1727 inputState.guessing++;
1728 try {
1729 {
1730 {
1731 int _cnt409=0;
1732 _loop409:
1733 do {
1734 if (((LA(1) >= '0' && LA(1) <= '9'))) {
1735 matchRange('0','9');
1736 }
1737 else {
1738 if ( _cnt409>=1 ) { break _loop409; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1739 }
1740
1741 _cnt409++;
1742 } while (true);
1743 }
1744 {
1745 switch ( LA(1)) {
1746 case '.':
1747 {
1748 match('.');
1749 break;
1750 }
1751 case 'E': case 'e':
1752 {
1753 mEXPONENT(false);
1754 break;
1755 }
1756 case 'D': case 'F': case 'd': case 'f':
1757 {
1758 mFLOAT_SUFFIX(false);
1759 break;
1760 }
1761 default:
1762 {
1763 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1764 }
1765 }
1766 }
1767 }
1768 }
1769 catch (RecognitionException pe) {
1770 synPredMatched411 = false;
1771 }
1772 rewind(_m411);
1773 inputState.guessing--;
1774 }
1775 if ( synPredMatched411 ) {
1776 {
1777 int _cnt413=0;
1778 _loop413:
1779 do {
1780 if (((LA(1) >= '0' && LA(1) <= '9'))) {
1781 matchRange('0','9');
1782 }
1783 else {
1784 if ( _cnt413>=1 ) { break _loop413; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1785 }
1786
1787 _cnt413++;
1788 } while (true);
1789 }
1790 }
1791 else if (((LA(1) >= '0' && LA(1) <= '7')) && (true) && (true) && (true)) {
1792 {
1793 int _cnt415=0;
1794 _loop415:
1795 do {
1796 if (((LA(1) >= '0' && LA(1) <= '7'))) {
1797 matchRange('0','7');
1798 }
1799 else {
1800 if ( _cnt415>=1 ) { break _loop415; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
1801 }
1802
1803 _cnt415++;
1804 } while (true);
1805 }
1806 }
1807 else {
1808 }
1809 }
1810 }
1811 break;
1812 }
1813 case '1': case '2': case '3': case '4':
1814 case '5': case '6': case '7': case '8':
1815 case '9':
1816 {
1817 {
1818 matchRange('1','9');
1819 }
1820 {
1821 _loop418:
1822 do {
1823 if (((LA(1) >= '0' && LA(1) <= '9'))) {
1824 matchRange('0','9');
1825 }
1826 else {
1827 break _loop418;
1828 }
1829
1830 } while (true);
1831 }
1832 if ( inputState.guessing==0 ) {
1833 isDecimal=true;
1834 }
1835 break;
1836 }
1837 default:
1838 {
1839 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1840 }
1841 }
1842 }
1843 {
1844 if ((LA(1)=='L'||LA(1)=='l')) {
1845 {
1846 switch ( LA(1)) {
1847 case 'l':
1848 {
1849 match('l');
1850 break;
1851 }
1852 case 'L':
1853 {
1854 match('L');
1855 break;
1856 }
1857 default:
1858 {
1859 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1860 }
1861 }
1862 }
1863 if ( inputState.guessing==0 ) {
1864 _ttype = NUM_LONG;
1865 }
1866 }
1867 else if (((LA(1)=='.'||LA(1)=='D'||LA(1)=='E'||LA(1)=='F'||LA(1)=='d'||LA(1)=='e'||LA(1)=='f'))&&(isDecimal)) {
1868 {
1869 switch ( LA(1)) {
1870 case '.':
1871 {
1872 match('.');
1873 {
1874 _loop423:
1875 do {
1876 if (((LA(1) >= '0' && LA(1) <= '9'))) {
1877 matchRange('0','9');
1878 }
1879 else {
1880 break _loop423;
1881 }
1882
1883 } while (true);
1884 }
1885 {
1886 if ((LA(1)=='E'||LA(1)=='e')) {
1887 mEXPONENT(false);
1888 }
1889 else {
1890 }
1891
1892 }
1893 {
1894 if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
1895 mFLOAT_SUFFIX(true);
1896 f2=_returnToken;
1897 if ( inputState.guessing==0 ) {
1898 t=f2;
1899 }
1900 }
1901 else {
1902 }
1903
1904 }
1905 break;
1906 }
1907 case 'E': case 'e':
1908 {
1909 mEXPONENT(false);
1910 {
1911 if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
1912 mFLOAT_SUFFIX(true);
1913 f3=_returnToken;
1914 if ( inputState.guessing==0 ) {
1915 t=f3;
1916 }
1917 }
1918 else {
1919 }
1920
1921 }
1922 break;
1923 }
1924 case 'D': case 'F': case 'd': case 'f':
1925 {
1926 mFLOAT_SUFFIX(true);
1927 f4=_returnToken;
1928 if ( inputState.guessing==0 ) {
1929 t=f4;
1930 }
1931 break;
1932 }
1933 default:
1934 {
1935 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1936 }
1937 }
1938 }
1939 if ( inputState.guessing==0 ) {
1940
1941 if (t != null && t.getText().toUpperCase() .indexOf('F') >= 0) {
1942 _ttype = NUM_FLOAT;
1943 }
1944 else {
1945 _ttype = NUM_DOUBLE;
1946 }
1947
1948 }
1949 }
1950 else {
1951 }
1952
1953 }
1954 break;
1955 }
1956 default:
1957 {
1958 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1959 }
1960 }
1961 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1962 _token = makeToken(_ttype);
1963 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1964 }
1965 _returnToken = _token;
1966 }
1967
1968 protected final void mEXPONENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1969 int _ttype; Token _token=null; int _begin=text.length();
1970 _ttype = EXPONENT;
1971 int _saveIndex;
1972
1973 {
1974 switch ( LA(1)) {
1975 case 'e':
1976 {
1977 match('e');
1978 break;
1979 }
1980 case 'E':
1981 {
1982 match('E');
1983 break;
1984 }
1985 default:
1986 {
1987 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
1988 }
1989 }
1990 }
1991 {
1992 switch ( LA(1)) {
1993 case '+':
1994 {
1995 match('+');
1996 break;
1997 }
1998 case '-':
1999 {
2000 match('-');
2001 break;
2002 }
2003 case '0': case '1': case '2': case '3':
2004 case '4': case '5': case '6': case '7':
2005 case '8': case '9':
2006 {
2007 break;
2008 }
2009 default:
2010 {
2011 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2012 }
2013 }
2014 }
2015 {
2016 int _cnt432=0;
2017 _loop432:
2018 do {
2019 if (((LA(1) >= '0' && LA(1) <= '9'))) {
2020 matchRange('0','9');
2021 }
2022 else {
2023 if ( _cnt432>=1 ) { break _loop432; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
2024 }
2025
2026 _cnt432++;
2027 } while (true);
2028 }
2029 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2030 _token = makeToken(_ttype);
2031 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2032 }
2033 _returnToken = _token;
2034 }
2035
2036 protected final void mFLOAT_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2037 int _ttype; Token _token=null; int _begin=text.length();
2038 _ttype = FLOAT_SUFFIX;
2039 int _saveIndex;
2040
2041 switch ( LA(1)) {
2042 case 'f':
2043 {
2044 match('f');
2045 break;
2046 }
2047 case 'F':
2048 {
2049 match('F');
2050 break;
2051 }
2052 case 'd':
2053 {
2054 match('d');
2055 break;
2056 }
2057 case 'D':
2058 {
2059 match('D');
2060 break;
2061 }
2062 default:
2063 {
2064 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
2065 }
2066 }
2067 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2068 _token = makeToken(_ttype);
2069 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2070 }
2071 _returnToken = _token;
2072 }
2073
2074 public final void mAT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
2075 int _ttype; Token _token=null; int _begin=text.length();
2076 _ttype = AT;
2077 int _saveIndex;
2078
2079 match('@');
2080 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
2081 _token = makeToken(_ttype);
2082 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
2083 }
2084 _returnToken = _token;
2085 }
2086
2087
2088 private static final long[] mk_tokenSet_0() {
2089 long[] data = new long[2048];
2090 data[0]=-9224L;
2091 for (int i = 1; i<=1023; i++) { data[i]=-1L; }
2092 return data;
2093 }
2094 public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
2095 private static final long[] mk_tokenSet_1() {
2096 long[] data = new long[2048];
2097 data[0]=-4398046520328L;
2098 for (int i = 1; i<=1023; i++) { data[i]=-1L; }
2099 return data;
2100 }
2101 public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
2102 private static final long[] mk_tokenSet_2() {
2103 long[] data = new long[2048];
2104 data[0]=-17179878408L;
2105 data[1]=-268435457L;
2106 for (int i = 2; i<=1023; i++) { data[i]=-1L; }
2107 return data;
2108 }
2109 public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
2110 private static final long[] mk_tokenSet_3() {
2111 long[] data = new long[2048];
2112 data[0]=-549755823112L;
2113 data[1]=-268435457L;
2114 for (int i = 2; i<=1023; i++) { data[i]=-1L; }
2115 return data;
2116 }
2117 public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
2118 private static final long[] mk_tokenSet_4() {
2119 long[] data = new long[1025];
2120 data[0]=287948901175001088L;
2121 data[1]=541165879422L;
2122 return data;
2123 }
2124 public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
2125
2126 }