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