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.shared.ldap.trigger; 025 026import java.util.ArrayList; 027import java.util.List; 028 029import org.apache.directory.shared.ldap.model.name.Dn; 030import org.apache.directory.shared.ldap.model.schema.NormalizerMappingResolver; 031import org.apache.directory.shared.ldap.trigger.StoredProcedureOption; 032import org.apache.directory.shared.ldap.trigger.StoredProcedureParameter; 033import org.apache.directory.shared.ldap.trigger.TriggerSpecification.SPSpec; 034import org.apache.directory.shared.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 }