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