?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Better handling of complex primary key params.
[castle.git] / AspectSharp / AspectSharp.Lang / AspectLanguageParser.cs
blob61907f2b23818e47a07adcd99b7e75560afae4e3
1 // $ANTLR 2.7.4: "langparser.g" -> "AspectLanguageParser.cs"$
2
3 using antlr;
4 using System.Text;
5 using AspectSharp.Lang.AST;
6
7 // Generate the header common to all output files.
8 using System;
9
10 using TokenBuffer = antlr.TokenBuffer;
11 using TokenStreamException = antlr.TokenStreamException;
12 using TokenStreamIOException = antlr.TokenStreamIOException;
13 using ANTLRException = antlr.ANTLRException;
14 using LLkParser = antlr.LLkParser;
15 using Token = antlr.Token;
16 using TokenStream = antlr.TokenStream;
17 using RecognitionException = antlr.RecognitionException;
18 using NoViableAltException = antlr.NoViableAltException;
19 using MismatchedTokenException = antlr.MismatchedTokenException;
20 using SemanticException = antlr.SemanticException;
21 using ParserSharedInputState = antlr.ParserSharedInputState;
22 using BitSet = antlr.collections.impl.BitSet;
23
24 public class AspectLanguageParser : antlr.LLkParser
25 {
26 public const int EOF = 1;
27 public const int NULL_TREE_LOOKAHEAD = 3;
28 public const int ASPECT = 4;
29 public const int FOR = 5;
30 public const int IN = 6;
31 public const int END = 7;
32 public const int IMPORT = 8;
33 public const int MIXINS = 9;
34 public const int INCLUDE = 10;
35 public const int INTERCEPTORS = 11;
36 public const int ADVICEINTERCEPTOR = 12;
37 public const int POINTCUT = 13;
38 public const int METHOD = 14;
39 public const int PROPERTY = 15;
40 public const int PROPERTY_READ = 16;
41 public const int PROPERTY_WRITE = 17;
42 public const int ASSIGNFROM = 18;
43 public const int CUSTOMMATCHER = 19;
44 public const int EXCLUDES = 20;
45 public const int INCLUDES = 21;
46 public const int EOS = 22;
47 public const int LBRACK = 23;
48 public const int SEMI = 24;
49 public const int RBRACK = 25;
50 public const int STRING_LITERAL = 26;
51 public const int COLON = 27;
52 public const int ID = 28;
53 public const int LCURLY = 29;
54 public const int RCURLY = 30;
55 public const int OR = 31;
56 public const int ALL = 32;
57 public const int COMMA = 33;
58 public const int DOT = 34;
59 public const int WS = 35;
60
61
62 protected StringBuilder sbuilder = new StringBuilder();
63
64 protected LexicalInfo ToLexicalInfo(antlr.IToken token)
65 {
66 int line = token.getLine();
67 int startColumn = token.getColumn();
68 int endColumn = token.getColumn() + token.getText().Length;
69 String filename = token.getFilename();
70 return new LexicalInfo(filename, line, startColumn, endColumn);
71 }
72
73 protected String methodAll(String s)
74 {
75 if (s == "*")
76 return ".*";
77 return s;
78 }
79
80 protected void initialize()
81 {
82 tokenNames = tokenNames_;
83 }
84
85
86 protected AspectLanguageParser(TokenBuffer tokenBuf, int k) : base(tokenBuf, k)
87 {
88 initialize();
89 }
90
91 public AspectLanguageParser(TokenBuffer tokenBuf) : this(tokenBuf,1)
92 {
93 }
94
95 protected AspectLanguageParser(TokenStream lexer, int k) : base(lexer,k)
96 {
97 initialize();
98 }
99
100 public AspectLanguageParser(TokenStream lexer) : this(lexer,1)
101 {
102 }
103
104 public AspectLanguageParser(ParserSharedInputState state) : base(state,1)
105 {
106 initialize();
107 }
108
109 public EngineConfiguration start() //throws RecognitionException, TokenStreamException
110 {
111 EngineConfiguration conf;
112
113
114 conf = new EngineConfiguration();
115
116
117 try { // for error handling
118 { // ( ... )*
119 for (;;)
120 {
121 if ((LA(1)==EOS))
122 {
123 match(EOS);
124 }
125 else
126 {
127 goto _loop3_breakloop;
128 }
129
130 }
131 _loop3_breakloop: ;
132 } // ( ... )*
133 { // ( ... )*
134 for (;;)
135 {
136 if ((LA(1)==IMPORT))
137 {
138 import_directive(conf);
139 }
140 else
141 {
142 goto _loop5_breakloop;
143 }
144
145 }
146 _loop5_breakloop: ;
147 } // ( ... )*
148 { // ( ... )*
149 for (;;)
150 {
151 if ((LA(1)==INTERCEPTORS))
152 {
153 interceptors_global(conf);
154 }
155 else
156 {
157 goto _loop7_breakloop;
158 }
159
160 }
161 _loop7_breakloop: ;
162 } // ( ... )*
163 { // ( ... )*
164 for (;;)
165 {
166 if ((LA(1)==MIXINS))
167 {
168 mixins_global(conf);
169 }
170 else
171 {
172 goto _loop9_breakloop;
173 }
174
175 }
176 _loop9_breakloop: ;
177 } // ( ... )*
178 { // ( ... )*
179 for (;;)
180 {
181 if ((LA(1)==ASPECT))
182 {
183 aspects(conf);
184 }
185 else
186 {
187 goto _loop11_breakloop;
188 }
189
190 }
191 _loop11_breakloop: ;
192 } // ( ... )*
193 match(Token.EOF_TYPE);
194 }
195 catch (RecognitionException ex)
196 {
197 reportError(ex);
198 consume();
199 consumeUntil(tokenSet_0_);
200 }
201 return conf;
202 }
203
204 protected void import_directive(
205 EngineConfiguration conf
206 ) //throws RecognitionException, TokenStreamException
207 {
208
209 IToken i = null;
210
211 String ns;
212 String assemblyName;
213 ImportDirective import = null;
214
215
216 try { // for error handling
217 i = LT(1);
218 match(IMPORT);
219 ns=identifier();
220
221 import = new ImportDirective( ToLexicalInfo(i), ns );
222 conf.Imports.Add(import);
223
224 {
225 switch ( LA(1) )
226 {
227 case IN:
228 {
229 match(IN);
230 assemblyName=identifier();
231
232 import.AssemblyReference = new AssemblyReference( ToLexicalInfo(i), assemblyName);
233
234 break;
235 }
236 case EOF:
237 case ASPECT:
238 case IMPORT:
239 case MIXINS:
240 case INTERCEPTORS:
241 {
242 break;
243 }
244 default:
245 {
246 throw new NoViableAltException(LT(1), getFilename());
247 }
248 }
249 }
250 }
251 catch (RecognitionException ex)
252 {
253 reportError(ex);
254 consume();
255 consumeUntil(tokenSet_1_);
256 }
257 }
258
259 protected void interceptors_global(
260 EngineConfiguration conf
261 ) //throws RecognitionException, TokenStreamException
262 {
263
264
265 try { // for error handling
266 match(INTERCEPTORS);
267 keytypepair(conf.Interceptors);
268
269
270 }
271 catch (RecognitionException ex)
272 {
273 reportError(ex);
274 consume();
275 consumeUntil(tokenSet_2_);
276 }
277 }
278
279 protected void mixins_global(
280 EngineConfiguration conf
281 ) //throws RecognitionException, TokenStreamException
282 {
283
284
285 try { // for error handling
286 match(MIXINS);
287 keytypepair(conf.Mixins);
288
289
290 }
291 catch (RecognitionException ex)
292 {
293 reportError(ex);
294 consume();
295 consumeUntil(tokenSet_3_);
296 }
297 }
298
299 protected void aspects(
300 EngineConfiguration conf
301 ) //throws RecognitionException, TokenStreamException
302 {
303
304 IToken a = null;
305 IToken aspectId = null;
306
307 AspectDefinition aspect = null;
308 TargetTypeDefinition target = null;
309 TypeReference tr = null;
310
311
312 try { // for error handling
313 a = LT(1);
314 match(ASPECT);
315 aspectId = LT(1);
316 match(ID);
317 match(FOR);
318
319 aspect = new AspectDefinition( ToLexicalInfo(a), aspectId.getText() );
320 conf.Aspects.Add(aspect);
321
322 {
323 switch ( LA(1) )
324 {
325 case ID:
326 {
327 tr=type_name_def();
328
329 target = new TargetTypeDefinition( tr );
330 target.TargetStrategy = TargetStrategyEnum.SingleType;
331 aspect.TargetType = target;
332
333 break;
334 }
335 case LBRACK:
336 {
337 match(LBRACK);
338
339 target = new TargetTypeDefinition( );
340 aspect.TargetType = target;
341 String namespaceRegEx = null;
342
343 {
344 switch ( LA(1) )
345 {
346 case ASSIGNFROM:
347 {
348 match(ASSIGNFROM);
349 match(LCURLY);
350 tr=type_name_def();
351 match(RCURLY);
352
353 target.TargetStrategy = TargetStrategyEnum.Assignable;
354 target.AssignType = tr;
355
356 break;
357 }
358 case CUSTOMMATCHER:
359 {
360 match(CUSTOMMATCHER);
361 match(LCURLY);
362 tr=type_name_def();
363 match(RCURLY);
364
365 target.TargetStrategy = TargetStrategyEnum.Custom;
366 target.CustomMatcherType = tr;
367
368 break;
369 }
370 case ID:
371 {
372 {
373 namespaceRegEx=identifier();
374
375 target.TargetStrategy = TargetStrategyEnum.Namespace;
376 target.NamespaceRoot = namespaceRegEx;
377
378 {
379 switch ( LA(1) )
380 {
381 case EXCLUDES:
382 {
383 match(EXCLUDES);
384 match(LCURLY);
385 type_list(target.Excludes);
386 match(RCURLY);
387 break;
388 }
389 case RBRACK:
390 {
391 break;
392 }
393 default:
394 {
395 throw new NoViableAltException(LT(1), getFilename());
396 }
397 }
398 }
399 }
400 break;
401 }
402 default:
403 {
404 throw new NoViableAltException(LT(1), getFilename());
405 }
406 }
407 }
408 match(RBRACK);
409 break;
410 }
411 default:
412 {
413 throw new NoViableAltException(LT(1), getFilename());
414 }
415 }
416 }
417 {
418 { // ( ... )*
419 for (;;)
420 {
421 if ((LA(1)==INCLUDE))
422 {
423 include(aspect);
424 }
425 else
426 {
427 goto _loop33_breakloop;
428 }
429
430 }
431 _loop33_breakloop: ;
432 } // ( ... )*
433 { // ( ... )*
434 for (;;)
435 {
436 if ((LA(1)==POINTCUT))
437 {
438 pointcut(aspect);
439 }
440 else
441 {
442 goto _loop35_breakloop;
443 }
444
445 }
446 _loop35_breakloop: ;
447 } // ( ... )*
448 }
449 match(END);
450 }
451 catch (RecognitionException ex)
452 {
453 reportError(ex);
454 consume();
455 consumeUntil(tokenSet_4_);
456 }
457 }
458
459 protected String identifier() //throws RecognitionException, TokenStreamException
460 {
461 String value;
462
463 IToken id = null;
464 IToken id2 = null;
465
466 value = null; sbuilder.Length = 0;
467
468
469 try { // for error handling
470 id = LT(1);
471 match(ID);
472
473 sbuilder.Append(id.getText());
474 value = sbuilder.ToString();
475
476 { // ( ... )*
477 for (;;)
478 {
479 if ((LA(1)==DOT))
480 {
481 match(DOT);
482 id2 = LT(1);
483 match(ID);
484
485 sbuilder.Append('.');
486 sbuilder.Append(id2.getText());
487
488 }
489 else
490 {
491 goto _loop65_breakloop;
492 }
493
494 }
495 _loop65_breakloop: ;
496 } // ( ... )*
497
498 value = sbuilder.ToString();
499
500 }
501 catch (RecognitionException ex)
502 {
503 reportError(ex);
504 consume();
505 consumeUntil(tokenSet_5_);
506 }
507 return value;
508 }
509
510 protected void keytypepair(
511 IDeclarationCollection collection
512 ) //throws RecognitionException, TokenStreamException
513 {
514
515
516 try { // for error handling
517 match(LBRACK);
518 {
519 {
520 pairvalue(collection);
521 { // ( ... )*
522 for (;;)
523 {
524 if ((LA(1)==SEMI))
525 {
526 match(SEMI);
527 pairvalue(collection);
528 }
529 else
530 {
531 goto _loop20_breakloop;
532 }
533
534 }
535 _loop20_breakloop: ;
536 } // ( ... )*
537 }
538 }
539 match(RBRACK);
540 }
541 catch (RecognitionException ex)
542 {
543 reportError(ex);
544 consume();
545 consumeUntil(tokenSet_2_);
546 }
547 }
548
549 protected void pairvalue(
550 IDeclarationCollection collection
551 ) //throws RecognitionException, TokenStreamException
552 {
553
554 IToken keyToken = null;
555
556 DefinitionBase definition = null;
557
558
559 try { // for error handling
560 keyToken = LT(1);
561 match(STRING_LITERAL);
562 match(COLON);
563
564 String key = keyToken.getText();
565 definition = collection.Add( key, ToLexicalInfo(keyToken) );
566
567 type_name(definition);
568 }
569 catch (RecognitionException ex)
570 {
571 reportError(ex);
572 consume();
573 consumeUntil(tokenSet_6_);
574 }
575 }
576
577 protected void type_name(
578 DefinitionBase definition
579 ) //throws RecognitionException, TokenStreamException
580 {
581
582
583 TypeReference tr = null;
584
585
586 try { // for error handling
587 tr=type_name_def();
588
589 definition.TypeReference = tr;
590
591 }
592 catch (RecognitionException ex)
593 {
594 reportError(ex);
595 consume();
596 consumeUntil(tokenSet_6_);
597 }
598 }
599
600 protected TypeReference type_name_or_ref() //throws RecognitionException, TokenStreamException
601 {
602 TypeReference type;
603
604 IToken refTypeToken = null;
605
606 type = null;
607
608
609 try { // for error handling
610 switch ( LA(1) )
611 {
612 case STRING_LITERAL:
613 {
614 refTypeToken = LT(1);
615 match(STRING_LITERAL);
616
617 type = new TypeReference();
618 type.LinkRef = refTypeToken.getText();
619
620 break;
621 }
622 case ID:
623 {
624 type=type_name_def();
625 break;
626 }
627 default:
628 {
629 throw new NoViableAltException(LT(1), getFilename());
630 }
631 }
632 }
633 catch (RecognitionException ex)
634 {
635 reportError(ex);
636 consume();
637 consumeUntil(tokenSet_7_);
638 }
639 return type;
640 }
641
642 protected TypeReference type_name_def() //throws RecognitionException, TokenStreamException
643 {
644 TypeReference type;
645
646 IToken i = null;
647
648 type = new TypeReference();
649 String typeToken = null;
650 String assemblyToken = null;
651
652
653 try { // for error handling
654 typeToken=identifier();
655
656 type.TypeName = typeToken;
657
658 {
659 switch ( LA(1) )
660 {
661 case IN:
662 {
663 i = LT(1);
664 match(IN);
665 assemblyToken=identifier();
666
667 type.AssemblyReference = new AssemblyReference( ToLexicalInfo(i), assemblyToken );
668
669 break;
670 }
671 case END:
672 case INCLUDE:
673 case POINTCUT:
674 case SEMI:
675 case RBRACK:
676 case RCURLY:
677 {
678 break;
679 }
680 default:
681 {
682 throw new NoViableAltException(LT(1), getFilename());
683 }
684 }
685 }
686 }
687 catch (RecognitionException ex)
688 {
689 reportError(ex);
690 consume();
691 consumeUntil(tokenSet_8_);
692 }
693 return type;
694 }
695
696 protected void type_list(
697 TypeReferenceCollection types
698 ) //throws RecognitionException, TokenStreamException
699 {
700
701
702 TypeReference tr = null;
703
704
705 try { // for error handling
706 tr=type_name_def();
707
708 types.Add(tr);
709
710 { // ( ... )*
711 for (;;)
712 {
713 if ((LA(1)==SEMI))
714 {
715 match(SEMI);
716 tr=type_name_def();
717
718 types.Add(tr);
719
720 }
721 else
722 {
723 goto _loop38_breakloop;
724 }
725
726 }
727 _loop38_breakloop: ;
728 } // ( ... )*
729 }
730 catch (RecognitionException ex)
731 {
732 reportError(ex);
733 consume();
734 consumeUntil(tokenSet_9_);
735 }
736 }
737
738 protected void include(
739 AspectDefinition aspect
740 ) //throws RecognitionException, TokenStreamException
741 {
742
743 IToken i = null;
744
745 TypeReference tr = null;
746 MixinDefinition md;
747
748
749 try { // for error handling
750 i = LT(1);
751 match(INCLUDE);
752
753 md = new MixinDefinition( ToLexicalInfo(i) );
754
755 tr=type_name_or_ref();
756
757 md.TypeReference = tr;
758 aspect.Mixins.Add( md );
759
760 }
761 catch (RecognitionException ex)
762 {
763 reportError(ex);
764 consume();
765 consumeUntil(tokenSet_10_);
766 }
767 }
768
769 protected void pointcut(
770 AspectDefinition aspect
771 ) //throws RecognitionException, TokenStreamException
772 {
773
774 IToken p = null;
775
776 PointCutDefinition pointcut = null;
777 PointCutFlags flags = PointCutFlags.Unspecified;
778
779
780 try { // for error handling
781 p = LT(1);
782 match(POINTCUT);
783 flags=pointcutflags();
784
785 pointcut = new PointCutDefinition( ToLexicalInfo(p), flags );
786 aspect.PointCuts.Add( pointcut );
787
788 pointcuttarget(pointcut);
789 advices(pointcut);
790 match(END);
791 }
792 catch (RecognitionException ex)
793 {
794 reportError(ex);
795 consume();
796 consumeUntil(tokenSet_11_);
797 }
798 }
799
800 protected PointCutFlags pointcutflags() //throws RecognitionException, TokenStreamException
801 {
802 PointCutFlags flags;
803
804
805 flags = PointCutFlags.Unspecified;
806
807
808 try { // for error handling
809 flags=pointcutflag(flags);
810 {
811 switch ( LA(1) )
812 {
813 case OR:
814 {
815 match(OR);
816 flags=pointcutflag(flags);
817 break;
818 }
819 case LCURLY:
820 {
821 break;
822 }
823 default:
824 {
825 throw new NoViableAltException(LT(1), getFilename());
826 }
827 }
828 }
829 }
830 catch (RecognitionException ex)
831 {
832 reportError(ex);
833 consume();
834 consumeUntil(tokenSet_12_);
835 }
836 return flags;
837 }
838
839 protected void pointcuttarget(
840 PointCutDefinition pointcut
841 ) //throws RecognitionException, TokenStreamException
842 {
843
844
845 try { // for error handling
846 match(LCURLY);
847 pointcutsignature(pointcut);
848 }
849 catch (RecognitionException ex)
850 {
851 reportError(ex);
852 consume();
853 consumeUntil(tokenSet_13_);
854 }
855 }
856
857 protected void advices(
858 PointCutDefinition pointcut
859 ) //throws RecognitionException, TokenStreamException
860 {
861
862
863 try { // for error handling
864 { // ( ... )*
865 for (;;)
866 {
867 if ((LA(1)==ADVICEINTERCEPTOR))
868 {
869 advice(pointcut);
870 }
871 else
872 {
873 goto _loop43_breakloop;
874 }
875
876 }
877 _loop43_breakloop: ;
878 } // ( ... )*
879 }
880 catch (RecognitionException ex)
881 {
882 reportError(ex);
883 consume();
884 consumeUntil(tokenSet_14_);
885 }
886 }
887
888 protected void advice(
889 PointCutDefinition pointcut
890 ) //throws RecognitionException, TokenStreamException
891 {
892
893 IToken i = null;
894
895 TypeReference tr = null;
896 InterceptorDefinition interDef = null;
897
898
899 try { // for error handling
900 i = LT(1);
901 match(ADVICEINTERCEPTOR);
902
903 interDef = new InterceptorDefinition( ToLexicalInfo(i) );
904
905 match(LCURLY);
906 tr=type_name_or_ref();
907
908 interDef.TypeReference = tr;
909 pointcut.Advices.Add( interDef );
910
911 match(RCURLY);
912 }
913 catch (RecognitionException ex)
914 {
915 reportError(ex);
916 consume();
917 consumeUntil(tokenSet_13_);
918 }
919 }
920
921 protected PointCutFlags pointcutflag(
922 PointCutFlags flags
923 ) //throws RecognitionException, TokenStreamException
924 {
925 PointCutFlags retValue;
926
927
928 retValue = flags;
929
930
931 try { // for error handling
932 switch ( LA(1) )
933 {
934 case METHOD:
935 {
936 match(METHOD);
937 retValue |= PointCutFlags.Method;
938 break;
939 }
940 case PROPERTY:
941 {
942 match(PROPERTY);
943 retValue |= PointCutFlags.Property;
944 break;
945 }
946 case PROPERTY_READ:
947 {
948 match(PROPERTY_READ);
949 retValue |= PointCutFlags.PropertyRead;
950 break;
951 }
952 case PROPERTY_WRITE:
953 {
954 match(PROPERTY_WRITE);
955 retValue |= PointCutFlags.PropertyWrite;
956 break;
957 }
958 default:
959 {
960 throw new NoViableAltException(LT(1), getFilename());
961 }
962 }
963 }
964 catch (RecognitionException ex)
965 {
966 reportError(ex);
967 consume();
968 consumeUntil(tokenSet_15_);
969 }
970 return retValue;
971 }
972
973 protected void pointcutsignature(
974 PointCutDefinition pointcut
975 ) //throws RecognitionException, TokenStreamException
976 {
977
978
979 try { // for error handling
980 pointcutsig1(pointcut);
981 }
982 catch (RecognitionException ex)
983 {
984 reportError(ex);
985 consume();
986 consumeUntil(tokenSet_13_);
987 }
988 }
989
990 protected void pointcutsig1(
991 PointCutDefinition pointcut
992 ) //throws RecognitionException, TokenStreamException
993 {
994
995
996 String part1;
997 MethodSignature ms = null;
998
999
1000 try { // for error handling
1001 {
1002 switch ( LA(1) )
1003 {
1004 case ALL:
1005 {
1006 match(ALL);
1007
1008 part1 = "*";
1009 ms = AllMethodSignature.Instance;
1010
1011 break;
1012 }
1013 case ID:
1014 {
1015 part1=reg_ex(true);
1016 ms = new MethodSignature(part1, methodAll("*"));
1017 break;
1018 }
1019 default:
1020 {
1021 throw new NoViableAltException(LT(1), getFilename());
1022 }
1023 }
1024 }
1025 pointcut.Method = pointcutsig2(part1, ms);
1026 }
1027 catch (RecognitionException ex)
1028 {
1029 reportError(ex);
1030 consume();
1031 consumeUntil(tokenSet_13_);
1032 }
1033 }
1034
1035 protected String reg_ex(
1036 Boolean allowALL
1037 ) //throws RecognitionException, TokenStreamException
1038 {
1039 String value;
1040
1041 IToken id = null;
1042
1043 value = null; sbuilder.Length = 0;
1044
1045
1046 try { // for error handling
1047 {
1048 id = LT(1);
1049 match(ID);
1050
1051 sbuilder.Append(id.getText());
1052 value = sbuilder.ToString();
1053
1054 {
1055 switch ( LA(1) )
1056 {
1057 case WS:
1058 {
1059 match(WS);
1060 break;
1061 }
1062 case DOT:
1063 {
1064 match(DOT);
1065
1066 sbuilder.Append('.');
1067
1068 match(ALL);
1069
1070 sbuilder.Append('*');
1071
1072 break;
1073 }
1074 default:
1075 if ((tokenSet_16_.member(LA(1))))
1076 {
1077 if (LA(1) == ALL) {
1078
1079 if (allowALL)
1080 break;
1081 throw new NoViableAltException(LT(1), getFilename());
1082 }
1083
1084 }
1085 else if ((tokenSet_16_.member(LA(1)))) {
1086 }
1087 else
1088 {
1089 throw new NoViableAltException(LT(1), getFilename());
1090 }
1091 break; }
1092 }
1093 }
1094
1095 value = sbuilder.ToString();
1096
1097 }
1098 catch (RecognitionException ex)
1099 {
1100 reportError(ex);
1101 consume();
1102 consumeUntil(tokenSet_16_);
1103 }
1104 return value;
1105 }
1106
1107 protected MethodSignature pointcutsig2(
1108 String part1, MethodSignature ms
1109 ) //throws RecognitionException, TokenStreamException
1110 {
1111 MethodSignature ret;
1112
1113
1114 String part2;
1115 ret = null;
1116
1117
1118 try { // for error handling
1119 {
1120 switch ( LA(1) )
1121 {
1122 case ALL:
1123 {
1124 match(ALL);
1125 part2 = "*";
1126 ret=pointcutsig3(part1, part2, ms);
1127 break;
1128 }
1129 case LCURLY:
1130 {
1131 match(LCURLY);
1132 pointcutarguments(ms);
1133 match(RCURLY);
1134 match(RCURLY);
1135 ret = ms;
1136 break;
1137 }
1138 case RCURLY:
1139 {
1140 match(RCURLY);
1141 ret = ms;
1142 break;
1143 }
1144 case ID:
1145 {
1146 part2=reg_ex(true);
1147 ret=pointcutsig3(part1, part2, ms);
1148 break;
1149 }
1150 default:
1151 {
1152 throw new NoViableAltException(LT(1), getFilename());
1153 }
1154 }
1155 }
1156 }
1157 catch (RecognitionException ex)
1158 {
1159 reportError(ex);
1160 consume();
1161 consumeUntil(tokenSet_0_);
1162 }
1163 return ret;
1164 }
1165
1166 protected MethodSignature pointcutsig3(
1167 String part1, String part2, MethodSignature ms
1168 ) //throws RecognitionException, TokenStreamException
1169 {
1170 MethodSignature ret;
1171
1172
1173 String part3;
1174 ret = null;
1175
1176
1177 try { // for error handling
1178 {
1179 switch ( LA(1) )
1180 {
1181 case ALL:
1182 {
1183 match(ALL);
1184 part3 = "*";
1185 ms = new MethodSignature(part1, part2, methodAll(part3));
1186 pointcutsig4(ms);
1187 break;
1188 }
1189 case LCURLY:
1190 {
1191 match(LCURLY);
1192 ms = new MethodSignature(part1, methodAll(part2));
1193 pointcutarguments(ms);
1194 match(RCURLY);
1195 match(RCURLY);
1196 break;
1197 }
1198 case RCURLY:
1199 {
1200 match(RCURLY);
1201 ms = new MethodSignature(part1, methodAll(part2));
1202 break;
1203 }
1204 case ID:
1205 {
1206 part3=reg_ex(false);
1207 ms = new MethodSignature(part1, part2, methodAll(part3));
1208 pointcutsig4(ms);
1209 break;
1210 }
1211 default:
1212 {
1213 throw new NoViableAltException(LT(1), getFilename());
1214 }
1215 }
1216 }
1217 ret = ms;
1218 }
1219 catch (RecognitionException ex)
1220 {
1221 reportError(ex);
1222 consume();
1223 consumeUntil(tokenSet_0_);
1224 }
1225 return ret;
1226 }
1227
1228 protected void pointcutarguments(
1229 MethodSignature ms
1230 ) //throws RecognitionException, TokenStreamException
1231 {
1232
1233
1234 try { // for error handling
1235 {
1236 switch ( LA(1) )
1237 {
1238 case ID:
1239 case ALL:
1240 {
1241 pointcutargument(ms);
1242 { // ( ... )*
1243 for (;;)
1244 {
1245 if ((LA(1)==COMMA))
1246 {
1247 match(COMMA);
1248 pointcutargument(ms);
1249 }
1250 else
1251 {
1252 goto _loop61_breakloop;
1253 }
1254
1255 }
1256 _loop61_breakloop: ;
1257 } // ( ... )*
1258 break;
1259 }
1260 case RCURLY:
1261 {
1262 break;
1263 }
1264 default:
1265 {
1266 throw new NoViableAltException(LT(1), getFilename());
1267 }
1268 }
1269 }
1270 }
1271 catch (RecognitionException ex)
1272 {
1273 reportError(ex);
1274 consume();
1275 consumeUntil(tokenSet_9_);
1276 }
1277 }
1278
1279 protected void pointcutsig4(
1280 MethodSignature ms
1281 ) //throws RecognitionException, TokenStreamException
1282 {
1283
1284
1285 try { // for error handling
1286 {
1287 switch ( LA(1) )
1288 {
1289 case LCURLY:
1290 {
1291 match(LCURLY);
1292 pointcutarguments(ms);
1293 match(RCURLY);
1294 match(RCURLY);
1295 break;
1296 }
1297 case RCURLY:
1298 {
1299 match(RCURLY);
1300 break;
1301 }
1302 default:
1303 {
1304 throw new NoViableAltException(LT(1), getFilename());
1305 }
1306 }
1307 }
1308 }
1309 catch (RecognitionException ex)
1310 {
1311 reportError(ex);
1312 consume();
1313 consumeUntil(tokenSet_0_);
1314 }
1315 }
1316
1317 protected void pointcutargument(
1318 MethodSignature ms
1319 ) //throws RecognitionException, TokenStreamException
1320 {
1321
1322
1323 String argType = String.Empty;
1324
1325
1326 try { // for error handling
1327 switch ( LA(1) )
1328 {
1329 case ALL:
1330 {
1331 match(ALL);
1332
1333 ms.AddArgumentType( "*" );
1334
1335 break;
1336 }
1337 case ID:
1338 {
1339 argType=reg_ex(false);
1340
1341 ms.AddArgumentType( argType );
1342
1343 break;
1344 }
1345 default:
1346 {
1347 throw new NoViableAltException(LT(1), getFilename());
1348 }
1349 }
1350 }
1351 catch (RecognitionException ex)
1352 {
1353 reportError(ex);
1354 consume();
1355 consumeUntil(tokenSet_17_);
1356 }
1357 }
1358
1359 private void initializeFactory()
1360 {
1361 }
1362
1363 public static readonly string[] tokenNames_ = new string[] {
1364 @"""<0>""",
1365 @"""EOF""",
1366 @"""<2>""",
1367 @"""NULL_TREE_LOOKAHEAD""",
1368 @"""aspect""",
1369 @"""for""",
1370 @"""in""",
1371 @"""end""",
1372 @"""import""",
1373 @"""mixins""",
1374 @"""include""",
1375 @"""interceptors""",
1376 @"""advice""",
1377 @"""pointcut""",
1378 @"""method""",
1379 @"""property""",
1380 @"""propertyread""",
1381 @"""propertywrite""",
1382 @"""assignableFrom""",
1383 @"""customMatcher""",
1384 @"""excludes""",
1385 @"""includes""",
1386 @"""EOS""",
1387 @"""LBRACK""",
1388 @"""SEMI""",
1389 @"""RBRACK""",
1390 @"""STRING_LITERAL""",
1391 @"""COLON""",
1392 @"""ID""",
1393 @"""LCURLY""",
1394 @"""RCURLY""",
1395 @"""OR""",
1396 @"""ALL""",
1397 @"""COMMA""",
1398 @"""DOT""",
1399 @"""WS"""
1400 };
1401
1402 private static long[] mk_tokenSet_0_()
1403 {
1404 long[] data = { 2L, 0L};
1405 return data;
1406 }
1407 public static readonly BitSet tokenSet_0_ = new BitSet(mk_tokenSet_0_());
1408 private static long[] mk_tokenSet_1_()
1409 {
1410 long[] data = { 2834L, 0L};
1411 return data;
1412 }
1413 public static readonly BitSet tokenSet_1_ = new BitSet(mk_tokenSet_1_());
1414 private static long[] mk_tokenSet_2_()
1415 {
1416 long[] data = { 2578L, 0L};
1417 return data;
1418 }
1419 public static readonly BitSet tokenSet_2_ = new BitSet(mk_tokenSet_2_());
1420 private static long[] mk_tokenSet_3_()
1421 {
1422 long[] data = { 530L, 0L};
1423 return data;
1424 }
1425 public static readonly BitSet tokenSet_3_ = new BitSet(mk_tokenSet_3_());
1426 private static long[] mk_tokenSet_4_()
1427 {
1428 long[] data = { 18L, 0L};
1429 return data;
1430 }
1431 public static readonly BitSet tokenSet_4_ = new BitSet(mk_tokenSet_4_());
1432 private static long[] mk_tokenSet_5_()
1433 {
1434 long[] data = { 1125134290L, 0L};
1435 return data;
1436 }
1437 public static readonly BitSet tokenSet_5_ = new BitSet(mk_tokenSet_5_());
1438 private static long[] mk_tokenSet_6_()
1439 {
1440 long[] data = { 50331648L, 0L};
1441 return data;
1442 }
1443 public static readonly BitSet tokenSet_6_ = new BitSet(mk_tokenSet_6_());
1444 private static long[] mk_tokenSet_7_()
1445 {
1446 long[] data = { 1073751168L, 0L};
1447 return data;
1448 }
1449 public static readonly BitSet tokenSet_7_ = new BitSet(mk_tokenSet_7_());
1450 private static long[] mk_tokenSet_8_()
1451 {
1452 long[] data = { 1124082816L, 0L};
1453 return data;
1454 }
1455 public static readonly BitSet tokenSet_8_ = new BitSet(mk_tokenSet_8_());
1456 private static long[] mk_tokenSet_9_()
1457 {
1458 long[] data = { 1073741824L, 0L};
1459 return data;
1460 }
1461 public static readonly BitSet tokenSet_9_ = new BitSet(mk_tokenSet_9_());
1462 private static long[] mk_tokenSet_10_()
1463 {
1464 long[] data = { 9344L, 0L};
1465 return data;
1466 }
1467 public static readonly BitSet tokenSet_10_ = new BitSet(mk_tokenSet_10_());
1468 private static long[] mk_tokenSet_11_()
1469 {
1470 long[] data = { 8320L, 0L};
1471 return data;
1472 }
1473 public static readonly BitSet tokenSet_11_ = new BitSet(mk_tokenSet_11_());
1474 private static long[] mk_tokenSet_12_()
1475 {
1476 long[] data = { 536870912L, 0L};
1477 return data;
1478 }
1479 public static readonly BitSet tokenSet_12_ = new BitSet(mk_tokenSet_12_());
1480 private static long[] mk_tokenSet_13_()
1481 {
1482 long[] data = { 4224L, 0L};
1483 return data;
1484 }
1485 public static readonly BitSet tokenSet_13_ = new BitSet(mk_tokenSet_13_());
1486 private static long[] mk_tokenSet_14_()
1487 {
1488 long[] data = { 128L, 0L};
1489 return data;
1490 }
1491 public static readonly BitSet tokenSet_14_ = new BitSet(mk_tokenSet_14_());
1492 private static long[] mk_tokenSet_15_()
1493 {
1494 long[] data = { 2684354560L, 0L};
1495 return data;
1496 }
1497 public static readonly BitSet tokenSet_15_ = new BitSet(mk_tokenSet_15_());
1498 private static long[] mk_tokenSet_16_()
1499 {
1500 long[] data = { 14763954304L, 0L};
1501 return data;
1502 }
1503 public static readonly BitSet tokenSet_16_ = new BitSet(mk_tokenSet_16_());
1504 private static long[] mk_tokenSet_17_()
1505 {
1506 long[] data = { 9663676416L, 0L};
1507 return data;
1508 }
1509 public static readonly BitSet tokenSet_17_ = new BitSet(mk_tokenSet_17_());
1510
1511 }
Git import of castle svn