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