Source/cmDependsJavaParser.y

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