Source/LexerParser/cmDependsJavaParser.y

   1 %{
   2 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   3    file Copyright.txt or https://cmake.org/licensing for details.  */
   4 /*
   5
   6 This file must be translated to C and modified to build everywhere.
   7
   8 Run bison like this:
   9
  10   bison --name-prefix=cmDependsJava_yy --defines=cmDependsJavaParserTokens.h -ocmDependsJavaParser.cxx cmDependsJavaParser.y
  11
  12 */
  13
  14 #include "cmConfigure.h" // IWYU pragma: keep
  15
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <string>
  19
  20 #define yyGetParser (cmDependsJava_yyget_extra(yyscanner))
  21
  22 /*-------------------------------------------------------------------------*/
  23 #include "cmDependsJavaParserHelper.h" /* Interface to parser object.  */
  24 #include "cmDependsJavaLexer.h"  /* Interface to lexer object.  */
  25
  26 /* Forward declare the lexer entry point.  */
  27 YY_DECL;
  28
  29 /* Helper function to forward error callback from parser.  */
  30 static void cmDependsJava_yyerror(yyscan_t yyscanner, const char* message);
  31
  32 #define YYMAXDEPTH 1000000
  33
  34
  35 #define jpCheckEmpty(cnt) yyGetParser->CheckEmpty(__LINE__, cnt, yyvsp)
  36 #define jpElementStart(cnt) yyGetParser->PrepareElement(&yyval)
  37 #define jpStoreClass(str) yyGetParser->AddClassFound(str); yyGetParser->DeallocateParserType(&(str))
  38 /* Disable some warnings in the generated code.  */
  39 #ifdef _MSC_VER
  40 # pragma warning (disable: 4102) /* Unused goto label.  */
  41 # pragma warning (disable: 4065) /* Switch statement contains default but no case. */
  42 #endif
  43 #if defined(__GNUC__) && __GNUC__ >= 8
  44 # pragma GCC diagnostic ignored "-Wconversion"
  45 # pragma GCC diagnostic ignored "-Wfree-nonheap-object"
  46 #endif
  47 #if defined(__clang__) && defined(__has_warning)
  48 # if __has_warning("-Wunused-but-set-variable")
  49 #  pragma clang diagnostic ignored "-Wunused-but-set-variable"
  50 # endif
  51 #endif
  52 %}
  53
  54 /* Generate a reentrant parser object.  */
  55 %define api.pure
  56
  57 /* Configure the parser to use a lexer object.  */
  58 %lex-param   {yyscan_t yyscanner}
  59 %parse-param {yyscan_t yyscanner}
  60
  61 %define parse.error verbose
  62
  63 /*
  64 %union {
  65   char* string;
  66 }
  67 */
  68
  69 /*-------------------------------------------------------------------------*/
  70 /* Tokens */
  71 %token jp_ABSTRACT
  72 %token jp_ASSERT
  73 %token jp_BOOLEAN_TYPE
  74 %token jp_BREAK
  75 %token jp_BYTE_TYPE
  76 %token jp_CASE
  77 %token jp_CATCH
  78 %token jp_CHAR_TYPE
  79 %token jp_CLASS
  80 %token jp_CONTINUE
  81 %token jp_DEFAULT
  82 %token jp_DO
  83 %token jp_DOUBLE_TYPE
  84 %token jp_ELSE
  85 %token jp_EXTENDS
  86 %token jp_FINAL
  87 %token jp_FINALLY
  88 %token jp_FLOAT_TYPE
  89 %token jp_FOR
  90 %token jp_IF
  91 %token jp_IMPLEMENTS
  92 %token jp_IMPORT
  93 %token jp_INSTANCEOF
  94 %token jp_INT_TYPE
  95 %token jp_INTERFACE
  96 %token jp_LONG_TYPE
  97 %token jp_NATIVE
  98 %token jp_NEW
  99 %token jp_PACKAGE
 100 %token jp_PRIVATE
 101 %token jp_PROTECTED
 102 %token jp_PUBLIC
 103 %token jp_RETURN
 104 %token jp_SHORT_TYPE
 105 %token jp_STATIC
 106 %token jp_STRICTFP
 107 %token jp_SUPER
 108 %token jp_SWITCH
 109 %token jp_SYNCHRONIZED
 110 %token jp_THIS
 111 %token jp_THROW
 112 %token jp_THROWS
 113 %token jp_TRANSIENT
 114 %token jp_TRY
 115 %token jp_VOID
 116 %token jp_VOLATILE
 117 %token jp_WHILE
 118
 119 %token jp_BOOLEANLITERAL
 120 %token jp_CHARACTERLITERAL
 121 %token jp_DECIMALINTEGERLITERAL
 122 %token jp_FLOATINGPOINTLITERAL
 123 %token jp_HEXINTEGERLITERAL
 124 %token jp_NULLLITERAL
 125 %token jp_STRINGLITERAL
 126
 127 %token jp_NAME
 128
 129 %token jp_AND
 130 %token jp_ANDAND
 131 %token jp_ANDEQUALS
 132 %token jp_BRACKETEND
 133 %token jp_BRACKETSTART
 134 %token jp_CARROT
 135 %token jp_CARROTEQUALS
 136 %token jp_COLON
 137 %token jp_COMMA
 138 %token jp_CURLYEND
 139 %token jp_CURLYSTART
 140 %token jp_DIVIDE
 141 %token jp_DIVIDEEQUALS
 142 %token jp_DOLLAR
 143 %token jp_DOT
 144 %token jp_EQUALS
 145 %token jp_EQUALSEQUALS
 146 %token jp_EXCLAMATION
 147 %token jp_EXCLAMATIONEQUALS
 148 %token jp_GREATER
 149 %token jp_GTEQUALS
 150 %token jp_GTGT
 151 %token jp_GTGTEQUALS
 152 %token jp_GTGTGT
 153 %token jp_GTGTGTEQUALS
 154 %token jp_LESLESEQUALS
 155 %token jp_LESSTHAN
 156 %token jp_LTEQUALS
 157 %token jp_LTLT
 158 %token jp_MINUS
 159 %token jp_MINUSEQUALS
 160 %token jp_MINUSMINUS
 161 %token jp_PAREEND
 162 %token jp_PARESTART
 163 %token jp_PERCENT
 164 %token jp_PERCENTEQUALS
 165 %token jp_PIPE
 166 %token jp_PIPEEQUALS
 167 %token jp_PIPEPIPE
 168 %token jp_PLUS
 169 %token jp_PLUSEQUALS
 170 %token jp_PLUSPLUS
 171 %token jp_QUESTION
 172 %token jp_SEMICOL
 173 %token jp_TILDE
 174 %token jp_TIMES
 175 %token jp_TIMESEQUALS
 176
 177 %token jp_ERROR
 178
 179 /*-------------------------------------------------------------------------*/
 180 /* grammar */
 181 %%
 182
 183 Goal:
 184 CompilationUnit
 185 {
 186   jpElementStart(1);
 187   jpCheckEmpty(1);
 188   $<str>$ = 0;
 189   yyGetParser->SetCurrentCombine("");
 190 }
 191
 192 Literal:
 193 IntegerLiteral
 194 {
 195   jpElementStart(1);
 196   jpCheckEmpty(1);
 197   $<str>$ = 0;
 198   yyGetParser->SetCurrentCombine("");
 199 }
 200 |
 201 jp_FLOATINGPOINTLITERAL
 202 {
 203   jpElementStart(1);
 204   jpCheckEmpty(1);
 205   $<str>$ = 0;
 206   yyGetParser->SetCurrentCombine("");
 207 }
 208 |
 209 jp_BOOLEANLITERAL
 210 {
 211   jpElementStart(1);
 212   jpCheckEmpty(1);
 213   $<str>$ = 0;
 214   yyGetParser->SetCurrentCombine("");
 215 }
 216 |
 217 jp_CHARACTERLITERAL
 218 {
 219   jpElementStart(1);
 220   jpCheckEmpty(1);
 221   $<str>$ = 0;
 222   yyGetParser->SetCurrentCombine("");
 223 }
 224 |
 225 jp_STRINGLITERAL
 226 {
 227   jpElementStart(1);
 228   jpCheckEmpty(1);
 229   $<str>$ = 0;
 230   yyGetParser->SetCurrentCombine("");
 231 }
 232 |
 233 jp_NULLLITERAL
 234 {
 235   jpElementStart(1);
 236   jpCheckEmpty(1);
 237   $<str>$ = 0;
 238   yyGetParser->SetCurrentCombine("");
 239 }
 240
 241 IntegerLiteral:
 242 jp_DECIMALINTEGERLITERAL
 243 {
 244   jpElementStart(1);
 245   jpCheckEmpty(1);
 246   $<str>$ = 0;
 247   yyGetParser->SetCurrentCombine("");
 248 }
 249 |
 250 jp_HEXINTEGERLITERAL
 251 {
 252   jpElementStart(1);
 253   jpCheckEmpty(1);
 254   $<str>$ = 0;
 255   yyGetParser->SetCurrentCombine("");
 256 }
 257
 258 Type:
 259 PrimitiveType
 260 {
 261   jpElementStart(1);
 262   jpCheckEmpty(1);
 263   $<str>$ = 0;
 264   yyGetParser->SetCurrentCombine("");
 265 }
 266 |
 267 ReferenceType
 268 {
 269   jpElementStart(1);
 270   jpCheckEmpty(1);
 271   $<str>$ = 0;
 272   yyGetParser->SetCurrentCombine("");
 273 }
 274
 275 PrimitiveType:
 276 jp_BYTE_TYPE
 277 {
 278   jpElementStart(0);
 279 }
 280 |
 281 jp_SHORT_TYPE
 282 {
 283   jpElementStart(0);
 284 }
 285 |
 286 jp_INT_TYPE
 287 {
 288   jpElementStart(0);
 289 }
 290 |
 291 jp_LONG_TYPE
 292 {
 293   jpElementStart(0);
 294 }
 295 |
 296 jp_CHAR_TYPE
 297 {
 298   jpElementStart(0);
 299 }
 300 |
 301 jp_FLOAT_TYPE
 302 {
 303   jpElementStart(0);
 304 }
 305 |
 306 jp_DOUBLE_TYPE
 307 {
 308   jpElementStart(0);
 309 }
 310 |
 311 jp_BOOLEAN_TYPE
 312 {
 313   jpElementStart(0);
 314 }
 315
 316 ReferenceType:
 317 ClassOrInterfaceType
 318 {
 319   jpElementStart(1);
 320   jpCheckEmpty(1);
 321   $<str>$ = 0;
 322   yyGetParser->SetCurrentCombine("");
 323 }
 324 |
 325 ArrayType
 326 {
 327   jpElementStart(1);
 328   jpCheckEmpty(1);
 329   $<str>$ = 0;
 330   yyGetParser->SetCurrentCombine("");
 331 }
 332
 333 ClassOrInterfaceType:
 334 Name
 335 {
 336   jpElementStart(1);
 337   jpStoreClass($<str>1);
 338   jpCheckEmpty(1);
 339   $<str>$ = 0;
 340   yyGetParser->SetCurrentCombine("");
 341 }
 342
 343 ClassType:
 344 ClassOrInterfaceType
 345 {
 346   jpElementStart(1);
 347   jpCheckEmpty(1);
 348   $<str>$ = 0;
 349   yyGetParser->SetCurrentCombine("");
 350 }
 351
 352 InterfaceType:
 353 ClassOrInterfaceType
 354 {
 355   jpElementStart(1);
 356   jpCheckEmpty(1);
 357   $<str>$ = 0;
 358   yyGetParser->SetCurrentCombine("");
 359 }
 360
 361 ArrayType:
 362 PrimitiveType Dims
 363 {
 364   jpElementStart(2);
 365   jpCheckEmpty(2);
 366   $<str>$ = 0;
 367   yyGetParser->SetCurrentCombine("");
 368 }
 369 |
 370 Name Dims
 371 {
 372   jpElementStart(2);
 373   jpStoreClass($<str>1);
 374   jpCheckEmpty(2);
 375   $<str>$ = 0;
 376   yyGetParser->SetCurrentCombine("");
 377 }
 378
 379 Name:
 380 SimpleName
 381 {
 382   jpElementStart(1);
 383   $<str>$ = $<str>1;
 384 }
 385 |
 386 QualifiedName
 387 {
 388   jpElementStart(1);
 389   $<str>$ = $<str>1;
 390 }
 391
 392 SimpleName:
 393 Identifier
 394 {
 395   jpElementStart(1);
 396   $<str>$ = $<str>1;
 397 }
 398
 399 Identifier:
 400 jp_NAME
 401 {
 402   jpElementStart(1);
 403   $<str>$ = $<str>1;
 404 }
 405 |
 406 jp_DOLLAR jp_NAME
 407 {
 408   jpElementStart(2);
 409   $<str>$ = $<str>2;
 410 }
 411
 412 QualifiedName:
 413 Name jp_DOT Identifier
 414 {
 415   jpElementStart(3);
 416   yyGetParser->AddClassFound($<str>1);
 417   yyGetParser->UpdateCombine($<str>1, $<str>3);
 418   yyGetParser->DeallocateParserType(&($<str>1));
 419   $<str>$ = const_cast<char*>(yyGetParser->GetCurrentCombine());
 420 }
 421 |
 422 Name jp_DOT jp_CLASS
 423 {
 424   jpElementStart(3);
 425   jpStoreClass($<str>1);
 426   jpCheckEmpty(3);
 427   yyGetParser->SetCurrentCombine("");
 428   $<str>$ = 0;
 429   yyGetParser->SetCurrentCombine("");
 430 }
 431 |
 432 Name jp_DOT jp_THIS
 433 {
 434   jpElementStart(3);
 435   jpStoreClass($<str>1);
 436   yyGetParser->SetCurrentCombine("");
 437   jpCheckEmpty(3);
 438   $<str>$ = 0;
 439   yyGetParser->SetCurrentCombine("");
 440 }
 441 |
 442 SimpleType jp_DOT jp_CLASS
 443 {
 444   jpElementStart(3);
 445   jpCheckEmpty(3);
 446   $<str>$ = 0;
 447   yyGetParser->SetCurrentCombine("");
 448 }
 449
 450 SimpleType:
 451 PrimitiveType
 452 {
 453   jpElementStart(1);
 454   jpCheckEmpty(1);
 455   $<str>$ = 0;
 456   yyGetParser->SetCurrentCombine("");
 457 }
 458 |
 459 jp_VOID
 460 {
 461   jpElementStart(1);
 462   jpCheckEmpty(1);
 463   $<str>$ = 0;
 464   yyGetParser->SetCurrentCombine("");
 465 }
 466
 467 CompilationUnit:
 468 PackageDeclarationopt ImportDeclarations TypeDeclarations
 469 {
 470   jpElementStart(3);
 471   jpCheckEmpty(3);
 472   $<str>$ = 0;
 473   yyGetParser->SetCurrentCombine("");
 474 }
 475
 476 PackageDeclarationopt:
 477 {
 478   jpElementStart(0);
 479   $<str>$ = 0;
 480   yyGetParser->SetCurrentCombine("");
 481 }
 482 |
 483 PackageDeclaration
 484 {
 485   jpElementStart(1);
 486   jpCheckEmpty(1);
 487   $<str>$ = 0;
 488   yyGetParser->SetCurrentCombine("");
 489 }
 490
 491 ImportDeclarations:
 492 {
 493   jpElementStart(0);
 494   $<str>$ = 0;
 495   yyGetParser->SetCurrentCombine("");
 496 }
 497 |
 498 ImportDeclarations ImportDeclaration
 499 {
 500   jpElementStart(2);
 501   jpCheckEmpty(2);
 502   $<str>$ = 0;
 503   yyGetParser->SetCurrentCombine("");
 504 }
 505
 506 TypeDeclarations:
 507 {
 508   jpElementStart(0);
 509   $<str>$ = 0;
 510   yyGetParser->SetCurrentCombine("");
 511 }
 512 |
 513 TypeDeclarations TypeDeclaration
 514 {
 515   jpElementStart(2);
 516   jpCheckEmpty(2);
 517   $<str>$ = 0;
 518   yyGetParser->SetCurrentCombine("");
 519 }
 520
 521 PackageDeclaration:
 522 jp_PACKAGE Name jp_SEMICOL
 523 {
 524   jpElementStart(3);
 525   yyGetParser->SetCurrentPackage($<str>2);
 526   yyGetParser->DeallocateParserType(&($<str>2));
 527   yyGetParser->SetCurrentCombine("");
 528   jpCheckEmpty(3);
 529   $<str>$ = 0;
 530   yyGetParser->SetCurrentCombine("");
 531 }
 532
 533 ImportDeclaration:
 534 SingleTypeImportDeclaration
 535 {
 536   jpElementStart(1);
 537   jpCheckEmpty(1);
 538   $<str>$ = 0;
 539   yyGetParser->SetCurrentCombine("");
 540 }
 541 |
 542 TypeImportOnDemandDeclaration
 543 {
 544   jpElementStart(1);
 545   jpCheckEmpty(1);
 546   $<str>$ = 0;
 547   yyGetParser->SetCurrentCombine("");
 548 }
 549
 550 SingleTypeImportDeclaration:
 551 jp_IMPORT Name jp_SEMICOL
 552 {
 553   jpElementStart(3);
 554   yyGetParser->AddPackagesImport($<str>2);
 555   yyGetParser->DeallocateParserType(&($<str>2));
 556   yyGetParser->SetCurrentCombine("");
 557   jpCheckEmpty(3);
 558   $<str>$ = 0;
 559   yyGetParser->SetCurrentCombine("");
 560 }
 561
 562 TypeImportOnDemandDeclaration:
 563 jp_IMPORT Name jp_DOT jp_TIMES jp_SEMICOL
 564 {
 565   jpElementStart(5);
 566   std::string str = $<str>2;
 567   str += ".*";
 568   yyGetParser->AddPackagesImport(str.c_str());
 569   yyGetParser->DeallocateParserType(&($<str>2));
 570   yyGetParser->SetCurrentCombine("");
 571   $<str>$ = 0;
 572   yyGetParser->SetCurrentCombine("");
 573 }
 574
 575 TypeDeclaration:
 576 ClassDeclaration
 577 {
 578   jpElementStart(1);
 579   jpCheckEmpty(1);
 580   $<str>$ = 0;
 581   yyGetParser->SetCurrentCombine("");
 582 }
 583 |
 584 InterfaceDeclaration
 585 {
 586   jpElementStart(1);
 587   jpCheckEmpty(1);
 588   $<str>$ = 0;
 589   yyGetParser->SetCurrentCombine("");
 590 }
 591 |
 592 jp_SEMICOL
 593 {
 594   jpElementStart(1);
 595   jpCheckEmpty(1);
 596   $<str>$ = 0;
 597   yyGetParser->SetCurrentCombine("");
 598 }
 599
 600 Modifiers:
 601 Modifier
 602 {
 603   jpElementStart(1);
 604   jpCheckEmpty(1);
 605   $<str>$ = 0;
 606   yyGetParser->SetCurrentCombine("");
 607 }
 608 |
 609 Modifiers Modifier
 610 {
 611   jpElementStart(2);
 612   jpCheckEmpty(2);
 613   $<str>$ = 0;
 614   yyGetParser->SetCurrentCombine("");
 615 }
 616
 617 Modifier:
 618 jp_PUBLIC | jp_PROTECTED | jp_PRIVATE |
 619 jp_STATIC |
 620 jp_ABSTRACT | jp_FINAL | jp_NATIVE | jp_SYNCHRONIZED | jp_TRANSIENT | jp_VOLATILE |
 621 jp_STRICTFP
 622
 623 ClassHeader:
 624 Modifiersopt jp_CLASS Identifier
 625 {
 626   yyGetParser->StartClass($<str>3);
 627   jpElementStart(3);
 628   yyGetParser->DeallocateParserType(&($<str>3));
 629   jpCheckEmpty(3);
 630 }
 631
 632
 633 ClassDeclaration:
 634 ClassHeader ClassBody
 635 {
 636   jpElementStart(2);
 637   jpCheckEmpty(2);
 638   $<str>$ = 0;
 639   yyGetParser->SetCurrentCombine("");
 640   yyGetParser->EndClass();
 641 }
 642 |
 643 ClassHeader Interfaces ClassBody
 644 {
 645   jpElementStart(3);
 646   jpCheckEmpty(2);
 647   $<str>$ = 0;
 648   yyGetParser->SetCurrentCombine("");
 649   yyGetParser->EndClass();
 650 }
 651 |
 652 ClassHeader Super ClassBody
 653 {
 654   jpElementStart(3);
 655   jpCheckEmpty(3);
 656   $<str>$ = 0;
 657   yyGetParser->SetCurrentCombine("");
 658   yyGetParser->EndClass();
 659 }
 660 |
 661 ClassHeader Super Interfaces ClassBody
 662 {
 663   jpElementStart(4);
 664   jpCheckEmpty(4);
 665   $<str>$ = 0;
 666   yyGetParser->SetCurrentCombine("");
 667   yyGetParser->EndClass();
 668 }
 669
 670 Modifiersopt:
 671 {
 672   jpElementStart(0);
 673   $<str>$ = 0;
 674   yyGetParser->SetCurrentCombine("");
 675 }
 676 |
 677 Modifiers
 678 {
 679   jpElementStart(1);
 680   jpCheckEmpty(1);
 681   $<str>$ = 0;
 682   yyGetParser->SetCurrentCombine("");
 683 }
 684
 685 Super:
 686 jp_EXTENDS ClassType
 687 {
 688   jpElementStart(2);
 689   jpCheckEmpty(2);
 690   $<str>$ = 0;
 691   yyGetParser->SetCurrentCombine("");
 692 }
 693
 694 Interfaces:
 695 jp_IMPLEMENTS InterfaceTypeList
 696 {
 697   jpElementStart(2);
 698   jpCheckEmpty(2);
 699   $<str>$ = 0;
 700   yyGetParser->SetCurrentCombine("");
 701 }
 702
 703 InterfaceTypeList:
 704 InterfaceType
 705 {
 706   jpElementStart(1);
 707   jpCheckEmpty(1);
 708   $<str>$ = 0;
 709   yyGetParser->SetCurrentCombine("");
 710 }
 711 |
 712 InterfaceTypeList jp_COMMA InterfaceType
 713 {
 714   jpElementStart(3);
 715   jpCheckEmpty(3);
 716   $<str>$ = 0;
 717   yyGetParser->SetCurrentCombine("");
 718 }
 719
 720 ClassBody:
 721 jp_CURLYSTART ClassBodyDeclarations jp_CURLYEND
 722 {
 723   jpElementStart(3);
 724   jpCheckEmpty(3);
 725   $<str>$ = 0;
 726   yyGetParser->SetCurrentCombine("");
 727 }
 728
 729 ClassBodyDeclarations:
 730 {
 731   jpElementStart(1);
 732   $<str>$ = 0;
 733   yyGetParser->SetCurrentCombine("");
 734 }
 735 |
 736 ClassBodyDeclarations ClassBodyDeclaration
 737 {
 738   jpElementStart(2);
 739   jpCheckEmpty(2);
 740   $<str>$ = 0;
 741   yyGetParser->SetCurrentCombine("");
 742 }
 743
 744 ClassBodyDeclaration:
 745 ClassMemberDeclaration
 746 {
 747   jpElementStart(1);
 748   jpCheckEmpty(1);
 749   $<str>$ = 0;
 750   yyGetParser->SetCurrentCombine("");
 751 }
 752 |
 753 StaticInitializer
 754 {
 755   jpElementStart(1);
 756   jpCheckEmpty(1);
 757   $<str>$ = 0;
 758   yyGetParser->SetCurrentCombine("");
 759 }
 760 |
 761 ConstructorDeclaration
 762 {
 763   jpElementStart(1);
 764   jpCheckEmpty(1);
 765   $<str>$ = 0;
 766   yyGetParser->SetCurrentCombine("");
 767 }
 768 |
 769 TypeDeclaration
 770 {
 771   jpElementStart(1);
 772   jpCheckEmpty(1);
 773   $<str>$ = 0;
 774   yyGetParser->SetCurrentCombine("");
 775 }
 776
 777 ClassMemberDeclaration:
 778 FieldDeclaration
 779 {
 780   jpElementStart(1);
 781   jpCheckEmpty(1);
 782   $<str>$ = 0;
 783   yyGetParser->SetCurrentCombine("");
 784 }
 785 |
 786 MethodDeclaration
 787 {
 788   jpElementStart(1);
 789   jpCheckEmpty(1);
 790   $<str>$ = 0;
 791   yyGetParser->SetCurrentCombine("");
 792 }
 793
 794 FieldDeclaration:
 795 Modifiersopt Type VariableDeclarators jp_SEMICOL
 796 {
 797   jpElementStart(4);
 798 }
 799
 800 VariableDeclarators:
 801 VariableDeclarator
 802 {
 803   jpElementStart(1);
 804   jpCheckEmpty(1);
 805   $<str>$ = 0;
 806   yyGetParser->SetCurrentCombine("");
 807 }
 808 |
 809 VariableDeclarators jp_COMMA VariableDeclarator
 810 {
 811   jpElementStart(3);
 812   jpCheckEmpty(3);
 813   $<str>$ = 0;
 814   yyGetParser->SetCurrentCombine("");
 815 }
 816
 817 VariableDeclarator:
 818 VariableDeclaratorId
 819 {
 820   jpElementStart(1);
 821   jpCheckEmpty(1);
 822   $<str>$ = 0;
 823   yyGetParser->SetCurrentCombine("");
 824 }
 825 |
 826 VariableDeclaratorId jp_EQUALS VariableInitializer
 827 {
 828   jpElementStart(3);
 829   jpCheckEmpty(3);
 830   $<str>$ = 0;
 831   yyGetParser->SetCurrentCombine("");
 832 }
 833
 834 VariableDeclaratorId:
 835 Identifier
 836 {
 837   jpElementStart(1);
 838   yyGetParser->DeallocateParserType(&($<str>1));
 839   jpCheckEmpty(1);
 840   $<str>$ = 0;
 841   yyGetParser->SetCurrentCombine("");
 842 }
 843 |
 844 VariableDeclaratorId jp_BRACKETSTART jp_BRACKETEND
 845 {
 846   jpElementStart(1);
 847   jpCheckEmpty(1);
 848   $<str>$ = 0;
 849   yyGetParser->SetCurrentCombine("");
 850 }
 851
 852 VariableInitializer:
 853 Expression
 854 {
 855   jpElementStart(1);
 856   jpCheckEmpty(1);
 857   $<str>$ = 0;
 858   yyGetParser->SetCurrentCombine("");
 859 }
 860 |
 861 ArrayInitializer
 862 {
 863   jpElementStart(1);
 864   jpCheckEmpty(1);
 865   $<str>$ = 0;
 866   yyGetParser->SetCurrentCombine("");
 867 }
 868
 869 MethodDeclaration:
 870 MethodHeader jp_SEMICOL
 871 {
 872   jpElementStart(2);
 873   jpCheckEmpty(2);
 874   $<str>$ = 0;
 875   yyGetParser->SetCurrentCombine("");
 876 }
 877 |
 878 MethodHeader MethodBody
 879 {
 880   jpElementStart(2);
 881   jpCheckEmpty(2);
 882   $<str>$ = 0;
 883   yyGetParser->SetCurrentCombine("");
 884 }
 885 |
 886 MethodHeader MethodBody jp_SEMICOL
 887 {
 888   jpElementStart(3);
 889   jpCheckEmpty(3);
 890   $<str>$ = 0;
 891   yyGetParser->SetCurrentCombine("");
 892 }
 893
 894 MethodHeader:
 895 Modifiersopt Type MethodDeclarator Throwsopt
 896 {
 897   jpElementStart(4);
 898   jpCheckEmpty(4);
 899   $<str>$ = 0;
 900   yyGetParser->SetCurrentCombine("");
 901
 902 }
 903 |
 904 Modifiersopt jp_VOID MethodDeclarator Throwsopt
 905 {
 906   jpElementStart(4);
 907   jpCheckEmpty(4);
 908   $<str>$ = 0;
 909   yyGetParser->SetCurrentCombine("");
 910
 911 }
 912
 913 Throwsopt:
 914 {
 915   jpElementStart(0);
 916   $<str>$ = 0;
 917   yyGetParser->SetCurrentCombine("");
 918
 919 }
 920 |
 921 Throws
 922 {
 923   jpElementStart(1);
 924   jpCheckEmpty(1);
 925   $<str>$ = 0;
 926   yyGetParser->SetCurrentCombine("");
 927
 928 }
 929
 930 MethodDeclarator:
 931 Identifier jp_PARESTART FormalParameterListopt jp_PAREEND
 932 {
 933   jpElementStart(4);
 934   yyGetParser->DeallocateParserType(&($<str>1));
 935   jpCheckEmpty(4);
 936   $<str>$ = 0;
 937   yyGetParser->SetCurrentCombine("");
 938
 939 }
 940 |
 941 MethodDeclarator jp_BRACKETSTART jp_BRACKETEND
 942 {
 943   jpElementStart(3);
 944
 945 }
 946
 947 FormalParameterListopt:
 948 {
 949   jpElementStart(0);
 950   $<str>$ = 0;
 951   yyGetParser->SetCurrentCombine("");
 952
 953 }
 954 |
 955 FormalParameterList
 956
 957 FormalParameterList:
 958 FormalParameter
 959 {
 960   jpElementStart(1);
 961
 962 }
 963 |
 964 FormalParameterList jp_COMMA FormalParameter
 965 {
 966   jpElementStart(3);
 967   jpCheckEmpty(3);
 968   $<str>$ = 0;
 969   yyGetParser->SetCurrentCombine("");
 970
 971 }
 972
 973 FormalParameter:
 974 Modifiersopt Type VariableDeclaratorId
 975 {
 976   jpElementStart(3);
 977   jpCheckEmpty(3);
 978   $<str>$ = 0;
 979   yyGetParser->SetCurrentCombine("");
 980
 981 }
 982
 983 Throws:
 984 jp_THROWS ClassTypeList
 985 {
 986   jpElementStart(2);
 987   jpCheckEmpty(2);
 988   $<str>$ = 0;
 989   yyGetParser->SetCurrentCombine("");
 990
 991 }
 992
 993 ClassTypeList:
 994 ClassType
 995 {
 996   jpElementStart(1);
 997
 998 }
 999 |
