gcc/java/parse.y

   1 /* Source code parsing and tree node generation for the GNU compiler
   2    for the Java(TM) language.
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   4    Free Software Foundation, Inc.
   5    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.
  23
  24 Java and all Java-based marks are trademarks or registered trademarks
  25 of Sun Microsystems, Inc. in the United States and other countries.
  26 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  27
  28 /* This file parses java source code and issues a tree node image
  29 suitable for code generation (byte code and targeted CPU assembly
  30 language).
  31
  32 The grammar conforms to the Java grammar described in "The Java(TM)
  33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  34 1996, ISBN 0-201-63451-1"
  35
  36 The following modifications were brought to the original grammar:
  37
  38 method_body: added the rule '| block SC_TK'
  39 static_initializer: added the rule 'static block SC_TK'.
  40
  41 Note: All the extra rules described above should go away when the
  42       empty_statement rule will work.
  43
  44 statement_nsi: 'nsi' should be read no_short_if.
  45
  46 Some rules have been modified to support JDK1.1 inner classes
  47 definitions and other extensions.  */
  48
  49 %{
  50 #include "config.h"
  51 #include "system.h"
  52 #include "coretypes.h"
  53 #include "tm.h"
  54 #include <dirent.h>
  55 #include "tree.h"
  56 #include "rtl.h"
  57 #include "real.h"
  58 #include "obstack.h"
  59 #include "toplev.h"
  60 #include "flags.h"
  61 #include "java-tree.h"
  62 #include "jcf.h"
  63 #include "lex.h"
  64 #include "parse.h"
  65 #include "zipfile.h"
  66 #include "convert.h"
  67 #include "buffer.h"
  68 #include "xref.h"
  69 #include "function.h"
  70 #include "except.h"
  71 #include "ggc.h"
  72 #include "debug.h"
  73 #include "tree-inline.h"
  74 #include "cgraph.h"
  75 #include "target.h"
  76
  77 /* Local function prototypes */
  78 static char *java_accstring_lookup (int);
  79 static const char *accessibility_string (int);
  80 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  81 static void  variable_redefinition_error (tree, tree, tree, int);
  82 static tree  create_class (int, tree, tree, tree);
  83 static tree  create_interface (int, tree, tree);
  84 static void  end_class_declaration (int);
  85 static tree  find_field (tree, tree);
  86 static tree lookup_field_wrapper (tree, tree);
  87 static int   duplicate_declaration_error_p (tree, tree, tree);
  88 static void  register_fields (int, tree, tree);
  89 static tree parser_qualified_classname (tree);
  90 static int  parser_check_super (tree, tree, tree);
  91 static int  parser_check_super_interface (tree, tree, tree);
  92 static void check_modifiers_consistency (int);
  93 static tree lookup_cl (tree);
  94 static tree lookup_java_method2 (tree, tree, int);
  95 static tree method_header (int, tree, tree, tree);
  96 static void fix_method_argument_names (tree ,tree);
  97 static tree method_declarator (tree, tree);
  98 static void parse_warning_context (tree cl, const char *msg, ...)
  99   ATTRIBUTE_PRINTF_2;
 100 static void issue_warning_error_from_context (tree, const char *msg, va_list)
 101   ATTRIBUTE_PRINTF (2, 0);
 102 static void parse_ctor_invocation_error (void);
 103 static tree parse_jdk1_1_error (const char *);
 104 static void complete_class_report_errors (jdep *);
 105 static int process_imports (void);
 106 static void read_import_dir (tree);
 107 static int find_in_imports_on_demand (tree, tree);
 108 static void find_in_imports (tree, tree);
 109 static void check_inner_class_access (tree, tree, tree);
 110 static int check_pkg_class_access (tree, tree, bool, tree);
 111 static void register_package (tree);
 112 static tree resolve_package (tree, tree *, tree *);
 113 static tree resolve_class (tree, tree, tree, tree);
 114 static void declare_local_variables (int, tree, tree);
 115 static void dump_java_tree (enum tree_dump_index, tree);
 116 static void source_start_java_method (tree);
 117 static void source_end_java_method (void);
 118 static tree find_name_in_single_imports (tree);
 119 static void check_abstract_method_header (tree);
 120 static tree lookup_java_interface_method2 (tree, tree);
 121 static tree resolve_expression_name (tree, tree *);
 122 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 123 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 124 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 125 static tree resolve_and_layout (tree, tree);
 126 static tree qualify_and_find (tree, tree, tree);
 127 static tree resolve_no_layout (tree, tree);
 128 static int invocation_mode (tree, int);
 129 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 130 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 131 static tree find_most_specific_methods_list (tree);
 132 static int argument_types_convertible (tree, tree);
 133 static tree patch_invoke (tree, tree, tree);
 134 static int maybe_use_access_method (int, tree *, tree *);
 135 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 136 static tree register_incomplete_type (int, tree, tree, tree);
 137 static tree check_inner_circular_reference (tree, tree);
 138 static tree check_circular_reference (tree);
 139 static tree obtain_incomplete_type (tree);
 140 static tree java_complete_lhs (tree);
 141 static tree java_complete_tree (tree);
 142 static tree maybe_generate_pre_expand_clinit (tree);
 143 static int analyze_clinit_body (tree, tree);
 144 static int maybe_yank_clinit (tree);
 145 static void start_complete_expand_method (tree);
 146 static void java_complete_expand_method (tree);
 147 static void java_expand_method_bodies (tree);
 148 static int  unresolved_type_p (tree, tree *);
 149 static void create_jdep_list (struct parser_ctxt *);
 150 static tree build_expr_block (tree, tree);
 151 static tree enter_block (void);
 152 static tree exit_block (void);
 153 static tree lookup_name_in_blocks (tree);
 154 static void maybe_absorb_scoping_blocks (void);
 155 static tree build_method_invocation (tree, tree);
 156 static tree build_new_invocation (tree, tree);
 157 static tree build_assignment (int, int, tree, tree);
 158 static tree build_binop (enum tree_code, int, tree, tree);
 159 static tree patch_assignment (tree, tree);
 160 static tree patch_binop (tree, tree, tree);
 161 static tree build_unaryop (int, int, tree);
 162 static tree build_incdec (int, int, tree, int);
 163 static tree patch_unaryop (tree, tree);
 164 static tree build_cast (int, tree, tree);
 165 static tree build_null_of_type (tree);
 166 static tree patch_cast (tree, tree);
 167 static int valid_ref_assignconv_cast_p (tree, tree, int);
 168 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 169 static int valid_cast_to_p (tree, tree);
 170 static int valid_method_invocation_conversion_p (tree, tree);
 171 static tree try_builtin_assignconv (tree, tree, tree);
 172 static tree try_reference_assignconv (tree, tree);
 173 static tree build_unresolved_array_type (tree);
 174 static int build_type_name_from_array_name (tree, tree *);
 175 static tree build_array_from_name (tree, tree, tree, tree *);
 176 static tree build_array_ref (int, tree, tree);
 177 static tree patch_array_ref (tree);
 178 static tree make_qualified_name (tree, tree, int);
 179 static tree merge_qualified_name (tree, tree);
 180 static tree make_qualified_primary (tree, tree, int);
 181 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 182 static void qualify_ambiguous_name (tree);
 183 static tree resolve_field_access (tree, tree *, tree *);
 184 static tree build_newarray_node (tree, tree, int);
 185 static tree patch_newarray (tree);
 186 static tree resolve_type_during_patch (tree);
 187 static tree build_this (int);
 188 static tree build_wfl_wrap (tree, int);
 189 static tree build_return (int, tree);
 190 static tree patch_return (tree);
 191 static tree maybe_access_field (tree, tree, tree);
 192 static int complete_function_arguments (tree);
 193 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 194 static int not_accessible_p (tree, tree, tree, int);
 195 static void check_deprecation (tree, tree);
 196 static int class_in_current_package (tree);
 197 static tree build_if_else_statement (int, tree, tree, tree);
 198 static tree patch_if_else_statement (tree);
 199 static tree add_stmt_to_block (tree, tree, tree);
 200 static tree patch_exit_expr (tree);
 201 static tree build_labeled_block (int, tree);
 202 static tree finish_labeled_statement (tree, tree);
 203 static tree build_bc_statement (int, int, tree);
 204 static tree patch_bc_statement (tree);
 205 static tree patch_loop_statement (tree);
 206 static tree build_new_loop (tree);
 207 static tree build_loop_body (int, tree, int);
 208 static tree finish_loop_body (int, tree, tree, int);
 209 static tree build_debugable_stmt (int, tree);
 210 static tree finish_for_loop (int, tree, tree, tree);
 211 static tree patch_switch_statement (tree);
 212 static tree string_constant_concatenation (tree, tree);
 213 static tree build_string_concatenation (tree, tree);
 214 static tree patch_string_cst (tree);
 215 static tree patch_string (tree);
 216 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 217 static tree build_assertion (int, tree, tree);
 218 static tree build_try_statement (int, tree, tree);
 219 static tree build_try_finally_statement (int, tree, tree);
 220 static tree patch_try_statement (tree);
 221 static tree patch_synchronized_statement (tree, tree);
 222 static tree patch_throw_statement (tree, tree);
 223 static void check_thrown_exceptions (int, tree, tree);
 224 static int check_thrown_exceptions_do (tree);
 225 static void purge_unchecked_exceptions (tree);
 226 static bool ctors_unchecked_throws_clause_p (tree);
 227 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 228 static void check_throws_clauses (tree, tree, tree);
 229 static void finish_method_declaration (tree);
 230 static tree build_super_invocation (tree);
 231 static int verify_constructor_circularity (tree, tree);
 232 static char *constructor_circularity_msg (tree, tree);
 233 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 234 static const char *get_printable_method_name (tree);
 235 static tree patch_conditional_expr (tree, tree, tree);
 236 static tree generate_finit (tree);
 237 static tree generate_instinit (tree);
 238 static tree build_instinit_invocation (tree);
 239 static void fix_constructors (tree);
 240 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 241 static tree craft_constructor (tree, tree);
 242 static int verify_constructor_super (tree);
 243 static tree create_artificial_method (tree, int, tree, tree, tree);
 244 static void start_artificial_method_body (tree);
 245 static void end_artificial_method_body (tree);
 246 static int check_method_redefinition (tree, tree);
 247 static int check_method_types_complete (tree);
 248 static bool hack_is_accessible_p (tree, tree);
 249 static void java_check_regular_methods (tree);
 250 static void check_interface_throws_clauses (tree, tree);
 251 static void java_check_abstract_methods (tree);
 252 static void unreachable_stmt_error (tree);
 253 static int not_accessible_field_error (tree, tree);
 254 static tree find_expr_with_wfl (tree);
 255 static void missing_return_error (tree);
 256 static tree build_new_array_init (int, tree);
 257 static tree patch_new_array_init (tree, tree);
 258 static tree maybe_build_array_element_wfl (tree);
 259 static int array_constructor_check_entry (tree, tree);
 260 static const char *purify_type_name (const char *);
 261 static tree fold_constant_for_init (tree, tree);
 262 static tree strip_out_static_field_access_decl (tree);
 263 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 264 static void static_ref_err (tree, tree, tree);
 265 static void parser_add_interface (tree, tree, tree);
 266 static void add_superinterfaces (tree, tree);
 267 static tree jdep_resolve_class (jdep *);
 268 static int note_possible_classname (const char *, int);
 269 static void java_complete_expand_classes (void);
 270 static void java_complete_expand_class (tree);
 271 static void java_complete_expand_methods (tree);
 272 static tree cut_identifier_in_qualified (tree);
 273 static tree java_stabilize_reference (tree);
 274 static tree do_unary_numeric_promotion (tree);
 275 static char * operator_string (tree);
 276 static tree do_merge_string_cste (tree, const char *, int, int);
 277 static tree merge_string_cste (tree, tree, int);
 278 static tree java_refold (tree);
 279 static int java_decl_equiv (tree, tree);
 280 static int binop_compound_p (enum tree_code);
 281 static tree search_loop (tree);
 282 static int labeled_block_contains_loop_p (tree, tree);
 283 static int check_abstract_method_definitions (int, tree, tree);
 284 static void java_check_abstract_method_definitions (tree);
 285 static void java_debug_context_do (int);
 286 static void java_parser_context_push_initialized_field (void);
 287 static void java_parser_context_pop_initialized_field (void);
 288 static tree reorder_static_initialized (tree);
 289 static void java_parser_context_suspend (void);
 290 static void java_parser_context_resume (void);
 291 static int pop_current_osb (struct parser_ctxt *);
 292
 293 /* JDK 1.1 work. FIXME */
 294
 295 static tree maybe_make_nested_class_name (tree);
 296 static int make_nested_class_name (tree);
 297 static void link_nested_class_to_enclosing (void);
 298 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 299 static tree find_as_inner_class (tree, tree, tree);
 300 static tree find_as_inner_class_do (tree, tree);
 301 static int check_inner_class_redefinition (tree, tree);
 302
 303 static tree build_thisn_assign (void);
 304 static tree build_current_thisn (tree);
 305 static tree build_access_to_thisn (tree, tree, int);
 306 static tree maybe_build_thisn_access_method (tree);
 307
 308 static tree build_outer_field_access (tree, tree);
 309 static tree build_outer_field_access_methods (tree);
 310 static tree build_outer_field_access_expr (int, tree, tree,
 311                                                   tree, tree);
 312 static tree build_outer_method_access_method (tree);
 313 static tree build_new_access_id (void);
 314 static tree build_outer_field_access_method (tree, tree, tree,
 315                                                     tree, tree);
 316
 317 static int outer_field_access_p (tree, tree);
 318 static int outer_field_expanded_access_p (tree, tree *,
 319                                                  tree *, tree *);
 320 static tree outer_field_access_fix (tree, tree, tree);
 321 static tree build_incomplete_class_ref (int, tree);
 322 static tree patch_incomplete_class_ref (tree);
 323 static tree create_anonymous_class (tree);
 324 static void patch_anonymous_class (tree, tree, tree);
 325 static void add_inner_class_fields (tree, tree);
 326
 327 static tree build_dot_class_method (tree);
 328 static tree build_dot_class_method_invocation (tree, tree);
 329 static void create_new_parser_context (int);
 330 static tree maybe_build_class_init_for_field (tree, tree);
 331
 332 static int attach_init_test_initialization_flags (void **, void *);
 333 static int emit_test_initialization (void **, void *);
 334
 335 static char *string_convert_int_cst (tree);
 336
 337 /* Number of error found so far. */
 338 int java_error_count;
 339 /* Number of warning found so far. */
 340 int java_warning_count;
 341 /* Tell when not to fold, when doing xrefs */
 342 int do_not_fold;
 343 /* Cyclic inheritance report, as it can be set by layout_class */
 344 const char *cyclic_inheritance_report;
 345
 346 /* The current parser context */
 347 struct parser_ctxt *ctxp;
 348
 349 /* List of things that were analyzed for which code will be generated */
 350 struct parser_ctxt *ctxp_for_generation = NULL;
 351
 352 /* binop_lookup maps token to tree_code. It is used where binary
 353    operations are involved and required by the parser. RDIV_EXPR
 354    covers both integral/floating point division. The code is changed
 355    once the type of both operator is worked out.  */
 356
 357 static const enum tree_code binop_lookup[19] =
 358   {
 359     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 360     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 361     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 362     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 363     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 364    };
 365 #define BINOP_LOOKUP(VALUE)                                             \
 366   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 367
 368 /* This is the end index for binary operators that can also be used
 369    in compound assignments. */
 370 #define BINOP_COMPOUND_CANDIDATES 11
 371
 372 /* The "$L" identifier we use to create labels.  */
 373 static GTY(()) tree label_id;
 374
 375 /* The "StringBuffer" identifier used for the String `+' operator. */
 376 static GTY(()) tree wfl_string_buffer;
 377
 378 /* The "append" identifier used for String `+' operator.  */
 379 static GTY(()) tree wfl_append;
 380
 381 /* The "toString" identifier used for String `+' operator. */
 382 static GTY(()) tree wfl_to_string;
 383
 384 /* The "java.lang" import qualified name.  */
 385 static GTY(()) tree java_lang_id;
 386
 387 /* The generated `inst$' identifier used for generated enclosing
 388    instance/field access functions.  */
 389 static GTY(()) tree inst_id;
 390
 391 /* Context and flag for static blocks */
 392 static GTY(()) tree current_static_block;
 393
 394 /* The generated `write_parm_value$' identifier.  */
 395 static GTY(()) tree wpv_id;
 396
 397 /* The list of all packages we've seen so far */
 398 static GTY(()) tree package_list;
 399
 400 /* Hold THIS for the scope of the current method decl.  */
 401 static GTY(()) tree current_this;
 402
 403 /* Hold a list of catch clauses list. The first element of this list is
 404    the list of the catch clauses of the currently analyzed try block. */
 405 static GTY(()) tree currently_caught_type_list;
 406
 407 /* This holds a linked list of all the case labels for the current
 408    switch statement.  It is only used when checking to see if there
 409    are duplicate labels.  FIXME: probably this should just be attached
 410    to the switch itself; then it could be referenced via
 411    `ctxp->current_loop'.  */
 412 static GTY(()) tree case_label_list;
 413
 414 /* Anonymous class counter. Will be reset to 1 every time a non
 415    anonymous class gets created. */
 416 static int anonymous_class_counter = 1;
 417
 418 static GTY(()) tree src_parse_roots[1];
 419
 420 /* All classes seen from source code */
 421 #define gclass_list src_parse_roots[0]
 422
 423 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 424    line and point it out.  */
 425 /* Should point out the one that don't fit. ASCII/unicode, going
 426    backward. FIXME */
 427
 428 #define check_modifiers(__message, __value, __mask) do {        \
 429   if ((__value) & ~(__mask))                                    \
 430     {                                                           \
 431       size_t i, remainder = (__value) & ~(__mask);              \
 432       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 433         if ((1 << i) & remainder)                               \
 434           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 435                                java_accstring_lookup (1 << i)); \
 436     }                                                           \
 437 } while (0)
 438
 439 %}
 440
 441 %union {
 442   tree node;
 443   int sub_token;
 444   struct {
 445     int token;
 446     int location;
 447   } operator;
 448   int value;
 449 }
 450
 451 %{
 452 #include "lex.c"
 453 %}
 454
 455 %pure_parser
 456
 457 /* Things defined here have to match the order of what's in the
 458    binop_lookup table.  */
 459
 460 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 461 %token   LS_TK           SRS_TK          ZRS_TK
 462 %token   AND_TK          XOR_TK          OR_TK
 463 %token   BOOL_AND_TK BOOL_OR_TK
 464 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 465
 466 /* This maps to the same binop_lookup entry than the token above */
 467
 468 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 469 %token   REM_ASSIGN_TK
 470 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 471 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 472
 473
 474 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 475
 476 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 477 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 478 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 479 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 480 %token   MODIFIER_TK
 481
 482 /* Keep those two in order, too */
 483 %token   DECR_TK INCR_TK
 484
 485 /* From now one, things can be in any order */
 486
 487 %token   DEFAULT_TK      IF_TK              THROW_TK
 488 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 489 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 490 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 491 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 492 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 493 %token   SUPER_TK        WHILE_TK           CLASS_TK
 494 %token   SWITCH_TK       CONST_TK           TRY_TK
 495 %token   FOR_TK          NEW_TK             CONTINUE_TK
 496 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 497 %token   ASSERT_TK
 498
 499 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 500 %token   CHAR_TK         INTEGRAL_TK
 501
 502 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 503
 504 %token   ID_TK
 505
 506 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 507
 508 %token   ASSIGN_ANY_TK   ASSIGN_TK
 509 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 510
 511 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 512 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 513
 514 %type    <value>        modifiers MODIFIER_TK final synchronized
 515
 516 %type    <node>         super ID_TK identifier
 517 %type    <node>         name simple_name qualified_name
 518 %type    <node>         type_declaration compilation_unit
 519                         field_declaration method_declaration extends_interfaces
 520                         interfaces interface_type_list
 521                         import_declarations package_declaration
 522                         type_declarations interface_body
 523                         interface_member_declaration constant_declaration
 524                         interface_member_declarations interface_type
 525                         abstract_method_declaration
 526 %type    <node>         class_body_declaration class_member_declaration
 527                         static_initializer constructor_declaration block
 528 %type    <node>         class_body_declarations constructor_header
 529 %type    <node>         class_or_interface_type class_type class_type_list
 530                         constructor_declarator explicit_constructor_invocation
 531 %type    <node>         dim_expr dim_exprs this_or_super throws
 532
 533 %type    <node>         variable_declarator_id variable_declarator
 534                         variable_declarators variable_initializer
 535                         variable_initializers constructor_body
 536                         array_initializer
 537
 538 %type    <node>         class_body block_end constructor_block_end
 539 %type    <node>         statement statement_without_trailing_substatement
 540                         labeled_statement if_then_statement label_decl
 541                         if_then_else_statement while_statement for_statement
 542                         statement_nsi labeled_statement_nsi do_statement
 543                         if_then_else_statement_nsi while_statement_nsi
 544                         for_statement_nsi statement_expression_list for_init
 545                         for_update statement_expression expression_statement
 546                         primary_no_new_array expression primary
 547                         array_creation_expression array_type
 548                         class_instance_creation_expression field_access
 549                         method_invocation array_access something_dot_new
 550                         argument_list postfix_expression while_expression
 551                         post_increment_expression post_decrement_expression
 552                         unary_expression_not_plus_minus unary_expression
 553                         pre_increment_expression pre_decrement_expression
 554                         cast_expression
 555                         multiplicative_expression additive_expression
 556                         shift_expression relational_expression
 557                         equality_expression and_expression
 558                         exclusive_or_expression inclusive_or_expression
 559                         conditional_and_expression conditional_or_expression
 560                         conditional_expression assignment_expression
 561                         left_hand_side assignment for_header for_begin
 562                         constant_expression do_statement_begin empty_statement
 563                         switch_statement synchronized_statement throw_statement
 564                         try_statement assert_statement
 565                         switch_expression switch_block
 566                         catches catch_clause catch_clause_parameter finally
 567                         anonymous_class_creation trap_overflow_corner_case
 568 %type    <node>         return_statement break_statement continue_statement
 569
 570 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 571 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 572 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 573 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 574 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 575 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 576 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 577 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 578 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 579 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 580 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 581 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 582 %type    <operator>     NEW_TK ASSERT_TK
 583
 584 %type    <node>         method_body
 585
 586 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 587                         STRING_LIT_TK NULL_TK VOID_TK
 588
 589 %type    <node>         IF_TK WHILE_TK FOR_TK
 590
 591 %type    <node>         formal_parameter_list formal_parameter
 592                         method_declarator method_header
 593
 594 %type    <node>         primitive_type reference_type type
 595                         BOOLEAN_TK INTEGRAL_TK FP_TK
 596
 597 /* Added or modified JDK 1.1 rule types  */
 598 %type    <node>         type_literals
 599
 600 %%
 601 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 602 goal:  compilation_unit
 603                 {}
 604 ;
 605
 606 /* 19.3 Productions from 3: Lexical structure  */
 607 literal:
 608         INT_LIT_TK
 609 |       FP_LIT_TK
 610 |       BOOL_LIT_TK
 611 |       CHAR_LIT_TK
 612 |       STRING_LIT_TK
 613 |       NULL_TK
 614 ;
 615
 616 /* 19.4 Productions from 4: Types, Values and Variables  */
 617 type:
 618         primitive_type
 619 |       reference_type
 620 ;
 621
 622 primitive_type:
 623         INTEGRAL_TK
 624 |       FP_TK
 625 |       BOOLEAN_TK
 626 ;
 627
 628 reference_type:
 629         class_or_interface_type
 630 |       array_type
 631 ;
 632
 633 class_or_interface_type:
 634         name
 635 ;
 636
 637 class_type:
 638         class_or_interface_type /* Default rule */
 639 ;
 640
 641 interface_type:
 642          class_or_interface_type
 643 ;
 644
 645 array_type:
 646         primitive_type dims
 647                 {
 648                   int osb = pop_current_osb (ctxp);
 649                   tree t = build_java_array_type (($1), -1);
 650                   while (--osb)
 651                     t = build_unresolved_array_type (t);
 652                   $$ = t;
 653                 }
 654 |       name dims
 655                 {
 656                   int osb = pop_current_osb (ctxp);
 657                   tree t = $1;
 658                   while (osb--)
 659                     t = build_unresolved_array_type (t);
 660                   $$ = t;
 661                 }
 662 ;
 663
 664 /* 19.5 Productions from 6: Names  */
 665 name:
 666         simple_name             /* Default rule */
 667 |       qualified_name          /* Default rule */
 668 ;
 669
 670 simple_name:
 671         identifier              /* Default rule */
 672 ;
 673
 674 qualified_name:
 675         name DOT_TK identifier
 676                 { $$ = make_qualified_name ($1, $3, $2.location); }
 677 ;
 678
 679 identifier:
 680         ID_TK
 681 ;
 682
 683 /* 19.6: Production from 7: Packages  */
 684 compilation_unit:
 685                 {$$ = NULL;}
 686 |       package_declaration
 687 |       import_declarations
 688 |       type_declarations
 689 |       package_declaration import_declarations
 690 |       package_declaration type_declarations
 691 |       import_declarations type_declarations
 692 |       package_declaration import_declarations type_declarations
 693 ;
 694
 695 import_declarations:
 696         import_declaration
 697                 {
 698                   $$ = NULL;
 699                 }
 700 |       import_declarations import_declaration
 701                 {
 702                   $$ = NULL;
 703                 }
 704 ;
 705
 706 type_declarations:
 707         type_declaration
 708 |       type_declarations type_declaration
 709 ;
 710
 711 package_declaration:
 712         PACKAGE_TK name SC_TK
 713                 {
 714                   ctxp->package = EXPR_WFL_NODE ($2);
 715                   register_package (ctxp->package);
 716                 }
 717 |       PACKAGE_TK error
 718                 {yyerror ("Missing name"); RECOVER;}
 719 |       PACKAGE_TK name error
 720                 {yyerror ("';' expected"); RECOVER;}
 721 ;
 722
 723 import_declaration:
 724         single_type_import_declaration
 725 |       type_import_on_demand_declaration
 726 ;
 727
 728 single_type_import_declaration:
 729         IMPORT_TK name SC_TK
 730                 {
 731                   tree name = EXPR_WFL_NODE ($2), last_name;
 732                   int   i = IDENTIFIER_LENGTH (name)-1;
 733                   const char *last = &IDENTIFIER_POINTER (name)[i];
 734                   while (last != IDENTIFIER_POINTER (name))
 735                     {
 736                       if (last [0] == '.')
 737                         break;
 738                       last--;
 739                     }
 740                   last_name = get_identifier (++last);
 741                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 742                     {
 743                       tree err = find_name_in_single_imports (last_name);
 744                       if (err && err != name)
 745                         parse_error_context
 746                           ($2, "Ambiguous class: `%s' and `%s'",
 747                            IDENTIFIER_POINTER (name),
 748                            IDENTIFIER_POINTER (err));
 749                       else
 750                         REGISTER_IMPORT ($2, last_name);
 751                     }
 752                   else
 753                     REGISTER_IMPORT ($2, last_name);
 754                 }
 755 |       IMPORT_TK error
 756                 {yyerror ("Missing name"); RECOVER;}
 757 |       IMPORT_TK name error
 758                 {yyerror ("';' expected"); RECOVER;}
 759 ;
 760
 761 type_import_on_demand_declaration:
 762         IMPORT_TK name DOT_TK MULT_TK SC_TK
 763                 {
 764                   tree name = EXPR_WFL_NODE ($2);
 765                   tree it;
 766                   /* Search for duplicates. */
 767                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 768                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 769                       break;
 770                   /* Don't import the same thing more than once, just ignore
 771                      duplicates (7.5.2) */
 772                   if (! it)
 773                     {
 774                       read_import_dir ($2);
 775                       ctxp->import_demand_list =
 776                         chainon (ctxp->import_demand_list,
 777                                  build_tree_list ($2, NULL_TREE));
 778                     }
 779                 }
 780 |       IMPORT_TK name DOT_TK error
 781                 {yyerror ("'*' expected"); RECOVER;}
 782 |       IMPORT_TK name DOT_TK MULT_TK error
 783                 {yyerror ("';' expected"); RECOVER;}
 784 ;
 785
 786 type_declaration:
 787         class_declaration
 788                 { end_class_declaration (0); }
 789 |       interface_declaration
 790                 { end_class_declaration (0); }
 791 |       empty_statement
 792 |       error
 793                 {
 794                   YYERROR_NOW;
 795                   yyerror ("Class or interface declaration expected");
 796                 }
 797 ;
 798
 799 /* 19.7 Shortened from the original:
 800    modifiers: modifier | modifiers modifier
 801    modifier: any of public...  */
 802 modifiers:
 803         MODIFIER_TK
 804                 {
 805                   $$ = (1 << $1);
 806                 }
 807 |       modifiers MODIFIER_TK
 808                 {
 809                   int acc = (1 << $2);
 810                   if ($$ & acc)
 811                     parse_error_context
 812                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 813                        java_accstring_lookup (acc));
 814                   else
 815                     {
 816                       $$ |= acc;
 817                     }
 818                 }
 819 ;
 820
 821 /* 19.8.1 Production from $8.1: Class Declaration */
 822 class_declaration:
 823         modifiers CLASS_TK identifier super interfaces
 824                 { create_class ($1, $3, $4, $5); }
 825         class_body
 826                 {;}
 827 |       CLASS_TK identifier super interfaces
 828                 { create_class (0, $2, $3, $4); }
 829         class_body
 830                 {;}
 831 |       modifiers CLASS_TK error
 832                 { yyerror ("Missing class name"); RECOVER; }
 833 |       CLASS_TK error
 834                 { yyerror ("Missing class name"); RECOVER; }
 835 |       CLASS_TK identifier error
 836                 {
 837                   if (!ctxp->class_err) yyerror ("'{' expected");
 838                   DRECOVER(class1);
 839                 }
 840 |       modifiers CLASS_TK identifier error
 841                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 842 ;
 843
 844 super:
 845                 { $$ = NULL; }
 846 |       EXTENDS_TK class_type
 847                 { $$ = $2; }
 848 |       EXTENDS_TK class_type error
 849                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 850 |       EXTENDS_TK error
 851                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 852 ;
 853
 854 interfaces:
 855                 { $$ = NULL_TREE; }
 856 |       IMPLEMENTS_TK interface_type_list
 857                 { $$ = $2; }
 858 |       IMPLEMENTS_TK error
 859                 {
 860                   ctxp->class_err=1;
 861                   yyerror ("Missing interface name");
 862                 }
 863 ;
 864
 865 interface_type_list:
 866         interface_type
 867                 {
 868                   ctxp->interface_number = 1;
 869                   $$ = build_tree_list ($1, NULL_TREE);
 870                 }
 871 |       interface_type_list C_TK interface_type
 872                 {
 873                   ctxp->interface_number++;
 874                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 875                 }
 876 |       interface_type_list C_TK error
 877                 {yyerror ("Missing interface name"); RECOVER;}
 878 ;
 879
 880 class_body:
 881         OCB_TK CCB_TK
 882                 {
 883                   /* Store the location of the `}' when doing xrefs */
 884                   if (flag_emit_xref)
 885                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 886                       EXPR_WFL_ADD_COL ($2.location, 1);
 887                   $$ = GET_CPC ();
 888                 }
 889 |       OCB_TK class_body_declarations CCB_TK
 890                 {
 891                   /* Store the location of the `}' when doing xrefs */
 892                   if (flag_emit_xref)
 893                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 894                       EXPR_WFL_ADD_COL ($3.location, 1);
 895                   $$ = GET_CPC ();
 896                 }
 897 ;
 898
 899 class_body_declarations:
 900         class_body_declaration
 901 |       class_body_declarations class_body_declaration
 902 ;
 903
 904 class_body_declaration:
 905         class_member_declaration
 906 |       static_initializer
 907 |       constructor_declaration
 908 |       block                   /* Added, JDK1.1, instance initializer */
 909                 {
 910                   if (!IS_EMPTY_STMT ($1))
 911                     {
 912                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 913                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 914                     }
 915                 }
 916 ;
 917
 918 class_member_declaration:
 919         field_declaration
 920 |       method_declaration
 921 |       class_declaration       /* Added, JDK1.1 inner classes */
 922                 { end_class_declaration (1); }
 923 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 924                 { end_class_declaration (1); }
 925 |       empty_statement
 926 ;
 927
 928 /* 19.8.2 Productions from 8.3: Field Declarations  */
 929 field_declaration:
 930         type variable_declarators SC_TK
 931                 { register_fields (0, $1, $2); }
 932 |       modifiers type variable_declarators SC_TK
 933                 {
 934                   check_modifiers
 935                     ("Illegal modifier `%s' for field declaration",
 936                      $1, FIELD_MODIFIERS);
 937                   check_modifiers_consistency ($1);
 938                   register_fields ($1, $2, $3);
 939                 }
 940 ;
 941
 942 variable_declarators:
 943         /* Should we use build_decl_list () instead ? FIXME */
 944         variable_declarator     /* Default rule */
 945 |       variable_declarators C_TK variable_declarator
 946                 { $$ = chainon ($1, $3); }
 947 |       variable_declarators C_TK error
 948                 {yyerror ("Missing term"); RECOVER;}
 949 ;
 950
 951 variable_declarator:
 952         variable_declarator_id
 953                 { $$ = build_tree_list ($1, NULL_TREE); }
 954 |       variable_declarator_id ASSIGN_TK variable_initializer
 955                 {
 956                   if (java_error_count)
 957                     $3 = NULL_TREE;
 958                   $$ = build_tree_list
 959                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 960                 }
 961 |       variable_declarator_id ASSIGN_TK error
 962                 {
 963                   yyerror ("Missing variable initializer");
 964                   $$ = build_tree_list ($1, NULL_TREE);
 965                   RECOVER;
 966                 }
 967 |       variable_declarator_id ASSIGN_TK variable_initializer error
 968                 {
 969                   yyerror ("';' expected");
 970                   $$ = build_tree_list ($1, NULL_TREE);
 971                   RECOVER;
 972                 }
 973 ;
 974
 975 variable_declarator_id:
 976         identifier
 977 |       variable_declarator_id OSB_TK CSB_TK
 978                 { $$ = build_unresolved_array_type ($1); }
 979 |       identifier error
 980                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 981 |       variable_declarator_id OSB_TK error
 982                 {
 983                   yyerror ("']' expected");
 984                   DRECOVER(vdi);
 985                 }
 986 |       variable_declarator_id CSB_TK error
 987                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 988 ;
 989
 990 variable_initializer:
 991         expression
 992 |       array_initializer
 993 ;
 994
 995 /* 19.8.3 Productions from 8.4: Method Declarations  */
 996 method_declaration:
 997         method_header
 998                 {
 999                   current_function_decl = $1;
1000                   if (current_function_decl
1001                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1002                     source_start_java_method (current_function_decl);
1003                   else
1004                     current_function_decl = NULL_TREE;
1005                 }
1006         method_body
1007                 { finish_method_declaration ($3); }
1008 |       method_header error
1009                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1010 ;
1011
1012 method_header:
1013         type method_declarator throws
1014                 { $$ = method_header (0, $1, $2, $3); }
1015 |       VOID_TK method_declarator throws
1016                 { $$ = method_header (0, void_type_node, $2, $3); }
1017 |       modifiers type method_declarator throws
1018                 { $$ = method_header ($1, $2, $3, $4); }
1019 |       modifiers VOID_TK method_declarator throws
1020                 { $$ = method_header ($1, void_type_node, $3, $4); }
1021 |       type error
1022                 {
1023                   yyerror ("Invalid method declaration, method name required");
1024                   RECOVER;
1025                 }
1026 |       modifiers type error
1027                 {
1028                   yyerror ("Identifier expected");
1029                   RECOVER;
1030                 }
1031 |       VOID_TK error
1032                 {
1033                   yyerror ("Identifier expected");
1034                   RECOVER;
1035                 }
1036 |       modifiers VOID_TK error
1037                 {
1038                   yyerror ("Identifier expected");
1039                   RECOVER;
1040                 }
1041 |       modifiers error
1042                 {
1043                   yyerror ("Invalid method declaration, return type required");
1044                   RECOVER;
1045                 }
1046 ;
1047
1048 method_declarator:
1049         identifier OP_TK CP_TK
1050                 {
1051                   ctxp->formal_parameter_number = 0;
1052                   $$ = method_declarator ($1, NULL_TREE);
1053                 }
1054 |       identifier OP_TK formal_parameter_list CP_TK
1055                 { $$ = method_declarator ($1, $3); }
1056 |       method_declarator OSB_TK CSB_TK
1057                 {
1058                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1059                   TREE_PURPOSE ($1) =
1060                     build_unresolved_array_type (TREE_PURPOSE ($1));
1061                   parse_warning_context
1062                     (wfl_operator,
1063                      "Discouraged form of returned type specification");
1064                 }
1065 |       identifier OP_TK error
1066                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1067 |       method_declarator OSB_TK error
1068                 {yyerror ("']' expected"); RECOVER;}
1069 ;
1070
1071 formal_parameter_list:
1072         formal_parameter
1073                 {
1074                   ctxp->formal_parameter_number = 1;
1075                 }
1076 |       formal_parameter_list C_TK formal_parameter
1077                 {
1078                   ctxp->formal_parameter_number += 1;
1079                   $$ = chainon ($1, $3);
1080                 }
1081 |       formal_parameter_list C_TK error
1082                 { yyerror ("Missing formal parameter term"); RECOVER; }
1083 ;
1084
1085 formal_parameter:
1086         type variable_declarator_id
1087                 {
1088                   $$ = build_tree_list ($2, $1);
1089                 }
1090 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1091                 {
1092                   $$ = build_tree_list ($3, $2);
1093                   ARG_FINAL_P ($$) = 1;
1094                 }
1095 |       type error
1096                 {
1097                   yyerror ("Missing identifier"); RECOVER;
1098                   $$ = NULL_TREE;
1099                 }
1100 |       final type error
1101                 {
1102                   yyerror ("Missing identifier"); RECOVER;
1103                   $$ = NULL_TREE;
1104                 }
1105 ;
1106
1107 final:
1108         modifiers
1109                 {
1110                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1111                                    $1, ACC_FINAL);
1112                   if ($1 != ACC_FINAL)
1113                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1114                 }
1115 ;
1116
1117 throws:
1118                 { $$ = NULL_TREE; }
1119 |       THROWS_TK class_type_list
1120                 { $$ = $2; }
1121 |       THROWS_TK error
1122                 {yyerror ("Missing class type term"); RECOVER;}
1123 ;
1124
1125 class_type_list:
1126         class_type
1127                 { $$ = build_tree_list ($1, $1); }
1128 |       class_type_list C_TK class_type
1129                 { $$ = tree_cons ($3, $3, $1); }
1130 |       class_type_list C_TK error
1131                 {yyerror ("Missing class type term"); RECOVER;}
1132 ;
1133
1134 method_body:
1135         block
1136 |       SC_TK { $$ = NULL_TREE; }
1137 ;
1138
1139 /* 19.8.4 Productions from 8.5: Static Initializers  */
1140 static_initializer:
1141         static block
1142                 {
1143                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1144                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1145                   current_static_block = NULL_TREE;
1146                 }
1147 ;
1148
1149 static:                         /* Test lval.sub_token here */
1150         modifiers
1151                 {
1152                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1153                   /* Can't have a static initializer in an innerclass */
1154                   if ($1 | ACC_STATIC &&
1155                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1156                     parse_error_context
1157                       (MODIFIER_WFL (STATIC_TK),
1158                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1159                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1160                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1161                 }
1162 ;
1163
1164 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1165 constructor_declaration:
1166         constructor_header
1167                 {
1168                   current_function_decl = $1;
1169                   source_start_java_method (current_function_decl);
1170                 }
1171         constructor_body
1172                 { finish_method_declaration ($3); }
1173 ;
1174
1175 constructor_header:
1176         constructor_declarator throws
1177                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1178 |       modifiers constructor_declarator throws
1179                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1180 ;
1181
1182 constructor_declarator:
1183         simple_name OP_TK CP_TK
1184                 {
1185                   ctxp->formal_parameter_number = 0;
1186                   $$ = method_declarator ($1, NULL_TREE);
1187                 }
1188 |       simple_name OP_TK formal_parameter_list CP_TK
1189                 { $$ = method_declarator ($1, $3); }
1190 ;
1191
1192 constructor_body:
1193         /* Unlike regular method, we always need a complete (empty)
1194            body so we can safely perform all the required code
1195            addition (super invocation and field initialization) */
1196         block_begin constructor_block_end
1197                 {
1198                   BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
1199                   $$ = $2;
1200                 }
1201 |       block_begin explicit_constructor_invocation constructor_block_end
1202                 { $$ = $3; }
1203 |       block_begin block_statements constructor_block_end
1204                 { $$ = $3; }
1205 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1206                 { $$ = $4; }
1207 ;
1208
1209 constructor_block_end:
1210         block_end
1211 ;
1212
1213 /* Error recovery for that rule moved down expression_statement: rule.  */
1214 explicit_constructor_invocation:
1215         this_or_super OP_TK CP_TK SC_TK
1216                 {
1217                   $$ = build_method_invocation ($1, NULL_TREE);
1218                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1219                   $$ = java_method_add_stmt (current_function_decl, $$);
1220                 }
1221 |       this_or_super OP_TK argument_list CP_TK SC_TK
1222                 {
1223                   $$ = build_method_invocation ($1, $3);
1224                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1225                   $$ = java_method_add_stmt (current_function_decl, $$);
1226                 }
1227         /* Added, JDK1.1 inner classes. Modified because the rule
1228            'primary' couldn't work.  */
1229 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1230                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1231 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1232                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1233 ;
1234
1235 this_or_super:                  /* Added, simplifies error diagnostics */
1236         THIS_TK
1237                 {
1238                   tree wfl = build_wfl_node (this_identifier_node);
1239                   EXPR_WFL_LINECOL (wfl) = $1.location;
1240                   $$ = wfl;
1241                 }
1242 |       SUPER_TK
1243                 {
1244                   tree wfl = build_wfl_node (super_identifier_node);
1245                   EXPR_WFL_LINECOL (wfl) = $1.location;
1246                   $$ = wfl;
1247                 }
1248 ;
1249
1250 /* 19.9 Productions from 9: Interfaces  */
1251 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1252 interface_declaration:
1253         INTERFACE_TK identifier
1254                 { create_interface (0, $2, NULL_TREE); }
1255         interface_body
1256                 { ; }
1257 |       modifiers INTERFACE_TK identifier
1258                 { create_interface ($1, $3, NULL_TREE); }
1259         interface_body
1260                 { ; }
1261 |       INTERFACE_TK identifier extends_interfaces
1262                 { create_interface (0, $2, $3); }
1263         interface_body
1264                 { ; }
1265 |       modifiers INTERFACE_TK identifier extends_interfaces
1266                 { create_interface ($1, $3, $4); }
1267         interface_body
1268                 { ; }
1269 |       INTERFACE_TK identifier error
1270                 { yyerror ("'{' expected"); RECOVER; }
1271 |       modifiers INTERFACE_TK identifier error
1272                 { yyerror ("'{' expected"); RECOVER; }
1273 ;
1274
1275 extends_interfaces:
1276         EXTENDS_TK interface_type
1277                 {
1278                   ctxp->interface_number = 1;
1279                   $$ = build_tree_list ($2, NULL_TREE);
1280                 }
1281 |       extends_interfaces C_TK interface_type
1282                 {
1283                   ctxp->interface_number++;
1284                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1285                 }
1286 |       EXTENDS_TK error
1287                 {yyerror ("Invalid interface type"); RECOVER;}
1288 |       extends_interfaces C_TK error
1289                 {yyerror ("Missing term"); RECOVER;}
1290 ;
1291
1292 interface_body:
1293         OCB_TK CCB_TK
1294                 { $$ = NULL_TREE; }
1295 |       OCB_TK interface_member_declarations CCB_TK
1296                 { $$ = NULL_TREE; }
1297 ;
1298
1299 interface_member_declarations:
1300         interface_member_declaration
1301 |       interface_member_declarations interface_member_declaration
1302 ;
1303
1304 interface_member_declaration:
1305         constant_declaration
1306 |       abstract_method_declaration
1307 |       class_declaration       /* Added, JDK1.1 inner classes */
1308                 { end_class_declaration (1); }
1309 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1310                 { end_class_declaration (1); }
1311 ;
1312
1313 constant_declaration:
1314         field_declaration
1315 ;
1316
1317 abstract_method_declaration:
1318         method_header SC_TK
1319                 {
1320                   check_abstract_method_header ($1);
1321                   current_function_decl = NULL_TREE; /* FIXME ? */
1322                 }
1323 |       method_header error
1324                 {yyerror ("';' expected"); RECOVER;}
1325 ;
1326
1327 /* 19.10 Productions from 10: Arrays  */
1328 array_initializer:
1329         OCB_TK CCB_TK
1330                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1331 |       OCB_TK C_TK CCB_TK
1332                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1333 |       OCB_TK variable_initializers CCB_TK
1334                 { $$ = build_new_array_init ($1.location, $2); }
1335 |       OCB_TK variable_initializers C_TK CCB_TK
1336                 { $$ = build_new_array_init ($1.location, $2); }
1337 ;
1338
1339 variable_initializers:
1340         variable_initializer
1341                 {
1342                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1343                                   $1, NULL_TREE);
1344                 }
1345 |       variable_initializers C_TK variable_initializer
1346                 {
1347                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1348                 }
1349 |       variable_initializers C_TK error
1350                 {yyerror ("Missing term"); RECOVER;}
1351 ;
1352
1353 /* 19.11 Production from 14: Blocks and Statements  */
1354 block:
1355         block_begin block_end
1356                 { $$ = $2; }
1357 |       block_begin block_statements block_end
1358                 { $$ = $3; }
1359 ;
1360
1361 block_begin:
1362         OCB_TK
1363                 { enter_block (); }
1364 ;
1365
1366 block_end:
1367         CCB_TK
1368                 {
1369                   maybe_absorb_scoping_blocks ();
1370                   /* Store the location of the `}' when doing xrefs */
1371                   if (current_function_decl && flag_emit_xref)
1372                     DECL_END_SOURCE_LINE (current_function_decl) =
1373                       EXPR_WFL_ADD_COL ($1.location, 1);
1374                   $$ = exit_block ();
1375                   if (!BLOCK_SUBBLOCKS ($$))
1376                     BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
1377                 }
1378 ;
1379
1380 block_statements:
1381         block_statement
1382 |       block_statements block_statement
1383 ;
1384
1385 block_statement:
1386         local_variable_declaration_statement
1387 |       statement
1388                 { java_method_add_stmt (current_function_decl, $1); }
1389 |       class_declaration       /* Added, JDK1.1 local classes */
1390                 {
1391                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1392                   end_class_declaration (1);
1393                 }
1394 ;
1395
1396 local_variable_declaration_statement:
1397         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1398 ;
1399
1400 local_variable_declaration:
1401         type variable_declarators
1402                 { declare_local_variables (0, $1, $2); }
1403 |       final type variable_declarators /* Added, JDK1.1 final locals */
1404                 { declare_local_variables ($1, $2, $3); }
1405 ;
1406
1407 statement:
1408         statement_without_trailing_substatement
1409 |       labeled_statement
1410 |       if_then_statement
1411 |       if_then_else_statement
1412 |       while_statement
1413 |       for_statement
1414                 { $$ = exit_block (); }
1415 ;
1416
1417 statement_nsi:
1418         statement_without_trailing_substatement
1419 |       labeled_statement_nsi
1420 |       if_then_else_statement_nsi
1421 |       while_statement_nsi
1422 |       for_statement_nsi
1423                 { $$ = exit_block (); }
1424 ;
1425
1426 statement_without_trailing_substatement:
1427         block
1428 |       empty_statement
1429 |       expression_statement
1430 |       switch_statement
1431 |       do_statement
1432 |       break_statement
1433 |       continue_statement
1434 |       return_statement
1435 |       synchronized_statement
1436 |       throw_statement
1437 |       try_statement
1438 |       assert_statement
1439 ;
1440
1441 empty_statement:
1442         SC_TK
1443                 {
1444                   if (flag_extraneous_semicolon
1445                       && ! current_static_block
1446                       && (! current_function_decl ||
1447                           /* Verify we're not in a inner class declaration */
1448                           (GET_CPC () != TYPE_NAME
1449                            (DECL_CONTEXT (current_function_decl)))))
1450
1451                     {
1452                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1453                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1454                     }
1455                   $$ = build_java_empty_stmt ();
1456                 }
1457 ;
1458
1459 label_decl:
1460         identifier REL_CL_TK
1461                 {
1462                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1463                                             EXPR_WFL_NODE ($1));
1464                   pushlevel (2);
1465                   push_labeled_block ($$);
1466                   PUSH_LABELED_BLOCK ($$);
1467                 }
1468 ;
1469
1470 labeled_statement:
1471         label_decl statement
1472                 { $$ = finish_labeled_statement ($1, $2); }
1473 |       identifier error
1474                 {yyerror ("':' expected"); RECOVER;}
1475 ;
1476
1477 labeled_statement_nsi:
1478         label_decl statement_nsi
1479                 { $$ = finish_labeled_statement ($1, $2); }
1480 ;
1481
1482 /* We concentrate here a bunch of error handling rules that we couldn't write
1483    earlier, because expression_statement catches a missing ';'.  */
1484 expression_statement:
1485         statement_expression SC_TK
1486                 {
1487                   /* We have a statement. Generate a WFL around it so
1488                      we can debug it */
1489                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1490                   /* We know we have a statement, so set the debug
1491                      info to be eventually generate here. */
1492                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1493                 }
1494 |       error SC_TK
1495                 {
1496                   YYNOT_TWICE yyerror ("Invalid expression statement");
1497                   DRECOVER (expr_stmt);
1498                 }
1499 |       error OCB_TK
1500                 {
1501                   YYNOT_TWICE yyerror ("Invalid expression statement");
1502                   DRECOVER (expr_stmt);
1503                 }
1504 |       error CCB_TK
1505                 {
1506                   YYNOT_TWICE yyerror ("Invalid expression statement");
1507                   DRECOVER (expr_stmt);
1508                 }
1509 |       this_or_super OP_TK error
1510                 {yyerror ("')' expected"); RECOVER;}
1511 |       this_or_super OP_TK CP_TK error
1512                 {
1513                   parse_ctor_invocation_error ();
1514                   RECOVER;
1515                 }
1516 |       this_or_super OP_TK argument_list error
1517                 {yyerror ("')' expected"); RECOVER;}
1518 |       this_or_super OP_TK argument_list CP_TK error
1519                 {
1520                   parse_ctor_invocation_error ();
1521                   RECOVER;
1522                 }
1523 |       name DOT_TK SUPER_TK error
1524                 {yyerror ("'(' expected"); RECOVER;}
1525 |       name DOT_TK SUPER_TK OP_TK error
1526                 {yyerror ("')' expected"); RECOVER;}
1527 |       name DOT_TK SUPER_TK OP_TK argument_list error
1528                 {yyerror ("')' expected"); RECOVER;}
1529 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1530                 {yyerror ("';' expected"); RECOVER;}
1531 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1532                 {yyerror ("';' expected"); RECOVER;}
1533 ;
1534
1535 statement_expression:
1536         assignment
1537 |       pre_increment_expression
1538 |       pre_decrement_expression
1539 |       post_increment_expression
1540 |       post_decrement_expression
1541 |       method_invocation
1542 |       class_instance_creation_expression
1543 ;
1544
1545 if_then_statement:
1546         IF_TK OP_TK expression CP_TK statement
1547                 {
1548                   $$ = build_if_else_statement ($2.location, $3,
1549                                                 $5, NULL_TREE);
1550                 }
1551 |       IF_TK error
1552                 {yyerror ("'(' expected"); RECOVER;}
1553 |       IF_TK OP_TK error
1554                 {yyerror ("Missing term"); RECOVER;}
1555 |       IF_TK OP_TK expression error
1556                 {yyerror ("')' expected"); RECOVER;}
1557 ;
1558
1559 if_then_else_statement:
1560         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1561                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1562 ;
1563
1564 if_then_else_statement_nsi:
1565         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1566                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1567 ;
1568
1569 switch_statement:
1570         switch_expression
1571                 {
1572                   enter_block ();
1573                 }
1574         switch_block
1575                 {
1576                   /* Make into "proper list" of COMPOUND_EXPRs.
1577                      I.e. make the last statement also have its own
1578                      COMPOUND_EXPR. */
1579                   maybe_absorb_scoping_blocks ();
1580                   TREE_OPERAND ($1, 1) = exit_block ();
1581                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1582                 }
1583 ;
1584
1585 switch_expression:
1586         SWITCH_TK OP_TK expression CP_TK
1587                 {
1588                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE, NULL_TREE);
1589                   EXPR_WFL_LINECOL ($$) = $2.location;
1590                 }
1591 |       SWITCH_TK error
1592                 {yyerror ("'(' expected"); RECOVER;}
1593 |       SWITCH_TK OP_TK error
1594                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1595 |       SWITCH_TK OP_TK expression CP_TK error
1596                 {yyerror ("'{' expected"); RECOVER;}
1597 ;
1598
1599 /* Default assignment is there to avoid type node on switch_block
1600    node. */
1601
1602 switch_block:
1603         OCB_TK CCB_TK
1604                 { $$ = NULL_TREE; }
1605 |       OCB_TK switch_labels CCB_TK
1606                 { $$ = NULL_TREE; }
1607 |       OCB_TK switch_block_statement_groups CCB_TK
1608                 { $$ = NULL_TREE; }
1609 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1610                 { $$ = NULL_TREE; }
1611 ;
1612
1613 switch_block_statement_groups:
1614         switch_block_statement_group
1615 |       switch_block_statement_groups switch_block_statement_group
1616 ;
1617
1618 switch_block_statement_group:
1619         switch_labels block_statements
1620 ;
1621
1622 switch_labels:
1623         switch_label
1624 |       switch_labels switch_label
1625 ;
1626
1627 switch_label:
1628         CASE_TK constant_expression REL_CL_TK
1629                 {
1630                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1631                   EXPR_WFL_LINECOL (lab) = $1.location;
1632                   java_method_add_stmt (current_function_decl, lab);
1633                 }
1634 |       DEFAULT_TK REL_CL_TK
1635                 {
1636                   tree lab = make_node (DEFAULT_EXPR);
1637                   EXPR_WFL_LINECOL (lab) = $1.location;
1638                   java_method_add_stmt (current_function_decl, lab);
1639                 }
1640 |       CASE_TK error
1641                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1642 |       CASE_TK constant_expression error
1643                 {yyerror ("':' expected"); RECOVER;}
1644 |       DEFAULT_TK error
1645                 {yyerror ("':' expected"); RECOVER;}
1646 ;
1647
1648 while_expression:
1649         WHILE_TK OP_TK expression CP_TK
1650                 {
1651                   tree body = build_loop_body ($2.location, $3, 0);
1652                   $$ = build_new_loop (body);
1653                 }
1654 ;
1655
1656 while_statement:
1657         while_expression statement
1658                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1659 |       WHILE_TK error
1660                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1661 |       WHILE_TK OP_TK error
1662                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1663 |       WHILE_TK OP_TK expression error
1664                 {yyerror ("')' expected"); RECOVER;}
1665 ;
1666
1667 while_statement_nsi:
1668         while_expression statement_nsi
1669                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1670 ;
1671
1672 do_statement_begin:
1673         DO_TK
1674                 {
1675                   tree body = build_loop_body (0, NULL_TREE, 1);
1676                   $$ = build_new_loop (body);
1677                 }
1678         /* Need error handing here. FIXME */
1679 ;
1680
1681 do_statement:
1682         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1683                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1684 ;
1685
1686 for_statement:
1687         for_begin SC_TK expression SC_TK for_update CP_TK statement
1688                 {
1689                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1690                     $3 = build_wfl_node ($3);
1691                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1692                 }
1693 |       for_begin SC_TK SC_TK for_update CP_TK statement
1694                 {
1695                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1696                   /* We have not condition, so we get rid of the EXIT_EXPR */
1697                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1698                     build_java_empty_stmt ();
1699                 }
1700 |       for_begin SC_TK error
1701                 {yyerror ("Invalid control expression"); RECOVER;}
1702 |       for_begin SC_TK expression SC_TK error
1703                 {yyerror ("Invalid update expression"); RECOVER;}
1704 |       for_begin SC_TK SC_TK error
1705                 {yyerror ("Invalid update expression"); RECOVER;}
1706 ;
1707
1708 for_statement_nsi:
1709         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1710                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1711 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1712                 {
1713                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1714                   /* We have not condition, so we get rid of the EXIT_EXPR */
1715                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1716                     build_java_empty_stmt ();
1717                 }
1718 ;
1719
1720 for_header:
1721         FOR_TK OP_TK
1722                 {
1723                   /* This scope defined for local variable that may be
1724                      defined within the scope of the for loop */
1725                   enter_block ();
1726                 }
1727 |       FOR_TK error
1728                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1729 |       FOR_TK OP_TK error
1730                 {yyerror ("Invalid init statement"); RECOVER;}
1731 ;
1732
1733 for_begin:
1734         for_header for_init
1735                 {
1736                   /* We now declare the loop body. The loop is
1737                      declared as a for loop. */
1738                   tree body = build_loop_body (0, NULL_TREE, 0);
1739                   $$ =  build_new_loop (body);
1740                   FOR_LOOP_P ($$) = 1;
1741                   /* The loop is added to the current block the for
1742                      statement is defined within */
1743                   java_method_add_stmt (current_function_decl, $$);
1744                 }
1745 ;
1746 for_init:                       /* Can be empty */
1747                 { $$ = build_java_empty_stmt (); }
1748 |       statement_expression_list
1749                 {
1750                   /* Init statement recorded within the previously
1751                      defined block scope */
1752                   $$ = java_method_add_stmt (current_function_decl, $1);
1753                 }
1754 |       local_variable_declaration
1755                 {
1756                   /* Local variable are recorded within the previously
1757                      defined block scope */
1758                   $$ = NULL_TREE;
1759                 }
1760 |       statement_expression_list error
1761                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1762 ;
1763
1764 for_update:                     /* Can be empty */
1765                 {$$ = build_java_empty_stmt ();}
1766 |       statement_expression_list
1767                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1768 ;
1769
1770 statement_expression_list:
1771         statement_expression
1772                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1773 |       statement_expression_list C_TK statement_expression
1774                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1775 |       statement_expression_list C_TK error
1776                 {yyerror ("Missing term"); RECOVER;}
1777 ;
1778
1779 break_statement:
1780         BREAK_TK SC_TK
1781                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1782 |       BREAK_TK identifier SC_TK
1783                 { $$ = build_bc_statement ($1.location, 1, $2); }
1784 |       BREAK_TK error
1785                 {yyerror ("Missing term"); RECOVER;}
1786 |       BREAK_TK identifier error
1787                 {yyerror ("';' expected"); RECOVER;}
1788 ;
1789
1790 continue_statement:
1791         CONTINUE_TK SC_TK
1792                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1793 |       CONTINUE_TK identifier SC_TK
1794                 { $$ = build_bc_statement ($1.location, 0, $2); }
1795 |       CONTINUE_TK error
1796                 {yyerror ("Missing term"); RECOVER;}
1797 |       CONTINUE_TK identifier error
1798                 {yyerror ("';' expected"); RECOVER;}
1799 ;
1800
1801 return_statement:
1802         RETURN_TK SC_TK
1803                 { $$ = build_return ($1.location, NULL_TREE); }
1804 |       RETURN_TK expression SC_TK
1805                 { $$ = build_return ($1.location, $2); }
1806 |       RETURN_TK error
1807                 {yyerror ("Missing term"); RECOVER;}
1808 |       RETURN_TK expression error
1809                 {yyerror ("';' expected"); RECOVER;}
1810 ;
1811
1812 throw_statement:
1813         THROW_TK expression SC_TK
1814                 {
1815                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1816                   EXPR_WFL_LINECOL ($$) = $1.location;
1817                 }
1818 |       THROW_TK error
1819                 {yyerror ("Missing term"); RECOVER;}
1820 |       THROW_TK expression error
1821                 {yyerror ("';' expected"); RECOVER;}
1822 ;
1823
1824 assert_statement:
1825         ASSERT_TK expression REL_CL_TK expression SC_TK
1826                 {
1827                   $$ = build_assertion ($1.location, $2, $4);
1828                 }
1829 |       ASSERT_TK expression SC_TK
1830                 {
1831                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1832                 }
1833 |       ASSERT_TK error
1834                 {yyerror ("Missing term"); RECOVER;}
1835 |       ASSERT_TK expression error
1836                 {yyerror ("';' expected"); RECOVER;}
1837 ;
1838
1839 synchronized_statement:
1840         synchronized OP_TK expression CP_TK block
1841                 {
1842                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1843                   EXPR_WFL_LINECOL ($$) =
1844                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1845                 }
1846 |       synchronized OP_TK expression CP_TK error
1847                 {yyerror ("'{' expected"); RECOVER;}
1848 |       synchronized error
1849                 {yyerror ("'(' expected"); RECOVER;}
1850 |       synchronized OP_TK error CP_TK
1851                 {yyerror ("Missing term"); RECOVER;}
1852 |       synchronized OP_TK error
1853                 {yyerror ("Missing term"); RECOVER;}
1854 ;
1855
1856 synchronized:
1857         modifiers
1858                 {
1859                   check_modifiers (
1860              "Illegal modifier `%s'. Only `synchronized' was expected here",
1861                                    $1, ACC_SYNCHRONIZED);
1862                   if ($1 != ACC_SYNCHRONIZED)
1863                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1864                       build_wfl_node (NULL_TREE);
1865                 }
1866 ;
1867
1868 try_statement:
1869         TRY_TK block catches
1870                 { $$ = build_try_statement ($1.location, $2, $3); }
1871 |       TRY_TK block finally
1872                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1873 |       TRY_TK block catches finally
1874                 { $$ = build_try_finally_statement
1875                     ($1.location, build_try_statement ($1.location,
1876                                                        $2, $3), $4);
1877                 }
1878 |       TRY_TK error
1879                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1880 ;
1881
1882 catches:
1883         catch_clause
1884 |       catches catch_clause
1885                 {
1886                   TREE_CHAIN ($2) = $1;
1887                   $$ = $2;
1888                 }
1889 ;
1890
1891 catch_clause:
1892         catch_clause_parameter block
1893                 {
1894                   java_method_add_stmt (current_function_decl, $2);
1895                   exit_block ();
1896                   $$ = $1;
1897                 }
1898 ;
1899
1900 catch_clause_parameter:
1901         CATCH_TK OP_TK formal_parameter CP_TK
1902                 {
1903                   /* We add a block to define a scope for
1904                      formal_parameter (CCBP). The formal parameter is
1905                      declared initialized by the appropriate function
1906                      call */
1907                   tree ccpb;
1908                   tree init;
1909                   if ($3)
1910                     {
1911                       ccpb = enter_block ();
1912                       init = build_assignment
1913                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1914                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1915                       declare_local_variables (0, TREE_VALUE ($3),
1916                                                build_tree_list
1917                                                (TREE_PURPOSE ($3), init));
1918                       $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1919                       EXPR_WFL_LINECOL ($$) = $1.location;
1920                     }
1921                   else
1922                     {
1923                       $$ = error_mark_node;
1924                     }
1925                 }
1926 |       CATCH_TK error
1927                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1928 |       CATCH_TK OP_TK error
1929                 {
1930                   yyerror ("Missing term or ')' expected");
1931                   RECOVER; $$ = NULL_TREE;
1932                 }
1933 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1934                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1935 ;
1936
1937 finally:
1938         FINALLY_TK block
1939                 { $$ = $2; }
1940 |       FINALLY_TK error
1941                 {yyerror ("'{' expected"); RECOVER; }
1942 ;
1943
1944 /* 19.12 Production from 15: Expressions  */
1945 primary:
1946         primary_no_new_array
1947 |       array_creation_expression
1948 ;
1949
1950 primary_no_new_array:
1951         literal
1952 |       THIS_TK
1953                 { $$ = build_this ($1.location); }
1954 |       OP_TK expression CP_TK
1955                 {$$ = $2;}
1956 |       class_instance_creation_expression
1957 |       field_access
1958 |       method_invocation
1959 |       array_access
1960 |       type_literals
1961         /* Added, JDK1.1 inner classes. Documentation is wrong
1962            refering to a 'ClassName' (class_name) rule that doesn't
1963            exist. Used name: instead.  */
1964 |       name DOT_TK THIS_TK
1965                 {
1966                   tree wfl = build_wfl_node (this_identifier_node);
1967                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1968                 }
1969 |       OP_TK expression error
1970                 {yyerror ("')' expected"); RECOVER;}
1971 |       name DOT_TK error
1972                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1973 |       primitive_type DOT_TK error
1974                 {yyerror ("'class' expected" ); RECOVER;}
1975 |       VOID_TK DOT_TK error
1976                 {yyerror ("'class' expected" ); RECOVER;}
1977 ;
1978
1979 type_literals:
1980         name DOT_TK CLASS_TK
1981                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1982 |       array_type DOT_TK CLASS_TK
1983                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1984 |       primitive_type DOT_TK CLASS_TK
1985                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1986 |       VOID_TK DOT_TK CLASS_TK
1987                 {
1988                    $$ = build_incomplete_class_ref ($2.location,
1989                                                    void_type_node);
1990                 }
1991 ;
1992
1993 class_instance_creation_expression:
1994         NEW_TK class_type OP_TK argument_list CP_TK
1995                 { $$ = build_new_invocation ($2, $4); }
1996 |       NEW_TK class_type OP_TK CP_TK
1997                 { $$ = build_new_invocation ($2, NULL_TREE); }
1998 |       anonymous_class_creation
1999         /* Added, JDK1.1 inner classes, modified to use name or
2000            primary instead of primary solely which couldn't work in
2001            all situations.  */
2002 |       something_dot_new identifier OP_TK CP_TK
2003                 {
2004                   tree ctor = build_new_invocation ($2, NULL_TREE);
2005                   $$ = make_qualified_primary ($1, ctor,
2006                                                EXPR_WFL_LINECOL ($1));
2007                 }
2008 |       something_dot_new identifier OP_TK CP_TK class_body
2009 |       something_dot_new identifier OP_TK argument_list CP_TK
2010                 {
2011                   tree ctor = build_new_invocation ($2, $4);
2012                   $$ = make_qualified_primary ($1, ctor,
2013                                                EXPR_WFL_LINECOL ($1));
2014                 }
2015 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2016 |       NEW_TK error SC_TK
2017                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2018 |       NEW_TK class_type error
2019                 {yyerror ("'(' expected"); RECOVER;}
2020 |       NEW_TK class_type OP_TK error
2021                 {yyerror ("')' or term expected"); RECOVER;}
2022 |       NEW_TK class_type OP_TK argument_list error
2023                 {yyerror ("')' expected"); RECOVER;}
2024 |       something_dot_new error
2025                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2026 |       something_dot_new identifier error
2027                 {yyerror ("'(' expected"); RECOVER;}
2028 ;
2029
2030 /* Created after JDK1.1 rules originally added to
2031    class_instance_creation_expression, but modified to use
2032    'class_type' instead of 'TypeName' (type_name) which is mentioned
2033    in the documentation but doesn't exist. */
2034
2035 anonymous_class_creation:
2036         NEW_TK class_type OP_TK argument_list CP_TK
2037                 { create_anonymous_class ($2); }
2038         class_body
2039                 {
2040                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2041                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2042
2043                   end_class_declaration (1);
2044
2045                   /* Now we can craft the new expression */
2046                   $$ = build_new_invocation (id, $4);
2047
2048                   /* Note that we can't possibly be here if
2049                      `class_type' is an interface (in which case the
2050                      anonymous class extends Object and implements
2051                      `class_type', hence its constructor can't have
2052                      arguments.) */
2053
2054                   /* Otherwise, the innerclass must feature a
2055                      constructor matching `argument_list'. Anonymous
2056                      classes are a bit special: it's impossible to
2057                      define constructor for them, hence constructors
2058                      must be generated following the hints provided by
2059                      the `new' expression. Whether a super constructor
2060                      of that nature exists or not is to be verified
2061                      later on in verify_constructor_super.
2062
2063                      It's during the expansion of a `new' statement
2064                      refering to an anonymous class that a ctor will
2065                      be generated for the anonymous class, with the
2066                      right arguments. */
2067
2068                 }
2069 |       NEW_TK class_type OP_TK CP_TK
2070                 { create_anonymous_class ($2); }
2071         class_body
2072                 {
2073                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2074                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2075
2076                   end_class_declaration (1);
2077
2078                   /* Now we can craft the new expression. The
2079                      statement doesn't need to be remember so that a
2080                      constructor can be generated, since its signature
2081                      is already known. */
2082                   $$ = build_new_invocation (id, NULL_TREE);
2083                 }
2084 ;
2085
2086 something_dot_new:              /* Added, not part of the specs. */
2087         name DOT_TK NEW_TK
2088                 { $$ = $1; }
2089 |       primary DOT_TK NEW_TK
2090                 { $$ = $1; }
2091 ;
2092
2093 argument_list:
2094         expression
2095                 {
2096                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2097                   ctxp->formal_parameter_number = 1;
2098                 }
2099 |       argument_list C_TK expression
2100                 {
2101                   ctxp->formal_parameter_number += 1;
2102                   $$ = tree_cons (NULL_TREE, $3, $1);
2103                 }
2104 |       argument_list C_TK error
2105                 {yyerror ("Missing term"); RECOVER;}
2106 ;
2107
2108 array_creation_expression:
2109         NEW_TK primitive_type dim_exprs
2110                 { $$ = build_newarray_node ($2, $3, 0); }
2111 |       NEW_TK class_or_interface_type dim_exprs
2112                 { $$ = build_newarray_node ($2, $3, 0); }
2113 |       NEW_TK primitive_type dim_exprs dims
2114                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2115 |       NEW_TK class_or_interface_type dim_exprs dims
2116                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2117         /* Added, JDK1.1 anonymous array. Initial documentation rule
2118            modified */
2119 |       NEW_TK class_or_interface_type dims array_initializer
2120                 {
2121                   char *sig;
2122                   int osb = pop_current_osb (ctxp);
2123                   while (osb--)
2124                     obstack_grow (&temporary_obstack, "[]", 2);
2125                   obstack_1grow (&temporary_obstack, '\0');
2126                   sig = obstack_finish (&temporary_obstack);
2127                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2128                               $2, get_identifier (sig), $4);
2129                 }
2130 |       NEW_TK primitive_type dims array_initializer
2131                 {
2132                   int osb = pop_current_osb (ctxp);
2133                   tree type = $2;
2134                   while (osb--)
2135                     type = build_java_array_type (type, -1);
2136                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2137                               build_pointer_type (type), NULL_TREE, $4);
2138                 }
2139 |       NEW_TK error CSB_TK
2140                 {yyerror ("'[' expected"); DRECOVER ("]");}
2141 |       NEW_TK error OSB_TK
2142                 {yyerror ("']' expected"); RECOVER;}
2143 ;
2144
2145 dim_exprs:
2146         dim_expr
2147                 { $$ = build_tree_list (NULL_TREE, $1); }
2148 |       dim_exprs dim_expr
2149                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2150 ;
2151
2152 dim_expr:
2153         OSB_TK expression CSB_TK
2154                 {
2155                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2156                     {
2157                       $2 = build_wfl_node ($2);
2158                       TREE_TYPE ($2) = NULL_TREE;
2159                     }
2160                   EXPR_WFL_LINECOL ($2) = $1.location;
2161                   $$ = $2;
2162                 }
2163 |       OSB_TK expression error
2164                 {yyerror ("']' expected"); RECOVER;}
2165 |       OSB_TK error
2166                 {
2167                   yyerror ("Missing term");
2168                   yyerror ("']' expected");
2169                   RECOVER;
2170                 }
2171 ;
2172
2173 dims:
2174         OSB_TK CSB_TK
2175                 {
2176                   int allocate = 0;
2177                   /* If not initialized, allocate memory for the osb
2178                      numbers stack */
2179                   if (!ctxp->osb_limit)
2180                     {
2181                       allocate = ctxp->osb_limit = 32;
2182                       ctxp->osb_depth = -1;
2183                     }
2184                   /* If capacity overflown, reallocate a bigger chunk */
2185                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2186                     allocate = ctxp->osb_limit << 1;
2187
2188                   if (allocate)
2189                     {
2190                       allocate *= sizeof (int);
2191                       if (ctxp->osb_number)
2192                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2193                                                      allocate);
2194                       else
2195                         ctxp->osb_number = xmalloc (allocate);
2196                     }
2197                   ctxp->osb_depth++;
2198                   CURRENT_OSB (ctxp) = 1;
2199                 }
2200 |       dims OSB_TK CSB_TK
2201                 { CURRENT_OSB (ctxp)++; }
2202 |       dims OSB_TK error
2203                 { yyerror ("']' expected"); RECOVER;}
2204 ;
2205
2206 field_access:
2207         primary DOT_TK identifier
2208                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2209                 /*  FIXME - REWRITE TO:
2210                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2211 |       SUPER_TK DOT_TK identifier
2212                 {
2213                   tree super_wfl = build_wfl_node (super_identifier_node);
2214                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2215                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2216                 }
2217 |       SUPER_TK error
2218                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2219 ;
2220
2221 method_invocation:
2222         name OP_TK CP_TK
2223                 { $$ = build_method_invocation ($1, NULL_TREE); }
2224 |       name OP_TK argument_list CP_TK
2225                 { $$ = build_method_invocation ($1, $3); }
2226 |       primary DOT_TK identifier OP_TK CP_TK
2227                 {
2228                   if (TREE_CODE ($1) == THIS_EXPR)
2229                     $$ = build_this_super_qualified_invocation
2230                       (1, $3, NULL_TREE, 0, $2.location);
2231                   else
2232                     {
2233                       tree invok = build_method_invocation ($3, NULL_TREE);
2234                       $$ = make_qualified_primary ($1, invok, $2.location);
2235                     }
2236                 }
2237 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2238                 {
2239                   if (TREE_CODE ($1) == THIS_EXPR)
2240                     $$ = build_this_super_qualified_invocation
2241                       (1, $3, $5, 0, $2.location);
2242                   else
2243                     {
2244                       tree invok = build_method_invocation ($3, $5);
2245                       $$ = make_qualified_primary ($1, invok, $2.location);
2246                     }
2247                 }
2248 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2249                 {
2250                   $$ = build_this_super_qualified_invocation
2251                     (0, $3, NULL_TREE, $1.location, $2.location);
2252                 }
2253 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2254                 {
2255                   $$ = build_this_super_qualified_invocation
2256                     (0, $3, $5, $1.location, $2.location);
2257                 }
2258         /* Screws up thing. I let it here until I'm convinced it can
2259            be removed. FIXME
2260 |       primary DOT_TK error
2261                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2262 |       SUPER_TK DOT_TK error CP_TK
2263                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2264 |       SUPER_TK DOT_TK error DOT_TK
2265                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2266 ;
2267
2268 array_access:
2269         name OSB_TK expression CSB_TK
2270                 { $$ = build_array_ref ($2.location, $1, $3); }
2271 |       primary_no_new_array OSB_TK expression CSB_TK
2272                 { $$ = build_array_ref ($2.location, $1, $3); }
2273 |       name OSB_TK error
2274                 {
2275                   yyerror ("Missing term and ']' expected");
2276                   DRECOVER(array_access);
2277                 }
2278 |       name OSB_TK expression error
2279                 {
2280                   yyerror ("']' expected");
2281                   DRECOVER(array_access);
2282                 }
2283 |       primary_no_new_array OSB_TK error
2284                 {
2285                   yyerror ("Missing term and ']' expected");
2286                   DRECOVER(array_access);
2287                 }
2288 |       primary_no_new_array OSB_TK expression error
2289                 {
2290                   yyerror ("']' expected");
2291                   DRECOVER(array_access);
2292                 }
2293 ;
2294
2295 postfix_expression:
2296         primary
2297 |       name
2298 |       post_increment_expression
2299 |       post_decrement_expression
2300 ;
2301
2302 post_increment_expression:
2303         postfix_expression INCR_TK
2304                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2305 ;
2306
2307 post_decrement_expression:
2308         postfix_expression DECR_TK
2309                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2310 ;
2311
2312 trap_overflow_corner_case:
2313         pre_increment_expression
2314 |       pre_decrement_expression
2315 |       PLUS_TK unary_expression
2316                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2317 |       unary_expression_not_plus_minus
2318 |       PLUS_TK error
2319                 {yyerror ("Missing term"); RECOVER}
2320 ;
2321
2322 unary_expression:
2323         trap_overflow_corner_case
2324                 {
2325                   error_if_numeric_overflow ($1);
2326                   $$ = $1;
2327                 }
2328 |       MINUS_TK trap_overflow_corner_case
2329                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2330 |       MINUS_TK error
2331                 {yyerror ("Missing term"); RECOVER}
2332 ;
2333
2334 pre_increment_expression:
2335         INCR_TK unary_expression
2336                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2337 |       INCR_TK error
2338                 {yyerror ("Missing term"); RECOVER}
2339 ;
2340
2341 pre_decrement_expression:
2342         DECR_TK unary_expression
2343                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2344 |       DECR_TK error
2345                 {yyerror ("Missing term"); RECOVER}
2346 ;
2347
2348 unary_expression_not_plus_minus:
2349         postfix_expression
2350 |       NOT_TK unary_expression
2351                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2352 |       NEG_TK unary_expression
2353                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2354 |       cast_expression
2355 |       NOT_TK error
2356                 {yyerror ("Missing term"); RECOVER}
2357 |       NEG_TK error
2358                 {yyerror ("Missing term"); RECOVER}
2359 ;
2360
2361 cast_expression:                /* Error handling here is potentially weak */
2362         OP_TK primitive_type dims CP_TK unary_expression
2363                 {
2364                   tree type = $2;
2365                   int osb = pop_current_osb (ctxp);
2366                   while (osb--)
2367                     type = build_java_array_type (type, -1);
2368                   $$ = build_cast ($1.location, type, $5);
2369                 }
2370 |       OP_TK primitive_type CP_TK unary_expression
2371                 { $$ = build_cast ($1.location, $2, $4); }
2372 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2373                 { $$ = build_cast ($1.location, $2, $4); }
2374 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2375                 {
2376                   const char *ptr;
2377                   int osb = pop_current_osb (ctxp);
2378                   obstack_grow (&temporary_obstack,
2379                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2380                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2381                   while (osb--)
2382                     obstack_grow (&temporary_obstack, "[]", 2);
2383                   obstack_1grow (&temporary_obstack, '\0');
2384                   ptr = obstack_finish (&temporary_obstack);
2385                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2386                   $$ = build_cast ($1.location, $2, $5);
2387                 }
2388 |       OP_TK primitive_type OSB_TK error
2389                 {yyerror ("']' expected, invalid type expression");}
2390 |       OP_TK error
2391                 {
2392                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2393                   RECOVER;
2394                 }
2395 |       OP_TK primitive_type dims CP_TK error
2396                 {yyerror ("Missing term"); RECOVER;}
2397 |       OP_TK primitive_type CP_TK error
2398                 {yyerror ("Missing term"); RECOVER;}
2399 |       OP_TK name dims CP_TK error
2400                 {yyerror ("Missing term"); RECOVER;}
2401 ;
2402
2403 multiplicative_expression:
2404         unary_expression
2405 |       multiplicative_expression MULT_TK unary_expression
2406                 {
2407                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2408                                     $2.location, $1, $3);
2409                 }
2410 |       multiplicative_expression DIV_TK unary_expression
2411                 {
2412                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2413                                     $1, $3);
2414                 }
2415 |       multiplicative_expression REM_TK unary_expression
2416                 {
2417                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2418                                     $1, $3);
2419                 }
2420 |       multiplicative_expression MULT_TK error
2421                 {yyerror ("Missing term"); RECOVER;}
2422 |       multiplicative_expression DIV_TK error
2423                 {yyerror ("Missing term"); RECOVER;}
2424 |       multiplicative_expression REM_TK error
2425                 {yyerror ("Missing term"); RECOVER;}
2426 ;
2427
2428 additive_expression:
2429         multiplicative_expression
2430 |       additive_expression PLUS_TK multiplicative_expression
2431                 {
2432                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2433                                     $1, $3);
2434                 }
2435 |       additive_expression MINUS_TK multiplicative_expression
2436                 {
2437                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2438                                     $1, $3);
2439                 }
2440 |       additive_expression PLUS_TK error
2441                 {yyerror ("Missing term"); RECOVER;}
2442 |       additive_expression MINUS_TK error
2443                 {yyerror ("Missing term"); RECOVER;}
2444 ;
2445
2446 shift_expression:
2447         additive_expression
2448 |       shift_expression LS_TK additive_expression
2449                 {
2450                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2451                                     $1, $3);
2452                 }
2453 |       shift_expression SRS_TK additive_expression
2454                 {
2455                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2456                                     $1, $3);
2457                 }
2458 |       shift_expression ZRS_TK additive_expression
2459                 {
2460                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2461                                     $1, $3);
2462                 }
2463 |       shift_expression LS_TK error
2464                 {yyerror ("Missing term"); RECOVER;}
2465 |       shift_expression SRS_TK error
2466                 {yyerror ("Missing term"); RECOVER;}
2467 |       shift_expression ZRS_TK error
2468                 {yyerror ("Missing term"); RECOVER;}
2469 ;
2470
2471 relational_expression:
2472         shift_expression
2473 |       relational_expression LT_TK shift_expression
2474                 {
2475                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2476                                     $1, $3);
2477                 }
2478 |       relational_expression GT_TK shift_expression
2479                 {
2480                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2481                                     $1, $3);
2482                 }
2483 |       relational_expression LTE_TK shift_expression
2484                 {
2485                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2486                                     $1, $3);
2487                 }
2488 |       relational_expression GTE_TK shift_expression
2489                 {
2490                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2491                                     $1, $3);
2492                 }
2493 |       relational_expression INSTANCEOF_TK reference_type
2494                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2495 |       relational_expression LT_TK error
2496                 {yyerror ("Missing term"); RECOVER;}
2497 |       relational_expression GT_TK error
2498                 {yyerror ("Missing term"); RECOVER;}
2499 |       relational_expression LTE_TK error
2500                 {yyerror ("Missing term"); RECOVER;}
2501 |       relational_expression GTE_TK error
2502                 {yyerror ("Missing term"); RECOVER;}
2503 |       relational_expression INSTANCEOF_TK error
2504                 {yyerror ("Invalid reference type"); RECOVER;}
2505 ;
2506
2507 equality_expression:
2508         relational_expression
2509 |       equality_expression EQ_TK relational_expression
2510                 {
2511                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2512                                     $1, $3);
2513                 }
2514 |       equality_expression NEQ_TK relational_expression
2515                 {
2516                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2517                                     $1, $3);
2518                 }
2519 |       equality_expression EQ_TK error
2520                 {yyerror ("Missing term"); RECOVER;}
2521 |       equality_expression NEQ_TK error
2522                 {yyerror ("Missing term"); RECOVER;}
2523 ;
2524
2525 and_expression:
2526         equality_expression
2527 |       and_expression AND_TK equality_expression
2528                 {
2529                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2530                                     $1, $3);
2531                 }
2532 |       and_expression AND_TK error
2533                 {yyerror ("Missing term"); RECOVER;}
2534 ;
2535
2536 exclusive_or_expression:
2537         and_expression
2538 |       exclusive_or_expression XOR_TK and_expression
2539                 {
2540                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2541                                     $1, $3);
2542                 }
2543 |       exclusive_or_expression XOR_TK error
2544                 {yyerror ("Missing term"); RECOVER;}
2545 ;
2546
2547 inclusive_or_expression:
2548         exclusive_or_expression
2549 |       inclusive_or_expression OR_TK exclusive_or_expression
2550                 {
2551                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2552                                     $1, $3);
2553                 }
2554 |       inclusive_or_expression OR_TK error
2555                 {yyerror ("Missing term"); RECOVER;}
2556 ;
2557
2558 conditional_and_expression:
2559         inclusive_or_expression
2560 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2561                 {
2562                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2563                                     $1, $3);
2564                 }
2565 |       conditional_and_expression BOOL_AND_TK error
2566                 {yyerror ("Missing term"); RECOVER;}
2567 ;
2568
2569 conditional_or_expression:
2570         conditional_and_expression
2571 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2572                 {
2573                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2574                                     $1, $3);
2575                 }
2576 |       conditional_or_expression BOOL_OR_TK error
2577                 {yyerror ("Missing term"); RECOVER;}
2578 ;
2579
2580 conditional_expression:         /* Error handling here is weak */
2581         conditional_or_expression
2582 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2583                 {
2584                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2585                   EXPR_WFL_LINECOL ($$) = $2.location;
2586                 }
2587 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2588                 {
2589                   YYERROR_NOW;
2590                   yyerror ("Missing term");
2591                   DRECOVER (1);
2592                 }
2593 |       conditional_or_expression REL_QM_TK error
2594                 {yyerror ("Missing term"); DRECOVER (2);}
2595 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2596                 {yyerror ("Missing term"); DRECOVER (3);}
2597 ;
2598
2599 assignment_expression:
2600         conditional_expression
2601 |       assignment
2602 ;
2603
2604 assignment:
2605         left_hand_side assignment_operator assignment_expression
2606                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2607 |       left_hand_side assignment_operator error
2608                 {
2609                   YYNOT_TWICE yyerror ("Missing term");
2610                   DRECOVER (assign);
2611                 }
2612 ;
2613
2614 left_hand_side:
2615         name
2616 |       field_access
2617 |       array_access
2618 ;
2619
2620 assignment_operator:
2621         ASSIGN_ANY_TK
2622 |       ASSIGN_TK
2623 ;
2624
2625 expression:
2626         assignment_expression
2627 ;
2628
2629 constant_expression:
2630         expression
2631 ;
2632
2633 %%
2634
2635 /* Helper function to retrieve an OSB count. Should be used when the
2636    `dims:' rule is being used.  */
2637
2638 static int
2639 pop_current_osb (struct parser_ctxt *ctxp)
2640 {
2641   int to_return;
2642
2643   if (ctxp->osb_depth < 0)
2644     abort ();
2645
2646   to_return = CURRENT_OSB (ctxp);
2647   ctxp->osb_depth--;
2648
2649   return to_return;
2650 }
2651
2652 \f
2653
2654 /* This section of the code deal with save/restoring parser contexts.
2655    Add mode documentation here. FIXME */
2656
2657 /* Helper function. Create a new parser context. With
2658    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2659    context is copied, otherwise, the new context is zeroed. The newly
2660    created context becomes the current one.  */
2661
2662 static void
2663 create_new_parser_context (int copy_from_previous)
2664 {
2665   struct parser_ctxt *new;
2666
2667   new = ggc_alloc (sizeof (struct parser_ctxt));
2668   if (copy_from_previous)
2669     {
2670       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2671       /* This flag, indicating the context saves global values,
2672          should only be set by java_parser_context_save_global.  */
2673       new->saved_data_ctx = 0;
2674     }
2675   else
2676     memset (new, 0, sizeof (struct parser_ctxt));
2677
2678   new->next = ctxp;
2679   ctxp = new;
2680 }
2681
2682 /* Create a new parser context and make it the current one. */
2683
2684 void
2685 java_push_parser_context (void)
2686 {
2687   create_new_parser_context (0);
2688 }
2689
2690 void
2691 java_pop_parser_context (int generate)
2692 {
2693   tree current;
2694   struct parser_ctxt *toFree, *next;
2695
2696   if (!ctxp)
2697     return;
2698
2699   toFree = ctxp;
2700   next = ctxp->next;
2701   if (next)
2702     {
2703       input_line = ctxp->lineno;
2704       current_class = ctxp->class_type;
2705     }
2706
2707   /* If the old and new lexers differ, then free the old one.  */
2708   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2709     java_destroy_lexer (ctxp->lexer);
2710
2711   /* Set the single import class file flag to 0 for the current list
2712      of imported things */
2713   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2714     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2715
2716   /* And restore those of the previous context */
2717   if ((ctxp = next))            /* Assignment is really meant here */
2718     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2719       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2720
2721   /* If we pushed a context to parse a class intended to be generated,
2722      we keep it so we can remember the class. What we could actually
2723      do is to just update a list of class names.  */
2724   if (generate)
2725     {
2726       toFree->next = ctxp_for_generation;
2727       ctxp_for_generation = toFree;
2728     }
2729 }
2730
2731 /* Create a parser context for the use of saving some global
2732    variables.  */
2733
2734 void
2735 java_parser_context_save_global (void)
2736 {
2737   if (!ctxp)
2738     {
2739       java_push_parser_context ();
2740       ctxp->saved_data_ctx = 1;
2741     }
2742
2743   /* If this context already stores data, create a new one suitable
2744      for data storage. */
2745   else if (ctxp->saved_data)
2746     {
2747       create_new_parser_context (1);
2748       ctxp->saved_data_ctx = 1;
2749     }
2750
2751   ctxp->lineno = input_line;
2752   ctxp->class_type = current_class;
2753   ctxp->filename = input_filename;
2754   ctxp->function_decl = current_function_decl;
2755   ctxp->saved_data = 1;
2756 }
2757
2758 /* Restore some global variables from the previous context. Make the
2759    previous context the current one.  */
2760
2761 void
2762 java_parser_context_restore_global (void)
2763 {
2764   input_line = ctxp->lineno;
2765   current_class = ctxp->class_type;
2766   input_filename = ctxp->filename;
2767   if (wfl_operator)
2768     {
2769       tree s;
2770       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2771       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2772     }
2773   current_function_decl = ctxp->function_decl;
2774   ctxp->saved_data = 0;
2775   if (ctxp->saved_data_ctx)
2776     java_pop_parser_context (0);
2777 }
2778
2779 /* Suspend vital data for the current class/function being parsed so
2780    that an other class can be parsed. Used to let local/anonymous
2781    classes be parsed.  */
2782
2783 static void
2784 java_parser_context_suspend (void)
2785 {
2786   /* This makes debugging through java_debug_context easier */
2787   static const char *const name = "<inner buffer context>";
2788
2789   /* Duplicate the previous context, use it to save the globals we're
2790      interested in */
2791   create_new_parser_context (1);
2792   ctxp->function_decl = current_function_decl;
2793   ctxp->class_type = current_class;
2794
2795   /* Then create a new context which inherits all data from the
2796      previous one. This will be the new current context  */
2797   create_new_parser_context (1);
2798
2799   /* Help debugging */
2800   ctxp->next->filename = name;
2801 }
2802
2803 /* Resume vital data for the current class/function being parsed so
2804    that an other class can be parsed. Used to let local/anonymous
2805    classes be parsed.  The trick is the data storing file position
2806    informations must be restored to their current value, so parsing
2807    can resume as if no context was ever saved. */
2808
2809 static void
2810 java_parser_context_resume (void)
2811 {
2812   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2813   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2814   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2815
2816   /* We need to inherit the list of classes to complete/generate */
2817   restored->classd_list = old->classd_list;
2818   restored->class_list = old->class_list;
2819
2820   /* Restore the current class and function from the saver */
2821   current_class = saver->class_type;
2822   current_function_decl = saver->function_decl;
2823
2824   /* Retrieve the restored context */
2825   ctxp = restored;
2826
2827   /* Re-installed the data for the parsing to carry on */
2828   memcpy (&ctxp->marker_begining, &old->marker_begining,
2829           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2830 }
2831
2832 /* Add a new anchor node to which all statement(s) initializing static
2833    and non static initialized upon declaration field(s) will be
2834    linked.  */
2835
2836 static void
2837 java_parser_context_push_initialized_field (void)
2838 {
2839   tree node;
2840
2841   node = build_tree_list (NULL_TREE, NULL_TREE);
2842   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2843   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2844
2845   node = build_tree_list (NULL_TREE, NULL_TREE);
2846   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2847   CPC_INITIALIZER_LIST (ctxp) = node;
2848
2849   node = build_tree_list (NULL_TREE, NULL_TREE);
2850   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2851   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2852 }
2853
2854 /* Pop the lists of initialized field. If this lists aren't empty,
2855    remember them so we can use it to create and populate the finit$
2856    or <clinit> functions. */
2857
2858 static void
2859 java_parser_context_pop_initialized_field (void)
2860 {
2861   tree stmts;
2862   tree class_type = TREE_TYPE (GET_CPC ());
2863
2864   if (CPC_INITIALIZER_LIST (ctxp))
2865     {
2866       stmts = CPC_INITIALIZER_STMT (ctxp);
2867       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2868       if (stmts && !java_error_count)
2869         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2870     }
2871
2872   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2873     {
2874       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2875       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2876         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2877       /* Keep initialization in order to enforce 8.5 */
2878       if (stmts && !java_error_count)
2879         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2880     }
2881
2882   /* JDK 1.1 instance initializers */
2883   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2884     {
2885       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2886       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2887         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2888       if (stmts && !java_error_count)
2889         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2890     }
2891 }
2892
2893 static tree
2894 reorder_static_initialized (tree list)
2895 {
2896   /* We have to keep things in order. The alias initializer have to
2897      come first, then the initialized regular field, in reverse to
2898      keep them in lexical order. */
2899   tree marker, previous = NULL_TREE;
2900   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2901     if (TREE_CODE (marker) == TREE_LIST
2902         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2903       break;
2904
2905   /* No static initialized, the list is fine as is */
2906   if (!previous)
2907     list = TREE_CHAIN (marker);
2908
2909   /* No marker? reverse the whole list */
2910   else if (!marker)
2911     list = nreverse (list);
2912
2913   /* Otherwise, reverse what's after the marker and the new reordered
2914      sublist will replace the marker. */
2915   else
2916     {
2917       TREE_CHAIN (previous) = NULL_TREE;
2918       list = nreverse (list);
2919       list = chainon (TREE_CHAIN (marker), list);
2920     }
2921   return list;
2922 }
2923
2924 /* Helper functions to dump the parser context stack.  */
2925
2926 #define TAB_CONTEXT(C) \
2927   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2928
2929 static void
2930 java_debug_context_do (int tab)
2931 {
2932   struct parser_ctxt *copy = ctxp;
2933   while (copy)
2934     {
2935       TAB_CONTEXT (tab);
2936       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2937       TAB_CONTEXT (tab);
2938       fprintf (stderr, "filename: %s\n", copy->filename);
2939       TAB_CONTEXT (tab);
2940       fprintf (stderr, "lineno: %d\n", copy->lineno);
2941       TAB_CONTEXT (tab);
2942       fprintf (stderr, "package: %s\n",
2943                (copy->package ?
2944                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2945       TAB_CONTEXT (tab);
2946       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2947       TAB_CONTEXT (tab);
2948       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2949       copy = copy->next;
2950       tab += 2;
2951     }
2952 }
2953
2954 /* Dump the stacked up parser contexts. Intended to be called from a
2955    debugger.  */
2956
2957 void
2958 java_debug_context (void)
2959 {
2960   java_debug_context_do (0);
2961 }
2962
2963 \f
2964
2965 /* Flag for the error report routine to issue the error the first time
2966    it's called (overriding the default behavior which is to drop the
2967    first invocation and honor the second one, taking advantage of a
2968    richer context.  */
2969 static int force_error = 0;
2970
2971 /* Reporting an constructor invocation error.  */
2972 static void
2973 parse_ctor_invocation_error (void)
2974 {
2975   if (DECL_CONSTRUCTOR_P (current_function_decl))
2976     yyerror ("Constructor invocation must be first thing in a constructor");
2977   else
2978     yyerror ("Only constructors can invoke constructors");
2979 }
2980
2981 /* Reporting JDK1.1 features not implemented.  */
2982
2983 static tree
2984 parse_jdk1_1_error (const char *msg)
2985 {
2986   sorry (": `%s' JDK1.1(TM) feature", msg);
2987   java_error_count++;
2988   return build_java_empty_stmt ();
2989 }
2990
2991 static int do_warning = 0;
2992
2993 void
2994 yyerror (const char *msg)
2995 {
2996   static java_lc elc;
2997   static int  prev_lineno;
2998   static const char *prev_msg;
2999
3000   int save_lineno;
3001   char *remainder, *code_from_source;
3002
3003   if (!force_error && prev_lineno == input_line)
3004     return;
3005
3006   /* Save current error location but report latter, when the context is
3007      richer.  */
3008   if (ctxp->java_error_flag == 0)
3009     {
3010       ctxp->java_error_flag = 1;
3011       elc = ctxp->elc;
3012       /* Do something to use the previous line if we're reaching the
3013          end of the file... */
3014 #ifdef VERBOSE_SKELETON
3015       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3016 #endif
3017       return;
3018     }
3019
3020   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3021   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3022     return;
3023
3024   ctxp->java_error_flag = 0;
3025   if (do_warning)
3026     java_warning_count++;
3027   else
3028     java_error_count++;
3029
3030   if (elc.col == 0 && msg && msg[1] == ';')
3031     {
3032       elc.col  = ctxp->p_line->char_col-1;
3033       elc.line = ctxp->p_line->lineno;
3034     }
3035
3036   save_lineno = input_line;
3037   prev_lineno = input_line = elc.line;
3038   prev_msg = msg;
3039
3040   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3041   obstack_grow0 (&temporary_obstack,
3042                  code_from_source, strlen (code_from_source));
3043   remainder = obstack_finish (&temporary_obstack);
3044   if (do_warning)
3045     warning ("%s.\n%s", msg, remainder);
3046   else
3047     error ("%s.\n%s", msg, remainder);
3048
3049   /* This allow us to cheaply avoid an extra 'Invalid expression
3050      statement' error report when errors have been already reported on
3051      the same line. This occurs when we report an error but don't have
3052      a synchronization point other than ';', which
3053      expression_statement is the only one to take care of.  */
3054   ctxp->prevent_ese = input_line = save_lineno;
3055 }
3056
3057 static void
3058 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3059 {
3060   const char *saved, *saved_input_filename;
3061   char buffer [4096];
3062   vsprintf (buffer, msg, ap);
3063   force_error = 1;
3064
3065   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3066   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3067                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3068
3069   /* We have a CL, that's a good reason for using it if it contains data */
3070   saved = ctxp->filename;
3071   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3072     ctxp->filename = EXPR_WFL_FILENAME (cl);
3073   saved_input_filename = input_filename;
3074   input_filename = ctxp->filename;
3075   java_error (NULL);
3076   java_error (buffer);
3077   ctxp->filename = saved;
3078   input_filename = saved_input_filename;
3079   force_error = 0;
3080 }
3081
3082 /* Issue an error message at a current source line CL */
3083
3084 void
3085 parse_error_context (tree cl, const char *msg, ...)
3086 {
3087   va_list ap;
3088   va_start (ap, msg);
3089   issue_warning_error_from_context (cl, msg, ap);
3090   va_end (ap);
3091 }
3092
3093 /* Issue a warning at a current source line CL */
3094
3095 static void
3096 parse_warning_context (tree cl, const char *msg, ...)
3097 {
3098   va_list ap;
3099   va_start (ap, msg);
3100
3101   force_error = do_warning = 1;
3102   issue_warning_error_from_context (cl, msg, ap);
3103   do_warning = force_error = 0;
3104   va_end (ap);
3105 }
3106
3107 static tree
3108 find_expr_with_wfl (tree node)
3109 {
3110   while (node)
3111     {
3112       char code;
3113       tree to_return;
3114
3115       switch (TREE_CODE (node))
3116         {
3117         case BLOCK:
3118           node = BLOCK_EXPR_BODY (node);
3119           continue;
3120
3121         case COMPOUND_EXPR:
3122           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3123           if (to_return)
3124             return to_return;
3125           node = TREE_OPERAND (node, 1);
3126           continue;
3127
3128         case LOOP_EXPR:
3129           node = TREE_OPERAND (node, 0);
3130           continue;
3131
3132         case LABELED_BLOCK_EXPR:
3133           node = TREE_OPERAND (node, 1);
3134           continue;
3135
3136         default:
3137           code = TREE_CODE_CLASS (TREE_CODE (node));
3138           if (((code == '1') || (code == '2') || (code == 'e'))
3139               && EXPR_WFL_LINECOL (node))
3140             return node;
3141           return NULL_TREE;
3142         }
3143     }
3144   return NULL_TREE;
3145 }
3146
3147 /* Issue a missing return statement error. Uses METHOD to figure the
3148    last line of the method the error occurs in.  */
3149
3150 static void
3151 missing_return_error (tree method)
3152 {
3153   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3154   parse_error_context (wfl_operator, "Missing return statement");
3155 }
3156
3157 /* Issue an unreachable statement error. From NODE, find the next
3158    statement to report appropriately.  */
3159 static void
3160 unreachable_stmt_error (tree node)
3161 {
3162   /* Browse node to find the next expression node that has a WFL. Use
3163      the location to report the error */
3164   if (TREE_CODE (node) == COMPOUND_EXPR)
3165     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3166   else
3167     node = find_expr_with_wfl (node);
3168
3169   if (node)
3170     {
3171       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3172       parse_error_context (wfl_operator, "Unreachable statement");
3173     }
3174   else
3175     abort ();
3176 }
3177
3178 static int
3179 not_accessible_field_error (tree wfl, tree decl)
3180 {
3181   parse_error_context
3182     (wfl, "Can't access %s field `%s.%s' from `%s'",
3183      accessibility_string (get_access_flags_from_decl (decl)),
3184      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3185      IDENTIFIER_POINTER (DECL_NAME (decl)),
3186      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3187   return 1;
3188 }
3189
3190 int
3191 java_report_errors (void)
3192 {
3193   if (java_error_count)
3194     fprintf (stderr, "%d error%s",
3195              java_error_count, (java_error_count == 1 ? "" : "s"));
3196   if (java_warning_count)
3197     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3198              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3199   if (java_error_count || java_warning_count)
3200     putc ('\n', stderr);
3201   return java_error_count;
3202 }
3203
3204 static char *
3205 java_accstring_lookup (int flags)
3206 {
3207   static char buffer [80];
3208 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3209
3210   /* Access modifier looked-up first for easier report on forbidden
3211      access. */
3212   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3213   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3214   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3215   if (flags & ACC_STATIC) COPY_RETURN ("static");
3216   if (flags & ACC_FINAL) COPY_RETURN ("final");
3217   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3218   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3219   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3220   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3221   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3222   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3223
3224   buffer [0] = '\0';
3225   return buffer;
3226 #undef COPY_RETURN
3227 }
3228
3229 /* Returns a string denoting the accessibility of a class or a member as
3230    indicated by FLAGS.  We need a separate function from
3231    java_accstring_lookup, as the latter can return spurious "static", etc.
3232    if package-private access is defined (in which case none of the
3233    relevant access control bits in FLAGS is set).  */
3234
3235 static const char *
3236 accessibility_string (int flags)
3237 {
3238   if (flags & ACC_PRIVATE) return "private";
3239   if (flags & ACC_PROTECTED) return "protected";
3240   if (flags & ACC_PUBLIC) return "public";
3241
3242   return "package-private";
3243 }
3244
3245 /* Issuing error messages upon redefinition of classes, interfaces or
3246    variables. */
3247
3248 static void
3249 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3250 {
3251   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3252                        context, IDENTIFIER_POINTER (id),
3253                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3254   /* Here we should point out where its redefined. It's a unicode. FIXME */
3255 }
3256
3257 static void
3258 variable_redefinition_error (tree context, tree name, tree type, int line)
3259 {
3260   const char *type_name;
3261
3262   /* Figure a proper name for type. We might haven't resolved it */
3263   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3264     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3265   else
3266     type_name = lang_printable_name (type, 0);
3267
3268   parse_error_context (context,
3269                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3270                        IDENTIFIER_POINTER (name),
3271                        type_name, IDENTIFIER_POINTER (name), line);
3272 }
3273
3274 /* If ANAME is terminated with `[]', it indicates an array. This
3275    function returns the number of `[]' found and if this number is
3276    greater than zero, it extracts the array type name and places it in
3277    the node pointed to by TRIMMED unless TRIMMED is null.  */
3278
3279 static int
3280 build_type_name_from_array_name (tree aname, tree *trimmed)
3281 {
3282   const char *name = IDENTIFIER_POINTER (aname);
3283   int len = IDENTIFIER_LENGTH (aname);
3284   int array_dims;
3285
3286   STRING_STRIP_BRACKETS (name, len, array_dims);
3287
3288   if (array_dims && trimmed)
3289     *trimmed = get_identifier_with_length (name, len);
3290
3291   return array_dims;
3292 }
3293
3294 static tree
3295 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3296 {
3297   int more_dims = 0;
3298
3299   /* Eventually get more dims */
3300   more_dims = build_type_name_from_array_name (name, &name);
3301
3302   /* If we have, then craft a new type for this variable */
3303   if (more_dims)
3304     {
3305       tree save = type;
3306
3307       /* If we have a pointer, use its type */
3308       if (TREE_CODE (type) == POINTER_TYPE)
3309         type = TREE_TYPE (type);
3310
3311       /* Building the first dimension of a primitive type uses this
3312          function */
3313       if (JPRIMITIVE_TYPE_P (type))
3314         {
3315           type = build_java_array_type (type, -1);
3316           more_dims--;
3317         }
3318       /* Otherwise, if we have a WFL for this type, use it (the type
3319          is already an array on an unresolved type, and we just keep
3320          on adding dimensions) */
3321       else if (type_wfl)
3322         {
3323           type = type_wfl;
3324           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3325                                                         NULL);
3326         }
3327
3328       /* Add all the dimensions */
3329       while (more_dims--)
3330         type = build_unresolved_array_type (type);
3331
3332       /* The type may have been incomplete in the first place */
3333       if (type_wfl)
3334         type = obtain_incomplete_type (type);
3335     }
3336
3337   if (ret_name)
3338     *ret_name = name;
3339   return type;
3340 }
3341
3342 /* Build something that the type identifier resolver will identify as
3343    being an array to an unresolved type. TYPE_WFL is a WFL on a
3344    identifier. */
3345
3346 static tree
3347 build_unresolved_array_type (tree type_or_wfl)
3348 {
3349   const char *ptr;
3350   tree wfl;
3351
3352   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3353      just create a array type */
3354   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3355     return build_java_array_type (type_or_wfl, -1);
3356
3357   obstack_grow (&temporary_obstack,
3358                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3359                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3360   obstack_grow0 (&temporary_obstack, "[]", 2);
3361   ptr = obstack_finish (&temporary_obstack);
3362   wfl = build_expr_wfl (get_identifier (ptr),
3363                         EXPR_WFL_FILENAME (type_or_wfl),
3364                         EXPR_WFL_LINENO (type_or_wfl),
3365                         EXPR_WFL_COLNO (type_or_wfl));
3366   /* Re-install the existing qualifications so that the type can be
3367      resolved properly. */
3368   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3369   return wfl;
3370 }
3371
3372 static void
3373 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3374 {
3375   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3376     parse_error_context (wfl, "Interface `%s' repeated",
3377                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3378 }
3379
3380 /* Bulk of common class/interface checks. Return 1 if an error was
3381    encountered. TAG is 0 for a class, 1 for an interface.  */
3382
3383 static int
3384 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3385                                 tree qualified_name, tree decl, tree cl)
3386 {
3387   tree node;
3388   int sca = 0;                  /* Static class allowed */
3389   int icaf = 0;                 /* Inner class allowed flags */
3390   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3391
3392   if (!quiet_flag)
3393     fprintf (stderr, " %s%s %s",
3394              (CPC_INNER_P () ? "inner" : ""),
3395              (is_interface ? "interface" : "class"),
3396              IDENTIFIER_POINTER (qualified_name));
3397
3398   /* Scope of an interface/class type name:
3399        - Can't be imported by a single type import
3400        - Can't already exists in the package */
3401   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3402       && (node = find_name_in_single_imports (raw_name))
3403       && !CPC_INNER_P ())
3404     {
3405       parse_error_context
3406         (cl, "%s name `%s' clashes with imported type `%s'",
3407          (is_interface ? "Interface" : "Class"),
3408          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3409       return 1;
3410     }
3411   if (decl && CLASS_COMPLETE_P (decl))
3412     {
3413       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3414                                    qualified_name, decl, cl);
3415       return 1;
3416     }
3417
3418   if (check_inner_class_redefinition (raw_name, cl))
3419     return 1;
3420
3421   /* If public, file name should match class/interface name, except
3422      when dealing with an inner class */
3423   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3424     {
3425       const char *f;
3426
3427       for (f = &input_filename [strlen (input_filename)];
3428            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3429            f--)
3430         ;
3431       if (IS_DIR_SEPARATOR (f[0]))
3432         f++;
3433       if (strncmp (IDENTIFIER_POINTER (raw_name),
3434                    f , IDENTIFIER_LENGTH (raw_name)) ||
3435           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3436         parse_error_context
3437           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3438                              (is_interface ? "interface" : "class"),
3439                              IDENTIFIER_POINTER (qualified_name),
3440                              IDENTIFIER_POINTER (raw_name));
3441     }
3442
3443   /* Static classes can be declared only in top level classes. Note:
3444      once static, a inner class is a top level class. */
3445   if (flags & ACC_STATIC)
3446     {
3447       /* Catch the specific error of declaring an class inner class
3448          with no toplevel enclosing class. Prevent check_modifiers from
3449          complaining a second time */
3450       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3451         {
3452           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3453                                IDENTIFIER_POINTER (qualified_name));
3454           sca = ACC_STATIC;
3455         }
3456       /* Else, in the context of a top-level class declaration, let
3457          `check_modifiers' do its job, otherwise, give it a go */
3458       else
3459         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3460     }
3461
3462   /* Inner classes can be declared private or protected
3463      within their enclosing classes. */
3464   if (CPC_INNER_P ())
3465     {
3466       /* A class which is local to a block can't be public, private,
3467          protected or static. But it is created final, so allow this
3468          one. */
3469       if (current_function_decl)
3470         icaf = sca = uaaf = ACC_FINAL;
3471       else
3472         {
3473           check_modifiers_consistency (flags);
3474           icaf = ACC_PROTECTED;
3475           if (! CLASS_INTERFACE (GET_CPC ()))
3476             icaf |= ACC_PRIVATE;
3477         }
3478     }
3479
3480   if (is_interface)
3481     {
3482       if (CPC_INNER_P ())
3483         uaaf = INTERFACE_INNER_MODIFIERS;
3484       else
3485         uaaf = INTERFACE_MODIFIERS;
3486
3487       check_modifiers ("Illegal modifier `%s' for interface declaration",
3488                        flags, uaaf);
3489     }
3490   else
3491     check_modifiers ((current_function_decl ?
3492                       "Illegal modifier `%s' for local class declaration" :
3493                       "Illegal modifier `%s' for class declaration"),
3494                      flags, uaaf|sca|icaf);
3495   return 0;
3496 }
3497
3498 /* Construct a nested class name.  If the final component starts with
3499    a digit, return true.  Otherwise return false.  */
3500 static int
3501 make_nested_class_name (tree cpc_list)
3502 {
3503   tree name;
3504
3505   if (!cpc_list)
3506     return 0;
3507
3508   make_nested_class_name (TREE_CHAIN (cpc_list));
3509
3510   /* Pick the qualified name when dealing with the first upmost
3511      enclosing class */
3512   name = (TREE_CHAIN (cpc_list)
3513           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3514   obstack_grow (&temporary_obstack,
3515                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3516   obstack_1grow (&temporary_obstack, '$');
3517
3518   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3519 }
3520
3521 /* Can't redefine a class already defined in an earlier scope. */
3522
3523 static int
3524 check_inner_class_redefinition (tree raw_name, tree cl)
3525 {
3526   tree scope_list;
3527
3528   for (scope_list = GET_CPC_LIST (); scope_list;
3529        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3530     if (raw_name == GET_CPC_UN_NODE (scope_list))
3531       {
3532         parse_error_context
3533           (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3534            IDENTIFIER_POINTER (raw_name));
3535         return 1;
3536       }
3537   return 0;
3538 }
3539
3540 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3541    we remember ENCLOSING and SUPER.  */
3542
3543 static tree
3544 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3545                      tree *super, tree class_type)
3546 {
3547   tree local_enclosing = *enclosing;
3548   tree local_super = NULL_TREE;
3549
3550   while (local_enclosing)
3551     {
3552       tree intermediate, decl;
3553
3554       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3555         local_enclosing;
3556
3557       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3558         return decl;
3559
3560       intermediate = local_enclosing;
3561       /* Explore enclosing contexts. */
3562       while (INNER_CLASS_DECL_P (intermediate))
3563         {
3564           intermediate = DECL_CONTEXT (intermediate);
3565           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3566             return decl;
3567         }
3568
3569       /* Now go to the upper classes, bail out if necessary.  We will
3570          analyze the returned SUPER and act accordingly (see
3571          do_resolve_class).  */
3572       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3573           || TREE_TYPE (local_enclosing) == void_type_node)
3574         {
3575           parse_error_context (cl, "Qualifier must be a reference");
3576           local_enclosing = NULL_TREE;
3577           break;
3578         }
3579       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3580       if (!local_super || local_super == object_type_node)
3581         break;
3582
3583       if (TREE_CODE (local_super) == POINTER_TYPE)
3584         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3585       else
3586         local_super = TYPE_NAME (local_super);
3587
3588       /* We may not have checked for circular inheritance yet, so do so
3589          here to prevent an infinite loop. */
3590       if (htab_find (circularity_hash, local_super) != NULL)
3591         {
3592           if (!cl)
3593             cl = lookup_cl (local_enclosing);
3594
3595           parse_error_context
3596             (cl, "Cyclic inheritance involving %s",
3597              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3598           local_enclosing = NULL_TREE;
3599         }
3600       else
3601         local_enclosing = local_super;
3602     }
3603
3604   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3605   *super = local_super;
3606   *enclosing = local_enclosing;
3607
3608   return NULL_TREE;
3609 }
3610
3611 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3612    qualified. */
3613
3614 static tree
3615 find_as_inner_class (tree enclosing, tree name, tree cl)
3616 {
3617   tree qual, to_return;
3618   if (!enclosing)
3619     return NULL_TREE;
3620
3621   name = TYPE_NAME (name);
3622
3623   /* First search: within the scope of `enclosing', search for name */
3624   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3625     qual = EXPR_WFL_QUALIFICATION (cl);
3626   else if (cl)
3627     qual = build_tree_list (cl, NULL_TREE);
3628   else
3629     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3630
3631   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3632     return to_return;
3633
3634   /* We're dealing with a qualified name. Try to resolve thing until
3635      we get something that is an enclosing class. */
3636   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3637     {
3638       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3639
3640       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3641            qual = TREE_CHAIN (qual))
3642         {
3643           acc = merge_qualified_name (acc,
3644                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3645           BUILD_PTR_FROM_NAME (ptr, acc);
3646           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3647         }
3648
3649       /* A NULL qual and a decl means that the search ended
3650          successfully?!? We have to do something then. FIXME */
3651
3652       if (decl)
3653         enclosing = decl;
3654       else
3655         qual = EXPR_WFL_QUALIFICATION (cl);
3656     }
3657   /* Otherwise, create a qual for the other part of the resolution. */
3658   else
3659     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3660
3661   return find_as_inner_class_do (qual, enclosing);
3662 }
3663
3664 /* We go inside the list of sub classes and try to find a way
3665    through. */
3666
3667 static tree
3668 find_as_inner_class_do (tree qual, tree enclosing)
3669 {
3670   if (!qual)
3671     return NULL_TREE;
3672
3673   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3674     {
3675       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3676       tree next_enclosing = NULL_TREE;
3677       tree inner_list;
3678
3679       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3680            inner_list; inner_list = TREE_CHAIN (inner_list))
3681         {
3682           if (TREE_VALUE (inner_list) == name_to_match)
3683             {
3684               next_enclosing = TREE_PURPOSE (inner_list);
3685               break;
3686             }
3687         }
3688       enclosing = next_enclosing;
3689     }
3690
3691   return (!qual && enclosing ? enclosing : NULL_TREE);
3692 }
3693
3694 static void
3695 link_nested_class_to_enclosing (void)
3696 {
3697   if (GET_ENCLOSING_CPC ())
3698     {
3699       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3700       DECL_INNER_CLASS_LIST (enclosing) =
3701         tree_cons (GET_CPC (), GET_CPC_UN (),
3702                    DECL_INNER_CLASS_LIST (enclosing));
3703     }
3704 }
3705
3706 static tree
3707 maybe_make_nested_class_name (tree name)
3708 {
3709   tree id = NULL_TREE;
3710
3711   if (CPC_INNER_P ())
3712     {
3713       /* If we're in a function, we must append a number to create the
3714          nested class name.  However, we don't do this if the class we
3715          are constructing is anonymous, because in that case we'll
3716          already have a number as the class name.  */
3717       if (! make_nested_class_name (GET_CPC_LIST ())
3718           && current_function_decl != NULL_TREE
3719           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3720         {
3721           char buf[10];
3722           sprintf (buf, "%d", anonymous_class_counter);
3723           ++anonymous_class_counter;
3724           obstack_grow (&temporary_obstack, buf, strlen (buf));
3725           obstack_1grow (&temporary_obstack, '$');
3726         }
3727       obstack_grow0 (&temporary_obstack,
3728                      IDENTIFIER_POINTER (name),
3729                      IDENTIFIER_LENGTH (name));
3730       id = get_identifier (obstack_finish (&temporary_obstack));
3731       if (ctxp->package)
3732         QUALIFIED_P (id) = 1;
3733     }
3734   return id;
3735 }
3736
3737 /* If DECL is NULL, create and push a new DECL, record the current
3738    line CL and do other maintenance things.  */
3739
3740 static tree
3741 maybe_create_class_interface_decl (tree decl, tree raw_name,
3742                                    tree qualified_name, tree cl)
3743 {
3744   if (!decl)
3745     decl = push_class (make_class (), qualified_name);
3746
3747   /* Take care of the file and line business */
3748   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3749   /* If we're emitting xrefs, store the line/col number information */
3750   if (flag_emit_xref)
3751     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3752   else
3753     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3754   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3755   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3756   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3757     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3758
3759   PUSH_CPC (decl, raw_name);
3760   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3761
3762   /* Link the declaration to the already seen ones */
3763   TREE_CHAIN (decl) = ctxp->class_list;
3764   ctxp->class_list = decl;
3765
3766   /* Create a new nodes in the global lists */
3767   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3768   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3769
3770   /* Install a new dependency list element */
3771   create_jdep_list (ctxp);
3772
3773   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3774                           IDENTIFIER_POINTER (qualified_name)));
3775   return decl;
3776 }
3777
3778 static void
3779 add_superinterfaces (tree decl, tree interface_list)
3780 {
3781   tree node;
3782   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3783      takes care of ensuring that:
3784        - This is an accessible interface type,
3785        - Circularity detection.
3786    parser_add_interface is then called. If present but not defined,
3787    the check operation is delayed until the super interface gets
3788    defined.  */
3789   for (node = interface_list; node; node = TREE_CHAIN (node))
3790     {
3791       tree current = TREE_PURPOSE (node);
3792       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3793       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3794         {
3795           if (!parser_check_super_interface (idecl, decl, current))
3796             parser_add_interface (decl, idecl, current);
3797         }
3798       else
3799         register_incomplete_type (JDEP_INTERFACE,
3800                                   current, decl, NULL_TREE);
3801     }
3802 }
3803
3804 /* Create an interface in pass1 and return its decl. Return the
3805    interface's decl in pass 2.  */
3806
3807 static tree
3808 create_interface (int flags, tree id, tree super)
3809 {
3810   tree raw_name = EXPR_WFL_NODE (id);
3811   tree q_name = parser_qualified_classname (raw_name);
3812   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3813
3814   /* Certain syntax errors are making SUPER be like ID. Avoid this
3815      case. */
3816   if (ctxp->class_err && id == super)
3817     super = NULL;
3818
3819   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3820
3821   /* Basic checks: scope, redefinition, modifiers */
3822   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3823     {
3824       PUSH_ERROR ();
3825       return NULL_TREE;
3826     }
3827
3828   /* Suspend the current parsing context if we're parsing an inner
3829      interface */
3830   if (CPC_INNER_P ())
3831     {
3832       java_parser_context_suspend ();
3833       /* Interface members are public. */
3834       if (CLASS_INTERFACE (GET_CPC ()))
3835         flags |= ACC_PUBLIC;
3836     }
3837
3838   /* Push a new context for (static) initialized upon declaration fields */
3839   java_parser_context_push_initialized_field ();
3840
3841   /* Interface modifiers check
3842        - public/abstract allowed (already done at that point)
3843        - abstract is obsolete (comes first, it's a warning, or should be)
3844        - Can't use twice the same (checked in the modifier rule) */
3845   if ((flags & ACC_ABSTRACT) && flag_redundant)
3846     parse_warning_context
3847       (MODIFIER_WFL (ABSTRACT_TK),
3848        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3849
3850   /* Create a new decl if DECL is NULL, otherwise fix it */
3851   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3852
3853   /* Interfaces are always abstract. */
3854   flags |= ACC_ABSTRACT;
3855
3856   /* Inner interfaces are always static.  */
3857   if (INNER_CLASS_DECL_P (decl))
3858     flags |= ACC_STATIC;
3859
3860   /* Set super info and mark the class a complete */
3861   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3862                   object_type_node, ctxp->interface_number);
3863   ctxp->interface_number = 0;
3864   CLASS_COMPLETE_P (decl) = 1;
3865   add_superinterfaces (decl, super);
3866
3867   /* Eventually sets the @deprecated tag flag */
3868   CHECK_DEPRECATED (decl);
3869
3870   return decl;
3871 }
3872
3873 /* Patch anonymous class CLASS, by either extending or implementing
3874    DEP.  */
3875
3876 static void
3877 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3878 {
3879   tree class = TREE_TYPE (class_decl);
3880   tree type =  TREE_TYPE (type_decl);
3881   tree binfo = TYPE_BINFO (class);
3882
3883   /* If it's an interface, implement it */
3884   if (CLASS_INTERFACE (type_decl))
3885     {
3886       tree s_binfo;
3887       int length;
3888
3889       if (parser_check_super_interface (type_decl, class_decl, wfl))
3890         return;
3891
3892       s_binfo = TREE_VEC_ELT (BINFO_BASE_BINFOS (TYPE_BINFO (class)), 0);
3893       length = TREE_VEC_LENGTH (BINFO_BASE_BINFOS (TYPE_BINFO (class)))+1;
3894       BINFO_BASE_BINFOS (TYPE_BINFO (class)) = make_tree_vec (length);
3895       TREE_VEC_ELT (BINFO_BASE_BINFOS (TYPE_BINFO (class)), 0) = s_binfo;
3896       /* And add the interface */
3897       parser_add_interface (class_decl, type_decl, wfl);
3898     }
3899   /* Otherwise, it's a type we want to extend */
3900   else
3901     {
3902       if (parser_check_super (type_decl, class_decl, wfl))
3903         return;
3904       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASE_BINFOS (binfo), 0)) = type;
3905     }
3906 }
3907
3908 /* Create an anonymous class which extends/implements TYPE_NAME, and return
3909    its decl.  */
3910
3911 static tree
3912 create_anonymous_class (tree type_name)
3913 {
3914   char buffer [80];
3915   tree super = NULL_TREE, itf = NULL_TREE;
3916   tree id, type_decl, class;
3917
3918   /* The unqualified name of the anonymous class. It's just a number. */
3919   sprintf (buffer, "%d", anonymous_class_counter++);
3920   id = build_wfl_node (get_identifier (buffer));
3921   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
3922
3923   /* We know about the type to extend/implement. We go ahead */
3924   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3925     {
3926       /* Create a class which either implements on extends the designated
3927          class. The class bears an inaccessible name. */
3928       if (CLASS_INTERFACE (type_decl))
3929         {
3930           /* It's OK to modify it here. It's been already used and
3931              shouldn't be reused */
3932           ctxp->interface_number = 1;
3933           /* Interfaces should presented as a list of WFLs */
3934           itf = build_tree_list (type_name, NULL_TREE);
3935         }
3936       else
3937         super = type_name;
3938     }
3939
3940   class = create_class (ACC_FINAL, id, super, itf);
3941
3942   /* We didn't know anything about the stuff. We register a dependence. */
3943   if (!type_decl)
3944     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3945
3946   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3947   return class;
3948 }
3949
3950 /* Create a class in pass1 and return its decl. Return class
3951    interface's decl in pass 2.  */
3952
3953 static tree
3954 create_class (int flags, tree id, tree super, tree interfaces)
3955 {
3956   tree raw_name = EXPR_WFL_NODE (id);
3957   tree class_id, decl;
3958   tree super_decl_type;
3959
3960   /* Certain syntax errors are making SUPER be like ID. Avoid this
3961      case. */
3962   if (ctxp->class_err && id == super)
3963     super = NULL;
3964
3965   class_id = parser_qualified_classname (raw_name);
3966   decl = IDENTIFIER_CLASS_VALUE (class_id);
3967   EXPR_WFL_NODE (id) = class_id;
3968
3969   /* Basic check: scope, redefinition, modifiers */
3970   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3971     {
3972       PUSH_ERROR ();
3973       return NULL_TREE;
3974     }
3975
3976   /* Suspend the current parsing context if we're parsing an inner
3977      class or an anonymous class. */
3978   if (CPC_INNER_P ())
3979     {
3980       java_parser_context_suspend ();
3981       /* Interface members are public. */
3982       if (CLASS_INTERFACE (GET_CPC ()))
3983         flags |= ACC_PUBLIC;
3984     }
3985
3986   /* Push a new context for (static) initialized upon declaration fields */