?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update changes.
[castle.git] / Experiments / Rook / Castle.Rook / RookLexer.cs
blob910450c605abd25a984b4a32eee949c4e47adad5
1 // $ANTLR 2.7.5 (20050128): "lang.g" -> "RookLexer.cs"$
2
3 // using CommonAST = antlr.CommonAST;
4 using System.Text;
5 using System.Collections;
6 using Castle.Rook.AST;
7
8 namespace Castle.Rook.Parse
9 {
10 // Generate header specific to lexer CSharp file
11 using System;
12 using Stream = System.IO.Stream;
13 using TextReader = System.IO.TextReader;
14 using Hashtable = System.Collections.Hashtable;
15 using Comparer = System.Collections.Comparer;
16
17 using TokenStreamException = antlr.TokenStreamException;
18 using TokenStreamIOException = antlr.TokenStreamIOException;
19 using TokenStreamRecognitionException = antlr.TokenStreamRecognitionException;
20 using CharStreamException = antlr.CharStreamException;
21 using CharStreamIOException = antlr.CharStreamIOException;
22 using ANTLRException = antlr.ANTLRException;
23 using CharScanner = antlr.CharScanner;
24 using InputBuffer = antlr.InputBuffer;
25 using ByteBuffer = antlr.ByteBuffer;
26 using CharBuffer = antlr.CharBuffer;
27 using Token = antlr.Token;
28 using IToken = antlr.IToken;
29 using CommonToken = antlr.CommonToken;
30 using SemanticException = antlr.SemanticException;
31 using RecognitionException = antlr.RecognitionException;
32 using NoViableAltForCharException = antlr.NoViableAltForCharException;
33 using MismatchedCharException = antlr.MismatchedCharException;
34 using TokenStream = antlr.TokenStream;
35 using LexerSharedInputState = antlr.LexerSharedInputState;
36 using BitSet = antlr.collections.impl.BitSet;
37
38 public class RookLexer : antlr.CharScanner , TokenStream
39 {
40 public const int EOF = 1;
41 public const int NULL_TREE_LOOKAHEAD = 3;
42 public const int CLASS_DEF = 4;
43 public const int MIXIN_DEF = 5;
44 public const int NAMESPACE = 6;
45 public const int INTERFACE = 7;
46 public const int INIT = 8;
47 public const int INIT2 = 9;
48 public const int END = 10;
49 public const int DEF = 11;
50 public const int ATTR = 12;
51 public const int GET = 13;
52 public const int SET = 14;
53 public const int INC = 15;
54 public const int DEC = 16;
55 public const int SELF = 17;
56 public const int BASE = 18;
57 public const int COLON = 19;
58 public const int DO = 20;
59 public const int EOS = 21;
60 public const int LESSTHAN = 22;
61 public const int COMMA = 23;
62 public const int LITERAL_public = 24;
63 public const int LITERAL_private = 25;
64 public const int LITERAL_protected = 26;
65 public const int LITERAL_internal = 27;
66 public const int IDENTIFIER = 28;
67 public const int DOT = 29;
68 public const int SEMI = 30;
69 public const int LPAREN = 31;
70 public const int RPAREN = 32;
71 public const int REF = 33;
72 public const int OUT = 34;
73 public const int STATIC_IDENTIFIER = 35;
74 public const int INSTANCE_IDENTIFIER = 36;
75 public const int ASSIGN = 37;
76 public const int INTEGER_LITERAL = 38;
77 public const int LBRACK = 39;
78 public const int RBRACK = 40;
79 public const int LCURLY = 41;
80 public const int RCURLY = 42;
81 public const int NEW_LINE = 43;
82 public const int NEW_LINE_CHARACTER = 44;
83 public const int NOT_NEW_LINE = 45;
84 public const int WHITESPACE = 46;
85 public const int SINGLE_LINE_COMMENT = 47;
86 public const int IDENTIFIER_START_CHARACTER = 48;
87 public const int IDENTIFIER_PART_CHARACTER = 49;
88 public const int NUMERIC_LITERAL = 50;
89 public const int DECIMAL_DIGIT = 51;
90
91 public RookLexer(Stream ins) : this(new ByteBuffer(ins))
92 {
93 }
94
95 public RookLexer(TextReader r) : this(new CharBuffer(r))
96 {
97 }
98
99 public RookLexer(InputBuffer ib) : this(new LexerSharedInputState(ib))
100 {
101 }
102
103 public RookLexer(LexerSharedInputState state) : base(state)
104 {
105 initialize();
106 }
107 private void initialize()
108 {
109 caseSensitiveLiterals = true;
110 setCaseSensitive(true);
111 literals = new Hashtable(100, (float) 0.4, null, Comparer.Default);
112 literals.Add("public", 24);
113 literals.Add("get", 13);
114 literals.Add("class", 4);
115 literals.Add("initialize", 8);
116 literals.Add("self", 17);
117 literals.Add("def", 11);
118 literals.Add("end", 10);
119 literals.Add("mixin", 5);
120 literals.Add("private", 25);
121 literals.Add("namespace", 6);
122 literals.Add("++", 15);
123 literals.Add("init", 9);
124 literals.Add("protected", 26);
125 literals.Add("attr", 12);
126 literals.Add("--", 16);
127 literals.Add(":", 19);
128 literals.Add("interface", 7);
129 literals.Add("do", 20);
130 literals.Add("base", 18);
131 literals.Add("internal", 27);
132 literals.Add("set", 14);
133 }
134
135 override public IToken nextToken() //throws TokenStreamException
136 {
137 IToken theRetToken = null;
138 tryAgain:
139 for (;;)
140 {
141 IToken _token = null;
142 int _ttype = Token.INVALID_TYPE;
143 setCommitToPath(false);
144 resetText();
145 try // for char stream error handling
146 {
147 try // for lexical error handling
148 {
149 switch ( cached_LA1 )
150 {
151 case '=':
152 {
153 mASSIGN(true);
154 theRetToken = returnToken_;
155 break;
156 }
157 case ';':
158 {
159 mSEMI(true);
160 theRetToken = returnToken_;
161 break;
162 }
163 case ',':
164 {
165 mCOMMA(true);
166 theRetToken = returnToken_;
167 break;
168 }
169 case '(':
170 {
171 mLPAREN(true);
172 theRetToken = returnToken_;
173 break;
174 }
175 case ')':
176 {
177 mRPAREN(true);
178 theRetToken = returnToken_;
179 break;
180 }
181 case '[':
182 {
183 mLBRACK(true);
184 theRetToken = returnToken_;
185 break;
186 }
187 case ']':
188 {
189 mRBRACK(true);
190 theRetToken = returnToken_;
191 break;
192 }
193 case '{':
194 {
195 mLCURLY(true);
196 theRetToken = returnToken_;
197 break;
198 }
199 case '}':
200 {
201 mRCURLY(true);
202 theRetToken = returnToken_;
203 break;
204 }
205 case ':':
206 {
207 mCOLON(true);
208 theRetToken = returnToken_;
209 break;
210 }
211 case '.':
212 {
213 mDOT(true);
214 theRetToken = returnToken_;
215 break;
216 }
217 case '<':
218 {
219 mLESSTHAN(true);
220 theRetToken = returnToken_;
221 break;
222 }
223 case '\t': case '\n': case '\u000b': case '\u000c':
224 case '\r': case ' ': case '\u2028': case '\u2029':
225 {
226 mWHITESPACE(true);
227 theRetToken = returnToken_;
228 break;
229 }
230 case '#':
231 {
232 mSINGLE_LINE_COMMENT(true);
233 theRetToken = returnToken_;
234 break;
235 }
236 case '$': case 'A': case 'B': case 'C':
237 case 'D': case 'E': case 'F': case 'G':
238 case 'H': case 'I': case 'J': case 'K':
239 case 'L': case 'M': case 'N': case 'O':
240 case 'P': case 'Q': case 'R': case 'S':
241 case 'T': case 'U': case 'V': case 'W':
242 case 'X': case 'Y': case 'Z': case '_':
243 case 'a': case 'b': case 'c': case 'd':
244 case 'e': case 'f': case 'g': case 'h':
245 case 'i': case 'j': case 'k': case 'l':
246 case 'm': case 'n': case 'o': case 'p':
247 case 'q': case 'r': case 's': case 't':
248 case 'u': case 'v': case 'w': case 'x':
249 case 'y': case 'z':
250 {
251 mIDENTIFIER(true);
252 theRetToken = returnToken_;
253 break;
254 }
255 case '0': case '1': case '2': case '3':
256 case '4': case '5': case '6': case '7':
257 case '8': case '9':
258 {
259 mNUMERIC_LITERAL(true);
260 theRetToken = returnToken_;
261 break;
262 }
263 default:
264 if ((cached_LA1=='@') && (cached_LA2=='@'))
265 {
266 mSTATIC_IDENTIFIER(true);
267 theRetToken = returnToken_;
268 }
269 else if ((cached_LA1=='@') && (tokenSet_0_.member(cached_LA2))) {
270 mINSTANCE_IDENTIFIER(true);
271 theRetToken = returnToken_;
272 }
273 else
274 {
275 if (cached_LA1==EOF_CHAR) { uponEOF(); returnToken_ = makeToken(Token.EOF_TYPE); }
276 else { consume(); goto tryAgain; }
277 }
278 break; }
279 if ( null==returnToken_ ) goto tryAgain; // found SKIP token
280 _ttype = returnToken_.Type;
281 returnToken_.Type = _ttype;
282 return returnToken_;
283 }
284 catch (RecognitionException e) {
285 if (!getCommitToPath())
286 {
287 consume();
288 goto tryAgain;
289 }
290 throw new TokenStreamRecognitionException(e);
291 }
292 }
293 catch (CharStreamException cse) {
294 if ( cse is CharStreamIOException ) {
295 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
296 }
297 else {
298 throw new TokenStreamException(cse.Message);
299 }
300 }
301 }
302 }
303
304 public void mASSIGN(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
305 {
306 int _ttype; IToken _token=null; int _begin=text.Length;
307 _ttype = ASSIGN;
308
309 match('=');
310 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
311 {
312 _token = makeToken(_ttype);
313 _token.setText(text.ToString(_begin, text.Length-_begin));
314 }
315 returnToken_ = _token;
316 }
317
318 public void mSEMI(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
319 {
320 int _ttype; IToken _token=null; int _begin=text.Length;
321 _ttype = SEMI;
322
323 match(';');
324 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
325 {
326 _token = makeToken(_ttype);
327 _token.setText(text.ToString(_begin, text.Length-_begin));
328 }
329 returnToken_ = _token;
330 }
331
332 public void mCOMMA(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
333 {
334 int _ttype; IToken _token=null; int _begin=text.Length;
335 _ttype = COMMA;
336
337 match(',');
338 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
339 {
340 _token = makeToken(_ttype);
341 _token.setText(text.ToString(_begin, text.Length-_begin));
342 }
343 returnToken_ = _token;
344 }
345
346 public void mLPAREN(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
347 {
348 int _ttype; IToken _token=null; int _begin=text.Length;
349 _ttype = LPAREN;
350
351 match('(');
352 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
353 {
354 _token = makeToken(_ttype);
355 _token.setText(text.ToString(_begin, text.Length-_begin));
356 }
357 returnToken_ = _token;
358 }
359
360 public void mRPAREN(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
361 {
362 int _ttype; IToken _token=null; int _begin=text.Length;
363 _ttype = RPAREN;
364
365 match(')');
366 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
367 {
368 _token = makeToken(_ttype);
369 _token.setText(text.ToString(_begin, text.Length-_begin));
370 }
371 returnToken_ = _token;
372 }
373
374 public void mLBRACK(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
375 {
376 int _ttype; IToken _token=null; int _begin=text.Length;
377 _ttype = LBRACK;
378
379 match('[');
380 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
381 {
382 _token = makeToken(_ttype);
383 _token.setText(text.ToString(_begin, text.Length-_begin));
384 }
385 returnToken_ = _token;
386 }
387
388 public void mRBRACK(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
389 {
390 int _ttype; IToken _token=null; int _begin=text.Length;
391 _ttype = RBRACK;
392
393 match(']');
394 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
395 {
396 _token = makeToken(_ttype);
397 _token.setText(text.ToString(_begin, text.Length-_begin));
398 }
399 returnToken_ = _token;
400 }
401
402 public void mLCURLY(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
403 {
404 int _ttype; IToken _token=null; int _begin=text.Length;
405 _ttype = LCURLY;
406
407 match('{');
408 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
409 {
410 _token = makeToken(_ttype);
411 _token.setText(text.ToString(_begin, text.Length-_begin));
412 }
413 returnToken_ = _token;
414 }
415
416 public void mRCURLY(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
417 {
418 int _ttype; IToken _token=null; int _begin=text.Length;
419 _ttype = RCURLY;
420
421 match('}');
422 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
423 {
424 _token = makeToken(_ttype);
425 _token.setText(text.ToString(_begin, text.Length-_begin));
426 }
427 returnToken_ = _token;
428 }
429
430 public void mCOLON(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
431 {
432 int _ttype; IToken _token=null; int _begin=text.Length;
433 _ttype = COLON;
434
435 match(':');
436 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
437 {
438 _token = makeToken(_ttype);
439 _token.setText(text.ToString(_begin, text.Length-_begin));
440 }
441 returnToken_ = _token;
442 }
443
444 public void mDOT(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
445 {
446 int _ttype; IToken _token=null; int _begin=text.Length;
447 _ttype = DOT;
448
449 match('.');
450 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
451 {
452 _token = makeToken(_ttype);
453 _token.setText(text.ToString(_begin, text.Length-_begin));
454 }
455 returnToken_ = _token;
456 }
457
458 public void mLESSTHAN(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
459 {
460 int _ttype; IToken _token=null; int _begin=text.Length;
461 _ttype = LESSTHAN;
462
463 match('<');
464 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
465 {
466 _token = makeToken(_ttype);
467 _token.setText(text.ToString(_begin, text.Length-_begin));
468 }
469 returnToken_ = _token;
470 }
471
472 protected void mNEW_LINE(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
473 {
474 int _ttype; IToken _token=null; int _begin=text.Length;
475 _ttype = NEW_LINE;
476
477 {
478 switch ( cached_LA1 )
479 {
480 case '\n':
481 {
482 match('\u000A');
483 break;
484 }
485 case '\u2028':
486 {
487 match('\u2028');
488 break;
489 }
490 case '\u2029':
491 {
492 match('\u2029');
493 break;
494 }
495 default:
496 if (((cached_LA1=='\r') && (cached_LA2=='\n') && (true) && (true))&&( LA(2)=='\u000A' ))
497 {
498 match('\u000D');
499 match('\u000A');
500 }
501 else if ((cached_LA1=='\r') && (true) && (true) && (true)) {
502 match('\u000D');
503 }
504 else
505 {
506 throw new NoViableAltForCharException(cached_LA1, getFilename(), getLine(), getColumn());
507 }
508 break; }
509 }
510 newline();
511 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
512 {
513 _token = makeToken(_ttype);
514 _token.setText(text.ToString(_begin, text.Length-_begin));
515 }
516 returnToken_ = _token;
517 }
518
519 protected void mNEW_LINE_CHARACTER(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
520 {
521 int _ttype; IToken _token=null; int _begin=text.Length;
522 _ttype = NEW_LINE_CHARACTER;
523
524 {
525 switch ( cached_LA1 )
526 {
527 case '\r':
528 {
529 match('\u000D');
530 break;
531 }
532 case '\n':
533 {
534 match('\u000A');
535 break;
536 }
537 case '\u2028':
538 {
539 match('\u2028');
540 break;
541 }
542 case '\u2029':
543 {
544 match('\u2029');
545 break;
546 }
547 default:
548 {
549 throw new NoViableAltForCharException(cached_LA1, getFilename(), getLine(), getColumn());
550 }
551 }
552 }
553 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
554 {
555 _token = makeToken(_ttype);
556 _token.setText(text.ToString(_begin, text.Length-_begin));
557 }
558 returnToken_ = _token;
559 }
560
561 protected void mNOT_NEW_LINE(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
562 {
563 int _ttype; IToken _token=null; int _begin=text.Length;
564 _ttype = NOT_NEW_LINE;
565
566 {
567 match(tokenSet_1_);
568 }
569 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
570 {
571 _token = makeToken(_ttype);
572 _token.setText(text.ToString(_begin, text.Length-_begin));
573 }
574 returnToken_ = _token;
575 }
576
577 public void mWHITESPACE(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
578 {
579 int _ttype; IToken _token=null; int _begin=text.Length;
580 _ttype = WHITESPACE;
581
582 { // ( ... )+
583 int _cnt94=0;
584 for (;;)
585 {
586 switch ( cached_LA1 )
587 {
588 case ' ':
589 {
590 match(' ');
591 break;
592 }
593 case '\t':
594 {
595 match('\u0009');
596 break;
597 }
598 case '\u000b':
599 {
600 match('\u000B');
601 break;
602 }
603 case '\u000c':
604 {
605 match('\u000C');
606 break;
607 }
608 case '\n': case '\r': case '\u2028': case '\u2029':
609 {
610 mNEW_LINE(false);
611 break;
612 }
613 default:
614 {
615 if (_cnt94 >= 1) { goto _loop94_breakloop; } else { throw new NoViableAltForCharException(cached_LA1, getFilename(), getLine(), getColumn());; }
616 }
617 break; }
618 _cnt94++;
619 }
620 _loop94_breakloop: ;
621 } // ( ... )+
622 _ttype = Token.SKIP;
623 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
624 {
625 _token = makeToken(_ttype);
626 _token.setText(text.ToString(_begin, text.Length-_begin));
627 }
628 returnToken_ = _token;
629 }
630
631 public void mSINGLE_LINE_COMMENT(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
632 {
633 int _ttype; IToken _token=null; int _begin=text.Length;
634 _ttype = SINGLE_LINE_COMMENT;
635
636 match("#");
637 { // ( ... )*
638 for (;;)
639 {
640 if ((tokenSet_1_.member(cached_LA1)))
641 {
642 mNOT_NEW_LINE(false);
643 }
644 else
645 {
646 goto _loop97_breakloop;
647 }
648
649 }
650 _loop97_breakloop: ;
651 } // ( ... )*
652 {
653 if ((tokenSet_2_.member(cached_LA1)))
654 {
655 mNEW_LINE(false);
656 }
657 else {
658 }
659
660 }
661 _ttype = Token.SKIP;
662 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
663 {
664 _token = makeToken(_ttype);
665 _token.setText(text.ToString(_begin, text.Length-_begin));
666 }
667 returnToken_ = _token;
668 }
669
670 public void mIDENTIFIER(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
671 {
672 int _ttype; IToken _token=null; int _begin=text.Length;
673 _ttype = IDENTIFIER;
674
675 mIDENTIFIER_START_CHARACTER(false);
676 { // ( ... )*
677 for (;;)
678 {
679 if ((tokenSet_3_.member(cached_LA1)))
680 {
681 mIDENTIFIER_PART_CHARACTER(false);
682 }
683 else
684 {
685 goto _loop101_breakloop;
686 }
687
688 }
689 _loop101_breakloop: ;
690 } // ( ... )*
691 _ttype = testLiteralsTable(_ttype);
692 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
693 {
694 _token = makeToken(_ttype);
695 _token.setText(text.ToString(_begin, text.Length-_begin));
696 }
697 returnToken_ = _token;
698 }
699
700 protected void mIDENTIFIER_START_CHARACTER(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
701 {
702 int _ttype; IToken _token=null; int _begin=text.Length;
703 _ttype = IDENTIFIER_START_CHARACTER;
704
705 {
706 switch ( cached_LA1 )
707 {
708 case 'a': case 'b': case 'c': case 'd':
709 case 'e': case 'f': case 'g': case 'h':
710 case 'i': case 'j': case 'k': case 'l':
711 case 'm': case 'n': case 'o': case 'p':
712 case 'q': case 'r': case 's': case 't':
713 case 'u': case 'v': case 'w': case 'x':
714 case 'y': case 'z':
715 {
716 matchRange('a','z');
717 break;
718 }
719 case 'A': case 'B': case 'C': case 'D':
720 case 'E': case 'F': case 'G': case 'H':
721 case 'I': case 'J': case 'K': case 'L':
722 case 'M': case 'N': case 'O': case 'P':
723 case 'Q': case 'R': case 'S': case 'T':
724 case 'U': case 'V': case 'W': case 'X':
725 case 'Y': case 'Z':
726 {
727 matchRange('A','Z');
728 break;
729 }
730 case '_':
731 {
732 match('_');
733 break;
734 }
735 case '$':
736 {
737 match('$');
738 break;
739 }
740 default:
741 {
742 throw new NoViableAltForCharException(cached_LA1, getFilename(), getLine(), getColumn());
743 }
744 }
745 }
746 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
747 {
748 _token = makeToken(_ttype);
749 _token.setText(text.ToString(_begin, text.Length-_begin));
750 }
751 returnToken_ = _token;
752 }
753
754 protected void mIDENTIFIER_PART_CHARACTER(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
755 {
756 int _ttype; IToken _token=null; int _begin=text.Length;
757 _ttype = IDENTIFIER_PART_CHARACTER;
758
759 {
760 switch ( cached_LA1 )
761 {
762 case 'a': case 'b': case 'c': case 'd':
763 case 'e': case 'f': case 'g': case 'h':
764 case 'i': case 'j': case 'k': case 'l':
765 case 'm': case 'n': case 'o': case 'p':
766 case 'q': case 'r': case 's': case 't':
767 case 'u': case 'v': case 'w': case 'x':
768 case 'y': case 'z':
769 {
770 matchRange('a','z');
771 break;
772 }
773 case 'A': case 'B': case 'C': case 'D':
774 case 'E': case 'F': case 'G': case 'H':
775 case 'I': case 'J': case 'K': case 'L':
776 case 'M': case 'N': case 'O': case 'P':
777 case 'Q': case 'R': case 'S': case 'T':
778 case 'U': case 'V': case 'W': case 'X':
779 case 'Y': case 'Z':
780 {
781 matchRange('A','Z');
782 break;
783 }
784 case '_':
785 {
786 match('_');
787 break;
788 }
789 case '0': case '1': case '2': case '3':
790 case '4': case '5': case '6': case '7':
791 case '8': case '9':
792 {
793 matchRange('0','9');
794 break;
795 }
796 default:
797 {
798 throw new NoViableAltForCharException(cached_LA1, getFilename(), getLine(), getColumn());
799 }
800 }
801 }
802 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
803 {
804 _token = makeToken(_ttype);
805 _token.setText(text.ToString(_begin, text.Length-_begin));
806 }
807 returnToken_ = _token;
808 }
809
810 public void mSTATIC_IDENTIFIER(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
811 {
812 int _ttype; IToken _token=null; int _begin=text.Length;
813 _ttype = STATIC_IDENTIFIER;
814
815 match("@@");
816 mIDENTIFIER_START_CHARACTER(false);
817 { // ( ... )*
818 for (;;)
819 {
820 if ((tokenSet_3_.member(cached_LA1)))
821 {
822 mIDENTIFIER_PART_CHARACTER(false);
823 }
824 else
825 {
826 goto _loop108_breakloop;
827 }
828
829 }
830 _loop108_breakloop: ;
831 } // ( ... )*
832 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
833 {
834 _token = makeToken(_ttype);
835 _token.setText(text.ToString(_begin, text.Length-_begin));
836 }
837 returnToken_ = _token;
838 }
839
840 public void mINSTANCE_IDENTIFIER(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
841 {
842 int _ttype; IToken _token=null; int _begin=text.Length;
843 _ttype = INSTANCE_IDENTIFIER;
844
845 match("@");
846 mIDENTIFIER_START_CHARACTER(false);
847 { // ( ... )*
848 for (;;)
849 {
850 if ((tokenSet_3_.member(cached_LA1)))
851 {
852 mIDENTIFIER_PART_CHARACTER(false);
853 }
854 else
855 {
856 goto _loop111_breakloop;
857 }
858
859 }
860 _loop111_breakloop: ;
861 } // ( ... )*
862 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
863 {
864 _token = makeToken(_ttype);
865 _token.setText(text.ToString(_begin, text.Length-_begin));
866 }
867 returnToken_ = _token;
868 }
869
870 public void mNUMERIC_LITERAL(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
871 {
872 int _ttype; IToken _token=null; int _begin=text.Length;
873 _ttype = NUMERIC_LITERAL;
874
875 { // ( ... )+
876 int _cnt114=0;
877 for (;;)
878 {
879 if (((cached_LA1 >= '0' && cached_LA1 <= '9')))
880 {
881 mDECIMAL_DIGIT(false);
882 }
883 else
884 {
885 if (_cnt114 >= 1) { goto _loop114_breakloop; } else { throw new NoViableAltForCharException(cached_LA1, getFilename(), getLine(), getColumn());; }
886 }
887
888 _cnt114++;
889 }
890 _loop114_breakloop: ;
891 } // ( ... )+
892
893 _ttype = INTEGER_LITERAL;
894
895 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
896 {
897 _token = makeToken(_ttype);
898 _token.setText(text.ToString(_begin, text.Length-_begin));
899 }
900 returnToken_ = _token;
901 }
902
903 protected void mDECIMAL_DIGIT(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
904 {
905 int _ttype; IToken _token=null; int _begin=text.Length;
906 _ttype = DECIMAL_DIGIT;
907
908 {
909 matchRange('0','9');
910 }
911 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
912 {
913 _token = makeToken(_ttype);
914 _token.setText(text.ToString(_begin, text.Length-_begin));
915 }
916 returnToken_ = _token;
917 }
918
919
920 private static long[] mk_tokenSet_0_()
921 {
922 long[] data = new long[513];
923 data[0]=68719476736L;
924 data[1]=576460745995190270L;
925 for (int i = 2; i<=512; i++) { data[i]=0L; }
926 return data;
927 }
928 public static readonly BitSet tokenSet_0_ = new BitSet(mk_tokenSet_0_());
929 private static long[] mk_tokenSet_1_()
930 {
931 long[] data = new long[1024];
932 data[0]=-9224L;
933 for (int i = 1; i<=127; i++) { data[i]=-1L; }
934 data[128]=-3298534883329L;
935 for (int i = 129; i<=511; i++) { data[i]=-1L; }
936 for (int i = 512; i<=1023; i++) { data[i]=0L; }
937 return data;
938 }
939 public static readonly BitSet tokenSet_1_ = new BitSet(mk_tokenSet_1_());
940 private static long[] mk_tokenSet_2_()
941 {
942 long[] data = new long[513];
943 data[0]=9216L;
944 for (int i = 1; i<=127; i++) { data[i]=0L; }
945 data[128]=3298534883328L;
946 for (int i = 129; i<=512; i++) { data[i]=0L; }
947 return data;
948 }
949 public static readonly BitSet tokenSet_2_ = new BitSet(mk_tokenSet_2_());
950 private static long[] mk_tokenSet_3_()
951 {
952 long[] data = new long[513];
953 data[0]=287948901175001088L;
954 data[1]=576460745995190270L;
955 for (int i = 2; i<=512; i++) { data[i]=0L; }
956 return data;
957 }
958 public static readonly BitSet tokenSet_3_ = new BitSet(mk_tokenSet_3_());
959
960 }
961 }
Git import of castle svn