1
2
3 package org.codehaus.groovy.antlr.parser;
4 import org.codehaus.groovy.antlr.*;
5 import java.util.*;
6 import java.io.InputStream;
7 import java.io.Reader;
8 import antlr.InputBuffer;
9 import antlr.LexerSharedInputState;
10
11 import java.io.InputStream;
12 import antlr.TokenStreamException;
13 import antlr.TokenStreamIOException;
14 import antlr.TokenStreamRecognitionException;
15 import antlr.CharStreamException;
16 import antlr.CharStreamIOException;
17 import antlr.ANTLRException;
18 import java.io.Reader;
19 import java.util.Hashtable;
20 import antlr.CharScanner;
21 import antlr.InputBuffer;
22 import antlr.ByteBuffer;
23 import antlr.CharBuffer;
24 import antlr.Token;
25 import antlr.CommonToken;
26 import antlr.RecognitionException;
27 import antlr.NoViableAltForCharException;
28 import antlr.MismatchedCharException;
29 import antlr.TokenStream;
30 import antlr.ANTLRHashString;
31 import antlr.LexerSharedInputState;
32 import antlr.collections.impl.BitSet;
33 import antlr.SemanticException;
34
35 public class GroovyLexer extends antlr.CharScanner implements GroovyTokenTypes, TokenStream
36 {
37
38 /*** flag for enabling the "assert" keyword */
39 private boolean assertEnabled = true;
40 /*** flag for enabling the "enum" keyword */
41 private boolean enumEnabled = true;
42 /*** flag for including whitespace tokens (for IDE preparsing) */
43 private boolean whitespaceIncluded = false;
44
45 /*** Enable the "assert" keyword */
46 public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }
47 /*** Query the "assert" keyword state */
48 public boolean isAssertEnabled() { return assertEnabled; }
49 /*** Enable the "enum" keyword */
50 public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }
51 /*** Query the "enum" keyword state */
52 public boolean isEnumEnabled() { return enumEnabled; }
53
54 /*** Include whitespace tokens. Note that this breaks the parser. */
55 public void setWhitespaceIncluded(boolean z) { whitespaceIncluded = z; }
56 /*** Are whitespace tokens included? */
57 public boolean isWhitespaceIncluded() { return whitespaceIncluded; }
58
59 {
60
61 setTabSize(1);
62 }
63
64 /*** Bumped when inside '[x]' or '(x)', reset inside '{x}'. See ONE_NL. */
65 protected int parenLevel = 0;
66 protected int suppressNewline = 0;
67 protected static final int SCS_TYPE = 3, SCS_VAL = 4, SCS_LIT = 8, SCS_LIMIT = 16;
68 protected static final int SCS_SQ_TYPE = 0, SCS_TQ_TYPE = 1, SCS_RE_TYPE = 2;
69 protected int stringCtorState = 0;
70 /*** Push parenLevel here and reset whenever inside '{x}'. */
71 protected ArrayList parenLevelStack = new ArrayList();
72 protected int lastSigTokenType = EOF;
73
74 protected void pushParenLevel() {
75 parenLevelStack.add(new Integer(parenLevel*SCS_LIMIT + stringCtorState));
76 parenLevel = 0;
77 stringCtorState = 0;
78 }
79 protected void popParenLevel() {
80 int npl = parenLevelStack.size();
81 if (npl == 0) return;
82 int i = ((Integer) parenLevelStack.remove(--npl)).intValue();
83 parenLevel = i / SCS_LIMIT;
84 stringCtorState = i % SCS_LIMIT;
85 }
86
87 protected void restartStringCtor(boolean expectLiteral) {
88 if (stringCtorState != 0) {
89 stringCtorState = (expectLiteral? SCS_LIT: SCS_VAL) + (stringCtorState & SCS_TYPE);
90 }
91 }
92
93 protected boolean allowRegexpLiteral() {
94 return !isExpressionEndingToken(lastSigTokenType);
95 }
96
97 /*** Return true for an operator or punctuation which can end an expression.
98 * Return true for keywords, identifiers, and literals.
99 * Return true for tokens which can end expressions (right brackets, ++, --).
100 * Return false for EOF and all other operator and punctuation tokens.
101 * Used to suppress the recognition of /foo/ as opposed to the simple division operator '/'.
102 */
103
104 protected static boolean isExpressionEndingToken(int ttype) {
105 switch (ttype) {
106 case INC:
107 case DEC:
108 case RPAREN:
109 case RBRACK:
110 case RCURLY:
111 case STRING_LITERAL:
112 case STRING_CTOR_END:
113 case NUM_INT:
114 case NUM_FLOAT:
115 case NUM_LONG:
116 case NUM_DOUBLE:
117 case NUM_BIG_INT:
118 case NUM_BIG_DECIMAL:
119 case IDENT:
120
121 case LITERAL_any:
122 case LITERAL_as:
123 case LITERAL_assert:
124 case LITERAL_boolean:
125 case LITERAL_break:
126 case LITERAL_byte:
127 case LITERAL_case:
128 case LITERAL_catch:
129 case LITERAL_char:
130 case LITERAL_class:
131 case LITERAL_continue:
132 case LITERAL_def:
133 case LITERAL_default:
134 case LITERAL_double:
135 case LITERAL_else:
136 case LITERAL_enum:
137 case LITERAL_extends:
138 case LITERAL_false:
139 case LITERAL_finally:
140 case LITERAL_float:
141 case LITERAL_for:
142 case LITERAL_if:
143 case LITERAL_implements:
144 case LITERAL_import:
145 case LITERAL_in:
146 case LITERAL_instanceof:
147 case LITERAL_int:
148 case LITERAL_interface:
149 case LITERAL_long:
150 case LITERAL_native:
151 case LITERAL_new:
152 case LITERAL_null:
153 case</strong> LITERAL_package:
154 case LITERAL_private:
155 case LITERAL_protected:
156 case LITERAL_public:
157 case LITERAL_return:
158 case LITERAL_short:
159 case LITERAL_static:
160 case LITERAL_super:
161 case LITERAL_switch:
162 case LITERAL_synchronized:
163 case LITERAL_this:
164 case LITERAL_threadsafe:
165 case LITERAL_throw:
166 case LITERAL_throws:
167 case LITERAL_transient:
168 case LITERAL_true:
169 case LITERAL_try:
170 case LITERAL_void:
171 case LITERAL_volatile:
172 case LITERAL_while:
173 case LITERAL_with:
174 return true;
175 default:
176 return false;
177 }
178 }
179
180 protected void newlineCheck(boolean check) throws RecognitionException {
181 if (check && suppressNewline > 0) {
182 require(suppressNewline == 0,
183 "end of line reached within a simple string 'x' or \"x\" or /x/",
184 "for multi-line literals, use triple quotes '''x''' or \"\"\"x\"\"\"");
185 suppressNewline = 0;
186 }
187 newline();
188 }
189
190 protected boolean atValidDollarEscape() throws CharStreamException {
191
192 int k = 1;
193 char lc = LA(k++);
194 if (lc != '$') return false;
195 lc = LA(k++);
196 if (lc == '*') lc = LA(k++);
197 return (lc == '{' || (lc != '$' && Character.isJavaIdentifierStart(lc)));
198 }
199
200 /*** This is a bit of plumbing which resumes collection of string constructor bodies,
201 * after an embedded expression has been parsed.
202 * Usage: new GroovyRecognizer(new GroovyLexer(in).plumb()).
203 */
204 public TokenStream plumb() {
205 return new TokenStream() {
206 public Token nextToken() throws TokenStreamException {
207 if (stringCtorState >= SCS_LIT) {
208
209 int quoteType = (stringCtorState & SCS_TYPE);
210 stringCtorState = 0;
211 resetText();
212 try {
213 switch (quoteType) {
214 case SCS_SQ_TYPE:
215 mSTRING_CTOR_END(true,
216 case SCS_TQ_TYPE:
217 mSTRING_CTOR_END(true,
218 case SCS_RE_TYPE:
219 mREGEXP_CTOR_END(true,
220 default: throw new AssertionError(false);
221 }
222 lastSigTokenType = _returnToken.getType();
223 return _returnToken;
224 } catch (RecognitionException e) {
225 throw new TokenStreamRecognitionException(e);
226 } catch (CharStreamException cse) {
227 if ( cse instanceof CharStreamIOException ) {
228 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
229 }
230 else {
231 throw new TokenStreamException(cse.getMessage());
232 }
233 }
234 }
235 Token token = GroovyLexer.this.nextToken();
236 int lasttype = token.getType();
237 if (whitespaceIncluded) {
238 switch (lasttype) {
239 case WS:
240 case ONE_NL:
241 case SL_COMMENT:
242 case ML_COMMENT:
243 lasttype = lastSigTokenType;
244 }
245 }
246 lastSigTokenType = lasttype;
247 return token;
248 }
249 };
250 }
251
252
253 public static boolean tracing = false;
254 public void traceIn(String rname) throws CharStreamException {
255 if (!GroovyLexer.tracing) return;
256 super.traceIn(rname);
257 }
258 public void traceOut(String rname) throws CharStreamException {
259 if (!GroovyLexer.tracing) return;
260 if (_returnToken != null) rname += tokenStringOf(_returnToken);
261 super.traceOut(rname);
262 }
263 private static java.util.HashMap ttypes;
264 private static String tokenStringOf(Token t) {
265 if (ttypes == null) {
266 java.util.HashMap map = new java.util.HashMap();
267 java.lang.reflect.Field[] fields = GroovyTokenTypes.class.getDeclaredFields();
268 for (int i = 0; i < fields.length; i++) {
269 if (fields[i].getType() != int.class) continue;
270 try {
271 map.put(fields[i].get(null), fields[i].getName());
272 } catch (IllegalAccessException ee) {
273 }
274 }
275 ttypes = map;
276 }
277 Integer tt = new Integer(t.getType());
278 Object ttn = ttypes.get(tt);
279 if (ttn == null) ttn = "<"+tt+">";
280 return "["+ttn+",\""+t.getText()+"\"]";
281 }
282
283 protected GroovyRecognizer parser;
284 private void require(boolean z, String problem, String solution) throws SemanticException {
285
286 if (!z) parser.requireFailed(problem, solution);
287 }
288 public GroovyLexer(InputStream in) {
289 this(new ByteBuffer(in));
290 }
291 public GroovyLexer(Reader in) {
292 this(new CharBuffer(in));
293 }
294 public GroovyLexer(InputBuffer ib) {
295 this(new LexerSharedInputState(ib));
296 }
297 public GroovyLexer(LexerSharedInputState state) {
298 super(state);
299 caseSensitiveLiterals = true;
300 setCaseSensitive(true);
301 literals = new Hashtable();
302 literals.put(new ANTLRHashString("byte", this), new Integer(101));
303 literals.put(new ANTLRHashString("public", this), new Integer(112));
304 literals.put(new ANTLRHashString("case", this), new Integer(148));
305 literals.put(new ANTLRHashString("short", this), new Integer(103));
306 literals.put(new ANTLRHashString("break", this), new Integer(142));
307 literals.put(new ANTLRHashString("while", this), new Integer(136));
308 literals.put(new ANTLRHashString("new", this), new Integer(192));
309 literals.put(new ANTLRHashString("instanceof", this), new Integer(178));
310 literals.put(new ANTLRHashString("implements", this), new Integer(128));
311 literals.put(new ANTLRHashString("synchronized", this), new Integer(117));
312 literals.put(new ANTLRHashString("const", this), new Integer(40));
313 literals.put(new ANTLRHashString("float", this), new Integer(105));
314 literals.put(new ANTLRHashString("package", this), new Integer(78));
315 literals.put(new ANTLRHashString("return", this), new Integer(141));
316 literals.put(new ANTLRHashString("throw", this), new Integer(144));
317 literals.put(new ANTLRHashString("null", this), new Integer(195));
318 literals.put(new ANTLRHashString("def", this), new Integer(81));
319 literals.put(new ANTLRHashString("threadsafe", this), new Integer(116));
320 literals.put(new ANTLRHashString("protected", this), new Integer(113));
321 literals.put(new ANTLRHashString("class", this), new Integer(88));
322 literals.put(new ANTLRHashString("throws", this), new Integer(127));
323 literals.put(new ANTLRHashString("do", this), new Integer(41));
324 literals.put(new ANTLRHashString("strictfp", this), new Integer(42));
325 literals.put(new ANTLRHashString("super", this), new Integer(93));
326 literals.put(new ANTLRHashString("with", this), new Integer(137));
327 literals.put(new ANTLRHashString("transient", this), new Integer(114));
328 literals.put(new ANTLRHashString("native", this), new Integer(115));
329 literals.put(new ANTLRHashString("interface", this), new Integer(89));
330 literals.put(new ANTLRHashString("final", this), new Integer(37));
331 literals.put(new ANTLRHashString("any", this), new Integer(108));
332 literals.put(new ANTLRHashString("if", this), new Integer(134));
333 literals.put(new ANTLRHashString("double", this), new Integer(107));
334 literals.put(new ANTLRHashString("volatile", this), new Integer(118));
335 literals.put(new ANTLRHashString("as", this), new Integer(110));
336 literals.put(new ANTLRHashString("assert", this), new Integer(145));
337 literals.put(new ANTLRHashString("catch", this), new Integer(151));
338 literals.put(new ANTLRHashString("try", this), new Integer(149));
339 literals.put(new ANTLRHashString("goto", this), new Integer(39));
340 literals.put(new ANTLRHashString("enum", this), new Integer(90));
341 literals.put(new ANTLRHashString("int", this), new Integer(104));
342 literals.put(new ANTLRHashString("for", this), new Integer(139));
343 literals.put(new ANTLRHashString("extends", this), new Integer(92));
344 literals.put(new ANTLRHashString("boolean", this), new Integer(100));
345 literals.put(new ANTLRHashString("char", this), new Integer(102));
346 literals.put(new ANTLRHashString("private", this), new Integer(111));
347 literals.put(new ANTLRHashString("default", this), new Integer(126));
348 literals.put(new ANTLRHashString("false", this), new Integer(194));
349 literals.put(new ANTLRHashString("this", this), new Integer(129));
350 literals.put(new ANTLRHashString("static", this), new Integer(80));
351 literals.put(new ANTLRHashString("abstract", this), new Integer(38));
352 literals.put(new ANTLRHashString("continue", this), new Integer(143));
353 literals.put(new ANTLRHashString("finally", this), new Integer(150));
354 literals.put(new ANTLRHashString("else", this), new Integer(135));
355 literals.put(new ANTLRHashString("import", this), new Integer(79));
356 literals.put(new ANTLRHashString("in", this), new Integer(140));
357 literals.put(new ANTLRHashString("void", this), new Integer(99));
358 literals.put(new ANTLRHashString("switch", this), new Integer(138));
359 literals.put(new ANTLRHashString("true", this), new Integer(193));
360 literals.put(new ANTLRHashString("long", this), new Integer(106));
361 }
362
363 public Token nextToken() throws TokenStreamException {
364 Token theRetToken=null;
365 tryAgain:
366 for (;;) {
367 Token _token = null;
368 int _ttype = Token.INVALID_TYPE;
369 resetText();
370 try {
371 try {
372 switch ( LA(1)) {
373 case '(':
374 {
375 mLPAREN(true);
376 theRetToken=_returnToken;
377 break;
378 }
379 case ')':
380 {
381 mRPAREN(true);
382 theRetToken=_returnToken;
383 break;
384 }
385 case '[':
386 {
387 mLBRACK(true);
388 theRetToken=_returnToken;
389 break;
390 }
391 case ']':
392 {
393 mRBRACK(true);
394 theRetToken=_returnToken;
395 break;
396 }
397 case '{':
398 {
399 mLCURLY(true);
400 theRetToken=_returnToken;
401 break;
402 }
403 case '}':
404 {
405 mRCURLY(true);
406 theRetToken=_returnToken;
407 break;
408 }
409 case ':':
410 {
411 mCOLON(true);
412 theRetToken=_returnToken;
413 break;
414 }
415 case ',':
416 {
417 mCOMMA(true);
418 theRetToken=_returnToken;
419 break;
420 }
421 case '~':
422 {
423 mBNOT(true);
424 theRetToken=_returnToken;
425 break;
426 }
427 case ';':
428 {
429 mSEMI(true);
430 theRetToken=_returnToken;
431 break;
432 }
433 case '$':
434 {
435 mDOLLAR(true);
436 theRetToken=_returnToken;
437 break;
438 }
439 case '\t': case '\u000c': case ' ': case '//':
440 {
441 mWS(true);
442 theRetToken=_returnToken;
443 break;
444 }
445 case '\n': case '\r':
446 {
447 mNLS(true);
448 theRetToken=_returnToken;
449 break;
450 }
451 case '"': case '\'':
452 {
453 mSTRING_LITERAL(true);
454 theRetToken=_returnToken;
455 break;
456 }
457 case '0': case '1': case '2': case '3':
458 case '4': case '5': case '6': case '7':
459 case '8': case '9':
460 {
461 mNUM_INT(true);
462 theRetToken=_returnToken;
463 break;
464 }
465 case '@':
466 {
467 mAT(true);
468 theRetToken=_returnToken;
469 break;
470 }
471 default:
472 if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (LA(4)=='=')) {
473 mBSR_ASSIGN(true);
474 theRetToken=_returnToken;
475 }
476 else if ((LA(1)=='<') && (LA(2)=='=') && (LA(3)=='>')) {
477 mCOMPARE_TO(true);
478 theRetToken=_returnToken;
479 }
480 else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='=')) {
481 mSR_ASSIGN(true);
482 theRetToken=_returnToken;
483 }
484 else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (true)) {
485 mBSR(true);
486 theRetToken=_returnToken;
487 }
488 else if ((LA(1)=='<') && (LA(2)=='<') && (LA(3)=='=')) {
489 mSL_ASSIGN(true);
490 theRetToken=_returnToken;
491 }
492 else if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='<')) {
493 mRANGE_EXCLUSIVE(true);
494 theRetToken=_returnToken;
495 }
496 else if ((LA(1)=='.') && (LA(2)=='.') && (LA(3)=='.')) {
497 mTRIPLE_DOT(true);
498 theRetToken=_returnToken;
499 }
500 else if ((LA(1)=='=') && (LA(2)=='=') && (LA(3)=='~')) {
501 mREGEX_MATCH(true);
502 theRetToken=_returnToken;
503 }
504 else if ((LA(1)=='*') && (LA(2)=='*') && (LA(3)=='=')) {
505 mSTAR_STAR_ASSIGN(true);
506 theRetToken=_returnToken;
507 }
508 else if ((LA(1)=='=') && (LA(2)=='=') && (true)) {
509 mEQUAL(true);
510 theRetToken=_returnToken;
511 }
512 else if ((LA(1)=='!') && (LA(2)=='=')) {
513 mNOT_EQUAL(true);
514 theRetToken=_returnToken;
515 }
516 else if ((LA(1)=='+') && (LA(2)=='=')) {
517 mPLUS_ASSIGN(true);
518 theRetToken=_returnToken;
519 }
520 else if ((LA(1)=='+') && (LA(2)=='+')) {
521 mINC(true);
522 theRetToken=_returnToken;
523 }
524 else if ((LA(1)=='-') && (LA(2)=='=')) {
525 mMINUS_ASSIGN(true);
526 theRetToken=_returnToken;
527 }
528 else if ((LA(1)=='-') && (LA(2)=='-')) {
529 mDEC(true);
530 theRetToken=_returnToken;
531 }
532 else if ((LA(1)=='*') && (LA(2)=='=')) {
533 mSTAR_ASSIGN(true);
534 theRetToken=_returnToken;
535 }
536 else if ((LA(1)=='%') && (LA(2)=='=')) {
537 mMOD_ASSIGN(true);
538 theRetToken=_returnToken;
539 }
540 else if ((LA(1)=='>') && (LA(2)=='>') && (true)) {
541 mSR(true);
542 theRetToken=_returnToken;
543 }
544 else if ((LA(1)=='>') && (LA(2)=='=')) {
545 mGE(true);
546 theRetToken=_returnToken;
547 }
548 else if ((LA(1)=='<') && (LA(2)=='<') && (true)) {
549 mSL(true);
550 theRetToken=_returnToken;
551 }
552 else if ((LA(1)=='<') && (LA(2)=='=') && (true)) {
553 mLE(true);
554 theRetToken=_returnToken;
555 }
556 else if ((LA(1)=='^') && (LA(2)=='=')) {
557 mBXOR_ASSIGN(true);
558 theRetToken=_returnToken;
559 }
560 else if ((LA(1)=='|') && (LA(2)=='=')) {
561 mBOR_ASSIGN(true);
562 theRetToken=_returnToken;
563 }
564 else if ((LA(1)=='|') && (LA(2)=='|')) {
565 mLOR(true);
566 theRetToken=_returnToken;
567 }
568 else if ((LA(1)=='&') && (LA(2)=='=')) {
569 mBAND_ASSIGN(true);
570 theRetToken=_returnToken;
571 }
572 else if ((LA(1)=='&') && (LA(2)=='&')) {
573 mLAND(true);
574 theRetToken=_returnToken;
575 }
576 else if ((LA(1)=='.') && (LA(2)=='.') && (true)) {
577 mRANGE_INCLUSIVE(true);
578 theRetToken=_returnToken;
579 }
580 else if ((LA(1)=='*') && (LA(2)=='.')) {
581 mSPREAD_DOT(true);
582 theRetToken=_returnToken;
583 }
584 else if ((LA(1)=='?') && (LA(2)=='.')) {
585 mOPTIONAL_DOT(true);
586 theRetToken=_returnToken;
587 }
588 else if ((LA(1)=='.') && (LA(2)=='&')) {
589 mMEMBER_POINTER(true);
590 theRetToken=_returnToken;
591 }
592 else if ((LA(1)=='=') && (LA(2)=='~')) {
593 mREGEX_FIND(true);
594 theRetToken=_returnToken;
595 }
596 else if ((LA(1)=='*') && (LA(2)=='*') && (true)) {
597 mSTAR_STAR(true);
598 theRetToken=_returnToken;
599 }
600 else if ((LA(1)=='-') && (LA(2)=='>')) {
601 mCLOSABLE_BLOCK_OP(true);
602 theRetToken=_returnToken;
603 }
604 else if ((LA(1)=='/') && (LA(2)=='/')) {
605 mSL_COMMENT(true);
606 theRetToken=_returnToken;
607 }
608 else if ((LA(1)=='/') && (LA(2)=='*')) {
609 mML_COMMENT(true);
610 theRetToken=_returnToken;
611 }
612 else if ((LA(1)=='?') && (true)) {
613 mQUESTION(true);
614 theRetToken=_returnToken;
615 }
616 else if ((LA(1)=='.') && (true)) {
617 mDOT(true);
618 theRetToken=_returnToken;
619 }
620 else if ((LA(1)=='=') && (true)) {
621 mASSIGN(true);
622 theRetToken=_returnToken;
623 }
624 else if ((LA(1)=='!') && (true)) {
625 mLNOT(true);
626 theRetToken=_returnToken;
627 }
628 else if ((LA(1)=='+') && (true)) {
629 mPLUS(true);
630 theRetToken=_returnToken;
631 }
632 else if ((LA(1)=='-') && (true)) {
633 mMINUS(true);
634 theRetToken=_returnToken;
635 }
636 else if ((LA(1)=='*') && (true)) {
637 mSTAR(true);
638 theRetToken=_returnToken;
639 }
640 else if ((LA(1)=='%') && (true)) {
641 mMOD(true);
642 theRetToken=_returnToken;
643 }
644 else if ((LA(1)=='>') && (true)) {
645 mGT(true);
646 theRetToken=_returnToken;
647 }
648 else if ((LA(1)=='<') && (true)) {
649 mLT(true);
650 theRetToken=_returnToken;
651 }
652 else if ((LA(1)=='^') && (true)) {
653 mBXOR(true);
654 theRetToken=_returnToken;
655 }
656 else if ((LA(1)=='|') && (true)) {
657 mBOR(true);
658 theRetToken=_returnToken;
659 }
660 else if ((LA(1)=='&') && (true)) {
661 mBAND(true);
662 theRetToken=_returnToken;
663 }
664 else if (((LA(1)=='#'))&&(getLine() == 1 && getColumn() == 1)) {
665 mSH_COMMENT(true);
666 theRetToken=_returnToken;
667 }
668 else if ((LA(1)=='/') && (true)) {
669 mREGEXP_LITERAL(true);
670 theRetToken=_returnToken;
671 }
672 else if ((_tokenSet_0.member(LA(1)))) {
673 mIDENT(true);
674 theRetToken=_returnToken;
675 }
676 else {
677 if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
678 else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
679 }
680 }
681 if ( _returnToken==null ) continue tryAgain;
682 _ttype = _returnToken.getType();
683 _returnToken.setType(_ttype);
684 return _returnToken;
685 }
686 catch (RecognitionException e) {
687 throw new TokenStreamRecognitionException(e);
688 }
689 }
690 catch (CharStreamException cse) {
691 if ( cse instanceof CharStreamIOException ) {
692 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
693 }
694 else {
695 throw new TokenStreamException(cse.getMessage());
696 }
697 }
698 }
699 }
700
701 public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
702 int _ttype; Token _token=null; int _begin=text.length();
703 _ttype = QUESTION;
704 int _saveIndex;
705
706 match('?');
707 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
708 _token = makeToken(_ttype);
709 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
710 }
711 _returnToken = _token;
712 }
713
714 public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
715 int _ttype; Token _token=null; int _begin=text.length();
716 _ttype = LPAREN;
717 int _saveIndex;
718
719 match('(');
720 if ( inputState.guessing==0 ) {
721 ++parenLevel;
722 }
723 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
724 _token = makeToken(_ttype);
725 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
726 }
727 _returnToken = _token;
728 }
729
730 public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
731 int _ttype; Token _token=null; int _begin=text.length();
732 _ttype = RPAREN;
733 int _saveIndex;
734
735 match(')');
736 if ( inputState.guessing==0 ) {
737 --parenLevel;
738 }
739 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
740 _token = makeToken(_ttype);
741 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
742 }
743 _returnToken = _token;
744 }
745
746 public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
747 int _ttype; Token _token=null; int _begin=text.length();
748 _ttype = LBRACK;
749 int _saveIndex;
750
751 match('[');
752 if ( inputState.guessing==0 ) {
753 ++parenLevel;
754 }
755 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
756 _token = makeToken(_ttype);
757 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
758 }
759 _returnToken = _token;
760 }
761
762 public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
763 int _ttype; Token _token=null; int _begin=text.length();
764 _ttype = RBRACK;
765 int _saveIndex;
766
767 match(']');
768 if ( inputState.guessing==0 ) {
769 --parenLevel;
770 }
771 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
772 _token = makeToken(_ttype);
773 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
774 }
775 _returnToken = _token;
776 }
777
778 public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
779 int _ttype; Token _token=null; int _begin=text.length();
780 _ttype = LCURLY;
781 int _saveIndex;
782
783 match('{');
784 if ( inputState.guessing==0 ) {
785 pushParenLevel();
786 }
787 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
788 _token = makeToken(_ttype);
789 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
790 }
791 _returnToken = _token;
792 }
793
794 public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
795 int _ttype; Token _token=null; int _begin=text.length();
796 _ttype = RCURLY;
797 int _saveIndex;
798
799 match('}');
800 if ( inputState.guessing==0 ) {
801 popParenLevel(); if(stringCtorState!=0) restartStringCtor(true);
802 }
803 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
804 _token = makeToken(_ttype);
805 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
806 }
807 _returnToken = _token;
808 }
809
810 public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
811 int _ttype; Token _token=null; int _begin=text.length();
812 _ttype = COLON;
813 int _saveIndex;
814
815 match(':');
816 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
817 _token = makeToken(_ttype);
818 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
819 }
820 _returnToken = _token;
821 }
822
823 public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
824 int _ttype; Token _token=null; int _begin=text.length();
825 _ttype = COMMA;
826 int _saveIndex;
827
828 match(',');
829 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
830 _token = makeToken(_ttype);
831 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
832 }
833 _returnToken = _token;
834 }
835
836 public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
837 int _ttype; Token _token=null; int _begin=text.length();
838 _ttype = DOT;
839 int _saveIndex;
840
841 match('.');
842 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
843 _token = makeToken(_ttype);
844 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
845 }
846 _returnToken = _token;
847 }
848
849 public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
850 int _ttype; Token _token=null; int _begin=text.length();
851 _ttype = ASSIGN;
852 int _saveIndex;
853
854 match('=');
855 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
856 _token = makeToken(_ttype);
857 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
858 }
859 _returnToken = _token;
860 }
861
862 public final void mCOMPARE_TO(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
863 int _ttype; Token _token=null; int _begin=text.length();
864 _ttype = COMPARE_TO;
865 int _saveIndex;
866
867 match("<=>");
868 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
869 _token = makeToken(_ttype);
870 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
871 }
872 _returnToken = _token;
873 }
874
875 public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
876 int _ttype; Token _token=null; int _begin=text.length();
877 _ttype = EQUAL;
878 int _saveIndex;
879
880 match("==");
881 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
882 _token = makeToken(_ttype);
883 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
884 }
885 _returnToken = _token;
886 }
887
888 public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
889 int _ttype; Token _token=null; int _begin=text.length();
890 _ttype = LNOT;
891 int _saveIndex;
892
893 match('!');
894 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
895 _token = makeToken(_ttype);
896 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
897 }
898 _returnToken = _token;
899 }
900
901 public final void mBNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
902 int _ttype; Token _token=null; int _begin=text.length();
903 _ttype = BNOT;
904 int _saveIndex;
905
906 match('~');
907 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
908 _token = makeToken(_ttype);
909 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
910 }
911 _returnToken = _token;
912 }
913
914 public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
915 int _ttype; Token _token=null; int _begin=text.length();
916 _ttype = NOT_EQUAL;
917 int _saveIndex;
918
919 match("!=");
920 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
921 _token = makeToken(_ttype);
922 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
923 }
924 _returnToken = _token;
925 }
926
927 protected final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
928 int _ttype; Token _token=null; int _begin=text.length();
929 _ttype = DIV;
930 int _saveIndex;
931
932 match('/');
933 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
934 _token = makeToken(_ttype);
935 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
936 }
937 _returnToken = _token;
938 }
939
940 protected final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
941 int _ttype; Token _token=null; int _begin=text.length();
942 _ttype = DIV_ASSIGN;
943 int _saveIndex;
944
945 match("/=");
946 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
947 _token = makeToken(_ttype);
948 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
949 }
950 _returnToken = _token;
951 }
952
953 public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
954 int _ttype; Token _token=null; int _begin=text.length();
955 _ttype = PLUS;
956 int _saveIndex;
957
958 match('+');
959 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
960 _token = makeToken(_ttype);
961 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
962 }
963 _returnToken = _token;
964 }
965
966 public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
967 int _ttype; Token _token=null; int _begin=text.length();
968 _ttype = PLUS_ASSIGN;
969 int _saveIndex;
970
971 match("+=");
972 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
973 _token = makeToken(_ttype);
974 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
975 }
976 _returnToken = _token;
977 }
978
979 public final void mINC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
980 int _ttype; Token _token=null; int _begin=text.length();
981 _ttype = INC;
982 int _saveIndex;
983
984 match("++");
985 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
986 _token = makeToken(_ttype);
987 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
988 }
989 _returnToken = _token;
990 }
991
992 public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
993 int _ttype; Token _token=null; int _begin=text.length();
994 _ttype = MINUS;
995 int _saveIndex;
996
997 match('-');
998 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
999 _token = makeToken(_ttype);
1000 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1001 }
1002 _returnToken = _token;
1003 }
1004
1005 public final void mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1006 int _ttype; Token _token=null; int _begin=text.length();
1007 _ttype = MINUS_ASSIGN;
1008 int _saveIndex;
1009
1010 match("-=");
1011 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1012 _token = makeToken(_ttype);
1013 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1014 }
1015 _returnToken = _token;
1016 }
1017
1018 public final void mDEC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1019 int _ttype; Token _token=null; int _begin=text.length();
1020 _ttype = DEC;
1021 int _saveIndex;
1022
1023 match("--");
1024 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1025 _token = makeToken(_ttype);
1026 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1027 }
1028 _returnToken = _token;
1029 }
1030
1031 public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1032 int _ttype; Token _token=null; int _begin=text.length();
1033 _ttype = STAR;
1034 int _saveIndex;
1035
1036 match('*');
1037 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1038 _token = makeToken(_ttype);
1039 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1040 }
1041 _returnToken = _token;
1042 }
1043
1044 public final void mSTAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1045 int _ttype; Token _token=null; int _begin=text.length();
1046 _ttype = STAR_ASSIGN;
1047 int _saveIndex;
1048
1049 match("*=");
1050 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1051 _token = makeToken(_ttype);
1052 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1053 }
1054 _returnToken = _token;
1055 }
1056
1057 public final void mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1058 int _ttype; Token _token=null; int _begin=text.length();
1059 _ttype = MOD;
1060 int _saveIndex;
1061
1062 match('%');
1063 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1064 _token = makeToken(_ttype);
1065 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1066 }
1067 _returnToken = _token;
1068 }
1069
1070 public final void mMOD_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1071 int _ttype; Token _token=null; int _begin=text.length();
1072 _ttype = MOD_ASSIGN;
1073 int _saveIndex;
1074
1075 match("%=");
1076 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1077 _token = makeToken(_ttype);
1078 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1079 }
1080 _returnToken = _token;
1081 }
1082
1083 public final void mSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1084 int _ttype; Token _token=null; int _begin=text.length();
1085 _ttype = SR;
1086 int _saveIndex;
1087
1088 match(">>");
1089 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1090 _token = makeToken(_ttype);
1091 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1092 }
1093 _returnToken = _token;
1094 }
1095
1096 public final void mSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1097 int _ttype; Token _token=null; int _begin=text.length();
1098 _ttype = SR_ASSIGN;
1099 int _saveIndex;
1100
1101 match(">>=");
1102 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1103 _token = makeToken(_ttype);
1104 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1105 }
1106 _returnToken = _token;
1107 }
1108
1109 public final void mBSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1110 int _ttype; Token _token=null; int _begin=text.length();
1111 _ttype = BSR;
1112 int _saveIndex;
1113
1114 match(">>>");
1115 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1116 _token = makeToken(_ttype);
1117 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1118 }
1119 _returnToken = _token;
1120 }
1121
1122 public final void mBSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1123 int _ttype; Token _token=null; int _begin=text.length();
1124 _ttype = BSR_ASSIGN;
1125 int _saveIndex;
1126
1127 match(">>>=");
1128 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1129 _token = makeToken(_ttype);
1130 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1131 }
1132 _returnToken = _token;
1133 }
1134
1135 public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1136 int _ttype; Token _token=null; int _begin=text.length();
1137 _ttype = GE;
1138 int _saveIndex;
1139
1140 match(">=");
1141 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1142 _token = makeToken(_ttype);
1143 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1144 }
1145 _returnToken = _token;
1146 }
1147
1148 public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1149 int _ttype; Token _token=null; int _begin=text.length();
1150 _ttype = GT;
1151 int _saveIndex;
1152
1153 match(">");
1154 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1155 _token = makeToken(_ttype);
1156 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1157 }
1158 _returnToken = _token;
1159 }
1160
1161 public final void mSL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1162 int _ttype; Token _token=null; int _begin=text.length();
1163 _ttype = SL;
1164 int _saveIndex;
1165
1166 match("<<");
1167 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1168 _token = makeToken(_ttype);
1169 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1170 }
1171 _returnToken = _token;
1172 }
1173
1174 public final void mSL_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1175 int _ttype; Token _token=null; int _begin=text.length();
1176 _ttype = SL_ASSIGN;
1177 int _saveIndex;
1178
1179 match("<<=");
1180 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1181 _token = makeToken(_ttype);
1182 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1183 }
1184 _returnToken = _token;
1185 }
1186
1187 public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1188 int _ttype; Token _token=null; int _begin=text.length();
1189 _ttype = LE;
1190 int _saveIndex;
1191
1192 match("<=");
1193 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1194 _token = makeToken(_ttype);
1195 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1196 }
1197 _returnToken = _token;
1198 }
1199
1200 public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1201 int _ttype; Token _token=null; int _begin=text.length();
1202 _ttype = LT;
1203 int _saveIndex;
1204
1205 match('<');
1206 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1207 _token = makeToken(_ttype);
1208 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1209 }
1210 _returnToken = _token;
1211 }
1212
1213 public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1214 int _ttype; Token _token=null; int _begin=text.length();
1215 _ttype = BXOR;
1216 int _saveIndex;
1217
1218 match('^');
1219 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1220 _token = makeToken(_ttype);
1221 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1222 }
1223 _returnToken = _token;
1224 }
1225
1226 public final void mBXOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1227 int _ttype; Token _token=null; int _begin=text.length();
1228 _ttype = BXOR_ASSIGN;
1229 int _saveIndex;
1230
1231 match("^=");
1232 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1233 _token = makeToken(_ttype);
1234 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1235 }
1236 _returnToken = _token;
1237 }
1238
1239 public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1240 int _ttype; Token _token=null; int _begin=text.length();
1241 _ttype = BOR;
1242 int _saveIndex;
1243
1244 match('|');
1245 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1246 _token = makeToken(_ttype);
1247 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1248 }
1249 _returnToken = _token;
1250 }
1251
1252 public final void mBOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1253 int _ttype; Token _token=null; int _begin=text.length();
1254 _ttype = BOR_ASSIGN;
1255 int _saveIndex;
1256
1257 match("|=");
1258 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1259 _token = makeToken(_ttype);
1260 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1261 }
1262 _returnToken = _token;
1263 }
1264
1265 public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1266 int _ttype; Token _token=null; int _begin=text.length();
1267 _ttype = LOR;
1268 int _saveIndex;
1269
1270 match("||");
1271 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1272 _token = makeToken(_ttype);
1273 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1274 }
1275 _returnToken = _token;
1276 }
1277
1278 public final void mBAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1279 int _ttype; Token _token=null; int _begin=text.length();
1280 _ttype = BAND;
1281 int _saveIndex;
1282
1283 match('&');
1284 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1285 _token = makeToken(_ttype);
1286 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1287 }
1288 _returnToken = _token;
1289 }
1290
1291 public final void mBAND_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1292 int _ttype; Token _token=null; int _begin=text.length();
1293 _ttype = BAND_ASSIGN;
1294 int _saveIndex;
1295
1296 match("&=");
1297 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1298 _token = makeToken(_ttype);
1299 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1300 }
1301 _returnToken = _token;
1302 }
1303
1304 public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1305 int _ttype; Token _token=null; int _begin=text.length();
1306 _ttype = LAND;
1307 int _saveIndex;
1308
1309 match("&&");
1310 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1311 _token = makeToken(_ttype);
1312 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1313 }
1314 _returnToken = _token;
1315 }
1316
1317 public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1318 int _ttype; Token _token=null; int _begin=text.length();
1319 _ttype = SEMI;
1320 int _saveIndex;
1321
1322 match(';');
1323 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1324 _token = makeToken(_ttype);
1325 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1326 }
1327 _returnToken = _token;
1328 }
1329
1330 public final void mDOLLAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1331 int _ttype; Token _token=null; int _begin=text.length();
1332 _ttype = DOLLAR;
1333 int _saveIndex;
1334
1335 match('$');
1336 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1337 _token = makeToken(_ttype);
1338 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1339 }
1340 _returnToken = _token;
1341 }
1342
1343 public final void mRANGE_INCLUSIVE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1344 int _ttype; Token _token=null; int _begin=text.length();
1345 _ttype = RANGE_INCLUSIVE;
1346 int _saveIndex;
1347
1348 match("..");
1349 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1350 _token = makeToken(_ttype);
1351 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1352 }
1353 _returnToken = _token;
1354 }
1355
1356 public final void mRANGE_EXCLUSIVE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1357 int _ttype; Token _token=null; int _begin=text.length();
1358 _ttype = RANGE_EXCLUSIVE;
1359 int _saveIndex;
1360
1361 match("..<");
1362 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1363 _token = makeToken(_ttype);
1364 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1365 }
1366 _returnToken = _token;
1367 }
1368
1369 public final void mTRIPLE_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1370 int _ttype; Token _token=null; int _begin=text.length();
1371 _ttype = TRIPLE_DOT;
1372 int _saveIndex;
1373
1374 match("...");
1375 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1376 _token = makeToken(_ttype);
1377 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1378 }
1379 _returnToken = _token;
1380 }
1381
1382 public final void mSPREAD_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1383 int _ttype; Token _token=null; int _begin=text.length();
1384 _ttype = SPREAD_DOT;
1385 int _saveIndex;
1386
1387 match("*.");
1388 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1389 _token = makeToken(_ttype);
1390 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1391 }
1392 _returnToken = _token;
1393 }
1394
1395 public final void mOPTIONAL_DOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1396 int _ttype; Token _token=null; int _begin=text.length();
1397 _ttype = OPTIONAL_DOT;
1398 int _saveIndex;
1399
1400 match("?.");
1401 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1402 _token = makeToken(_ttype);
1403 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1404 }
1405 _returnToken = _token;
1406 }
1407
1408 public final void mMEMBER_POINTER(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1409 int _ttype; Token _token=null; int _begin=text.length();
1410 _ttype = MEMBER_POINTER;
1411 int _saveIndex;
1412
1413 match(".&");
1414 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1415 _token = makeToken(_ttype);
1416 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1417 }
1418 _returnToken = _token;
1419 }
1420
1421 public final void mREGEX_FIND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1422 int _ttype; Token _token=null; int _begin=text.length();
1423 _ttype = REGEX_FIND;
1424 int _saveIndex;
1425
1426 match("=~");
1427 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1428 _token = makeToken(_ttype);
1429 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1430 }
1431 _returnToken = _token;
1432 }
1433
1434 public final void mREGEX_MATCH(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1435 int _ttype; Token _token=null; int _begin=text.length();
1436 _ttype = REGEX_MATCH;
1437 int _saveIndex;
1438
1439 match("==~");
1440 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
1441 _token = makeToken(_ttype);
1442 _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
1443 }
1444 _returnToken = _token;
1445 }
1446
1447 public final void mSTAR_STAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
1448 int _ttype; Token _token=null; int _begin=text.length();
1449 _ttype = STAR_STAR;
1450 int _saveIndex;
1451
1452 match("**");
1453 if ( _createTo