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