001// $ANTLR 2.7.7 (20060906): "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
024package org.apache.directory.api.ldap.trigger;
025
026import java.util.ArrayList;
027import java.util.List;
028
029import org.apache.directory.api.ldap.model.name.Dn;
030import org.apache.directory.api.ldap.model.schema.NormalizerMappingResolver;
031import org.apache.directory.api.ldap.trigger.StoredProcedureOption;
032import org.apache.directory.api.ldap.trigger.StoredProcedureParameter;
033import org.apache.directory.api.ldap.trigger.TriggerSpecification.SPSpec;
034import org.apache.directory.api.ldap.model.message.SearchScope;
035
036import org.slf4j.Logger;
037import org.slf4j.LoggerFactory;
038
039
040import antlr.TokenBuffer;
041import antlr.TokenStreamException;
042import antlr.TokenStreamIOException;
043import antlr.ANTLRException;
044import antlr.LLkParser;
045import antlr.Token;
046import antlr.TokenStream;
047import antlr.RecognitionException;
048import antlr.NoViableAltException;
049import antlr.MismatchedTokenException;
050import antlr.SemanticException;
051import antlr.ParserSharedInputState;
052import 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 */
061public 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
093protected AntlrTriggerSpecificationParser(TokenBuffer tokenBuf, int k) {
094  super(tokenBuf,k);
095  tokenNames = _tokenNames;
096}
097
098public AntlrTriggerSpecificationParser(TokenBuffer tokenBuf) {
099  this(tokenBuf,1);
100}
101
102protected AntlrTriggerSpecificationParser(TokenStream lexer, int k) {
103  super(lexer,k);
104  tokenNames = _tokenNames;
105}
106
107public AntlrTriggerSpecificationParser(TokenStream lexer) {
108  this(lexer,1);
109}
110
111public 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                _loop3:
127                do {
128                        if ((LA(1)==SP)) {
129                                match(SP);
130                        }
131                        else {
132                                break _loop3;
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 _cnt6=0;
153                _loop6:
154                do {
155                        if ((LA(1)==SP)) {
156                                match(SP);
157                        }
158                        else {
159                                if ( _cnt6>=1 ) { break _loop6; } else {throw new NoViableAltException(LT(1), getFilename());}
160                        }
161                        
162                        _cnt6++;
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 _cnt11=0;
230                _loop11:
231                do {
232                        if ((LA(1)==SP)) {
233                                match(SP);
234                        }
235                        else {
236                                if ( _cnt11>=1 ) { break _loop11; } else {throw new NoViableAltException(LT(1), getFilename());}
237                        }
238                        
239                        _cnt11++;
240                } while (true);
241                }
242                {
243                int _cnt20=0;
244                _loop20:
245                do {
246                        if ((LA(1)==ID_CALL)) {
247                                theCompositeRuleForCallAndSPNameAndSPOptionList();
248                                match(OPEN_PARAN);
249                                {
250                                _loop14:
251                                do {
252                                        if ((LA(1)==SP)) {
253                                                match(SP);
254                                        }
255                                        else {
256                                                break _loop14;
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                                _loop17:
286                                do {
287                                        if ((LA(1)==SP)) {
288                                                match(SP);
289                                        }
290                                        else {
291                                                break _loop17;
292                                        }
293                                        
294                                } while (true);
295                                }
296                                match(SEMI);
297                                {
298                                _loop19:
299                                do {
300                                        if ((LA(1)==SP)) {
301                                                match(SP);
302                                        }
303                                        else {
304                                                break _loop19;
305                                        }
306                                        
307                                } while (true);
308                                }
309                                
310                                spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
311                                
312                        }
313                        else {
314                                if ( _cnt20>=1 ) { break _loop20; } else {throw new NoViableAltException(LT(1), getFilename());}
315                        }
316                        
317                        _cnt20++;
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 _cnt23=0;
331                _loop23:
332                do {
333                        if ((LA(1)==SP)) {
334                                match(SP);
335                        }
336                        else {
337                                if ( _cnt23>=1 ) { break _loop23; } else {throw new NoViableAltException(LT(1), getFilename());}
338                        }
339                        
340                        _cnt23++;
341                } while (true);
342                }
343                {
344                int _cnt32=0;
345                _loop32:
346                do {
347                        if ((LA(1)==ID_CALL)) {
348                                theCompositeRuleForCallAndSPNameAndSPOptionList();
349                                match(OPEN_PARAN);
350                                {
351                                _loop26:
352                                do {
353                                        if ((LA(1)==SP)) {
354                                                match(SP);
355                                        }
356                                        else {
357                                                break _loop26;
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                                _loop29:
385                                do {
386                                        if ((LA(1)==SP)) {
387                                                match(SP);
388                                        }
389                                        else {
390                                                break _loop29;
391                                        }
392                                        
393                                } while (true);
394                                }
395                                match(SEMI);
396                                {
397                                _loop31:
398                                do {
399                                        if ((LA(1)==SP)) {
400                                                match(SP);
401                                        }
402                                        else {
403                                                break _loop31;
404                                        }
405                                        
406                                } while (true);
407                                }
408                                
409                                spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
410                                
411                        }
412                        else {
413                                if ( _cnt32>=1 ) { break _loop32; } else {throw new NoViableAltException(LT(1), getFilename());}
414                        }
415                        
416                        _cnt32++;
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 _cnt35=0;
430                _loop35:
431                do {
432                        if ((LA(1)==SP)) {
433                                match(SP);
434                        }
435                        else {
436                                if ( _cnt35>=1 ) { break _loop35; } else {throw new NoViableAltException(LT(1), getFilename());}
437                        }
438                        
439                        _cnt35++;
440                } while (true);
441                }
442                {
443                int _cnt44=0;
444                _loop44:
445                do {
446                        if ((LA(1)==ID_CALL)) {
447                                theCompositeRuleForCallAndSPNameAndSPOptionList();
448                                match(OPEN_PARAN);
449                                {
450                                _loop38:
451                                do {
452                                        if ((LA(1)==SP)) {
453                                                match(SP);
454                                        }
455                                        else {
456                                                break _loop38;
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                                _loop41:
484                                do {
485                                        if ((LA(1)==SP)) {
486                                                match(SP);
487                                        }
488                                        else {
489                                                break _loop41;
490                                        }
491                                        
492                                } while (true);
493                                }
494                                match(SEMI);
495                                {
496                                _loop43:
497                                do {
498                                        if ((LA(1)==SP)) {
499                                                match(SP);
500                                        }
501                                        else {
502                                                break _loop43;
503                                        }
504                                        
505                                } while (true);
506                                }
507                                
508                                spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
509                                
510                        }
511                        else {
512                                if ( _cnt44>=1 ) { break _loop44; } else {throw new NoViableAltException(LT(1), getFilename());}
513                        }
514                        
515                        _cnt44++;
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 _cnt57=0;
530                _loop57:
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 _cnt49=0;
561                                _loop49:
562                                do {
563                                        if ((LA(1)==SP)) {
564                                                match(SP);
565                                        }
566                                        else {
567                                                if ( _cnt49>=1 ) { break _loop49; } else {throw new NoViableAltException(LT(1), getFilename());}
568                                        }
569                                        
570                                        _cnt49++;
571                                } while (true);
572                                }
573                                theCompositeRuleForCallAndSPNameAndSPOptionList();
574                                match(OPEN_PARAN);
575                                {
576                                _loop51:
577                                do {
578                                        if ((LA(1)==SP)) {
579                                                match(SP);
580                                        }
581                                        else {
582                                                break _loop51;
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                                _loop54:
615                                do {
616                                        if ((LA(1)==SP)) {
617                                                match(SP);
618                                        }
619                                        else {
620                                                break _loop54;
621                                        }
622                                        
623                                } while (true);
624                                }
625                                match(SEMI);
626                                {
627                                _loop56:
628                                do {
629                                        if ((LA(1)==SP)) {
630                                                match(SP);
631                                        }
632                                        else {
633                                                break _loop56;
634                                        }
635                                        
636                                } while (true);
637                                }
638                                
639                                spSpecs.add( new SPSpec(triggerStoredProcedureName, triggerStoredProcedureOptions, triggerStoredProcedureParameters ) );
640                                
641                        }
642                        else {
643                                if ( _cnt57>=1 ) { break _loop57; } else {throw new NoViableAltException(LT(1), getFilename());}
644                        }
645                        
646                        _cnt57++;
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 _cnt60=0;
665                _loop60:
666                do {
667                        if ((LA(1)==SP)) {
668                                match(SP);
669                        }
670                        else {
671                                if ( _cnt60>=1 ) { break _loop60; } else {throw new NoViableAltException(LT(1), getFilename());}
672                        }
673                        
674                        _cnt60++;
675                } while (true);
676                }
677                triggerStoredProcedureName=fullyQualifiedStoredProcedureName();
678                {
679                _loop62:
680                do {
681                        if ((LA(1)==SP)) {
682                                match(SP);
683                        }
684                        else {
685                                break _loop62;
686                        }
687                        
688                } while (true);
689                }
690                {
691                switch ( LA(1)) {
692                case OPEN_CURLY:
693                {
694                        genericStoredProcedureOptionList();
695                        {
696                        _loop65:
697                        do {
698                                if ((LA(1)==SP)) {
699                                        match(SP);
700                                }
701                                else {
702                                        break _loop65;
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                _loop68:
731                do {
732                        if ((LA(1)==SP)) {
733                                match(SP);
734                        }
735                        else {
736                                break _loop68;
737                        }
738                        
739                } while (true);
740                }
741                {
742                _loop74:
743                do {
744                        if ((LA(1)==SEP)) {
745                                match(SEP);
746                                {
747                                _loop71:
748                                do {
749                                        if ((LA(1)==SP)) {
750                                                match(SP);
751                                        }
752                                        else {
753                                                break _loop71;
754                                        }
755                                        
756                                } while (true);
757                                }
758                                modifyStoredProcedureParameter();
759                                {
760                                _loop73:
761                                do {
762                                        if ((LA(1)==SP)) {
763                                                match(SP);
764                                        }
765                                        else {
766                                                break _loop73;
767                                        }
768                                        
769                                } while (true);
770                                }
771                        }
772                        else {
773                                break _loop74;
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                _loop77:
789                do {
790                        if ((LA(1)==SP)) {
791                                match(SP);
792                        }
793                        else {
794                                break _loop77;
795                        }
796                        
797                } while (true);
798                }
799                {
800                _loop83:
801                do {
802                        if ((LA(1)==SEP)) {
803                                match(SEP);
804                                {
805                                _loop80:
806                                do {
807                                        if ((LA(1)==SP)) {
808                                                match(SP);
809                                        }
810                                        else {
811                                                break _loop80;
812                                        }
813                                        
814                                } while (true);
815                                }
816                                addStoredProcedureParameter();
817                                {
818                                _loop82:
819                                do {
820                                        if ((LA(1)==SP)) {
821                                                match(SP);
822                                        }
823                                        else {
824                                                break _loop82;
825                                        }
826                                        
827                                } while (true);
828                                }
829                        }
830                        else {
831                                break _loop83;
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                _loop86:
847                do {
848                        if ((LA(1)==SP)) {
849                                match(SP);
850                        }
851                        else {
852                                break _loop86;
853                        }
854                        
855                } while (true);
856                }
857                {
858                _loop92:
859                do {
860                        if ((LA(1)==SEP)) {
861                                match(SEP);
862                                {
863                                _loop89:
864                                do {
865                                        if ((LA(1)==SP)) {
866                                                match(SP);
867                                        }
868                                        else {
869                                                break _loop89;
870                                        }
871                                        
872                                } while (true);
873                                }
874                                deleteStoredProcedureParameter();
875                                {
876                                _loop91:
877                                do {
878                                        if ((LA(1)==SP)) {
879                                                match(SP);
880                                        }
881                                        else {
882                                                break _loop91;
883                                        }
884                                        
885                                } while (true);
886                                }
887                        }
888                        else {
889                                break _loop92;
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                _loop95:
905                do {
906                        if ((LA(1)==SP)) {
907                                match(SP);
908                        }
909                        else {
910                                break _loop95;
911                        }
912                        
913                } while (true);
914                }
915                {
916                _loop101:
917                do {
918                        if ((LA(1)==SEP)) {
919                                match(SEP);
920                                {
921                                _loop98:
922                                do {
923                                        if ((LA(1)==SP)) {
924                                                match(SP);
925                                        }
926                                        else {
927                                                break _loop98;
928                                        }
929                                        
930                                } while (true);
931                                }
932                                modifyDNStoredProcedureParameter();
933                                {
934                                _loop100:
935                                do {
936                                        if ((LA(1)==SP)) {
937                                                match(SP);
938                                        }
939                                        else {
940                                                break _loop100;
941                                        }
942                                        
943                                } while (true);
944                                }
945                        }
946                        else {
947                                break _loop101;
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                _loop112:
978                do {
979                        if ((LA(1)==SP)) {
980                                match(SP);
981                        }
982                        else {
983                                break _loop112;
984                        }
985                        
986                } while (true);
987                }
988                {
989                _loop122:
990                do {
991                        if ((LA(1)==ID_languageScheme||LA(1)==ID_searchContext)) {
992                                genericStoredProcedureOption();
993                                {
994                                _loop115:
995                                do {
996                                        if ((LA(1)==SP)) {
997                                                match(SP);
998                                        }
999                                        else {
1000                                                break _loop115;
1001                                        }
1002                                        
1003                                } while (true);
1004                                }
1005                                {
1006                                _loop121:
1007                                do {
1008                                        if ((LA(1)==SEP)) {
1009                                                match(SEP);
1010                                                {
1011                                                _loop118:
1012                                                do {
1013                                                        if ((LA(1)==SP)) {
1014                                                                match(SP);
1015                                                        }
1016                                                        else {
1017                                                                break _loop118;
1018                                                        }
1019                                                        
1020                                                } while (true);
1021                                                }
1022                                                genericStoredProcedureOption();
1023                                                {
1024                                                _loop120:
1025                                                do {
1026                                                        if ((LA(1)==SP)) {
1027                                                                match(SP);
1028                                                        }
1029                                                        else {
1030                                                                break _loop120;
1031                                                        }
1032                                                        
1033                                                } while (true);
1034                                                }
1035                                        }
1036                                        else {
1037                                                break _loop121;
1038                                        }
1039                                        
1040                                } while (true);
1041                                }
1042                        }
1043                        else {
1044                                break _loop122;
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                Dn ldapContext = null;
1252                
1253                
1254                match(ID_ldapContext);
1255                {
1256                int _cnt109=0;
1257                _loop109:
1258                do {
1259                        if ((LA(1)==SP)) {
1260                                match(SP);
1261                        }
1262                        else {
1263                                if ( _cnt109>=1 ) { break _loop109; } else {throw new NoViableAltException(LT(1), getFilename());}
1264                        }
1265                        
1266                        _cnt109++;
1267                } while (true);
1268                }
1269                ldapContext=distinguishedName();
1270                triggerStoredProcedureParameters.add( StoredProcedureParameter.Generic_LDAP_CONTEXT.instance( ldapContext ) );
1271        }
1272        
1273        public final  Dn  distinguishedName() throws RecognitionException, TokenStreamException {
1274                 Dn 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 Dn( 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 _cnt127=0;
1337                _loop127:
1338                do {
1339                        if ((LA(1)==SP)) {
1340                                match(SP);
1341                        }
1342                        else {
1343                                if ( _cnt127>=1 ) { break _loop127; } else {throw new NoViableAltException(LT(1), getFilename());}
1344                        }
1345                        
1346                        _cnt127++;
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.OBJECT; // default scope
1362                Dn spSearchContext = null;
1363                
1364                
1365                match(ID_searchContext);
1366                {
1367                int _cnt130=0;
1368                _loop130:
1369                do {
1370                        if ((LA(1)==SP)) {
1371                                match(SP);
1372                        }
1373                        else {
1374                                if ( _cnt130>=1 ) { break _loop130; } else {throw new NoViableAltException(LT(1), getFilename());}
1375                        }
1376                        
1377                        _cnt130++;
1378                } while (true);
1379                }
1380                {
1381                switch ( LA(1)) {
1382                case OPEN_CURLY:
1383                {
1384                        match(OPEN_CURLY);
1385                        {
1386                        _loop133:
1387                        do {
1388                                if ((LA(1)==SP)) {
1389                                        match(SP);
1390                                }
1391                                else {
1392                                        break _loop133;
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 _cnt136=0;
1404                                _loop136:
1405                                do {
1406                                        if ((LA(1)==SP)) {
1407                                                match(SP);
1408                                        }
1409                                        else {
1410                                                if ( _cnt136>=1 ) { break _loop136; } else {throw new NoViableAltException(LT(1), getFilename());}
1411                                        }
1412                                        
1413                                        _cnt136++;
1414                                } while (true);
1415                                }
1416                                searchScope=storedProcedureSearchScope();
1417                                {
1418                                _loop138:
1419                                do {
1420                                        if ((LA(1)==SP)) {
1421                                                match(SP);
1422                                        }
1423                                        else {
1424                                                break _loop138;
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 _cnt140=0;
1444                        _loop140:
1445                        do {
1446                                if ((LA(1)==SP)) {
1447                                        match(SP);
1448                                }
1449                                else {
1450                                        if ( _cnt140>=1 ) { break _loop140; } else {throw new NoViableAltException(LT(1), getFilename());}
1451                                }
1452                                
1453                                _cnt140++;
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.OBJECT;
1486                        break;
1487                }
1488                case ID_scope_one:
1489                {
1490                        match(ID_scope_one);
1491                        scope = SearchScope.ONELEVEL;
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  Dn  storedProcedureSearchContext() throws RecognitionException, TokenStreamException {
1509                 Dn 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        }