001 // $ANTLR 2.7.4: "TriggerSpecification.g" -> "AntlrTriggerSpecificationParser.java"$
002
003 /*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements. See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership. The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License. You may obtain a copy of the License at
011 *
012 * http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied. See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 *
021 */
022
023
024 package org.apache.directory.shared.ldap.trigger;
025
026 import java.util.ArrayList;
027 import java.util.List;
028
029 import org.apache.directory.shared.ldap.name.DN;
030 import org.apache.directory.shared.ldap.schema.NormalizerMappingResolver;
031 import org.apache.directory.shared.ldap.trigger.StoredProcedureOption;
032 import org.apache.directory.shared.ldap.trigger.StoredProcedureParameter;
033 import org.apache.directory.shared.ldap.trigger.TriggerSpecification.SPSpec;
034 import org.apache.directory.shared.ldap.filter.SearchScope;
035
036 import org.slf4j.Logger;
037 import org.slf4j.LoggerFactory;
038
039
040 import antlr.TokenBuffer;
041 import antlr.TokenStreamException;
042 import antlr.TokenStreamIOException;
043 import antlr.ANTLRException;
044 import antlr.LLkParser;
045 import antlr.Token;
046 import antlr.TokenStream;
047 import antlr.RecognitionException;
048 import antlr.NoViableAltException;
049 import antlr.MismatchedTokenException;
050 import antlr.SemanticException;
051 import antlr.ParserSharedInputState;
052 import antlr.collections.impl.BitSet;
053
054 /**
055 * The ANTLR generated TriggerSpecification parser.
056 *
057 * @see http://docs.safehaus.org/display/APACHEDS/Grammar+for+Triggers
058 *
059 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
060 * @version $Rev:$, $Date:$
061 */
062 public class AntlrTriggerSpecificationParser extends antlr.LLkParser implements AntlrTriggerSpecificationParserTokenTypes
063 {
064
065 private static final Logger log = LoggerFactory.getLogger( AntlrTriggerSpecificationParser.class );
066
067 private NormalizerMappingResolver resolver;
068
069 private ActionTime triggerActionTime;
070
071 private LdapOperation triggerLdapOperation;
072
073 private String triggerStoredProcedureName;
074
075 private List<StoredProcedureParameter> triggerStoredProcedureParameters;
076
077 private List<StoredProcedureOption> triggerStoredProcedureOptions;
078
079 private List<SPSpec> spSpecs;
080
081 public void init()
082 {
083 }
084
085
086 /**
087 * Sets the NameComponentNormalizer for this parser's dnParser.
088 */
089 public void setNormalizerMappingResolver( NormalizerMappingResolver resolver )
090 {
091 this.resolver = resolver;
092 }
093
094 protected AntlrTriggerSpecificationParser(TokenBuffer tokenBuf, int k) {
095 super(tokenBuf,k);
096 tokenNames = _tokenNames;
097 }
098
099 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 _loop1704:
128 do {
129 if ((LA(1)==SP)) {
130 match(SP);
131 }
132 else {
133 break _loop1704;
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 _cnt1707=0;
154 _loop1707:
155 do {
156 if ((LA(1)==SP)) {
157 match(SP);
158 }
159 else {
160 if ( _cnt1707>=1 ) { break _loop1707; } else {throw new NoViableAltException(LT(1), getFilename());}
161 }
162
163 _cnt1707++;
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 _cnt1712=0;
231 _loop1712:
232 do {
233 if ((LA(1)==SP)) {
234 match(SP);
235 }
236 else {
237 if ( _cnt1712>=1 ) { break _loop1712; } else {throw new NoViableAltException(LT(1), getFilename());}
238 }
239
240 _cnt1712++;
241 } while (true);
242 }
243 {
244 int _cnt1721=0;
245 _loop1721:
246 do {
247 if ((LA(1)==ID_CALL)) {
248 theCompositeRuleForCallAndSPNameAndSPOptionList();
249 match(OPEN_PARAN);
250 {
251 _loop1715:
252 do {
253 if ((LA(1)==SP)) {
254 match(SP);
255 }
256 else {
257 break _loop1715;
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 _loop1718:
287 do {
288 if ((LA(1)==SP)) {
289 match(SP);
290 }
291 else {
292 break _loop1718;
293 }
294
295 } while (true);
296 }
297 match(SEMI);
298 {
299 _loop1720:
300 do {
301 if ((LA(1)==SP)) {
302 match(SP);
303 }
304 else {
305 break _loop1720;
306 }
307
308 } while (true);
309 }
310
311 spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
312
313 }
314 else {
315 if ( _cnt1721>=1 ) { break _loop1721; } else {throw new NoViableAltException(LT(1), getFilename());}
316 }
317
318 _cnt1721++;
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 _cnt1724=0;
332 _loop1724:
333 do {
334 if ((LA(1)==SP)) {
335 match(SP);
336 }
337 else {
338 if ( _cnt1724>=1 ) { break _loop1724; } else {throw new NoViableAltException(LT(1), getFilename());}
339 }
340
341 _cnt1724++;
342 } while (true);
343 }
344 {
345 int _cnt1733=0;
346 _loop1733:
347 do {
348 if ((LA(1)==ID_CALL)) {
349 theCompositeRuleForCallAndSPNameAndSPOptionList();
350 match(OPEN_PARAN);
351 {
352 _loop1727:
353 do {
354 if ((LA(1)==SP)) {
355 match(SP);
356 }
357 else {
358 break _loop1727;
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 _loop1730:
386 do {
387 if ((LA(1)==SP)) {
388 match(SP);
389 }
390 else {
391 break _loop1730;
392 }
393
394 } while (true);
395 }
396 match(SEMI);
397 {
398 _loop1732:
399 do {
400 if ((LA(1)==SP)) {
401 match(SP);
402 }
403 else {
404 break _loop1732;
405 }
406
407 } while (true);
408 }
409
410 spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
411
412 }
413 else {
414 if ( _cnt1733>=1 ) { break _loop1733; } else {throw new NoViableAltException(LT(1), getFilename());}
415 }
416
417 _cnt1733++;
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 _cnt1736=0;
431 _loop1736:
432 do {
433 if ((LA(1)==SP)) {
434 match(SP);
435 }
436 else {
437 if ( _cnt1736>=1 ) { break _loop1736; } else {throw new NoViableAltException(LT(1), getFilename());}
438 }
439
440 _cnt1736++;
441 } while (true);
442 }
443 {
444 int _cnt1745=0;
445 _loop1745:
446 do {
447 if ((LA(1)==ID_CALL)) {
448 theCompositeRuleForCallAndSPNameAndSPOptionList();
449 match(OPEN_PARAN);
450 {
451 _loop1739:
452 do {
453 if ((LA(1)==SP)) {
454 match(SP);
455 }
456 else {
457 break _loop1739;
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 _loop1742:
485 do {
486 if ((LA(1)==SP)) {
487 match(SP);
488 }
489 else {
490 break _loop1742;
491 }
492
493 } while (true);
494 }
495 match(SEMI);
496 {
497 _loop1744:
498 do {
499 if ((LA(1)==SP)) {
500 match(SP);
501 }
502 else {
503 break _loop1744;
504 }
505
506 } while (true);
507 }
508
509 spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
510
511 }
512 else {
513 if ( _cnt1745>=1 ) { break _loop1745; } else {throw new NoViableAltException(LT(1), getFilename());}
514 }
515
516 _cnt1745++;
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 _cnt1758=0;
531 _loop1758:
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 _cnt1750=0;
562 _loop1750:
563 do {
564 if ((LA(1)==SP)) {
565 match(SP);
566 }
567 else {
568 if ( _cnt1750>=1 ) { break _loop1750; } else {throw new NoViableAltException(LT(1), getFilename());}
569 }
570
571 _cnt1750++;
572 } while (true);
573 }
574 theCompositeRuleForCallAndSPNameAndSPOptionList();
575 match(OPEN_PARAN);
576 {
577 _loop1752:
578 do {
579 if ((LA(1)==SP)) {
580 match(SP);
581 }
582 else {
583 break _loop1752;
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 _loop1755:
616 do {
617 if ((LA(1)==SP)) {
618 match(SP);
619 }
620 else {
621 break _loop1755;
622 }
623
624 } while (true);
625 }
626 match(SEMI);
627 {
628 _loop1757:
629 do {
630 if ((LA(1)==SP)) {
631 match(SP);
632 }
633 else {
634 break _loop1757;
635 }
636
637 } while (true);
638 }
639
640 spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
641
642 }
643 else {
644 if ( _cnt1758>=1 ) { break _loop1758; } else {throw new NoViableAltException(LT(1), getFilename());}
645 }
646
647 _cnt1758++;
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 _cnt1761=0;
666 _loop1761:
667 do {
668 if ((LA(1)==SP)) {
669 match(SP);
670 }
671 else {
672 if ( _cnt1761>=1 ) { break _loop1761; } else {throw new NoViableAltException(LT(1), getFilename());}
673 }
674
675 _cnt1761++;
676 } while (true);
677 }
678 triggerStoredProcedureName=fullyQualifiedStoredProcedureName();
679 {
680 _loop1763:
681 do {
682 if ((LA(1)==SP)) {
683 match(SP);
684 }
685 else {
686 break _loop1763;
687 }
688
689 } while (true);
690 }
691 {
692 switch ( LA(1)) {
693 case OPEN_CURLY:
694 {
695 genericStoredProcedureOptionList();
696 {
697 _loop1766:
698 do {
699 if ((LA(1)==SP)) {
700 match(SP);
701 }
702 else {
703 break _loop1766;
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 _loop1769:
732 do {
733 if ((LA(1)==SP)) {
734 match(SP);
735 }
736 else {
737 break _loop1769;
738 }
739
740 } while (true);
741 }
742 {
743 _loop1775:
744 do {
745 if ((LA(1)==SEP)) {
746 match(SEP);
747 {
748 _loop1772:
749 do {
750 if ((LA(1)==SP)) {
751 match(SP);
752 }
753 else {
754 break _loop1772;
755 }
756
757 } while (true);
758 }
759 modifyStoredProcedureParameter();
760 {
761 _loop1774:
762 do {
763 if ((LA(1)==SP)) {
764 match(SP);
765 }
766 else {
767 break _loop1774;
768 }
769
770 } while (true);
771 }
772 }
773 else {
774 break _loop1775;
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 _loop1778:
790 do {
791 if ((LA(1)==SP)) {
792 match(SP);
793 }
794 else {
795 break _loop1778;
796 }
797
798 } while (true);
799 }
800 {
801 _loop1784:
802 do {
803 if ((LA(1)==SEP)) {
804 match(SEP);
805 {
806 _loop1781:
807 do {
808 if ((LA(1)==SP)) {
809 match(SP);
810 }
811 else {
812 break _loop1781;
813 }
814
815 } while (true);
816 }
817 addStoredProcedureParameter();
818 {
819 _loop1783:
820 do {
821 if ((LA(1)==SP)) {
822 match(SP);
823 }
824 else {
825 break _loop1783;
826 }
827
828 } while (true);
829 }
830 }
831 else {
832 break _loop1784;
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 _loop1787:
848 do {
849 if ((LA(1)==SP)) {
850 match(SP);
851 }
852 else {
853 break _loop1787;
854 }
855
856 } while (true);
857 }
858 {
859 _loop1793:
860 do {
861 if ((LA(1)==SEP)) {
862 match(SEP);
863 {
864 _loop1790:
865 do {
866 if ((LA(1)==SP)) {
867 match(SP);
868 }
869 else {
870 break _loop1790;
871 }
872
873 } while (true);
874 }
875 deleteStoredProcedureParameter();
876 {
877 _loop1792:
878 do {
879 if ((LA(1)==SP)) {
880 match(SP);
881 }
882 else {
883 break _loop1792;
884 }
885
886 } while (true);
887 }
888 }
889 else {
890 break _loop1793;
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 _loop1796:
906 do {
907 if ((LA(1)==SP)) {
908 match(SP);
909 }
910 else {
911 break _loop1796;
912 }
913
914 } while (true);
915 }
916 {
917 _loop1802:
918 do {
919 if ((LA(1)==SEP)) {
920 match(SEP);
921 {
922 _loop1799:
923 do {
924 if ((LA(1)==SP)) {
925 match(SP);
926 }
927 else {
928 break _loop1799;
929 }
930
931 } while (true);
932 }
933 modifyDNStoredProcedureParameter();
934 {
935 _loop1801:
936 do {
937 if ((LA(1)==SP)) {
938 match(SP);
939 }
940 else {
941 break _loop1801;
942 }
943
944 } while (true);
945 }
946 }
947 else {
948 break _loop1802;
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 _loop1813:
979 do {
980 if ((LA(1)==SP)) {
981 match(SP);
982 }
983 else {
984 break _loop1813;
985 }
986
987 } while (true);
988 }
989 {
990 _loop1823:
991 do {
992 if ((LA(1)==ID_languageScheme||LA(1)==ID_searchContext)) {
993 genericStoredProcedureOption();
994 {
995 _loop1816:
996 do {
997 if ((LA(1)==SP)) {
998 match(SP);
999 }
1000 else {
1001 break _loop1816;
1002 }
1003
1004 } while (true);
1005 }
1006 {
1007 _loop1822:
1008 do {
1009 if ((LA(1)==SEP)) {
1010 match(SEP);
1011 {
1012 _loop1819:
1013 do {
1014 if ((LA(1)==SP)) {
1015 match(SP);
1016 }
1017 else {
1018 break _loop1819;
1019 }
1020
1021 } while (true);
1022 }
1023 genericStoredProcedureOption();
1024 {
1025 _loop1821:
1026 do {
1027 if ((LA(1)==SP)) {
1028 match(SP);
1029 }
1030 else {
1031 break _loop1821;
1032 }
1033
1034 } while (true);
1035 }
1036 }
1037 else {
1038 break _loop1822;
1039 }
1040
1041 } while (true);
1042 }
1043 }
1044 else {
1045 break _loop1823;
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 _cnt1810=0;
1258 _loop1810:
1259 do {
1260 if ((LA(1)==SP)) {
1261 match(SP);
1262 }
1263 else {
1264 if ( _cnt1810>=1 ) { break _loop1810; } else {throw new NoViableAltException(LT(1), getFilename());}
1265 }
1266
1267 _cnt1810++;
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 { // for error handling
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( "name parse failed for " + 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 _cnt1828=0;
1338 _loop1828:
1339 do {
1340 if ((LA(1)==SP)) {
1341 match(SP);
1342 }
1343 else {
1344 if ( _cnt1828>=1 ) { break _loop1828; } else {throw new NoViableAltException(LT(1), getFilename());}
1345 }
1346
1347 _cnt1828++;
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; // default scope
1363 DN spSearchContext = null;
1364
1365
1366 match(ID_searchContext);
1367 {
1368 int _cnt1831=0;
1369 _loop1831:
1370 do {
1371 if ((LA(1)==SP)) {
1372 match(SP);
1373 }
1374 else {
1375 if ( _cnt1831>=1 ) { break _loop1831; } else {throw new NoViableAltException(LT(1), getFilename());}
1376 }
1377
1378 _cnt1831++;
1379 } while (true);
1380 }
1381 {
1382 switch ( LA(1)) {
1383 case OPEN_CURLY:
1384 {
1385 match(OPEN_CURLY);
1386 {
1387 _loop1834:
1388 do {
1389 if ((LA(1)==SP)) {
1390 match(SP);
1391 }
1392 else {
1393 break _loop1834;
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 _cnt1837=0;
1405 _loop1837:
1406 do {
1407 if ((LA(1)==SP)) {
1408 match(SP);
1409 }
1410 else {
1411 if ( _cnt1837>=1 ) { break _loop1837; } else {throw new NoViableAltException(LT(1), getFilename());}
1412 }
1413
1414 _cnt1837++;
1415 } while (true);
1416 }
1417 searchScope=storedProcedureSearchScope();
1418 {
1419 _loop1839:
1420 do {
1421 if ((LA(1)==SP)) {
1422 match(SP);
1423 }
1424 else {
1425 break _loop1839;
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 _cnt1841=0;
1445 _loop1841:
1446 do {
1447 if ((LA(1)==SP)) {
1448 match(SP);
1449 }
1450 else {
1451 if ( _cnt1841>=1 ) { break _loop1841; } else {throw new NoViableAltException(LT(1), getFilename());}
1452 }
1453
1454 _cnt1841++;
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 }