001// $ANTLR 2.7.7 (20060906): "subtree-specification.g" -> "AntlrSubtreeSpecificationParser.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.model.subtree; 025 026import java.util.Set; 027import java.util.Map; 028import java.util.HashSet; 029import java.util.List; 030import java.util.ArrayList; 031 032import org.apache.directory.api.ldap.model.name.Dn; 033import org.apache.directory.api.ldap.model.filter.ExprNode; 034import org.apache.directory.api.ldap.model.filter.LeafNode; 035import org.apache.directory.api.ldap.model.filter.BranchNode; 036import org.apache.directory.api.ldap.model.filter.AndNode; 037import org.apache.directory.api.ldap.model.filter.OrNode; 038import org.apache.directory.api.ldap.model.filter.NotNode; 039import org.apache.directory.api.ldap.model.filter.EqualityNode; 040import org.apache.directory.api.ldap.model.filter.FilterParser; 041import org.apache.directory.api.ldap.model.schema.ObjectClass; 042import org.apache.directory.api.ldap.model.schema.SchemaManager; 043import org.apache.directory.api.ldap.model.subtree.SubtreeSpecification; 044import org.apache.directory.api.ldap.model.subtree.SubtreeSpecificationModifier; 045import org.apache.directory.api.ldap.model.schema.NormalizerMappingResolver; 046import org.apache.directory.api.ldap.model.schema.normalizers.OidNormalizer; 047import org.apache.directory.api.util.ComponentsMonitor; 048import org.apache.directory.api.util.OptionalComponentsMonitor; 049import org.apache.directory.api.ldap.model.constants.SchemaConstants; 050import org.apache.directory.api.ldap.model.entry.StringValue; 051import org.apache.directory.api.ldap.model.exception.LdapException; 052import org.apache.directory.api.ldap.model.schema.AttributeType; 053 054import org.slf4j.Logger; 055import org.slf4j.LoggerFactory; 056 057import antlr.TokenBuffer; 058import antlr.TokenStreamException; 059import antlr.TokenStreamIOException; 060import antlr.ANTLRException; 061import antlr.LLkParser; 062import antlr.Token; 063import antlr.TokenStream; 064import antlr.RecognitionException; 065import antlr.NoViableAltException; 066import antlr.MismatchedTokenException; 067import antlr.SemanticException; 068import antlr.ParserSharedInputState; 069import antlr.collections.impl.BitSet; 070 071/** 072 * The antlr generated subtree specification parser. 073 * 074 * @see <a href="http://www.faqs.org/rfcs/rfc3672.html">RFC 3672</a> 075 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> 076 */ 077public class AntlrSubtreeSpecificationParser extends antlr.LLkParser implements AntlrSubtreeSpecificationParserTokenTypes 078 { 079 080 private static final Logger log = LoggerFactory.getLogger( AntlrSubtreeSpecificationParser.class ); 081 082 private NormalizerMappingResolver resolver; 083 084 private Set<Dn> chopBeforeExclusions = null; 085 private Set<Dn> chopAfterExclusions = null; 086 087 private SubtreeSpecificationModifier ssModifier = null; 088 089 /** The schemaManager */ 090 private SchemaManager schemaManager; 091 092 /** The ObjectClass AT */ 093 AttributeType OBJECT_CLASS_AT; 094 095 private ComponentsMonitor subtreeSpecificationComponentsMonitor = null; 096 097 098 099 /** 100 * Does nothing. 101 */ 102 public void init( SchemaManager schemaManager ) 103 { 104 this.schemaManager = schemaManager; 105 106 if ( schemaManager != null ) 107 { 108 OBJECT_CLASS_AT = schemaManager.getAttributeType( SchemaConstants.OBJECT_CLASS_AT ); 109 } 110 } 111 112 113 public void setNormalizerMappingResolver( NormalizerMappingResolver resolver ) 114 { 115 this.resolver = resolver; 116 } 117 118 119 public boolean isNormalizing() 120 { 121 return this.resolver != null; 122 } 123 124 125 private int token2Integer( Token token ) throws RecognitionException 126 { 127 int i = 0; 128 129 try 130 { 131 i = Integer.parseInt( token.getText()); 132 } 133 catch ( NumberFormatException e ) 134 { 135 throw new RecognitionException( "Value of INTEGER token " + 136 token.getText() + 137 " cannot be converted to an Integer" ); 138 } 139 140 return i; 141 } 142 143protected AntlrSubtreeSpecificationParser(TokenBuffer tokenBuf, int k) { 144 super(tokenBuf,k); 145 tokenNames = _tokenNames; 146} 147 148public AntlrSubtreeSpecificationParser(TokenBuffer tokenBuf) { 149 this(tokenBuf,1); 150} 151 152protected AntlrSubtreeSpecificationParser(TokenStream lexer, int k) { 153 super(lexer,k); 154 tokenNames = _tokenNames; 155} 156 157public AntlrSubtreeSpecificationParser(TokenStream lexer) { 158 this(lexer,1); 159} 160 161public AntlrSubtreeSpecificationParser(ParserSharedInputState state) { 162 super(state,1); 163 tokenNames = _tokenNames; 164} 165 166 public final SubtreeSpecification wrapperEntryPoint() throws RecognitionException, TokenStreamException { 167 SubtreeSpecification ss; 168 169 170 log.debug( "entered wrapperEntryPoint()" ); 171 ss = null; 172 SubtreeSpecification tempSs = null; 173 174 175 tempSs=subtreeSpecification(); 176 match(LITERAL_end); 177 178 ss = tempSs; 179 180 return ss; 181 } 182 183 public final SubtreeSpecification subtreeSpecification() throws RecognitionException, TokenStreamException { 184 SubtreeSpecification ss; 185 186 187 log.debug( "entered subtreeSpecification()" ); 188 // clear out ss, ssModifier, subtreeSpecificationComponentsMonitor, 189 // chopBeforeExclusions and chopAfterExclusions 190 // in case something is left from the last parse 191 ss = null; 192 ssModifier = new SubtreeSpecificationModifier(); 193 subtreeSpecificationComponentsMonitor = new OptionalComponentsMonitor( 194 new String [] { "base", "specificExclusions", "minimum", "maximum", "specificationFilter" } ); 195 chopBeforeExclusions = new HashSet<Dn>(); 196 chopAfterExclusions = new HashSet<Dn>(); 197 // always create a new filter parser in case we may have some statefulness problems with it 198 199 200 match(OPEN_CURLY); 201 { 202 _loop4: 203 do { 204 if ((LA(1)==SP)) { 205 match(SP); 206 } 207 else { 208 break _loop4; 209 } 210 211 } while (true); 212 } 213 { 214 switch ( LA(1)) { 215 case ID_base: 216 case ID_specificExclusions: 217 case ID_minimum: 218 case ID_maximum: 219 case ID_specificationFilter: 220 { 221 subtreeSpecificationComponent(); 222 { 223 _loop7: 224 do { 225 if ((LA(1)==SP)) { 226 match(SP); 227 } 228 else { 229 break _loop7; 230 } 231 232 } while (true); 233 } 234 { 235 _loop13: 236 do { 237 if ((LA(1)==SEP)) { 238 match(SEP); 239 { 240 _loop10: 241 do { 242 if ((LA(1)==SP)) { 243 match(SP); 244 } 245 else { 246 break _loop10; 247 } 248 249 } while (true); 250 } 251 subtreeSpecificationComponent(); 252 { 253 _loop12: 254 do { 255 if ((LA(1)==SP)) { 256 match(SP); 257 } 258 else { 259 break _loop12; 260 } 261 262 } while (true); 263 } 264 } 265 else { 266 break _loop13; 267 } 268 269 } while (true); 270 } 271 break; 272 } 273 case CLOSE_CURLY: 274 { 275 break; 276 } 277 default: 278 { 279 throw new NoViableAltException(LT(1), getFilename()); 280 } 281 } 282 } 283 match(CLOSE_CURLY); 284 285 ss = ssModifier.getSubtreeSpecification(); 286 287 return ss; 288 } 289 290 public final void subtreeSpecificationComponent() throws RecognitionException, TokenStreamException { 291 292 293 log.debug( "entered subtreeSpecification()" ); 294 295 296 try { // for error handling 297 switch ( LA(1)) { 298 case ID_base: 299 { 300 ss_base(); 301 302 subtreeSpecificationComponentsMonitor.useComponent( "base" ); 303 304 break; 305 } 306 case ID_specificExclusions: 307 { 308 ss_specificExclusions(); 309 310 subtreeSpecificationComponentsMonitor.useComponent( "specificExclusions" ); 311 312 break; 313 } 314 case ID_minimum: 315 { 316 ss_minimum(); 317 318 subtreeSpecificationComponentsMonitor.useComponent( "minimum" ); 319 320 break; 321 } 322 case ID_maximum: 323 { 324 ss_maximum(); 325 326 subtreeSpecificationComponentsMonitor.useComponent( "maximum" ); 327 328 break; 329 } 330 case ID_specificationFilter: 331 { 332 ss_specificationFilter(); 333 334 subtreeSpecificationComponentsMonitor.useComponent( "specificationFilter" ); 335 336 break; 337 } 338 default: 339 { 340 throw new NoViableAltException(LT(1), getFilename()); 341 } 342 } 343 } 344 catch (IllegalArgumentException e) { 345 346 throw new RecognitionException( e.getMessage() ); 347 348 } 349 } 350 351 public final void ss_base() throws RecognitionException, TokenStreamException { 352 353 354 log.debug( "entered ss_base()" ); 355 Dn base = null; 356 357 358 match(ID_base); 359 { 360 int _cnt17=0; 361 _loop17: 362 do { 363 if ((LA(1)==SP)) { 364 match(SP); 365 } 366 else { 367 if ( _cnt17>=1 ) { break _loop17; } else {throw new NoViableAltException(LT(1), getFilename());} 368 } 369 370 _cnt17++; 371 } while (true); 372 } 373 base=distinguishedName(); 374 375 ssModifier.setBase( base ); 376 377 } 378 379 public final void ss_specificExclusions() throws RecognitionException, TokenStreamException { 380 381 382 log.debug( "entered ss_specificExclusions()" ); 383 384 385 match(ID_specificExclusions); 386 { 387 int _cnt20=0; 388 _loop20: 389 do { 390 if ((LA(1)==SP)) { 391 match(SP); 392 } 393 else { 394 if ( _cnt20>=1 ) { break _loop20; } else {throw new NoViableAltException(LT(1), getFilename());} 395 } 396 397 _cnt20++; 398 } while (true); 399 } 400 specificExclusions(); 401 402 ssModifier.setChopBeforeExclusions( chopBeforeExclusions ); 403 ssModifier.setChopAfterExclusions( chopAfterExclusions ); 404 405 } 406 407 public final void ss_minimum() throws RecognitionException, TokenStreamException { 408 409 410 log.debug( "entered ss_minimum()" ); 411 int minimum = 0; 412 413 414 match(ID_minimum); 415 { 416 int _cnt46=0; 417 _loop46: 418 do { 419 if ((LA(1)==SP)) { 420 match(SP); 421 } 422 else { 423 if ( _cnt46>=1 ) { break _loop46; } else {throw new NoViableAltException(LT(1), getFilename());} 424 } 425 426 _cnt46++; 427 } while (true); 428 } 429 minimum=baseDistance(); 430 431 ssModifier.setMinBaseDistance( minimum ); 432 433 } 434 435 public final void ss_maximum() throws RecognitionException, TokenStreamException { 436 437 438 log.debug( "entered ss_maximum()" ); 439 int maximum = 0; 440 441 442 match(ID_maximum); 443 { 444 int _cnt49=0; 445 _loop49: 446 do { 447 if ((LA(1)==SP)) { 448 match(SP); 449 } 450 else { 451 if ( _cnt49>=1 ) { break _loop49; } else {throw new NoViableAltException(LT(1), getFilename());} 452 } 453 454 _cnt49++; 455 } while (true); 456 } 457 maximum=baseDistance(); 458 459 ssModifier.setMaxBaseDistance( maximum ); 460 461 } 462 463 public final void ss_specificationFilter() throws RecognitionException, TokenStreamException { 464 465 466 log.debug( "entered ss_specificationFilter()" ); 467 ExprNode filterExpr = null; 468 469 470 match(ID_specificationFilter); 471 { 472 int _cnt52=0; 473 _loop52: 474 do { 475 if ((LA(1)==SP)) { 476 match(SP); 477 } 478 else { 479 if ( _cnt52>=1 ) { break _loop52; } else {throw new NoViableAltException(LT(1), getFilename());} 480 } 481 482 _cnt52++; 483 } while (true); 484 } 485 { 486 switch ( LA(1)) { 487 case ID_item: 488 case ID_and: 489 case ID_or: 490 case ID_not: 491 { 492 { 493 filterExpr=refinement(); 494 } 495 break; 496 } 497 case FILTER: 498 { 499 { 500 filterExpr=filter(); 501 } 502 break; 503 } 504 default: 505 { 506 throw new NoViableAltException(LT(1), getFilename()); 507 } 508 } 509 } 510 ssModifier.setRefinement( filterExpr ); 511 } 512 513 public final Dn distinguishedName() throws RecognitionException, TokenStreamException { 514 Dn name ; 515 516 Token token = null; 517 518 log.debug( "entered distinguishedName()" ); 519 name = null; 520 521 522 try { // for error handling 523 token = LT(1); 524 match(SAFEUTF8STRING); 525 526 name = new Dn( token.getText() ); 527 name.apply( schemaManager ); 528 529 log.debug( "recognized a DistinguishedName: " + token.getText() ); 530 531 } 532 catch (Exception e) { 533 534 throw new RecognitionException( "dnParser failed for " + token.getText() + " " + e.getMessage() ); 535 536 } 537 return name ; 538 } 539 540 public final void specificExclusions() throws RecognitionException, TokenStreamException { 541 542 543 log.debug( "entered specificExclusions()" ); 544 545 546 match(OPEN_CURLY); 547 { 548 _loop23: 549 do { 550 if ((LA(1)==SP)) { 551 match(SP); 552 } 553 else { 554 break _loop23; 555 } 556 557 } while (true); 558 } 559 { 560 switch ( LA(1)) { 561 case ID_chopBefore: 562 case ID_chopAfter: 563 { 564 specificExclusion(); 565 { 566 _loop26: 567 do { 568 if ((LA(1)==SP)) { 569 match(SP); 570 } 571 else { 572 break _loop26; 573 } 574 575 } while (true); 576 } 577 { 578 _loop32: 579 do { 580 if ((LA(1)==SEP)) { 581 match(SEP); 582 { 583 _loop29: 584 do { 585 if ((LA(1)==SP)) { 586 match(SP); 587 } 588 else { 589 break _loop29; 590 } 591 592 } while (true); 593 } 594 specificExclusion(); 595 { 596 _loop31: 597 do { 598 if ((LA(1)==SP)) { 599 match(SP); 600 } 601 else { 602 break _loop31; 603 } 604 605 } while (true); 606 } 607 } 608 else { 609 break _loop32; 610 } 611 612 } while (true); 613 } 614 break; 615 } 616 case CLOSE_CURLY: 617 { 618 break; 619 } 620 default: 621 { 622 throw new NoViableAltException(LT(1), getFilename()); 623 } 624 } 625 } 626 match(CLOSE_CURLY); 627 } 628 629 public final void specificExclusion() throws RecognitionException, TokenStreamException { 630 631 632 log.debug( "entered specificExclusion()" ); 633 634 635 switch ( LA(1)) { 636 case ID_chopBefore: 637 { 638 chopBefore(); 639 break; 640 } 641 case ID_chopAfter: 642 { 643 chopAfter(); 644 break; 645 } 646 default: 647 { 648 throw new NoViableAltException(LT(1), getFilename()); 649 } 650 } 651 } 652 653 public final void chopBefore() throws RecognitionException, TokenStreamException { 654 655 656 log.debug( "entered chopBefore()" ); 657 Dn chopBeforeExclusion = null; 658 659 660 match(ID_chopBefore); 661 { 662 _loop36: 663 do { 664 if ((LA(1)==SP)) { 665 match(SP); 666 } 667 else { 668 break _loop36; 669 } 670 671 } while (true); 672 } 673 match(COLON); 674 { 675 _loop38: 676 do { 677 if ((LA(1)==SP)) { 678 match(SP); 679 } 680 else { 681 break _loop38; 682 } 683 684 } while (true); 685 } 686 chopBeforeExclusion=distinguishedName(); 687 688 chopBeforeExclusions.add( chopBeforeExclusion ); 689 690 } 691 692 public final void chopAfter() throws RecognitionException, TokenStreamException { 693 694 695 log.debug( "entered chopAfter()" ); 696 Dn chopAfterExclusion = null; 697 698 699 match(ID_chopAfter); 700 { 701 _loop41: 702 do { 703 if ((LA(1)==SP)) { 704 match(SP); 705 } 706 else { 707 break _loop41; 708 } 709 710 } while (true); 711 } 712 match(COLON); 713 { 714 _loop43: 715 do { 716 if ((LA(1)==SP)) { 717 match(SP); 718 } 719 else { 720 break _loop43; 721 } 722 723 } while (true); 724 } 725 chopAfterExclusion=distinguishedName(); 726 727 chopAfterExclusions.add( chopAfterExclusion ); 728 729 } 730 731 public final int baseDistance() throws RecognitionException, TokenStreamException { 732 int distance ; 733 734 Token token = null; 735 736 log.debug( "entered baseDistance()" ); 737 distance = 0; 738 739 740 token = LT(1); 741 match(INTEGER); 742 743 distance = token2Integer( token ); 744 745 return distance ; 746 } 747 748 public final ExprNode refinement() throws RecognitionException, TokenStreamException { 749 ExprNode node ; 750 751 752 log.debug( "entered refinement()" ); 753 node = null; 754 755 756 switch ( LA(1)) { 757 case ID_item: 758 { 759 node=item(); 760 break; 761 } 762 case ID_and: 763 { 764 node=and(); 765 break; 766 } 767 case ID_or: 768 { 769 node=or(); 770 break; 771 } 772 case ID_not: 773 { 774 node=not(); 775 break; 776 } 777 default: 778 { 779 throw new NoViableAltException(LT(1), getFilename()); 780 } 781 } 782 return node ; 783 } 784 785 public final ExprNode filter() throws RecognitionException, TokenStreamException { 786 ExprNode filterExpr = null ; 787 788 Token filterToken = null; 789 790 log.debug( "entered filter()" ); 791 792 793 try { // for error handling 794 { 795 filterToken = LT(1); 796 match(FILTER); 797 filterExpr=FilterParser.parse( schemaManager, filterToken.getText() ); 798 } 799 } 800 catch (Exception e) { 801 802 throw new RecognitionException( "filterParser failed. " + e.getMessage() ); 803 804 } 805 return filterExpr; 806 } 807 808 public final String oid() throws RecognitionException, TokenStreamException { 809 String result ; 810 811 812 log.debug( "entered oid()" ); 813 result = null; 814 Token token = null; 815 816 817 token = LT( 1 ); 818 { 819 switch ( LA(1)) { 820 case DESCR: 821 { 822 match(DESCR); 823 break; 824 } 825 case NUMERICOID: 826 { 827 match(NUMERICOID); 828 break; 829 } 830 default: 831 { 832 throw new NoViableAltException(LT(1), getFilename()); 833 } 834 } 835 } 836 837 result = token.getText(); 838 log.debug( "recognized an oid: " + result ); 839 840 return result ; 841 } 842 843 public final LeafNode item() throws RecognitionException, TokenStreamException { 844 LeafNode node ; 845 846 847 log.debug( "entered item()" ); 848 node = null; 849 String oid = null; 850 ObjectClass objectClass; 851 852 853 match(ID_item); 854 { 855 _loop65: 856 do { 857 if ((LA(1)==SP)) { 858 match(SP); 859 } 860 else { 861 break _loop65; 862 } 863 864 } while (true); 865 } 866 match(COLON); 867 { 868 _loop67: 869 do { 870 if ((LA(1)==SP)) { 871 match(SP); 872 } 873 else { 874 break _loop67; 875 } 876 877 } while (true); 878 } 879 oid=oid(); 880 881 try 882 { 883 objectClass = schemaManager.lookupObjectClassRegistry( oid ); 884 } 885 catch ( LdapException le ) 886 { 887 // The oid does not exist 888 // TODO : deal with such an exception 889 } 890 891 node = new EqualityNode( OBJECT_CLASS_AT, new StringValue( oid ) ); 892 893 return node ; 894 } 895 896 public final BranchNode and() throws RecognitionException, TokenStreamException { 897 BranchNode node ; 898 899 900 log.debug( "entered and()" ); 901 node = null; 902 List<ExprNode> children = null; 903 904 905 match(ID_and); 906 { 907 _loop70: 908 do { 909 if ((LA(1)==SP)) { 910 match(SP); 911 } 912 else { 913 break _loop70; 914 } 915 916 } while (true); 917 } 918 match(COLON); 919 { 920 _loop72: 921 do { 922 if ((LA(1)==SP)) { 923 match(SP); 924 } 925 else { 926 break _loop72; 927 } 928 929 } while (true); 930 } 931 children=refinements(); 932 933 node = new AndNode( children ); 934 935 return node ; 936 } 937 938 public final BranchNode or() throws RecognitionException, TokenStreamException { 939 BranchNode node ; 940 941 942 log.debug( "entered or()" ); 943 node = null; 944 List<ExprNode> children = null; 945 946 947 match(ID_or); 948 { 949 _loop75: 950 do { 951 if ((LA(1)==SP)) { 952 match(SP); 953 } 954 else { 955 break _loop75; 956 } 957 958 } while (true); 959 } 960 match(COLON); 961 { 962 _loop77: 963 do { 964 if ((LA(1)==SP)) { 965 match(SP); 966 } 967 else { 968 break _loop77; 969 } 970 971 } while (true); 972 } 973 children=refinements(); 974 975 node = new OrNode( children ); 976 977 return node ; 978 } 979 980 public final BranchNode not() throws RecognitionException, TokenStreamException { 981 BranchNode node ; 982 983 984 log.debug( "entered not()" ); 985 node = null; 986 ExprNode child = null; 987 988 989 match(ID_not); 990 { 991 _loop80: 992 do { 993 if ((LA(1)==SP)) { 994 match(SP); 995 } 996 else { 997 break _loop80; 998 } 999 1000 } while (true); 1001 } 1002 match(COLON); 1003 { 1004 _loop82: 1005 do { 1006 if ((LA(1)==SP)) { 1007 match(SP); 1008 } 1009 else { 1010 break _loop82; 1011 } 1012 1013 } while (true); 1014 } 1015 child=refinement(); 1016 1017 node = new NotNode( child ); 1018 1019 return node ; 1020 } 1021 1022 public final List<ExprNode> refinements() throws RecognitionException, TokenStreamException { 1023 List<ExprNode> children ; 1024 1025 1026 log.debug( "entered refinements()" ); 1027 children = null; 1028 ExprNode child = null; 1029 List<ExprNode> tempChildren = new ArrayList<ExprNode>(); 1030 1031 1032 match(OPEN_CURLY); 1033 { 1034 _loop85: 1035 do { 1036 if ((LA(1)==SP)) { 1037 match(SP); 1038 } 1039 else { 1040 break _loop85; 1041 } 1042 1043 } while (true); 1044 } 1045 { 1046 switch ( LA(1)) { 1047 case ID_item: 1048 case ID_and: 1049 case ID_or: 1050 case ID_not: 1051 { 1052 child=refinement(); 1053 { 1054 _loop88: 1055 do { 1056 if ((LA(1)==SP)) { 1057 match(SP); 1058 } 1059 else { 1060 break _loop88; 1061 } 1062 1063 } while (true); 1064 } 1065 1066 tempChildren.add( child ); 1067 1068 { 1069 _loop94: 1070 do { 1071 if ((LA(1)==SEP)) { 1072 match(SEP); 1073 { 1074 _loop91: 1075 do { 1076 if ((LA(1)==SP)) { 1077 match(SP); 1078 } 1079 else { 1080 break _loop91; 1081 } 1082 1083 } while (true); 1084 } 1085 child=refinement(); 1086 { 1087 _loop93: 1088 do { 1089 if ((LA(1)==SP)) { 1090 match(SP); 1091 } 1092 else { 1093 break _loop93; 1094 } 1095 1096 } while (true); 1097 } 1098 1099 tempChildren.add( child ); 1100 1101 } 1102 else { 1103 break _loop94; 1104 } 1105 1106 } while (true); 1107 } 1108 break; 1109 } 1110 case CLOSE_CURLY: 1111 { 1112 break; 1113 } 1114 default: 1115 { 1116 throw new NoViableAltException(LT(1), getFilename()); 1117 } 1118 } 1119 } 1120 match(CLOSE_CURLY); 1121 1122 children = tempChildren; 1123 1124 return children ; 1125 } 1126 1127 1128 public static final String[] _tokenNames = { 1129 "<0>", 1130 "EOF", 1131 "<2>", 1132 "NULL_TREE_LOOKAHEAD", 1133 "\"end\"", 1134 "OPEN_CURLY", 1135 "SP", 1136 "SEP", 1137 "CLOSE_CURLY", 1138 "\"base\"", 1139 "\"specificExclusions\"", 1140 "\"chopBefore\"", 1141 "COLON", 1142 "\"chopAfter\"", 1143 "\"minimum\"", 1144 "\"maximum\"", 1145 "\"specificationFilter\"", 1146 "FILTER", 1147 "SAFEUTF8STRING", 1148 "INTEGER", 1149 "DESCR", 1150 "NUMERICOID", 1151 "\"item\"", 1152 "\"and\"", 1153 "\"or\"", 1154 "\"not\"", 1155 "INTEGER_OR_NUMERICOID", 1156 "DOT", 1157 "DIGIT", 1158 "LDIGIT", 1159 "ALPHA", 1160 "SAFEUTF8CHAR", 1161 "FILTER_VALUE" 1162 }; 1163 1164 1165 }