1000 ClassTypeList jp_COMMA ClassType
1001 {
1002   jpElementStart(3);
1003   jpCheckEmpty(3);
1004   $<str>$ = 0;
1005   yyGetParser->SetCurrentCombine("");
1006
1007 }
1008
1009 MethodBody:
1010 Block
1011 {
1012   jpElementStart(1);
1013   jpCheckEmpty(1);
1014   $<str>$ = 0;
1015   yyGetParser->SetCurrentCombine("");
1016
1017 }
1018
1019 StaticInitializer:
1020 jp_STATIC Block
1021 {
1022   jpElementStart(2);
1023   jpCheckEmpty(2);
1024   $<str>$ = 0;
1025   yyGetParser->SetCurrentCombine("");
1026
1027 }
1028
1029 ConstructorDeclaration:
1030 Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody
1031 {
1032   jpElementStart(4);
1033   jpCheckEmpty(4);
1034   $<str>$ = 0;
1035   yyGetParser->SetCurrentCombine("");
1036
1037 }
1038 |
1039 Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody jp_SEMICOL
1040 {
1041   jpElementStart(5);
1042   jpCheckEmpty(5);
1043   $<str>$ = 0;
1044   yyGetParser->SetCurrentCombine("");
1045
1046 }
1047
1048 ConstructorDeclarator:
1049 SimpleName jp_PARESTART FormalParameterListopt jp_PAREEND
1050 {
1051   jpElementStart(4);
1052   yyGetParser->DeallocateParserType(&($<str>1));
1053   jpCheckEmpty(4);
1054   $<str>$ = 0;
1055   yyGetParser->SetCurrentCombine("");
1056
1057 }
1058
1059 ConstructorBody:
1060 jp_CURLYSTART ExplicitConstructorInvocationopt BlockStatementsopt jp_CURLYEND
1061 {
1062   jpElementStart(4);
1063   jpCheckEmpty(4);
1064   $<str>$ = 0;
1065   yyGetParser->SetCurrentCombine("");
1066
1067 }
1068
1069 ExplicitConstructorInvocationopt:
1070 {
1071   jpElementStart(0);
1072   $<str>$ = 0;
1073   yyGetParser->SetCurrentCombine("");
1074
1075 }
1076 |
1077 ExplicitConstructorInvocationopt ExplicitConstructorInvocation
1078 {
1079   jpElementStart(2);
1080   jpCheckEmpty(2);
1081   $<str>$ = 0;
1082   yyGetParser->SetCurrentCombine("");
1083
1084 }
1085
1086 ExplicitConstructorInvocation:
1087 jp_THIS jp_PARESTART ArgumentListopt jp_PAREEND jp_SEMICOL
1088 {
1089   jpElementStart(5);
1090   jpCheckEmpty(5);
1091   $<str>$ = 0;
1092   yyGetParser->SetCurrentCombine("");
1093
1094 }
1095 |
1096 jp_SUPER jp_PARESTART ArgumentListopt jp_PAREEND jp_SEMICOL
1097 {
1098   jpElementStart(5);
1099   jpCheckEmpty(5);
1100   $<str>$ = 0;
1101   yyGetParser->SetCurrentCombine("");
1102
1103 }
1104
1105 InterfaceHeader:
1106 Modifiersopt jp_INTERFACE Identifier
1107 {
1108   yyGetParser->StartClass($<str>3);
1109   jpElementStart(3);
1110   yyGetParser->DeallocateParserType(&($<str>3));
1111   jpCheckEmpty(3);
1112 }
1113
1114 InterfaceDeclaration:
1115 InterfaceHeader ExtendsInterfacesopt InterfaceBody
1116 {
1117   jpElementStart(2);
1118   jpCheckEmpty(2);
1119   $<str>$ = 0;
1120   yyGetParser->SetCurrentCombine("");
1121   yyGetParser->EndClass();
1122 }
1123
1124 ExtendsInterfacesopt:
1125 {
1126   jpElementStart(0);
1127   $<str>$ = 0;
1128   yyGetParser->SetCurrentCombine("");
1129 }
1130 |
1131 ExtendsInterfaces
1132 {
1133   jpElementStart(1);
1134   jpCheckEmpty(1);
1135   $<str>$ = 0;
1136   yyGetParser->SetCurrentCombine("");
1137
1138 }
1139
1140 ExtendsInterfaces:
1141 jp_EXTENDS InterfaceType
1142 {
1143   jpElementStart(2);
1144   jpCheckEmpty(2);
1145   $<str>$ = 0;
1146   yyGetParser->SetCurrentCombine("");
1147
1148 }
1149 |
1150 ExtendsInterfaces jp_COMMA InterfaceType
1151 {
1152   jpElementStart(3);
1153   jpCheckEmpty(3);
1154   $<str>$ = 0;
1155   yyGetParser->SetCurrentCombine("");
1156
1157 }
1158
1159 InterfaceBody:
1160 jp_CURLYSTART InterfaceMemberDeclarations jp_CURLYEND
1161 {
1162   jpElementStart(3);
1163   jpCheckEmpty(3);
1164   $<str>$ = 0;
1165   yyGetParser->SetCurrentCombine("");
1166
1167 }
1168
1169 InterfaceMemberDeclarations:
1170 {
1171   jpElementStart(0);
1172   $<str>$ = 0;
1173   yyGetParser->SetCurrentCombine("");
1174
1175 }
1176 |
1177 InterfaceMemberDeclarations InterfaceMemberDeclaration
1178 {
1179   jpElementStart(2);
1180   $<str>$ = 0;
1181   yyGetParser->SetCurrentCombine("");
1182
1183 }
1184
1185 InterfaceMemberDeclaration:
1186 ConstantDeclaration
1187 {
1188   jpElementStart(1);
1189   jpCheckEmpty(1);
1190   $<str>$ = 0;
1191   yyGetParser->SetCurrentCombine("");
1192
1193 }
1194 |
1195 AbstractMethodDeclaration
1196 {
1197   jpElementStart(1);
1198   jpCheckEmpty(1);
1199   $<str>$ = 0;
1200   yyGetParser->SetCurrentCombine("");
1201
1202 }
1203 |
1204 ClassDeclaration
1205 {
1206   jpElementStart(1);
1207   jpCheckEmpty(1);
1208   $<str>$ = 0;
1209   yyGetParser->SetCurrentCombine("");
1210
1211 }
1212 |
1213 ClassDeclaration jp_SEMICOL
1214 {
1215   jpElementStart(2);
1216   $<str>$ = 0;
1217   yyGetParser->SetCurrentCombine("");
1218
1219 }
1220 |
1221 InterfaceDeclaration
1222 {
1223   jpElementStart(1);
1224   jpCheckEmpty(1);
1225   $<str>$ = 0;
1226   yyGetParser->SetCurrentCombine("");
1227
1228 }
1229 |
1230 InterfaceDeclaration jp_SEMICOL
1231 {
1232   jpElementStart(2);
1233   $<str>$ = 0;
1234   yyGetParser->SetCurrentCombine("");
1235
1236 }
1237
1238 ConstantDeclaration:
1239 FieldDeclaration
1240 {
1241   jpElementStart(1);
1242   jpCheckEmpty(1);
1243   $<str>$ = 0;
1244   yyGetParser->SetCurrentCombine("");
1245
1246 }
1247
1248 AbstractMethodDeclaration:
1249 MethodHeader Semicols
1250 {
1251   jpElementStart(2);
1252   jpCheckEmpty(2);
1253   $<str>$ = 0;
1254   yyGetParser->SetCurrentCombine("");
1255
1256 }
1257
1258 Semicols:
1259 jp_SEMICOL
1260 {
1261   jpElementStart(1);
1262   jpCheckEmpty(1);
1263   $<str>$ = 0;
1264   yyGetParser->SetCurrentCombine("");
1265
1266 }
1267 |
1268 Semicols jp_SEMICOL
1269 {
1270   jpElementStart(2);
1271   jpCheckEmpty(2);
1272   $<str>$ = 0;
1273   yyGetParser->SetCurrentCombine("");
1274
1275 }
1276
1277 ArrayInitializer:
1278 jp_CURLYSTART VariableInitializersOptional jp_CURLYEND
1279 {
1280   jpElementStart(3);
1281   jpCheckEmpty(3);
1282   $<str>$ = 0;
1283   yyGetParser->SetCurrentCombine("");
1284
1285 }
1286
1287 VariableInitializersOptional:
1288 {
1289   jpElementStart(1);
1290   $<str>$ = 0;
1291   yyGetParser->SetCurrentCombine("");
1292
1293 }
1294 |
1295 VariableInitializers
1296 {
1297   jpElementStart(1);
1298   jpCheckEmpty(1);
1299   $<str>$ = 0;
1300   yyGetParser->SetCurrentCombine("");
1301
1302 }
1303 |
1304 VariableInitializers jp_COMMA
1305 {
1306   jpElementStart(2);
1307   jpCheckEmpty(2);
1308   $<str>$ = 0;
1309   yyGetParser->SetCurrentCombine("");
1310
1311 }
1312
1313 VariableInitializers:
1314 VariableInitializer
1315 {
1316   jpElementStart(1);
1317   jpCheckEmpty(1);
1318   $<str>$ = 0;
1319   yyGetParser->SetCurrentCombine("");
1320
1321 }
1322 |
1323 VariableInitializers jp_COMMA VariableInitializer
1324 {
1325   jpElementStart(3);
1326   jpCheckEmpty(3);
1327   $<str>$ = 0;
1328   yyGetParser->SetCurrentCombine("");
1329
1330 }
1331
1332 Block:
1333 jp_CURLYSTART BlockStatementsopt jp_CURLYEND
1334 {
1335   jpElementStart(4);
1336   $<str>$ = 0;
1337   yyGetParser->SetCurrentCombine("");
1338
1339 }
1340
1341 BlockStatementsopt:
1342 {
1343   jpElementStart(1);
1344   $<str>$ = 0;
1345   yyGetParser->SetCurrentCombine("");
1346
1347 }
1348 |
1349 BlockStatements
1350 {
1351   jpElementStart(1);
1352   jpCheckEmpty(1);
1353   $<str>$ = 0;
1354   yyGetParser->SetCurrentCombine("");
1355
1356 }
1357
1358 BlockStatements:
1359 BlockStatement
1360 {
1361   jpElementStart(1);
1362   jpCheckEmpty(1);
1363   $<str>$ = 0;
1364   yyGetParser->SetCurrentCombine("");
1365
1366 }
1367 |
1368 BlockStatements BlockStatement
1369 {
1370   jpElementStart(1);
1371   jpCheckEmpty(2);
1372   $<str>$ = 0;
1373   yyGetParser->SetCurrentCombine("");
1374
1375 }
1376
1377 BlockStatement:
1378 LocalVariableDeclarationStatement
1379 {
1380   jpElementStart(1);
1381   jpCheckEmpty(1);
1382   $<str>$ = 0;
1383   yyGetParser->SetCurrentCombine("");
1384
1385 }
1386 |
1387 Statement
1388 {
1389   jpElementStart(1);
1390   jpCheckEmpty(1);
1391   $<str>$ = 0;
1392   yyGetParser->SetCurrentCombine("");
1393
1394 }
1395 |
1396 ClassDeclaration
1397 {
1398   jpElementStart(1);
1399   jpCheckEmpty(1);
1400   $<str>$ = 0;
1401   yyGetParser->SetCurrentCombine("");
1402
1403 }
1404
1405 LocalVariableDeclarationStatement:
1406 LocalVariableDeclaration jp_SEMICOL
1407 {
1408   jpElementStart(1);
1409   jpCheckEmpty(2);
1410   $<str>$ = 0;
1411   yyGetParser->SetCurrentCombine("");
1412
1413 }
1414
1415 LocalVariableDeclaration:
1416 Modifiers Type VariableDeclarators
1417 {
1418   jpElementStart(1);
1419   jpCheckEmpty(3);
1420   $<str>$ = 0;
1421   yyGetParser->SetCurrentCombine("");
1422
1423 }
1424 |
1425 Type VariableDeclarators
1426 {
1427   jpElementStart(1);
1428   jpCheckEmpty(2);
1429   $<str>$ = 0;
1430   yyGetParser->SetCurrentCombine("");
1431
1432 }
1433
1434 Statement:
1435 StatementWithoutTrailingSubstatement
1436 {
1437   jpElementStart(1);
1438   jpCheckEmpty(1);
1439   $<str>$ = 0;
1440   yyGetParser->SetCurrentCombine("");
1441
1442 }
1443 |
1444 LabeledStatement
1445 {
1446   jpElementStart(1);
1447   jpCheckEmpty(1);
1448   $<str>$ = 0;
1449   yyGetParser->SetCurrentCombine("");
1450
1451 }
1452 |
1453 IfThenStatement
1454 {
1455   jpElementStart(1);
1456   jpCheckEmpty(1);
1457   $<str>$ = 0;
1458   yyGetParser->SetCurrentCombine("");
1459
1460 }
1461 |
1462 IfThenElseStatement
1463 {
1464   jpElementStart(1);
1465   jpCheckEmpty(1);
1466   $<str>$ = 0;
1467   yyGetParser->SetCurrentCombine("");
1468
1469 }
1470 |
1471 WhileStatement
1472 {
1473   jpElementStart(1);
1474   jpCheckEmpty(1);
1475   $<str>$ = 0;
1476   yyGetParser->SetCurrentCombine("");
1477
1478 }
1479 |
1480 ForStatement
1481 {
1482   jpElementStart(1);
1483   jpCheckEmpty(1);
1484   $<str>$ = 0;
1485   yyGetParser->SetCurrentCombine("");
1486
1487 }
1488
1489 StatementNoShortIf:
1490 StatementWithoutTrailingSubstatement
1491 {
1492   jpElementStart(1);
1493   jpCheckEmpty(1);
1494   $<str>$ = 0;
1495   yyGetParser->SetCurrentCombine("");
1496
1497 }
1498 |
1499 LabeledStatementNoShortIf
1500 {
1501   jpElementStart(1);
1502   jpCheckEmpty(1);
1503   $<str>$ = 0;
1504   yyGetParser->SetCurrentCombine("");
1505
1506 }
1507 |
1508 IfThenElseStatementNoShortIf
1509 {
1510   jpElementStart(1);
1511   jpCheckEmpty(1);
1512   $<str>$ = 0;
1513   yyGetParser->SetCurrentCombine("");
1514
1515 }
1516 |
1517 WhileStatementNoShortIf
1518 {
1519   jpElementStart(1);
1520   jpCheckEmpty(1);
1521   $<str>$ = 0;
1522   yyGetParser->SetCurrentCombine("");
1523
1524 }
1525 |
1526 ForStatementNoShortIf
1527 {
1528   jpElementStart(1);
1529   jpCheckEmpty(1);
1530   $<str>$ = 0;
1531   yyGetParser->SetCurrentCombine("");
1532
1533 }
1534
1535 StatementWithoutTrailingSubstatement:
1536 Block
1537 {
1538   jpElementStart(1);
1539   jpCheckEmpty(1);
1540   $<str>$ = 0;
1541   yyGetParser->SetCurrentCombine("");
1542
1543 }
1544 |
1545 EmptyStatement
1546 {
1547   jpElementStart(1);
1548   jpCheckEmpty(1);
1549   $<str>$ = 0;
1550   yyGetParser->SetCurrentCombine("");
1551
1552 }
1553 |
1554 ExpressionStatement
1555 {
1556   jpElementStart(1);
1557   jpCheckEmpty(1);
1558   $<str>$ = 0;
1559   yyGetParser->SetCurrentCombine("");
1560
1561 }
1562 |
1563 SwitchStatement
1564 {
1565   jpElementStart(1);
1566   jpCheckEmpty(1);
1567   $<str>$ = 0;
1568   yyGetParser->SetCurrentCombine("");
1569
1570 }
1571 |
1572 DoStatement
1573 {
1574   jpElementStart(1);
1575   jpCheckEmpty(1);
1576   $<str>$ = 0;
1577   yyGetParser->SetCurrentCombine("");
1578
1579 }
1580 |
1581 BreakStatement
1582 {
1583   jpElementStart(1);
1584   jpCheckEmpty(1);
1585   $<str>$ = 0;
1586   yyGetParser->SetCurrentCombine("");
1587
1588 }
1589 |
1590 ContinueStatement
1591 {
1592   jpElementStart(1);
1593   jpCheckEmpty(1);
1594   $<str>$ = 0;
1595   yyGetParser->SetCurrentCombine("");
1596
1597 }
1598 |
1599 ReturnStatement
1600 {
1601   jpElementStart(1);
1602   jpCheckEmpty(1);
1603   $<str>$ = 0;
1604   yyGetParser->SetCurrentCombine("");
1605
1606 }
1607 |
1608 SynchronizedStatement
1609 {
1610   jpElementStart(1);
1611   jpCheckEmpty(1);
1612   $<str>$ = 0;
1613   yyGetParser->SetCurrentCombine("");
1614
1615 }
1616 |
1617 ThrowStatement
1618 {
1619   jpElementStart(1);
1620   jpCheckEmpty(1);
1621   $<str>$ = 0;
1622   yyGetParser->SetCurrentCombine("");
1623
1624 }
1625 |
1626 TryStatement
1627 {
1628   jpElementStart(1);
1629   jpCheckEmpty(1);
1630   $<str>$ = 0;
1631   yyGetParser->SetCurrentCombine("");
1632
1633 }
1634 |
1635 AssertStatement
1636 {
1637   jpElementStart(1);
1638   jpCheckEmpty(1);
1639   $<str>$ = 0;
1640   yyGetParser->SetCurrentCombine("");
1641
1642 }
1643
1644 EmptyStatement:
1645 jp_SEMICOL
1646 {
1647   jpElementStart(1);
1648   jpCheckEmpty(1);
1649   $<str>$ = 0;
1650   yyGetParser->SetCurrentCombine("");
1651
1652 }
1653
1654 LabeledStatement:
1655 Identifier jp_COLON Statement
1656 {
1657   jpElementStart(3);
1658   yyGetParser->DeallocateParserType(&($<str>1));
1659   jpCheckEmpty(3);
1660   $<str>$ = 0;
1661   yyGetParser->SetCurrentCombine("");
1662
1663 }
1664
1665 LabeledStatementNoShortIf:
1666 Identifier jp_COLON StatementNoShortIf
1667 {
1668   jpElementStart(3);
1669   jpCheckEmpty(3);
1670   $<str>$ = 0;
1671   yyGetParser->SetCurrentCombine("");
1672
1673 }
1674
1675 ExpressionStatement:
1676 StatementExpression jp_SEMICOL
1677 {
1678   jpElementStart(2);
1679   jpCheckEmpty(2);
1680   $<str>$ = 0;
1681   yyGetParser->SetCurrentCombine("");
1682
1683 }
1684
1685 StatementExpression:
1686 Assignment
1687 {
1688   jpElementStart(1);
1689   jpCheckEmpty(1);
1690   $<str>$ = 0;
1691   yyGetParser->SetCurrentCombine("");
1692
1693 }
1694 |
1695 PreIncrementExpression
1696 {
1697   jpElementStart(1);
1698   jpCheckEmpty(1);
1699   $<str>$ = 0;
1700   yyGetParser->SetCurrentCombine("");
1701
1702 }
1703 |
1704 PreDecrementExpression
1705 {
1706   jpElementStart(1);
1707   jpCheckEmpty(1);
1708   $<str>$ = 0;
1709   yyGetParser->SetCurrentCombine("");
1710
1711 }
1712 |
1713 PostIncrementExpression
1714 {
1715   jpElementStart(1);
1716   jpCheckEmpty(1);
1717   $<str>$ = 0;
1718   yyGetParser->SetCurrentCombine("");
1719
1720 }
1721 |
1722 PostDecrementExpression
1723 {
1724   jpElementStart(1);
1725   jpCheckEmpty(1);
1726   $<str>$ = 0;
1727   yyGetParser->SetCurrentCombine("");
1728
1729 }
1730 |
1731 MethodInvocation
1732 {
1733   jpElementStart(1);
1734   jpCheckEmpty(1);
1735   $<str>$ = 0;
1736   yyGetParser->SetCurrentCombine("");
1737
1738 }
1739 |
1740 ClassInstanceCreationExpression
1741 {
1742   jpElementStart(1);
1743   jpCheckEmpty(1);
1744   $<str>$ = 0;
1745   yyGetParser->SetCurrentCombine("");
1746
1747 }
1748
1749 IfThenStatement:
1750 jp_IF jp_PARESTART Expression jp_PAREEND Statement
1751 {
1752   jpElementStart(5);
1753   jpCheckEmpty(5);
1754   $<str>$ = 0;
1755   yyGetParser->SetCurrentCombine("");
1756
1757 }
1758
1759 IfThenElseStatement:
1760 jp_IF jp_PARESTART Expression jp_PAREEND StatementNoShortIf jp_ELSE Statement
1761 {
1762   jpElementStart(7);
1763   jpCheckEmpty(7);
1764   $<str>$ = 0;
1765   yyGetParser->SetCurrentCombine("");
1766
1767 }
1768
1769 IfThenElseStatementNoShortIf:
1770 jp_IF jp_PARESTART Expression jp_PAREEND StatementNoShortIf jp_ELSE StatementNoShortIf
1771 {
1772   jpElementStart(7);
1773   jpCheckEmpty(7);
1774   $<str>$ = 0;
1775   yyGetParser->SetCurrentCombine("");
1776
1777 }
1778
1779 SwitchStatement:
1780 jp_SWITCH jp_PARESTART Expression jp_PAREEND SwitchBlock
1781 {
1782   jpElementStart(5);
1783
1784 }
1785
1786 SwitchBlock:
1787 jp_CURLYSTART SwitchBlockStatementGroups SwitchLabelsopt jp_CURLYEND
1788 {
1789   jpElementStart(4);
1790
1791 }
1792
1793 SwitchLabelsopt:
1794 {
1795   jpElementStart(0);
1796   $<str>$ = 0;
1797   yyGetParser->SetCurrentCombine("");
1798
1799 }
1800 |
1801 SwitchLabels
1802 {
1803   jpElementStart(1);
1804   jpCheckEmpty(1);
1805   $<str>$ = 0;
1806   yyGetParser->SetCurrentCombine("");
1807
1808 }
1809
1810 SwitchBlockStatementGroups:
1811 {
1812   jpElementStart(0);
1813   $<str>$ = 0;
1814   yyGetParser->SetCurrentCombine("");
1815
1816 }
1817 |
1818 SwitchBlockStatementGroups SwitchBlockStatementGroup
1819 {
1820   jpElementStart(2);
1821   jpCheckEmpty(2);
1822   $<str>$ = 0;
1823   yyGetParser->SetCurrentCombine("");
1824
1825 }
1826
1827 SwitchBlockStatementGroup:
1828 SwitchLabels BlockStatements
1829 {
1830   jpElementStart(2);
1831   jpCheckEmpty(2);
1832   $<str>$ = 0;
1833   yyGetParser->SetCurrentCombine("");
1834
1835 }
1836
1837 SwitchLabels:
1838 SwitchLabel
1839 {
1840   jpElementStart(1);
1841   jpCheckEmpty(1);
1842   $<str>$ = 0;
1843   yyGetParser->SetCurrentCombine("");
1844
1845 }
1846 |
1847 SwitchLabels SwitchLabel
1848 {
1849   jpElementStart(2);
1850   jpCheckEmpty(2);
1851   $<str>$ = 0;
1852   yyGetParser->SetCurrentCombine("");
1853
1854 }
1855
1856 SwitchLabel:
1857 jp_CASE ConstantExpression jp_COLON
1858 {
1859   jpElementStart(3);
1860   jpCheckEmpty(3);
1861   $<str>$ = 0;
1862   yyGetParser->SetCurrentCombine("");
1863
1864 }
1865 |
1866 jp_DEFAULT jp_COLON
1867 {
1868   jpElementStart(2);
1869   jpCheckEmpty(2);
1870   $<str>$ = 0;
1871   yyGetParser->SetCurrentCombine("");
1872
1873 }
1874
1875 WhileStatement:
1876 jp_WHILE jp_PARESTART Expression jp_PAREEND Statement
1877 {
1878   jpElementStart(5);
1879
1880 }
1881
1882 WhileStatementNoShortIf:
1883 jp_WHILE jp_PARESTART Expression jp_PAREEND StatementNoShortIf
1884 {
1885   jpElementStart(5);
1886
1887 }
1888
1889 DoStatement:
1890 jp_DO Statement jp_WHILE jp_PARESTART Expression jp_PAREEND jp_SEMICOL
1891 {
1892   jpElementStart(7);
1893
1894 }
1895
1896 ForStatement:
1897 jp_FOR jp_PARESTART ForInitopt jp_SEMICOL Expressionopt jp_SEMICOL ForUpdateopt jp_PAREEND
1898 Statement
1899 {
1900   jpElementStart(9);
1901
1902 }
1903
1904 ForUpdateopt:
1905 {
1906   jpElementStart(1);
1907   $<str>$ = 0;
1908   yyGetParser->SetCurrentCombine("");
1909
1910 }
1911 |
1912 ForUpdate
1913 {
1914   jpElementStart(1);
1915   jpCheckEmpty(1);
1916   $<str>$ = 0;
1917   yyGetParser->SetCurrentCombine("");
1918
1919 }
1920
1921 ForInitopt:
1922 {
1923   jpElementStart(0);
1924   $<str>$ = 0;
1925   yyGetParser->SetCurrentCombine("");
1926
1927 }
1928 |
1929 ForInit
1930 {
1931   jpElementStart(1);
1932   jpCheckEmpty(1);
1933   $<str>$ = 0;
1934   yyGetParser->SetCurrentCombine("");
1935
1936 }
1937
1938 ForStatementNoShortIf:
1939 jp_FOR jp_PARESTART ForInitopt jp_SEMICOL Expressionopt jp_SEMICOL ForUpdateopt jp_PAREEND
1940 StatementNoShortIf
1941 {
1942   jpElementStart(9);
1943   $<str>$ = 0;
1944   yyGetParser->SetCurrentCombine("");
1945
1946 }
1947
1948 Expressionopt:
1949 {
1950   jpElementStart(0);
1951   $<str>$ = 0;
1952   yyGetParser->SetCurrentCombine("");
1953
1954 }
1955 |
1956 Expression
1957 {
1958   jpElementStart(1);
1959   jpCheckEmpty(1);
1960   $<str>$ = 0;
1961   yyGetParser->SetCurrentCombine("");
1962
1963 }
1964
1965 ForInit:
1966 StatementExpressionList
1967 {
1968   jpElementStart(1);
1969   jpCheckEmpty(1);
1970   $<str>$ = 0;
1971   yyGetParser->SetCurrentCombine("");
1972
1973 }
1974 |
1975 LocalVariableDeclaration
1976 {
1977   jpElementStart(1);
1978   jpCheckEmpty(1);
1979   $<str>$ = 0;
1980   yyGetParser->SetCurrentCombine("");
1981
1982 }
1983
1984 ForUpdate:
1985 StatementExpressionList
1986 {
1987   jpElementStart(1);
1988   jpCheckEmpty(1);
1989   $<str>$ = 0;
1990   yyGetParser->SetCurrentCombine("");
1991
1992 }
1993
1994 StatementExpressionList:
1995 StatementExpression
1996 {
1997   jpElementStart(1);
1998   jpCheckEmpty(1);
1999   $<str>$ = 0;
2000   yyGetParser->SetCurrentCombine("");
2001
2002 }
2003 |
2004 StatementExpressionList jp_COMMA StatementExpression
2005 {
2006   jpElementStart(3);
2007   jpCheckEmpty(3);
2008   $<str>$ = 0;
2009   yyGetParser->SetCurrentCombine("");
2010
2011 }
2012
2013 AssertStatement:
2014 jp_ASSERT Expression jp_SEMICOL
2015 {
2016   jpElementStart(3);
2017   jpCheckEmpty(3);
2018   $<str>$ = 0;
2019   yyGetParser->SetCurrentCombine("");
2020
2021 }
2022 |
2023 jp_ASSERT Expression jp_COLON Expression jp_SEMICOL
2024 {
2025   jpElementStart(5);
2026   jpCheckEmpty(5);
2027   $<str>$ = 0;
2028   yyGetParser->SetCurrentCombine("");
2029
2030 }
2031
2032 BreakStatement:
2033 jp_BREAK Identifieropt jp_SEMICOL
2034 {
2035   jpElementStart(3);
2036   yyGetParser->DeallocateParserType(&($<str>2));
2037   jpCheckEmpty(3);
2038   $<str>$ = 0;
2039   yyGetParser->SetCurrentCombine("");
2040
2041 }
2042
2043 Identifieropt:
2044 {
2045   jpElementStart(0);
2046   $<str>$ = 0;
2047   yyGetParser->SetCurrentCombine("");
2048
2049 }
2050 |
2051 Identifier
2052 {
2053   jpElementStart(1);
2054
2055 }
2056
2057 ContinueStatement:
2058 jp_CONTINUE Identifieropt jp_SEMICOL
2059 {
2060   jpElementStart(3);
2061   yyGetParser->DeallocateParserType(&($<str>2));
2062   jpCheckEmpty(3);
2063   $<str>$ = 0;
2064   yyGetParser->SetCurrentCombine("");
2065
2066 }
2067
2068 ReturnStatement:
2069 jp_RETURN Expressionopt jp_SEMICOL
2070 {
2071   jpElementStart(3);
2072   jpCheckEmpty(3);
2073   $<str>$ = 0;
2074   yyGetParser->SetCurrentCombine("");
2075
2076 }
2077
2078 ThrowStatement:
2079 jp_THROW Expression jp_SEMICOL
2080 {
2081   jpElementStart(3);
2082   jpCheckEmpty(3);
2083   $<str>$ = 0;
2084   yyGetParser->SetCurrentCombine("");
2085
2086 }
2087
2088 SynchronizedStatement:
2089 jp_SYNCHRONIZED jp_PARESTART Expression jp_PAREEND Block
2090 {
2091   jpElementStart(5);
2092   jpCheckEmpty(5);
2093   $<str>$ = 0;
2094   yyGetParser->SetCurrentCombine("");
2095
2096 }
2097
2098 TryStatement:
2099 jp_TRY Block Catches
2100 {
2101   jpElementStart(3);
2102   jpCheckEmpty(3);
2103   $<str>$ = 0;
2104   yyGetParser->SetCurrentCombine("");
2105
2106 }
2107 |
2108 jp_TRY Block Catchesopt Finally
2109 {
2110   jpElementStart(4);
2111   jpCheckEmpty(4);
2112   $<str>$ = 0;
2113   yyGetParser->SetCurrentCombine("");
2114
2115 }
2116
2117 Catchesopt:
2118 {
2119   jpElementStart(1);
2120   $<str>$ = 0;
2121   yyGetParser->SetCurrentCombine("");
2122
2123 }
2124 |
2125 Catches
2126 {
2127   jpElementStart(1);
2128   jpCheckEmpty(1);
2129   $<str>$ = 0;
2130   yyGetParser->SetCurrentCombine("");
2131
2132 }
2133
2134 Catches:
2135 CatchClause
2136 {
2137   jpElementStart(1);
2138   jpCheckEmpty(1);
2139   $<str>$ = 0;
2140   yyGetParser->SetCurrentCombine("");
2141
2142 }
2143 |
2144 Catches CatchClause
2145 {
2146   jpElementStart(2);
2147   jpCheckEmpty(2);
2148   $<str>$ = 0;
2149   yyGetParser->SetCurrentCombine("");
2150
2151 }
2152
2153 CatchClause:
2154 jp_CATCH jp_PARESTART FormalParameter jp_PAREEND Block
2155 {
2156   jpElementStart(5);
2157
2158 }
2159
2160 Finally:
2161 jp_FINALLY Block
2162 {
2163   jpElementStart(2);
2164   jpCheckEmpty(2);
2165   $<str>$ = 0;
2166   yyGetParser->SetCurrentCombine("");
2167
2168 }
2169
2170 Primary:
2171 PrimaryNoNewArray
2172 {
2173   jpElementStart(1);
2174   jpCheckEmpty(1);
2175   $<str>$ = 0;
2176   yyGetParser->SetCurrentCombine("");
2177
2178 }
2179 |
2180 ArrayCreationExpression
2181 {
2182   jpElementStart(1);
2183   jpCheckEmpty(1);
2184   $<str>$ = 0;
2185   yyGetParser->SetCurrentCombine("");
2186
2187 }
2188
2189 PrimaryNoNewArray:
2190 Literal
2191 {
2192   jpElementStart(1);
2193   jpCheckEmpty(1);
2194   $<str>$ = 0;
2195   yyGetParser->SetCurrentCombine("");
2196
2197 }
2198 |
2199 jp_THIS
2200 {
2201   jpElementStart(1);
2202
2203 }
2204 |
2205 jp_PARESTART Expression jp_PAREEND
2206 {
2207   jpElementStart(3);
2208   jpCheckEmpty(3);
2209   $<str>$ = 0;
2210   yyGetParser->SetCurrentCombine("");
2211
2212 }
2213 |
2214 ClassInstanceCreationExpression
2215 {
2216   jpElementStart(1);
2217   jpCheckEmpty(1);
2218   $<str>$ = 0;
2219   yyGetParser->SetCurrentCombine("");
2220
2221 }
2222 |
2223 FieldAccess
2224 {
2225   jpElementStart(1);
2226   jpCheckEmpty(1);
2227   $<str>$ = 0;
2228   yyGetParser->SetCurrentCombine("");
2229
2230 }
2231 |
2232 MethodInvocation
2233 {
2234   jpElementStart(1);
2235   jpCheckEmpty(1);
2236   $<str>$ = 0;
2237   yyGetParser->SetCurrentCombine("");
2238
2239 }
2240 |
2241 ArrayAccess
2242 {
2243   jpElementStart(1);
2244   jpCheckEmpty(1);
2245   $<str>$ = 0;
2246   yyGetParser->SetCurrentCombine("");
2247
2248 }
2249
2250 ClassInstanceCreationExpression:
2251 New ClassType jp_PARESTART ArgumentListopt jp_PAREEND ClassBodyOpt
2252 {
2253   jpElementStart(6);
2254   jpCheckEmpty(6);
2255   $<str>$ = 0;
2256   yyGetParser->SetCurrentCombine("");
2257
2258 }
2259
2260 ClassBodyOpt:
2261 {
2262   jpElementStart(0);
2263   $<str>$ = 0;
2264   yyGetParser->SetCurrentCombine("");
2265
2266 }
2267 |
2268 ClassBody
2269 {
2270   jpElementStart(1);
2271   jpCheckEmpty(1);
2272   $<str>$ = 0;
2273   yyGetParser->SetCurrentCombine("");
2274
2275 }
2276
2277 ArgumentListopt:
2278 {
2279   jpElementStart(0);
2280   $<str>$ = 0;
2281   yyGetParser->SetCurrentCombine("");
2282
2283 }
2284 |
2285 ArgumentList
2286 {
2287   jpElementStart(1);
2288   jpCheckEmpty(1);
2289   $<str>$ = 0;
2290   yyGetParser->SetCurrentCombine("");
2291
2292 }
2293
2294 ArgumentList:
2295 Expression
2296 {
2297   jpElementStart(1);
2298   jpCheckEmpty(1);
2299   $<str>$ = 0;
2300   yyGetParser->SetCurrentCombine("");
2301
2302 }
2303 |
2304 ArgumentList jp_COMMA Expression
2305 {
2306   jpElementStart(3);
2307   jpCheckEmpty(3);
2308   $<str>$ = 0;
2309   yyGetParser->SetCurrentCombine("");
2310
2311 }
2312
2313 ArrayCreationExpression:
2314 New PrimitiveType DimExprs Dimsopt
2315 {
2316   jpElementStart(4);
2317   jpCheckEmpty(4);
2318   $<str>$ = 0;
2319   yyGetParser->SetCurrentCombine("");
2320
2321 }
2322 |
2323 New ClassOrInterfaceType DimExprs Dimsopt
2324 {
2325   jpElementStart(4);
2326   jpCheckEmpty(4);
2327   $<str>$ = 0;
2328   yyGetParser->SetCurrentCombine("");
2329
2330 }
2331 |
2332 New PrimitiveType Dims ArrayInitializer
2333 {
2334   jpElementStart(4);
2335   jpCheckEmpty(4);
2336   $<str>$ = 0;
2337   yyGetParser->SetCurrentCombine("");
2338
2339 }
2340 |
2341 New ClassOrInterfaceType Dims ArrayInitializer
2342 {
2343   jpElementStart(4);
2344   jpCheckEmpty(4);
2345   $<str>$ = 0;
2346   yyGetParser->SetCurrentCombine("");
2347
2348 }
2349
2350 Dimsopt:
2351 {
2352   jpElementStart(0);
2353   $<str>$ = 0;
2354   yyGetParser->SetCurrentCombine("");
2355
2356 }
2357 |
2358 Dims
2359 {
2360   jpElementStart(1);
2361   jpCheckEmpty(1);
2362   $<str>$ = 0;
2363   yyGetParser->SetCurrentCombine("");
2364
2365 }
2366
2367 DimExprs:
2368 DimExpr
2369 {
2370   jpElementStart(1);
2371   jpCheckEmpty(1);
2372   $<str>$ = 0;
2373   yyGetParser->SetCurrentCombine("");
2374
2375 }
2376 |
2377 DimExprs DimExpr
2378 {
2379   jpElementStart(2);
2380   jpCheckEmpty(2);
2381   $<str>$ = 0;
2382   yyGetParser->SetCurrentCombine("");
2383
2384 }
2385
2386 DimExpr:
2387 jp_BRACKETSTART Expression jp_BRACKETEND
2388 {
2389   jpElementStart(3);
2390   jpCheckEmpty(3);
2391   $<str>$ = 0;
2392   yyGetParser->SetCurrentCombine("");
2393
2394 }
2395
2396 Dims:
2397 jp_BRACKETSTART jp_BRACKETEND
2398 {
2399   jpElementStart(2);
2400
2401 }
2402 |
2403 Dims jp_BRACKETSTART jp_BRACKETEND
2404 {
2405   jpElementStart(3);
2406
2407 }
2408
2409 FieldAccess:
2410 Primary jp_DOT Identifier
2411 {
2412   jpElementStart(3);
2413   yyGetParser->DeallocateParserType(&($<str>3));
2414   jpCheckEmpty(3);
2415   $<str>$ = 0;
2416   yyGetParser->SetCurrentCombine("");
2417
2418 }
2419 |
2420 jp_SUPER jp_DOT Identifier
2421 {
2422   jpElementStart(3);
2423   yyGetParser->DeallocateParserType(&($<str>3));
2424   jpCheckEmpty(3);
2425   $<str>$ = 0;
2426   yyGetParser->SetCurrentCombine("");
2427
2428 }
2429 |
2430 jp_THIS jp_DOT Identifier
2431 {
2432   jpElementStart(3);
2433   yyGetParser->DeallocateParserType(&($<str>3));
2434   jpCheckEmpty(3);
2435   $<str>$ = 0;
2436   yyGetParser->SetCurrentCombine("");
2437
2438 }
2439 |
2440 Primary jp_DOT jp_THIS
2441 {
2442   jpElementStart(3);
2443   yyGetParser->DeallocateParserType(&($<str>3));
2444   jpCheckEmpty(3);
2445   $<str>$ = 0;
2446   yyGetParser->SetCurrentCombine("");
2447
2448 }
2449
2450 MethodInvocation:
2451 Name jp_PARESTART ArgumentListopt jp_PAREEND
2452 {
2453   jpElementStart(4);
2454   yyGetParser->DeallocateParserType(&($<str>1));
2455   jpCheckEmpty(4);
2456   $<str>$ = 0;
2457   yyGetParser->SetCurrentCombine("");
2458
2459 }
2460 |
2461 Primary jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
2462 {
2463   jpElementStart(6);
2464   yyGetParser->DeallocateParserType(&($<str>1));
2465   yyGetParser->DeallocateParserType(&($<str>3));
2466   jpCheckEmpty(6);
2467   $<str>$ = 0;
2468   yyGetParser->SetCurrentCombine("");
2469
2470 }
2471 |
2472 jp_SUPER jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
2473 {
2474   jpElementStart(6);
2475   yyGetParser->DeallocateParserType(&($<str>3));
2476   jpCheckEmpty(6);
2477   $<str>$ = 0;
2478   yyGetParser->SetCurrentCombine("");
2479
2480 }
2481 |
2482 jp_THIS jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
2483 {
2484   jpElementStart(6);
2485   yyGetParser->DeallocateParserType(&($<str>3));
2486   jpCheckEmpty(6);
2487   $<str>$ = 0;
2488   yyGetParser->SetCurrentCombine("");
2489
2490 }
2491
2492 ArrayAccess:
2493 Name jp_BRACKETSTART Expression jp_BRACKETEND
2494 {
2495   jpElementStart(4);
2496   yyGetParser->DeallocateParserType(&($<str>1));
2497   jpCheckEmpty(4);
2498   $<str>$ = 0;
2499   yyGetParser->SetCurrentCombine("");
2500
2501 }
2502 |
2503 PrimaryNoNewArray jp_BRACKETSTART Expression jp_BRACKETEND
2504 {
2505   jpElementStart(4);
2506   jpCheckEmpty(4);
2507   $<str>$ = 0;
2508   yyGetParser->SetCurrentCombine("");
2509
2510 }
2511
2512 PostfixExpression:
2513 Primary
2514 {
2515   jpElementStart(1);
2516   jpCheckEmpty(1);
2517   $<str>$ = 0;
2518   yyGetParser->SetCurrentCombine("");
2519
2520 }
2521 |
2522 Name
2523 {
2524   jpElementStart(1);
2525   yyGetParser->DeallocateParserType(&($<str>1));
2526   $<str>$ = 0;
2527   yyGetParser->SetCurrentCombine("");
2528
2529 }
2530 |
2531 ArrayType jp_DOT jp_CLASS
2532 {
2533   jpElementStart(3);
2534   jpCheckEmpty(3);
2535   $<str>$ = 0;
2536   yyGetParser->SetCurrentCombine("");
2537
2538 }
2539 |
2540 PostIncrementExpression
2541 {
2542   jpElementStart(1);
2543   jpCheckEmpty(1);
2544   $<str>$ = 0;
2545   yyGetParser->SetCurrentCombine("");
2546
2547 }
2548 |
2549 PostDecrementExpression
2550 {
2551   jpElementStart(1);
2552   jpCheckEmpty(1);
2553   $<str>$ = 0;
2554   yyGetParser->SetCurrentCombine("");
2555
2556 }
2557
2558 PostIncrementExpression:
2559 PostfixExpression jp_PLUSPLUS
2560 {
2561   jpElementStart(2);
2562   jpCheckEmpty(2);
2563   $<str>$ = 0;
2564   yyGetParser->SetCurrentCombine("");
2565
2566 }
2567
2568 PostDecrementExpression:
2569 PostfixExpression jp_MINUSMINUS
2570 {
2571   jpElementStart(2);
2572   jpCheckEmpty(2);
2573   $<str>$ = 0;
2574   yyGetParser->SetCurrentCombine("");
2575
2576 }
2577
2578 UnaryExpression:
2579 PreIncrementExpression
2580 {
2581   jpElementStart(1);
2582   jpCheckEmpty(1);
2583   $<str>$ = 0;
2584   yyGetParser->SetCurrentCombine("");
2585
2586 }
2587 |
2588 PreDecrementExpression
2589 {
2590   jpElementStart(1);
2591   jpCheckEmpty(1);
2592   $<str>$ = 0;
2593   yyGetParser->SetCurrentCombine("");
2594
2595 }
2596 |
2597 jp_PLUS UnaryExpression
2598 {
2599   jpElementStart(2);
2600   jpCheckEmpty(2);
2601   $<str>$ = 0;
2602   yyGetParser->SetCurrentCombine("");
2603
2604 }
2605 |
2606 jp_MINUS UnaryExpression
2607 {
2608   jpElementStart(2);
2609   jpCheckEmpty(2);
2610   $<str>$ = 0;
2611   yyGetParser->SetCurrentCombine("");
2612
2613 }
2614 |
2615 UnaryExpressionNotPlusMinus
2616 {
2617   jpElementStart(1);
2618   jpCheckEmpty(1);
2619   $<str>$ = 0;
2620   yyGetParser->SetCurrentCombine("");
2621
2622 }
2623
2624 PreIncrementExpression:
2625 jp_PLUSPLUS UnaryExpression
2626 {
2627   jpElementStart(2);
2628   jpCheckEmpty(2);
2629   $<str>$ = 0;
2630   yyGetParser->SetCurrentCombine("");
2631
2632 }
2633
2634 PreDecrementExpression:
2635 jp_MINUSMINUS UnaryExpression
2636 {
2637   jpElementStart(2);
2638   jpCheckEmpty(2);
2639   $<str>$ = 0;
2640   yyGetParser->SetCurrentCombine("");
2641
2642 }
2643
2644 UnaryExpressionNotPlusMinus:
2645 PostfixExpression
2646 {
2647   jpElementStart(1);
2648   jpCheckEmpty(1);
2649   $<str>$ = 0;
2650   yyGetParser->SetCurrentCombine("");
2651
2652 }
2653 |
2654 jp_TILDE UnaryExpression
2655 {
2656   jpElementStart(2);
2657   jpCheckEmpty(2);
2658   $<str>$ = 0;
2659   yyGetParser->SetCurrentCombine("");
2660
2661 }
2662 |
2663 jp_EXCLAMATION UnaryExpression
2664 {
2665   jpElementStart(2);
2666   jpCheckEmpty(2);
2667   $<str>$ = 0;
2668   yyGetParser->SetCurrentCombine("");
2669
2670 }
2671 |
2672 CastExpression
2673 {
2674   jpElementStart(1);
2675   jpCheckEmpty(1);
2676   $<str>$ = 0;
2677   yyGetParser->SetCurrentCombine("");
2678
2679 }
2680
2681 CastExpression:
2682 jp_PARESTART PrimitiveType Dimsopt jp_PAREEND UnaryExpression
2683 {
2684   jpElementStart(5);
2685   jpCheckEmpty(5);
2686   $<str>$ = 0;
2687   yyGetParser->SetCurrentCombine("");
2688
2689 }
2690 |
2691 jp_PARESTART Expression jp_PAREEND UnaryExpressionNotPlusMinus
2692 {
2693   jpElementStart(4);
2694   jpCheckEmpty(4);
2695   $<str>$ = 0;
2696   yyGetParser->SetCurrentCombine("");
2697
2698 }
2699 |
2700 jp_PARESTART Name Dims jp_PAREEND UnaryExpressionNotPlusMinus
2701 {
2702   jpElementStart(5);
2703
2704 }
2705
2706 MultiplicativeExpression:
2707 UnaryExpression
2708 {
2709   jpElementStart(1);
2710   jpCheckEmpty(1);
2711   $<str>$ = 0;
2712   yyGetParser->SetCurrentCombine("");
2713
2714 }
2715 |
2716 MultiplicativeExpression jp_TIMES UnaryExpression
2717 {
2718   jpElementStart(3);
2719   jpCheckEmpty(3);
2720   $<str>$ = 0;
2721   yyGetParser->SetCurrentCombine("");
2722
2723 }
2724 |
2725 MultiplicativeExpression jp_DIVIDE UnaryExpression
2726 {
2727   jpElementStart(3);
2728   jpCheckEmpty(3);
2729   $<str>$ = 0;
2730   yyGetParser->SetCurrentCombine("");
2731
2732 }
2733 |
2734 MultiplicativeExpression jp_PERCENT UnaryExpression
2735 {
2736   jpElementStart(3);
2737   jpCheckEmpty(3);
2738   $<str>$ = 0;
2739   yyGetParser->SetCurrentCombine("");
2740
2741 }
2742
2743 AdditiveExpression:
2744 MultiplicativeExpression
2745 {
2746   jpElementStart(1);
2747   jpCheckEmpty(1);
2748   $<str>$ = 0;
2749   yyGetParser->SetCurrentCombine("");
2750
2751 }
2752 |
2753 AdditiveExpression jp_PLUS MultiplicativeExpression
2754 {
2755   jpElementStart(3);
2756   jpCheckEmpty(3);
2757   $<str>$ = 0;
2758   yyGetParser->SetCurrentCombine("");
2759
2760 }
2761 |
2762 AdditiveExpression jp_MINUS MultiplicativeExpression
2763 {
2764   jpElementStart(3);
2765   jpCheckEmpty(3);
2766   $<str>$ = 0;
2767   yyGetParser->SetCurrentCombine("");
2768
2769 }
2770
2771 ShiftExpression:
2772 AdditiveExpression
2773 {
2774   jpElementStart(1);
2775   jpCheckEmpty(1);
2776   $<str>$ = 0;
2777   yyGetParser->SetCurrentCombine("");
2778
2779 }
2780 |
2781 ShiftExpression jp_LTLT AdditiveExpression
2782 {
2783   jpElementStart(3);
2784   jpCheckEmpty(3);
2785   $<str>$ = 0;
2786   yyGetParser->SetCurrentCombine("");
2787
2788 }
2789 |
2790 ShiftExpression jp_GTGT AdditiveExpression
2791 {
2792   jpElementStart(3);
2793   jpCheckEmpty(3);
2794   $<str>$ = 0;
2795   yyGetParser->SetCurrentCombine("");
2796
2797 }
2798 |
2799 ShiftExpression jp_GTGTGT AdditiveExpression
2800 {
2801   jpElementStart(3);
2802   jpCheckEmpty(3);
2803   $<str>$ = 0;
2804   yyGetParser->SetCurrentCombine("");
2805
2806 }
2807
2808 RelationalExpression:
2809 ShiftExpression
2810 {
2811   jpElementStart(1);
2812   jpCheckEmpty(1);
2813   $<str>$ = 0;
2814   yyGetParser->SetCurrentCombine("");
2815
2816 }
2817 |
2818 RelationalExpression jp_LESSTHAN ShiftExpression
2819 {
2820   jpElementStart(3);
2821   jpCheckEmpty(3);
2822   $<str>$ = 0;
2823   yyGetParser->SetCurrentCombine("");
2824
2825 }
2826 |
2827 RelationalExpression jp_GREATER ShiftExpression
2828 {
2829   jpElementStart(3);
2830   jpCheckEmpty(3);
2831   $<str>$ = 0;
2832   yyGetParser->SetCurrentCombine("");
2833
2834 }
2835 |
2836 RelationalExpression jp_LTEQUALS ShiftExpression
2837 {
2838   jpElementStart(3);
2839   jpCheckEmpty(3);
2840   $<str>$ = 0;
2841   yyGetParser->SetCurrentCombine("");
2842
2843 }
2844 |
2845 RelationalExpression jp_GTEQUALS ShiftExpression
2846 {
2847   jpElementStart(3);
2848   jpCheckEmpty(3);
2849   $<str>$ = 0;
2850   yyGetParser->SetCurrentCombine("");
2851
2852 }
2853 |
2854 RelationalExpression jp_INSTANCEOF ReferenceType
2855 {
2856   jpElementStart(3);
2857   jpCheckEmpty(3);
2858   $<str>$ = 0;
2859   yyGetParser->SetCurrentCombine("");
2860
2861 }
2862
2863 EqualityExpression:
2864 RelationalExpression
2865 {
2866   jpElementStart(1);
2867   jpCheckEmpty(1);
2868   $<str>$ = 0;
2869   yyGetParser->SetCurrentCombine("");
2870
2871 }
2872 |
2873 EqualityExpression jp_EQUALSEQUALS RelationalExpression
2874 {
2875   jpElementStart(3);
2876   jpCheckEmpty(3);
2877   $<str>$ = 0;
2878   yyGetParser->SetCurrentCombine("");
2879
2880 }
2881 |
2882 EqualityExpression jp_EXCLAMATIONEQUALS RelationalExpression
2883 {
2884   jpElementStart(3);
2885   jpCheckEmpty(3);
2886   $<str>$ = 0;
2887   yyGetParser->SetCurrentCombine("");
2888
2889 }
2890
2891 AndExpression:
2892 EqualityExpression
2893 {
2894   jpElementStart(1);
2895   jpCheckEmpty(1);
2896   $<str>$ = 0;
2897   yyGetParser->SetCurrentCombine("");
2898
2899 }
2900 |
2901 AndExpression jp_AND EqualityExpression
2902 {
2903   jpElementStart(3);
2904   jpCheckEmpty(3);
2905   $<str>$ = 0;
2906   yyGetParser->SetCurrentCombine("");
2907
2908 }
2909
2910 ExclusiveOrExpression:
2911 AndExpression
2912 {
2913   jpElementStart(1);
2914   jpCheckEmpty(1);
2915   $<str>$ = 0;
2916   yyGetParser->SetCurrentCombine("");
2917
2918 }
2919 |
2920 ExclusiveOrExpression jp_CARROT AndExpression
2921 {
2922   jpElementStart(3);
2923   jpCheckEmpty(3);
2924   $<str>$ = 0;
2925   yyGetParser->SetCurrentCombine("");
2926
2927 }
2928
2929 InclusiveOrExpression:
2930 ExclusiveOrExpression
2931 {
2932   jpElementStart(1);
2933   jpCheckEmpty(1);
2934   $<str>$ = 0;
2935   yyGetParser->SetCurrentCombine("");
2936
2937 }
2938 |
2939 InclusiveOrExpression jp_PIPE ExclusiveOrExpression
2940 {
2941   jpElementStart(3);
2942   jpCheckEmpty(3);
2943   $<str>$ = 0;
2944   yyGetParser->SetCurrentCombine("");
2945
2946 }
2947
2948 ConditionalAndExpression:
2949 InclusiveOrExpression
2950 {
2951   jpElementStart(1);
2952   jpCheckEmpty(1);
2953   $<str>$ = 0;
2954   yyGetParser->SetCurrentCombine("");
2955
2956 }
2957 |
2958 ConditionalAndExpression jp_ANDAND InclusiveOrExpression
2959 {
2960   jpElementStart(3);
2961   jpCheckEmpty(3);
2962   $<str>$ = 0;
2963   yyGetParser->SetCurrentCombine("");
2964
2965 }
2966
2967 ConditionalOrExpression:
2968 ConditionalAndExpression
2969 {
2970   jpElementStart(1);
2971   jpCheckEmpty(1);
2972   $<str>$ = 0;
2973   yyGetParser->SetCurrentCombine("");
2974
2975 }
2976 |
2977 ConditionalOrExpression jp_PIPEPIPE ConditionalAndExpression
2978 {
2979   jpElementStart(3);
2980   jpCheckEmpty(3);
2981   $<str>$ = 0;
2982   yyGetParser->SetCurrentCombine("");
2983
2984 }
2985
2986 ConditionalExpression:
2987 ConditionalOrExpression
2988 {
2989   jpElementStart(1);
2990   jpCheckEmpty(1);
2991   $<str>$ = 0;
2992   yyGetParser->SetCurrentCombine("");
2993
2994 }
2995 |
2996 ConditionalOrExpression jp_QUESTION Expression jp_COLON ConditionalExpression
2997 {
2998   jpElementStart(5);
2999   jpCheckEmpty(5);
3000   $<str>$ = 0;
3001   yyGetParser->SetCurrentCombine("");
3002
3003 }
3004
3005 AssignmentExpression:
3006 ConditionalExpression
3007 {
3008   jpElementStart(1);
3009   jpCheckEmpty(1);
3010   $<str>$ = 0;
3011   yyGetParser->SetCurrentCombine("");
3012
3013 }
3014 |
3015 Assignment
3016 {
3017   jpElementStart(1);
3018   jpCheckEmpty(1);
3019   $<str>$ = 0;
3020   yyGetParser->SetCurrentCombine("");
3021
3022 }
3023
3024 Assignment:
3025 LeftHandSide AssignmentOperator AssignmentExpression
3026 {
3027   jpElementStart(3);
3028   jpCheckEmpty(3);
3029   $<str>$ = 0;
3030   yyGetParser->SetCurrentCombine("");
3031
3032 }
3033
3034 LeftHandSide:
3035 Name
3036 {
3037   jpElementStart(1);
3038   yyGetParser->DeallocateParserType(&($<str>1));
3039   jpCheckEmpty(1);
3040   $<str>$ = 0;
3041   yyGetParser->SetCurrentCombine("");
3042
3043 }
3044 |
3045 FieldAccess
3046 {
3047   jpElementStart(1);
3048   jpCheckEmpty(1);
3049   $<str>$ = 0;
3050   yyGetParser->SetCurrentCombine("");
3051
3052 }
3053 |
3054 ArrayAccess
3055 {
3056   jpElementStart(1);
3057   jpCheckEmpty(1);
3058   $<str>$ = 0;
3059   yyGetParser->SetCurrentCombine("");
3060
3061 }
3062
3063 AssignmentOperator:
3064 jp_EQUALS
3065 {
3066   jpElementStart(1);
3067   jpCheckEmpty(1);
3068   $<str>$ = 0;
3069   yyGetParser->SetCurrentCombine("");
3070
3071 }
3072 |
3073 jp_TIMESEQUALS
3074 {
3075   jpElementStart(1);
3076   jpCheckEmpty(1);
3077   $<str>$ = 0;
3078   yyGetParser->SetCurrentCombine("");
3079
3080 }
3081 |
3082 jp_DIVIDEEQUALS
3083 {
3084   jpElementStart(1);
3085   jpCheckEmpty(1);
3086   $<str>$ = 0;
3087   yyGetParser->SetCurrentCombine("");
3088
3089 }
3090 |
3091 jp_PERCENTEQUALS
3092 {
3093   jpElementStart(1);
3094   jpCheckEmpty(1);
3095   $<str>$ = 0;
3096   yyGetParser->SetCurrentCombine("");
3097
3098 }
3099 |
3100 jp_PLUSEQUALS
3101 {
3102   jpElementStart(1);
3103   jpCheckEmpty(1);
3104   $<str>$ = 0;
3105   yyGetParser->SetCurrentCombine("");
3106
3107 }
3108 |
3109 jp_MINUSEQUALS
3110 {
3111   jpElementStart(1);
3112   jpCheckEmpty(1);
3113   $<str>$ = 0;
3114   yyGetParser->SetCurrentCombine("");
3115
3116 }
3117 |
3118 jp_LESLESEQUALS
3119 {
3120   jpElementStart(1);
3121   jpCheckEmpty(1);
3122   $<str>$ = 0;
3123   yyGetParser->SetCurrentCombine("");
3124
3125 }
3126 |
3127 jp_GTGTEQUALS
3128 {
3129   jpElementStart(1);
3130   jpCheckEmpty(1);
3131   $<str>$ = 0;
3132   yyGetParser->SetCurrentCombine("");
3133
3134 }
3135 |
3136 jp_GTGTGTEQUALS
3137 {
3138   jpElementStart(1);
3139   jpCheckEmpty(1);
3140   $<str>$ = 0;
3141   yyGetParser->SetCurrentCombine("");
3142
3143 }
3144 |
3145 jp_ANDEQUALS
3146 {
3147   jpElementStart(1);
3148   jpCheckEmpty(1);
3149   $<str>$ = 0;
3150   yyGetParser->SetCurrentCombine("");
3151
3152 }
3153 |
3154 jp_CARROTEQUALS
3155 {
3156   jpElementStart(1);
3157   jpCheckEmpty(1);
3158   $<str>$ = 0;
3159   yyGetParser->SetCurrentCombine("");
3160
3161 }
3162 |
3163 jp_PIPEEQUALS
3164 {
3165   jpElementStart(1);
3166   jpCheckEmpty(1);
3167   $<str>$ = 0;
3168   yyGetParser->SetCurrentCombine("");
3169
3170 }
3171
3172 Expression:
3173 AssignmentExpression
3174 {
3175   jpElementStart(1);
3176   jpCheckEmpty(1);
3177   $<str>$ = 0;
3178   yyGetParser->SetCurrentCombine("");
3179
3180 }
3181
3182 ConstantExpression:
3183 Expression
3184 {
3185   jpElementStart(1);
3186   jpCheckEmpty(1);
3187   $<str>$ = 0;
3188   yyGetParser->SetCurrentCombine("");
3189
3190 }
3191
3192 New:
3193 jp_NEW
3194 {
3195   jpElementStart(1);
3196   jpCheckEmpty(1);
3197   $<str>$ = 0;
3198   yyGetParser->SetCurrentCombine("");
3199
3200 }
3201 |
3202 Name jp_DOT jp_NEW
3203 {
3204   jpElementStart(3);
3205   jpStoreClass($<str>1);
3206   jpCheckEmpty(3);
3207   $<str>$ = 0;
3208   yyGetParser->SetCurrentCombine("");
3209
3210 }
3211
3212 %%
3213 /* End of grammar */
3214
3215 /*--------------------------------------------------------------------------*/
3216 void cmDependsJava_yyerror(yyscan_t yyscanner, const char* message)
3217 {
3218   yyGetParser->Error(message);
3219 }