Source code

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