1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 package org.apache.directory.api.ldap.trigger;
25
26 import java.util.ArrayList;
27 import java.util.List;
28
29 import org.apache.directory.api.i18n.I18n;
30 import org.apache.directory.api.ldap.model.name.Dn;
31 import org.apache.directory.api.ldap.model.schema.NormalizerMappingResolver;
32 import org.apache.directory.api.ldap.trigger.StoredProcedureOption;
33 import org.apache.directory.api.ldap.trigger.StoredProcedureParameter;
34 import org.apache.directory.api.ldap.trigger.TriggerSpecification.SPSpec;
35 import org.apache.directory.api.ldap.model.message.SearchScope;
36
37 import org.slf4j.Logger;
38 import org.slf4j.LoggerFactory;
39
40
41 import antlr.TokenBuffer;
42 import antlr.TokenStreamException;
43 import antlr.TokenStreamIOException;
44 import antlr.ANTLRException;
45 import antlr.LLkParser;
46 import antlr.Token;
47 import antlr.TokenStream;
48 import antlr.RecognitionException;
49 import antlr.NoViableAltException;
50 import antlr.MismatchedTokenException;
51 import antlr.SemanticException;
52 import antlr.ParserSharedInputState;
53 import antlr.collections.impl.BitSet;
54
55
56
57
58
59
60 public class AntlrTriggerSpecificationParser extends antlr.LLkParser implements AntlrTriggerSpecificationParserTokenTypes
61 {
62
63 private static final Logger log = LoggerFactory.getLogger( AntlrTriggerSpecificationParser.class );
64
65 private NormalizerMappingResolver resolver;
66
67 private ActionTime triggerActionTime;
68
69 private LdapOperation triggerLdapOperation;
70
71 private String triggerStoredProcedureName;
72
73 private List<StoredProcedureParameter> triggerStoredProcedureParameters;
74
75 private List<StoredProcedureOption> triggerStoredProcedureOptions;
76
77 private List<SPSpec> spSpecs;
78
79 public void init()
80 {
81 }
82
83
84
85
86
87
88
89 public void setNormalizerMappingResolver( NormalizerMappingResolver resolver )
90 {
91 this.resolver = resolver;
92 }
93
94 protected AntlrTriggerSpecificationParser(TokenBuffer tokenBuf, int k) {
95 super(tokenBuf,k);
96 tokenNames = _tokenNames;
97 }
98
99 public AntlrTriggerSpecificationParser(TokenBuffer tokenBuf) {
100 this(tokenBuf,1);
101 }
102
103 protected AntlrTriggerSpecificationParser(TokenStream lexer, int k) {
104 super(lexer,k);
105 tokenNames = _tokenNames;
106 }
107
108 public AntlrTriggerSpecificationParser(TokenStream lexer) {
109 this(lexer,1);
110 }
111
112 public AntlrTriggerSpecificationParser(ParserSharedInputState state) {
113 super(state,1);
114 tokenNames = _tokenNames;
115 }
116
117 public final TriggerSpecification wrapperEntryPoint() throws RecognitionException, TokenStreamException {
118 TriggerSpecification triggerSpec ;
119
120
121 log.debug( "entered wrapperEntryPoint()" );
122 triggerSpec = null;
123 spSpecs = new ArrayList<SPSpec>();
124
125
126 {
127 _loop3:
128 do {
129 if ((LA(1)==SP)) {
130 match(SP);
131 }
132 else {
133 break _loop3;
134 }
135
136 } while (true);
137 }
138 triggerSpec=triggerSpecification();
139 match(Token.EOF_TYPE);
140 return triggerSpec ;
141 }
142
143 public final TriggerSpecification triggerSpecification() throws RecognitionException, TokenStreamException {
144 TriggerSpecification triggerSpec ;
145
146
147 log.debug( "entered triggerSpecification()" );
148 triggerSpec = null;
149
150
151 actionTime();
152 {
153 int _cnt6=0;
154 _loop6:
155 do {
156 if ((LA(1)==SP)) {
157 match(SP);
158 }
159 else {
160 if ( _cnt6>=1 ) { break _loop6; } else {throw new NoViableAltException(LT(1), getFilename());}
161 }
162
163 _cnt6++;
164 } while (true);
165 }
166 ldapOperationAndStoredProcedureCalls();
167 triggerSpec = new TriggerSpecification( triggerLdapOperation,
168 triggerActionTime,
169 spSpecs
170 );
171
172 return triggerSpec ;
173 }
174
175 public final void actionTime() throws RecognitionException, TokenStreamException {
176
177
178 log.debug( "entered actionTime()" );
179
180
181 match(ID_AFTER);
182 triggerActionTime = ActionTime.AFTER;
183 }
184
185 public final void ldapOperationAndStoredProcedureCalls() throws RecognitionException, TokenStreamException {
186
187
188 log.debug( "entered ldapOperationAndStoredProcedureCall()" );
189
190
191 switch ( LA(1)) {
192 case ID_modify:
193 {
194 modifyOperationAndStoredProcedureCalls();
195 triggerLdapOperation = LdapOperation.MODIFY;
196 break;
197 }
198 case ID_add:
199 {
200 addOperationAndStoredProcedureCalls();
201 triggerLdapOperation = LdapOperation.ADD;
202 break;
203 }
204 case ID_delete:
205 {
206 deleteOperationAndStoredProcedureCalls();
207 triggerLdapOperation = LdapOperation.DELETE;
208 break;
209 }
210 case ID_modifyDN:
211 {
212 modifyDNOperationAndStoredProcedureCalls();
213 break;
214 }
215 default:
216 {
217 throw new NoViableAltException(LT(1), getFilename());
218 }
219 }
220 }
221
222 public final void modifyOperationAndStoredProcedureCalls() throws RecognitionException, TokenStreamException {
223
224
225 log.debug( "entered modifyOperationAndStoredProcedureCalls()" );
226
227
228 match(ID_modify);
229 {
230 int _cnt11=0;
231 _loop11:
232 do {
233 if ((LA(1)==SP)) {
234 match(SP);
235 }
236 else {
237 if ( _cnt11>=1 ) { break _loop11; } else {throw new NoViableAltException(LT(1), getFilename());}
238 }
239
240 _cnt11++;
241 } while (true);
242 }
243 {
244 int _cnt20=0;
245 _loop20:
246 do {
247 if ((LA(1)==ID_CALL)) {
248 theCompositeRuleForCallAndSPNameAndSPOptionList();
249 match(OPEN_PARAN);
250 {
251 _loop14:
252 do {
253 if ((LA(1)==SP)) {
254 match(SP);
255 }
256 else {
257 break _loop14;
258 }
259
260 } while (true);
261 }
262 {
263 switch ( LA(1)) {
264 case ID_object:
265 case ID_modification:
266 case ID_oldEntry:
267 case ID_newEntry:
268 case ID_operationPrincipal:
269 case ID_ldapContext:
270 {
271 modifyStoredProcedureParameterList();
272 break;
273 }
274 case CLOSE_PARAN:
275 {
276 break;
277 }
278 default:
279 {
280 throw new NoViableAltException(LT(1), getFilename());
281 }
282 }
283 }
284 match(CLOSE_PARAN);
285 {
286 _loop17:
287 do {
288 if ((LA(1)==SP)) {
289 match(SP);
290 }
291 else {
292 break _loop17;
293 }
294
295 } while (true);
296 }
297 match(SEMI);
298 {
299 _loop19:
300 do {
301 if ((LA(1)==SP)) {
302 match(SP);
303 }
304 else {
305 break _loop19;
306 }
307
308 } while (true);
309 }
310
311 spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
312
313 }
314 else {
315 if ( _cnt20>=1 ) { break _loop20; } else {throw new NoViableAltException(LT(1), getFilename());}
316 }
317
318 _cnt20++;
319 } while (true);
320 }
321 }
322
323 public final void addOperationAndStoredProcedureCalls() throws RecognitionException, TokenStreamException {
324
325
326 log.debug( "entered addOperationAndStoredProcedureCalls()" );
327
328
329 match(ID_add);
330 {
331 int _cnt23=0;
332 _loop23:
333 do {
334 if ((LA(1)==SP)) {
335 match(SP);
336 }
337 else {
338 if ( _cnt23>=1 ) { break _loop23; } else {throw new NoViableAltException(LT(1), getFilename());}
339 }
340
341 _cnt23++;
342 } while (true);
343 }
344 {
345 int _cnt32=0;
346 _loop32:
347 do {
348 if ((LA(1)==ID_CALL)) {
349 theCompositeRuleForCallAndSPNameAndSPOptionList();
350 match(OPEN_PARAN);
351 {
352 _loop26:
353 do {
354 if ((LA(1)==SP)) {
355 match(SP);
356 }
357 else {
358 break _loop26;
359 }
360
361 } while (true);
362 }
363 {
364 switch ( LA(1)) {
365 case ID_entry:
366 case ID_attributes:
367 case ID_operationPrincipal:
368 case ID_ldapContext:
369 {
370 addStoredProcedureParameterList();
371 break;
372 }
373 case CLOSE_PARAN:
374 {
375 break;
376 }
377 default:
378 {
379 throw new NoViableAltException(LT(1), getFilename());
380 }
381 }
382 }
383 match(CLOSE_PARAN);
384 {
385 _loop29:
386 do {
387 if ((LA(1)==SP)) {
388 match(SP);
389 }
390 else {
391 break _loop29;
392 }
393
394 } while (true);
395 }
396 match(SEMI);
397 {
398 _loop31:
399 do {
400 if ((LA(1)==SP)) {
401 match(SP);
402 }
403 else {
404 break _loop31;
405 }
406
407 } while (true);
408 }
409
410 spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
411
412 }
413 else {
414 if ( _cnt32>=1 ) { break _loop32; } else {throw new NoViableAltException(LT(1), getFilename());}
415 }
416
417 _cnt32++;
418 } while (true);
419 }
420 }
421
422 public final void deleteOperationAndStoredProcedureCalls() throws RecognitionException, TokenStreamException {
423
424
425 log.debug( "entered deleteOperationAndStoredProcedureCalls()" );
426
427
428 match(ID_delete);
429 {
430 int _cnt35=0;
431 _loop35:
432 do {
433 if ((LA(1)==SP)) {
434 match(SP);
435 }
436 else {
437 if ( _cnt35>=1 ) { break _loop35; } else {throw new NoViableAltException(LT(1), getFilename());}
438 }
439
440 _cnt35++;
441 } while (true);
442 }
443 {
444 int _cnt44=0;
445 _loop44:
446 do {
447 if ((LA(1)==ID_CALL)) {
448 theCompositeRuleForCallAndSPNameAndSPOptionList();
449 match(OPEN_PARAN);
450 {
451 _loop38:
452 do {
453 if ((LA(1)==SP)) {
454 match(SP);
455 }
456 else {
457 break _loop38;
458 }
459
460 } while (true);
461 }
462 {
463 switch ( LA(1)) {
464 case ID_name:
465 case ID_deletedEntry:
466 case ID_operationPrincipal:
467 case ID_ldapContext:
468 {
469 deleteStoredProcedureParameterList();
470 break;
471 }
472 case CLOSE_PARAN:
473 {
474 break;
475 }
476 default:
477 {
478 throw new NoViableAltException(LT(1), getFilename());
479 }
480 }
481 }
482 match(CLOSE_PARAN);
483 {
484 _loop41:
485 do {
486 if ((LA(1)==SP)) {
487 match(SP);
488 }
489 else {
490 break _loop41;
491 }
492
493 } while (true);
494 }
495 match(SEMI);
496 {
497 _loop43:
498 do {
499 if ((LA(1)==SP)) {
500 match(SP);
501 }
502 else {
503 break _loop43;
504 }
505
506 } while (true);
507 }
508
509 spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
510
511 }
512 else {
513 if ( _cnt44>=1 ) { break _loop44; } else {throw new NoViableAltException(LT(1), getFilename());}
514 }
515
516 _cnt44++;
517 } while (true);
518 }
519 }
520
521 public final void modifyDNOperationAndStoredProcedureCalls() throws RecognitionException, TokenStreamException {
522
523
524 log.debug( "entered modifyDNOperationAndStoredProcedureCalls()" );
525
526
527 match(ID_modifyDN);
528 match(DOT);
529 {
530 int _cnt57=0;
531 _loop57:
532 do {
533 if (((LA(1) >= ID_modifyDNRename && LA(1) <= ID_modifyDNImport))) {
534 {
535 switch ( LA(1)) {
536 case ID_modifyDNRename:
537 {
538 match(ID_modifyDNRename);
539 triggerLdapOperation = LdapOperation.MODIFYDN_RENAME;
540 break;
541 }
542 case ID_modifyDNExport:
543 {
544 match(ID_modifyDNExport);
545 triggerLdapOperation = LdapOperation.MODIFYDN_EXPORT;
546 break;
547 }
548 case ID_modifyDNImport:
549 {
550 match(ID_modifyDNImport);
551 triggerLdapOperation = LdapOperation.MODIFYDN_IMPORT;
552 break;
553 }
554 default:
555 {
556 throw new NoViableAltException(LT(1), getFilename());
557 }
558 }
559 }
560 {
561 int _cnt49=0;
562 _loop49:
563 do {
564 if ((LA(1)==SP)) {
565 match(SP);
566 }
567 else {
568 if ( _cnt49>=1 ) { break _loop49; } else {throw new NoViableAltException(LT(1), getFilename());}
569 }
570
571 _cnt49++;
572 } while (true);
573 }
574 theCompositeRuleForCallAndSPNameAndSPOptionList();
575 match(OPEN_PARAN);
576 {
577 _loop51:
578 do {
579 if ((LA(1)==SP)) {
580 match(SP);
581 }
582 else {
583 break _loop51;
584 }
585
586 } while (true);
587 }
588 {
589 switch ( LA(1)) {
590 case ID_entry:
591 case ID_newrdn:
592 case ID_deleteoldrdn:
593 case ID_newSuperior:
594 case ID_oldRDN:
595 case ID_oldSuperiorDN:
596 case ID_newDN:
597 case ID_operationPrincipal:
598 case ID_ldapContext:
599 {
600 modifyDNStoredProcedureParameterList();
601 break;
602 }
603 case CLOSE_PARAN:
604 {
605 break;
606 }
607 default:
608 {
609 throw new NoViableAltException(LT(1), getFilename());
610 }
611 }
612 }
613 match(CLOSE_PARAN);
614 {
615 _loop54:
616 do {
617 if ((LA(1)==SP)) {
618 match(SP);
619 }
620 else {
621 break _loop54;
622 }
623
624 } while (true);
625 }
626 match(SEMI);
627 {
628 _loop56:
629 do {
630 if ((LA(1)==SP)) {
631 match(SP);
632 }
633 else {
634 break _loop56;
635 }
636
637 } while (true);
638 }
639
640 spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
641
642 }
643 else {
644 if ( _cnt57>=1 ) { break _loop57; } else {throw new NoViableAltException(LT(1), getFilename());}
645 }
646
647 _cnt57++;
648 } while (true);
649 }
650 }
651
652 public final void theCompositeRuleForCallAndSPNameAndSPOptionList() throws RecognitionException, TokenStreamException {
653
654
655 log.debug( "entered theCompositeRuleForCallAndSPNameAndSPOptionList()" );
656
657
658 match(ID_CALL);
659
660 triggerStoredProcedureName = null;
661 triggerStoredProcedureParameters = new ArrayList<StoredProcedureParameter>();
662 triggerStoredProcedureOptions = new ArrayList<StoredProcedureOption>();
663
664 {
665 int _cnt60=0;
666 _loop60:
667 do {
668 if ((LA(1)==SP)) {
669 match(SP);
670 }
671 else {
672 if ( _cnt60>=1 ) { break _loop60; } else {throw new NoViableAltException(LT(1), getFilename());}
673 }
674
675 _cnt60++;
676 } while (true);
677 }
678 triggerStoredProcedureName=fullyQualifiedStoredProcedureName();
679 {
680 _loop62:
681 do {
682 if ((LA(1)==SP)) {
683 match(SP);
684 }
685 else {
686 break _loop62;
687 }
688
689 } while (true);
690 }
691 {
692 switch ( LA(1)) {
693 case OPEN_CURLY:
694 {
695 genericStoredProcedureOptionList();
696 {
697 _loop65:
698 do {
699 if ((LA(1)==SP)) {
700 match(SP);
701 }
702 else {
703 break _loop65;
704 }
705
706 } while (true);
707 }
708 break;
709 }
710 case OPEN_PARAN:
711 {
712 break;
713 }
714 default:
715 {
716 throw new NoViableAltException(LT(1), getFilename());
717 }
718 }
719 }
720
721 }
722
723 public final void modifyStoredProcedureParameterList() throws RecognitionException, TokenStreamException {
724
725
726 log.debug( "entered modifyStoredProcedureParameterList()" );
727
728
729 modifyStoredProcedureParameter();
730 {
731 _loop68:
732 do {
733 if ((LA(1)==SP)) {
734 match(SP);
735 }
736 else {
737 break _loop68;
738 }
739
740 } while (true);
741 }
742 {
743 _loop74:
744 do {
745 if ((LA(1)==SEP)) {
746 match(SEP);
747 {
748 _loop71:
749 do {
750 if ((LA(1)==SP)) {
751 match(SP);
752 }
753 else {
754 break _loop71;
755 }
756
757 } while (true);
758 }
759 modifyStoredProcedureParameter();
760 {
761 _loop73:
762 do {
763 if ((LA(1)==SP)) {
764 match(SP);
765 }
766 else {
767 break _loop73;
768 }
769
770 } while (true);
771 }
772 }
773 else {
774 break _loop74;
775 }
776
777 } while (true);
778 }
779 }
780
781 public final void addStoredProcedureParameterList() throws RecognitionException, TokenStreamException {
782
783
784 log.debug( "entered addStoredProcedureParameterList()" );
785
786
787 addStoredProcedureParameter();
788 {
789 _loop77:
790 do {
791 if ((LA(1)==SP)) {
792 match(SP);
793 }
794 else {
795 break _loop77;
796 }
797
798 } while (true);
799 }
800 {
801 _loop83:
802 do {
803 if ((LA(1)==SEP)) {
804 match(SEP);
805 {
806 _loop80:
807 do {
808 if ((LA(1)==SP)) {
809 match(SP);
810 }
811 else {
812 break _loop80;
813 }
814
815 } while (true);
816 }
817 addStoredProcedureParameter();
818 {
819 _loop82:
820 do {
821 if ((LA(1)==SP)) {
822 match(SP);
823 }
824 else {
825 break _loop82;
826 }
827
828 } while (true);
829 }
830 }
831 else {
832 break _loop83;
833 }
834
835 } while (true);
836 }
837 }
838
839 public final void deleteStoredProcedureParameterList() throws RecognitionException, TokenStreamException {
840
841
842 log.debug( "entered deleteStoredProcedureParameterList()" );
843
844
845 deleteStoredProcedureParameter();
846 {
847 _loop86:
848 do {
849 if ((LA(1)==SP)) {
850 match(SP);
851 }
852 else {
853 break _loop86;
854 }
855
856 } while (true);
857 }
858 {
859 _loop92:
860 do {
861 if ((LA(1)==SEP)) {
862 match(SEP);
863 {
864 _loop89:
865 do {
866 if ((LA(1)==SP)) {
867 match(SP);
868 }
869 else {
870 break _loop89;
871 }
872
873 } while (true);
874 }
875 deleteStoredProcedureParameter();
876 {
877 _loop91:
878 do {
879 if ((LA(1)==SP)) {
880 match(SP);
881 }
882 else {
883 break _loop91;
884 }
885
886 } while (true);
887 }
888 }
889 else {
890 break _loop92;
891 }
892
893 } while (true);
894 }
895 }
896
897 public final void modifyDNStoredProcedureParameterList() throws RecognitionException, TokenStreamException {
898
899
900 log.debug( "entered modifyDNStoredProcedureParameterList()" );
901
902
903 modifyDNStoredProcedureParameter();
904 {
905 _loop95:
906 do {
907 if ((LA(1)==SP)) {
908 match(SP);
909 }
910 else {
911 break _loop95;
912 }
913
914 } while (true);
915 }
916 {
917 _loop101:
918 do {
919 if ((LA(1)==SEP)) {
920 match(SEP);
921 {
922 _loop98:
923 do {
924 if ((LA(1)==SP)) {
925 match(SP);
926 }
927 else {
928 break _loop98;
929 }
930
931 } while (true);
932 }
933 modifyDNStoredProcedureParameter();
934 {
935 _loop100:
936 do {
937 if ((LA(1)==SP)) {
938 match(SP);
939 }
940 else {
941 break _loop100;
942 }
943
944 } while (true);
945 }
946 }
947 else {
948 break _loop101;
949 }
950
951 } while (true);
952 }
953 }
954
955 public final String fullyQualifiedStoredProcedureName() throws RecognitionException, TokenStreamException {
956 String spName ;
957
958 Token spNameToken = null;
959
960 log.debug( "entered fullyQualifiedStoredProcedureName()" );
961 spName = null;
962
963
964 spNameToken = LT(1);
965 match(UTF8String);
966 spName = spNameToken.getText();
967 return spName ;
968 }
969
970 public final void genericStoredProcedureOptionList() throws RecognitionException, TokenStreamException {
971
972
973 log.debug( "entered genericStoredProcedureOptionList()" );
974
975
976 match(OPEN_CURLY);
977 {
978 _loop112:
979 do {
980 if ((LA(1)==SP)) {
981 match(SP);
982 }
983 else {
984 break _loop112;
985 }
986
987 } while (true);
988 }
989 {
990 _loop122:
991 do {
992 if ((LA(1)==ID_languageScheme||LA(1)==ID_searchContext)) {
993 genericStoredProcedureOption();
994 {
995 _loop115:
996 do {
997 if ((LA(1)==SP)) {
998 match(SP);
999 }
1000 else {
1001 break _loop115;
1002 }
1003
1004 } while (true);
1005 }
1006 {
1007 _loop121:
1008 do {
1009 if ((LA(1)==SEP)) {
1010 match(SEP);
1011 {
1012 _loop118:
1013 do {
1014 if ((LA(1)==SP)) {
1015 match(SP);
1016 }
1017 else {
1018 break _loop118;
1019 }
1020
1021 } while (true);
1022 }
1023 genericStoredProcedureOption();
1024 {
1025 _loop120:
1026 do {
1027 if ((LA(1)==SP)) {
1028 match(SP);
1029 }
1030 else {
1031 break _loop120;
1032 }
1033
1034 } while (true);
1035 }
1036 }
1037 else {
1038 break _loop121;
1039 }
1040
1041 } while (true);
1042 }
1043 }
1044 else {
1045 break _loop122;
1046 }
1047
1048 } while (true);
1049 }
1050 match(CLOSE_CURLY);
1051 }
1052
1053 public final void modifyStoredProcedureParameter() throws RecognitionException, TokenStreamException {
1054
1055
1056 log.debug( "entered modifyStoredProcedureParameter()" );
1057
1058
1059 switch ( LA(1)) {
1060 case ID_object:
1061 {
1062 match(ID_object);
1063 triggerStoredProcedureParameters.add( StoredProcedureParameter.Modify_OBJECT.instance() );
1064 break;
1065 }
1066 case ID_modification:
1067 {
1068 match(ID_modification);
1069 triggerStoredProcedureParameters.add( StoredProcedureParameter.Modify_MODIFICATION.instance() );
1070 break;
1071 }
1072 case ID_oldEntry:
1073 {
1074 match(ID_oldEntry);
1075 triggerStoredProcedureParameters.add( StoredProcedureParameter.Modify_OLD_ENTRY.instance() );
1076 break;
1077 }
1078 case ID_newEntry:
1079 {
1080 match(ID_newEntry);
1081 triggerStoredProcedureParameters.add( StoredProcedureParameter.Modify_NEW_ENTRY.instance() );
1082 break;
1083 }
1084 case ID_operationPrincipal:
1085 case ID_ldapContext:
1086 {
1087 genericStoredProcedureParameter();
1088 break;
1089 }
1090 default:
1091 {
1092 throw new NoViableAltException(LT(1), getFilename());
1093 }
1094 }
1095 }
1096
1097 public final void addStoredProcedureParameter() throws RecognitionException, TokenStreamException {
1098
1099
1100 log.debug( "entered addStoredProcedureParameter()" );
1101
1102
1103 switch ( LA(1)) {
1104 case ID_entry:
1105 {
1106 match(ID_entry);
1107 triggerStoredProcedureParameters.add( StoredProcedureParameter.Add_ENTRY.instance() );
1108 break;
1109 }
1110 case ID_attributes:
1111 {
1112 match(ID_attributes);
1113 triggerStoredProcedureParameters.add( StoredProcedureParameter.Add_ATTRIBUTES.instance() );
1114 break;
1115 }
1116 case ID_operationPrincipal:
1117 case ID_ldapContext:
1118 {
1119 genericStoredProcedureParameter();
1120 break;
1121 }
1122 default:
1123 {
1124 throw new NoViableAltException(LT(1), getFilename());
1125 }
1126 }
1127 }
1128
1129 public final void deleteStoredProcedureParameter() throws RecognitionException, TokenStreamException {
1130
1131
1132 log.debug( "entered deleteStoredProcedureParameter()" );
1133
1134
1135 switch ( LA(1)) {
1136 case ID_name:
1137 {
1138 match(ID_name);
1139 triggerStoredProcedureParameters.add( StoredProcedureParameter.Delete_NAME.instance() );
1140 break;
1141 }
1142 case ID_deletedEntry:
1143 {
1144 match(ID_deletedEntry);
1145 triggerStoredProcedureParameters.add( StoredProcedureParameter.Delete_DELETED_ENTRY.instance() );
1146 break;
1147 }
1148 case ID_operationPrincipal:
1149 case ID_ldapContext:
1150 {
1151 genericStoredProcedureParameter();
1152 break;
1153 }
1154 default:
1155 {
1156 throw new NoViableAltException(LT(1), getFilename());
1157 }
1158 }
1159 }
1160
1161 public final void modifyDNStoredProcedureParameter() throws RecognitionException, TokenStreamException {
1162
1163
1164 log.debug( "entered modifyDNStoredProcedureParameter()" );
1165
1166
1167 switch ( LA(1)) {
1168 case ID_entry:
1169 {
1170 match(ID_entry);
1171 triggerStoredProcedureParameters.add( StoredProcedureParameter.ModifyDN_ENTRY.instance() );
1172 break;
1173 }
1174 case ID_newrdn:
1175 {
1176 match(ID_newrdn);
1177 triggerStoredProcedureParameters.add( StoredProcedureParameter.ModifyDN_NEW_RDN.instance() );
1178 break;
1179 }
1180 case ID_deleteoldrdn:
1181 {
1182 match(ID_deleteoldrdn);
1183 triggerStoredProcedureParameters.add( StoredProcedureParameter.ModifyDN_DELETE_OLD_RDN.instance() );
1184 break;
1185 }
1186 case ID_newSuperior:
1187 {
1188 match(ID_newSuperior);
1189 triggerStoredProcedureParameters.add( StoredProcedureParameter.ModifyDN_NEW_SUPERIOR.instance() );
1190 break;
1191 }
1192 case ID_oldRDN:
1193 {
1194 match(ID_oldRDN);
1195 triggerStoredProcedureParameters.add( StoredProcedureParameter.ModifyDN_OLD_RDN.instance() );
1196 break;
1197 }
1198 case ID_oldSuperiorDN:
1199 {
1200 match(ID_oldSuperiorDN);
1201 triggerStoredProcedureParameters.add( StoredProcedureParameter.ModifyDN_OLD_SUPERIOR_DN.instance() );
1202 break;
1203 }
1204 case ID_newDN:
1205 {
1206 match(ID_newDN);
1207 triggerStoredProcedureParameters.add( StoredProcedureParameter.ModifyDN_NEW_DN.instance() );
1208 break;
1209 }
1210 case ID_operationPrincipal:
1211 case ID_ldapContext:
1212 {
1213 genericStoredProcedureParameter();
1214 break;
1215 }
1216 default:
1217 {
1218 throw new NoViableAltException(LT(1), getFilename());
1219 }
1220 }
1221 }
1222
1223 public final void genericStoredProcedureParameter() throws RecognitionException, TokenStreamException {
1224
1225
1226 log.debug( "entered genericStoredProcedureParameter()" );
1227
1228
1229 switch ( LA(1)) {
1230 case ID_ldapContext:
1231 {
1232 ldapContextStoredProcedureParameter();
1233 break;
1234 }
1235 case ID_operationPrincipal:
1236 {
1237 match(ID_operationPrincipal);
1238 triggerStoredProcedureParameters.add( StoredProcedureParameter.Generic_OPERATION_PRINCIPAL.instance() );
1239 break;
1240 }
1241 default:
1242 {
1243 throw new NoViableAltException(LT(1), getFilename());
1244 }
1245 }
1246 }
1247
1248 public final void ldapContextStoredProcedureParameter() throws RecognitionException, TokenStreamException {
1249
1250
1251 log.debug( "entered ldapContextStoredProcedureParameter()" );
1252 Dn ldapContext = null;
1253
1254
1255 match(ID_ldapContext);
1256 {
1257 int _cnt109=0;
1258 _loop109:
1259 do {
1260 if ((LA(1)==SP)) {
1261 match(SP);
1262 }
1263 else {
1264 if ( _cnt109>=1 ) { break _loop109; } else {throw new NoViableAltException(LT(1), getFilename());}
1265 }
1266
1267 _cnt109++;
1268 } while (true);
1269 }
1270 ldapContext=distinguishedName();
1271 triggerStoredProcedureParameters.add( StoredProcedureParameter.Generic_LDAP_CONTEXT.instance( ldapContext ) );
1272 }
1273
1274 public final Dn distinguishedName() throws RecognitionException, TokenStreamException {
1275 Dn name ;
1276
1277 Token nameToken = null;
1278
1279 log.debug( "entered distinguishedName()" );
1280 name = null;
1281
1282
1283 try {
1284 nameToken = LT(1);
1285 match(UTF8String);
1286
1287 name = new Dn( nameToken.getText() );
1288
1289 }
1290 catch (Exception e) {
1291
1292 throw new RecognitionException( I18n.err( I18n.ERR_11003_NAME_PARSE_FAILED, nameToken.getText(), e.getMessage() ) );
1293
1294 }
1295 return name ;
1296 }
1297
1298 public final void genericStoredProcedureOption() throws RecognitionException, TokenStreamException {
1299
1300
1301 log.debug( "entered genericStoredProcedureOption()" );
1302 StoredProcedureOption spOption = null;
1303
1304
1305 {
1306 switch ( LA(1)) {
1307 case ID_languageScheme:
1308 {
1309 spOption=storedProcedureLanguageSchemeOption();
1310 break;
1311 }
1312 case ID_searchContext:
1313 {
1314 spOption=storedProcedureSearchContextOption();
1315 break;
1316 }
1317 default:
1318 {
1319 throw new NoViableAltException(LT(1), getFilename());
1320 }
1321 }
1322 }
1323 triggerStoredProcedureOptions.add( spOption );
1324 }
1325
1326 public final StoredProcedureLanguageSchemeOption storedProcedureLanguageSchemeOption() throws RecognitionException, TokenStreamException {
1327 StoredProcedureLanguageSchemeOption spLanguageSchemeOption ;
1328
1329 Token languageToken = null;
1330
1331 log.debug( "entered storedProcedureLanguageSchemeOption()" );
1332 spLanguageSchemeOption = null;
1333
1334
1335 match(ID_languageScheme);
1336 {
1337 int _cnt127=0;
1338 _loop127:
1339 do {
1340 if ((LA(1)==SP)) {
1341 match(SP);
1342 }
1343 else {
1344 if ( _cnt127>=1 ) { break _loop127; } else {throw new NoViableAltException(LT(1), getFilename());}
1345 }
1346
1347 _cnt127++;
1348 } while (true);
1349 }
1350 languageToken = LT(1);
1351 match(UTF8String);
1352 spLanguageSchemeOption = new StoredProcedureLanguageSchemeOption( languageToken.getText() );
1353 return spLanguageSchemeOption ;
1354 }
1355
1356 public final StoredProcedureSearchContextOption storedProcedureSearchContextOption() throws RecognitionException, TokenStreamException {
1357 StoredProcedureSearchContextOption spSearchContextOption ;
1358
1359
1360 log.debug( "entered storedProcedureSearchContextOption()" );
1361 spSearchContextOption = null;
1362 SearchScope searchScope = SearchScope.OBJECT;
1363 Dn spSearchContext = null;
1364
1365
1366 match(ID_searchContext);
1367 {
1368 int _cnt130=0;
1369 _loop130:
1370 do {
1371 if ((LA(1)==SP)) {
1372 match(SP);
1373 }
1374 else {
1375 if ( _cnt130>=1 ) { break _loop130; } else {throw new NoViableAltException(LT(1), getFilename());}
1376 }
1377
1378 _cnt130++;
1379 } while (true);
1380 }
1381 {
1382 switch ( LA(1)) {
1383 case OPEN_CURLY:
1384 {
1385 match(OPEN_CURLY);
1386 {
1387 _loop133:
1388 do {
1389 if ((LA(1)==SP)) {
1390 match(SP);
1391 }
1392 else {
1393 break _loop133;
1394 }
1395
1396 } while (true);
1397 }
1398 {
1399 switch ( LA(1)) {
1400 case ID_search_scope:
1401 {
1402 match(ID_search_scope);
1403 {
1404 int _cnt136=0;
1405 _loop136:
1406 do {
1407 if ((LA(1)==SP)) {
1408 match(SP);
1409 }
1410 else {
1411 if ( _cnt136>=1 ) { break _loop136; } else {throw new NoViableAltException(LT(1), getFilename());}
1412 }
1413
1414 _cnt136++;
1415 } while (true);
1416 }
1417 searchScope=storedProcedureSearchScope();
1418 {
1419 _loop138:
1420 do {
1421 if ((LA(1)==SP)) {
1422 match(SP);
1423 }
1424 else {
1425 break _loop138;
1426 }
1427
1428 } while (true);
1429 }
1430 break;
1431 }
1432 case CLOSE_CURLY:
1433 {
1434 break;
1435 }
1436 default:
1437 {
1438 throw new NoViableAltException(LT(1), getFilename());
1439 }
1440 }
1441 }
1442 match(CLOSE_CURLY);
1443 {
1444 int _cnt140=0;
1445 _loop140:
1446 do {
1447 if ((LA(1)==SP)) {
1448 match(SP);
1449 }
1450 else {
1451 if ( _cnt140>=1 ) { break _loop140; } else {throw new NoViableAltException(LT(1), getFilename());}
1452 }
1453
1454 _cnt140++;
1455 } while (true);
1456 }
1457 break;
1458 }
1459 case UTF8String:
1460 {
1461 break;
1462 }
1463 default:
1464 {
1465 throw new NoViableAltException(LT(1), getFilename());
1466 }
1467 }
1468 }
1469 spSearchContext=storedProcedureSearchContext();
1470 spSearchContextOption = new StoredProcedureSearchContextOption( spSearchContext, searchScope );
1471 return spSearchContextOption ;
1472 }
1473
1474 public final SearchScope storedProcedureSearchScope() throws RecognitionException, TokenStreamException {
1475 SearchScope scope ;
1476
1477
1478 log.debug( "entered storedProcedureSearchScope()" );
1479 scope = null;
1480
1481
1482 switch ( LA(1)) {
1483 case ID_scope_base:
1484 {
1485 match(ID_scope_base);
1486 scope = SearchScope.OBJECT;
1487 break;
1488 }
1489 case ID_scope_one:
1490 {
1491 match(ID_scope_one);
1492 scope = SearchScope.ONELEVEL;
1493 break;
1494 }
1495 case ID_scope_subtree:
1496 {
1497 match(ID_scope_subtree);
1498 scope = SearchScope.SUBTREE;
1499 break;
1500 }
1501 default:
1502 {
1503 throw new NoViableAltException(LT(1), getFilename());
1504 }
1505 }
1506 return scope ;
1507 }
1508
1509 public final Dn storedProcedureSearchContext() throws RecognitionException, TokenStreamException {
1510 Dn spSearchContext ;
1511
1512
1513 log.debug( "entered storedProcedureSearchContext()" );
1514 spSearchContext = null;
1515
1516
1517 spSearchContext=distinguishedName();
1518 return spSearchContext ;
1519 }
1520
1521
1522 public static final String[] _tokenNames = {
1523 "<0>",
1524 "EOF",
1525 "<2>",
1526 "NULL_TREE_LOOKAHEAD",
1527 "SP",
1528 "\"after\"",
1529 "\"modify\"",
1530 "OPEN_PARAN",
1531 "CLOSE_PARAN",
1532 "SEMI",
1533 "\"add\"",
1534 "\"delete\"",
1535 "\"modifydn\"",
1536 "DOT",
1537 "\"rename\"",
1538 "\"export\"",
1539 "\"import\"",
1540 "\"call\"",
1541 "SEP",
1542 "\"$object\"",
1543 "\"$modification\"",
1544 "\"$oldentry\"",
1545 "\"$newentry\"",
1546 "\"$entry\"",
1547 "\"$attributes\"",
1548 "\"$name\"",
1549 "\"$deletedentry\"",
1550 "\"$newrdn\"",
1551 "\"$deleteoldrdn\"",
1552 "\"$newSuperior\"",
1553 "\"$oldRdn\"",
1554 "\"$oldSuperiorDn\"",
1555 "\"$newDn\"",
1556 "\"$operationprincipal\"",
1557 "\"$ldapcontext\"",
1558 "OPEN_CURLY",
1559 "CLOSE_CURLY",
1560 "\"languagescheme\"",
1561 "UTF8String",
1562 "\"searchcontext\"",
1563 "\"scope\"",
1564 "\"base\"",
1565 "\"one\"",
1566 "\"subtree\"",
1567 "SAFEUTF8CHAR",
1568 "COMMENT",
1569 "IDENTIFIER",
1570 "ALPHA"
1571 };
1572
1573
1574 }