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