?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Refactored the Kernel registration fluent interface to be more readable, better suppo...
[castle.git] / AspectSharp / AspectSharp.Lang / AspectLanguageLexer.cs
blobbeaf2c8fa24eb15d09aa1600a07fdf8b53e48fbc
1 // $ANTLR 2.7.4: "langlexer.g" -> "AspectLanguageLexer.cs"$
2
3 // Generate header specific to lexer CSharp file
4 using System;
5 using antlr;
6 using Stream = System.IO.Stream;
7 using TextReader = System.IO.TextReader;
8 using Hashtable = System.Collections.Hashtable;
9 using Comparer = System.Collections.Comparer;
10
11 using TokenStreamException = antlr.TokenStreamException;
12 using TokenStreamIOException = antlr.TokenStreamIOException;
13 using TokenStreamRecognitionException = antlr.TokenStreamRecognitionException;
14 using CharStreamException = antlr.CharStreamException;
15 using CharStreamIOException = antlr.CharStreamIOException;
16 using ANTLRException = antlr.ANTLRException;
17 using CharScanner = antlr.CharScanner;
18 using InputBuffer = antlr.InputBuffer;
19 using ByteBuffer = antlr.ByteBuffer;
20 using CharBuffer = antlr.CharBuffer;
21 using Token = antlr.Token;
22 using CommonToken = antlr.CommonToken;
23 using SemanticException = antlr.SemanticException;
24 using RecognitionException = antlr.RecognitionException;
25 using NoViableAltForCharException = antlr.NoViableAltForCharException;
26 using MismatchedCharException = antlr.MismatchedCharException;
27 using TokenStream = antlr.TokenStream;
28 using LexerSharedInputState = antlr.LexerSharedInputState;
29 using BitSet = antlr.collections.impl.BitSet;
30
31 public class AspectLanguageLexer : antlr.CharScanner , TokenStream
32 {
33 public const int EOF = 1;
34 public const int NULL_TREE_LOOKAHEAD = 3;
35 public const int ASPECT = 4;
36 public const int FOR = 5;
37 public const int IN = 6;
38 public const int END = 7;
39 public const int IMPORT = 8;
40 public const int MIXINS = 9;
41 public const int INCLUDE = 10;
42 public const int INTERCEPTORS = 11;
43 public const int ADVICEINTERCEPTOR = 12;
44 public const int POINTCUT = 13;
45 public const int METHOD = 14;
46 public const int PROPERTY = 15;
47 public const int PROPERTY_READ = 16;
48 public const int PROPERTY_WRITE = 17;
49 public const int ASSIGNFROM = 18;
50 public const int CUSTOMMATCHER = 19;
51 public const int EXCLUDES = 20;
52 public const int INCLUDES = 21;
53 public const int EOS = 22;
54 public const int LBRACK = 23;
55 public const int SEMI = 24;
56 public const int RBRACK = 25;
57 public const int STRING_LITERAL = 26;
58 public const int COLON = 27;
59 public const int ID = 28;
60 public const int LCURLY = 29;
61 public const int RCURLY = 30;
62 public const int OR = 31;
63 public const int ALL = 32;
64 public const int COMMA = 33;
65 public const int DOT = 34;
66 public const int WS = 35;
67 public const int INHERITS = 36;
68 public const int COMMENT = 37;
69 public const int DIGIT = 38;
70 public const int INTLIT = 39;
71 public const int CHARLIT = 40;
72
73 public AspectLanguageLexer(Stream ins) : this(new ByteBuffer(ins))
74 {
75 }
76
77 public AspectLanguageLexer(TextReader r) : this(new CharBuffer(r))
78 {
79 }
80
81 public AspectLanguageLexer(InputBuffer ib) : this(new LexerSharedInputState(ib))
82 {
83 }
84
85 public AspectLanguageLexer(LexerSharedInputState state) : base(state)
86 {
87 initialize();
88 }
89 private void initialize()
90 {
91 caseSensitiveLiterals = true;
92 setCaseSensitive(true);
93 literals = new Hashtable(100, (float) 0.4, StringComparer.CurrentCulture);
94 literals.Add("assignableFrom", 18);
95 literals.Add("for", 5);
96 literals.Add("method", 14);
97 literals.Add("propertyread", 16);
98 literals.Add("aspect", 4);
99 literals.Add("interceptors", 11);
100 literals.Add("end", 7);
101 literals.Add("in", 6);
102 literals.Add("advice", 12);
103 literals.Add("customMatcher", 19);
104 literals.Add("propertywrite", 17);
105 literals.Add("pointcut", 13);
106 literals.Add("include", 10);
107 literals.Add("property", 15);
108 literals.Add("import", 8);
109 literals.Add("mixins", 9);
110 literals.Add("includes", 21);
111 literals.Add("excludes", 20);
112 }
113
114 override public IToken nextToken() //throws TokenStreamException
115 {
116 IToken theRetToken = null;
117 tryAgain:
118 for (;;)
119 {
120 int _ttype = Token.INVALID_TYPE;
121 setCommitToPath(false);
122 resetText();
123 try // for char stream error handling
124 {
125 try // for lexical error handling
126 {
127 switch ( LA(1) )
128 {
129 case '*':
130 {
131 mALL(true);
132 theRetToken = returnToken_;
133 break;
134 }
135 case ':':
136 {
137 mCOLON(true);
138 theRetToken = returnToken_;
139 break;
140 }
141 case ';':
142 {
143 mSEMI(true);
144 theRetToken = returnToken_;
145 break;
146 }
147 case ',':
148 {
149 mCOMMA(true);
150 theRetToken = returnToken_;
151 break;
152 }
153 case '|':
154 {
155 mOR(true);
156 theRetToken = returnToken_;
157 break;
158 }
159 case '<':
160 {
161 mINHERITS(true);
162 theRetToken = returnToken_;
163 break;
164 }
165 case '[':
166 {
167 mLBRACK(true);
168 theRetToken = returnToken_;
169 break;
170 }
171 case ']':
172 {
173 mRBRACK(true);
174 theRetToken = returnToken_;
175 break;
176 }
177 case '(':
178 {
179 mLCURLY(true);
180 theRetToken = returnToken_;
181 break;
182 }
183 case ')':
184 {
185 mRCURLY(true);
186 theRetToken = returnToken_;
187 break;
188 }
189 case '.':
190 {
191 mDOT(true);
192 theRetToken = returnToken_;
193 break;
194 }
195 case '/':
196 {
197 mCOMMENT(true);
198 theRetToken = returnToken_;
199 break;
200 }
201 case '0': case '1': case '2': case '3':
202 case '4': case '5': case '6': case '7':
203 case '8': case '9':
204 {
205 mINTLIT(true);
206 theRetToken = returnToken_;
207 break;
208 }
209 case '\'':
210 {
211 mCHARLIT(true);
212 theRetToken = returnToken_;
213 break;
214 }
215 case '"':
216 {
217 mSTRING_LITERAL(true);
218 theRetToken = returnToken_;
219 break;
220 }
221 case '\t': case '\n': case '\u000c': case '\r':
222 case ' ':
223 {
224 mWS(true);
225 theRetToken = returnToken_;
226 break;
227 }
228 case 'A': case 'B': case 'C': case 'D':
229 case 'E': case 'F': case 'G': case 'H':
230 case 'I': case 'J': case 'K': case 'L':
231 case 'M': case 'N': case 'O': case 'P':
232 case 'Q': case 'R': case 'S': case 'T':
233 case 'U': case 'V': case 'W': case 'X':
234 case 'Y': case 'Z': case 'a': case 'b':
235 case 'c': case 'd': case 'e': case 'f':
236 case 'g': case 'h': case 'i': case 'j':
237 case 'k': case 'l': case 'm': case 'n':
238 case 'o': case 'p': case 'q': case 'r':
239 case 's': case 't': case 'u': case 'v':
240 case 'w': case 'x': case 'y': case 'z':
241 case '_':
242 {
243 mID(true);
244 theRetToken = returnToken_;
245 break;
246 }
247 default:
248 {
249 if (LA(1)==EOF_CHAR) { uponEOF(); returnToken_ = makeToken(Token.EOF_TYPE); }
250 else { consume(); goto tryAgain; }
251 }
252 break; }
253 if ( null==returnToken_ ) goto tryAgain; // found SKIP token
254 _ttype = returnToken_.Type;
255 returnToken_.Type = _ttype;
256 return returnToken_;
257 }
258 catch (RecognitionException e) {
259 if (!getCommitToPath())
260 {
261 consume();
262 goto tryAgain;
263 }
264 throw new TokenStreamRecognitionException(e);
265 }
266 }
267 catch (CharStreamException cse) {
268 if ( cse is CharStreamIOException ) {
269 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
270 }
271 else {
272 throw new TokenStreamException(cse.Message);
273 }
274 }
275 }
276 }
277
278 public void mALL(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
279 {
280 int _ttype; IToken _token=null; int _begin=text.Length;
281 _ttype = ALL;
282
283 match('*');
284 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
285 {
286 _token = makeToken(_ttype);
287 _token.setText(text.ToString(_begin, text.Length-_begin));
288 }
289 returnToken_ = _token;
290 }
291
292 public void mCOLON(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
293 {
294 int _ttype; IToken _token=null; int _begin=text.Length;
295 _ttype = COLON;
296
297 match(':');
298 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
299 {
300 _token = makeToken(_ttype);
301 _token.setText(text.ToString(_begin, text.Length-_begin));
302 }
303 returnToken_ = _token;
304 }
305
306 public void mSEMI(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
307 {
308 int _ttype; IToken _token=null; int _begin=text.Length;
309 _ttype = SEMI;
310
311 match(';');
312 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
313 {
314 _token = makeToken(_ttype);
315 _token.setText(text.ToString(_begin, text.Length-_begin));
316 }
317 returnToken_ = _token;
318 }
319
320 public void mCOMMA(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
321 {
322 int _ttype; IToken _token=null; int _begin=text.Length;
323 _ttype = COMMA;
324
325 match(',');
326 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
327 {
328 _token = makeToken(_ttype);
329 _token.setText(text.ToString(_begin, text.Length-_begin));
330 }
331 returnToken_ = _token;
332 }
333
334 public void mOR(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
335 {
336 int _ttype; IToken _token=null; int _begin=text.Length;
337 _ttype = OR;
338
339 match('|');
340 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
341 {
342 _token = makeToken(_ttype);
343 _token.setText(text.ToString(_begin, text.Length-_begin));
344 }
345 returnToken_ = _token;
346 }
347
348 public void mINHERITS(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
349 {
350 int _ttype; IToken _token=null; int _begin=text.Length;
351 _ttype = INHERITS;
352
353 match('<');
354 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
355 {
356 _token = makeToken(_ttype);
357 _token.setText(text.ToString(_begin, text.Length-_begin));
358 }
359 returnToken_ = _token;
360 }
361
362 public void mLBRACK(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
363 {
364 int _ttype; IToken _token=null; int _begin=text.Length;
365 _ttype = LBRACK;
366
367 match('[');
368 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
369 {
370 _token = makeToken(_ttype);
371 _token.setText(text.ToString(_begin, text.Length-_begin));
372 }
373 returnToken_ = _token;
374 }
375
376 public void mRBRACK(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
377 {
378 int _ttype; IToken _token=null; int _begin=text.Length;
379 _ttype = RBRACK;
380
381 match(']');
382 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
383 {
384 _token = makeToken(_ttype);
385 _token.setText(text.ToString(_begin, text.Length-_begin));
386 }
387 returnToken_ = _token;
388 }
389
390 public void mLCURLY(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
391 {
392 int _ttype; IToken _token=null; int _begin=text.Length;
393 _ttype = LCURLY;
394
395 match('(');
396 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
397 {
398 _token = makeToken(_ttype);
399 _token.setText(text.ToString(_begin, text.Length-_begin));
400 }
401 returnToken_ = _token;
402 }
403
404 public void mRCURLY(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
405 {
406 int _ttype; IToken _token=null; int _begin=text.Length;
407 _ttype = RCURLY;
408
409 match(')');
410 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
411 {
412 _token = makeToken(_ttype);
413 _token.setText(text.ToString(_begin, text.Length-_begin));
414 }
415 returnToken_ = _token;
416 }
417
418 public void mDOT(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
419 {
420 int _ttype; IToken _token=null; int _begin=text.Length;
421 _ttype = DOT;
422
423 match('.');
424 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
425 {
426 _token = makeToken(_ttype);
427 _token.setText(text.ToString(_begin, text.Length-_begin));
428 }
429 returnToken_ = _token;
430 }
431
432 public void mCOMMENT(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
433 {
434 int _ttype; IToken _token=null; int _begin=text.Length;
435 _ttype = COMMENT;
436
437 match("//");
438 { // ( ... )*
439 for (;;)
440 {
441 if ((tokenSet_0_.member(LA(1))))
442 {
443 {
444 match(tokenSet_0_);
445 }
446 }
447 else
448 {
449 goto _loop15_breakloop;
450 }
451
452 }
453 _loop15_breakloop: ;
454 } // ( ... )*
455 _ttype = Token.SKIP;
456 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
457 {
458 _token = makeToken(_ttype);
459 _token.setText(text.ToString(_begin, text.Length-_begin));
460 }
461 returnToken_ = _token;
462 }
463
464 protected void mDIGIT(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
465 {
466 int _ttype; IToken _token=null; int _begin=text.Length;
467 _ttype = DIGIT;
468
469 matchRange('0','9');
470 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
471 {
472 _token = makeToken(_ttype);
473 _token.setText(text.ToString(_begin, text.Length-_begin));
474 }
475 returnToken_ = _token;
476 }
477
478 public void mINTLIT(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
479 {
480 int _ttype; IToken _token=null; int _begin=text.Length;
481 _ttype = INTLIT;
482
483 { // ( ... )+
484 int _cnt19=0;
485 for (;;)
486 {
487 if (((LA(1) >= '0' && LA(1) <= '9')))
488 {
489 mDIGIT(false);
490 }
491 else
492 {
493 if (_cnt19 >= 1) { goto _loop19_breakloop; } else { throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());; }
494 }
495
496 _cnt19++;
497 }
498 _loop19_breakloop: ;
499 } // ( ... )+
500 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
501 {
502 _token = makeToken(_ttype);
503 _token.setText(text.ToString(_begin, text.Length-_begin));
504 }
505 returnToken_ = _token;
506 }
507
508 public void mCHARLIT(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
509 {
510 int _ttype; IToken _token=null; int _begin=text.Length;
511 _ttype = CHARLIT;
512
513 int _saveIndex = 0;
514 _saveIndex = text.Length;
515 match('\'');
516 text.Length = _saveIndex;
517 matchNot(EOF/*_CHAR*/);
518 _saveIndex = text.Length;
519 match('\'');
520 text.Length = _saveIndex;
521 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
522 {
523 _token = makeToken(_ttype);
524 _token.setText(text.ToString(_begin, text.Length-_begin));
525 }
526 returnToken_ = _token;
527 }
528
529 public void mSTRING_LITERAL(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
530 {
531 int _ttype; IToken _token=null; int _begin=text.Length;
532 _ttype = STRING_LITERAL;
533
534 int _saveIndex = 0;
535 _saveIndex = text.Length;
536 match('"');
537 text.Length = _saveIndex;
538 { // ( ... )*
539 for (;;)
540 {
541 if ((LA(1)=='"') && (LA(2)=='"'))
542 {
543 match('"');
544 _saveIndex = text.Length;
545 match('"');
546 text.Length = _saveIndex;
547 }
548 else if ((tokenSet_1_.member(LA(1)))) {
549 {
550 match(tokenSet_1_);
551 }
552 }
553 else
554 {
555 goto _loop24_breakloop;
556 }
557
558 }
559 _loop24_breakloop: ;
560 } // ( ... )*
561 {
562 if ((LA(1)=='"'))
563 {
564 _saveIndex = text.Length;
565 match('"');
566 text.Length = _saveIndex;
567 }
568 else {
569 }
570
571 }
572 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
573 {
574 _token = makeToken(_ttype);
575 _token.setText(text.ToString(_begin, text.Length-_begin));
576 }
577 returnToken_ = _token;
578 }
579
580 public void mWS(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
581 {
582 int _ttype; IToken _token=null; int _begin=text.Length;
583 _ttype = WS;
584
585 {
586 switch ( LA(1) )
587 {
588 case ' ':
589 {
590 match(' ');
591 break;
592 }
593 case '\t':
594 {
595 match('\t');
596 break;
597 }
598 case '\u000c':
599 {
600 match('\f');
601 break;
602 }
603 case '\n': case '\r':
604 {
605 {
606 if ((LA(1)=='\r') && (LA(2)=='\n'))
607 {
608 match("\r\n");
609 }
610 else if ((LA(1)=='\r') && (true)) {
611 match('\r');
612 }
613 else if ((LA(1)=='\n')) {
614 match('\n');
615 }
616 else
617 {
618 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
619 }
620
621 }
622 newline();
623 break;
624 }
625 default:
626 {
627 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
628 }
629 }
630 }
631 _ttype = Token.SKIP;
632 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
633 {
634 _token = makeToken(_ttype);
635 _token.setText(text.ToString(_begin, text.Length-_begin));
636 }
637 returnToken_ = _token;
638 }
639
640 public void mID(bool _createToken) //throws RecognitionException, CharStreamException, TokenStreamException
641 {
642 int _ttype; IToken _token=null; int _begin=text.Length;
643 _ttype = ID;
644
645 {
646 switch ( LA(1) )
647 {
648 case 'a': case 'b': case 'c': case 'd':
649 case 'e': case 'f': case 'g': case 'h':
650 case 'i': case 'j': case 'k': case 'l':
651 case 'm': case 'n': case 'o': case 'p':
652 case 'q': case 'r': case 's': case 't':
653 case 'u': case 'v': case 'w': case 'x':
654 case 'y': case 'z':
655 {
656 matchRange('a','z');
657 break;
658 }
659 case 'A': case 'B': case 'C': case 'D':
660 case 'E': case 'F': case 'G': case 'H':
661 case 'I': case 'J': case 'K': case 'L':
662 case 'M': case 'N': case 'O': case 'P':
663 case 'Q': case 'R': case 'S': case 'T':
664 case 'U': case 'V': case 'W': case 'X':
665 case 'Y': case 'Z':
666 {
667 matchRange('A','Z');
668 break;
669 }
670 case '_':
671 {
672 match('_');
673 break;
674 }
675 default:
676 {
677 throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
678 }
679 }
680 }
681 { // ( ... )*
682 for (;;)
683 {
684 switch ( LA(1) )
685 {
686 case 'a': case 'b': case 'c': case 'd':
687 case 'e': case 'f': case 'g': case 'h':
688 case 'i': case 'j': case 'k': case 'l':
689 case 'm': case 'n': case 'o': case 'p':
690 case 'q': case 'r': case 's': case 't':
691 case 'u': case 'v': case 'w': case 'x':
692 case 'y': case 'z':
693 {
694 matchRange('a','z');
695 break;
696 }
697 case 'A': case 'B': case 'C': case 'D':
698 case 'E': case 'F': case 'G': case 'H':
699 case 'I': case 'J': case 'K': case 'L':
700 case 'M': case 'N': case 'O': case 'P':
701 case 'Q': case 'R': case 'S': case 'T':
702 case 'U': case 'V': case 'W': case 'X':
703 case 'Y': case 'Z':
704 {
705 matchRange('A','Z');
706 break;
707 }
708 case '0': case '1': case '2': case '3':
709 case '4': case '5': case '6': case '7':
710 case '8': case '9':
711 {
712 matchRange('0','9');
713 break;
714 }
715 case '_': {
716 match('_');
717 break;
718 }
719 default: {
720 goto _loop32_breakloop;
721 }
722 }
723 }
724 _loop32_breakloop: ;
725 } // ( ... )*
726 _ttype = testLiteralsTable(_ttype);
727 if (_createToken && (null == _token) && (_ttype != Token.SKIP))
728 {
729 _token = makeToken(_ttype);
730 _token.setText(text.ToString(_begin, text.Length-_begin));
731 }
732 returnToken_ = _token;
733 }
734
735
736 private static long[] mk_tokenSet_0_()
737 {
738 long[] data = { 2305798500467610112L, 1729382249125642238L, 0L, 0L};
739 return data;
740 }
741 public static readonly BitSet tokenSet_0_ = new BitSet(mk_tokenSet_0_());
742 private static long[] mk_tokenSet_1_()
743 {
744 long[] data = { 2305798483287740928L, 1729382249125642238L, 0L, 0L};
745 return data;
746 }
747 public static readonly BitSet tokenSet_1_ = new BitSet(mk_tokenSet_1_());
748
749 }
Git import of castle svn