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 array_type
 547                         array_creation_initialized array_creation_uninitialized
 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                   $$ = build3 (SWITCH_EXPR, NULL_TREE, $3,
1589                                NULL_TREE, NULL_TREE);
1590                   EXPR_WFL_LINECOL ($$) = $2.location;
1591                 }
1592 |       SWITCH_TK error
1593                 {yyerror ("'(' expected"); RECOVER;}
1594 |       SWITCH_TK OP_TK error
1595                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1596 |       SWITCH_TK OP_TK expression CP_TK error
1597                 {yyerror ("'{' expected"); RECOVER;}
1598 ;
1599
1600 /* Default assignment is there to avoid type node on switch_block
1601    node. */
1602
1603 switch_block:
1604         OCB_TK CCB_TK
1605                 { $$ = NULL_TREE; }
1606 |       OCB_TK switch_labels CCB_TK
1607                 { $$ = NULL_TREE; }
1608 |       OCB_TK switch_block_statement_groups CCB_TK
1609                 { $$ = NULL_TREE; }
1610 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1611                 { $$ = NULL_TREE; }
1612 ;
1613
1614 switch_block_statement_groups:
1615         switch_block_statement_group
1616 |       switch_block_statement_groups switch_block_statement_group
1617 ;
1618
1619 switch_block_statement_group:
1620         switch_labels block_statements
1621 ;
1622
1623 switch_labels:
1624         switch_label
1625 |       switch_labels switch_label
1626 ;
1627
1628 switch_label:
1629         CASE_TK constant_expression REL_CL_TK
1630                 {
1631                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1632                   EXPR_WFL_LINECOL (lab) = $1.location;
1633                   java_method_add_stmt (current_function_decl, lab);
1634                 }
1635 |       DEFAULT_TK REL_CL_TK
1636                 {
1637                   tree lab = make_node (DEFAULT_EXPR);
1638                   EXPR_WFL_LINECOL (lab) = $1.location;
1639                   java_method_add_stmt (current_function_decl, lab);
1640                 }
1641 |       CASE_TK error
1642                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1643 |       CASE_TK constant_expression error
1644                 {yyerror ("':' expected"); RECOVER;}
1645 |       DEFAULT_TK error
1646                 {yyerror ("':' expected"); RECOVER;}
1647 ;
1648
1649 while_expression:
1650         WHILE_TK OP_TK expression CP_TK
1651                 {
1652                   tree body = build_loop_body ($2.location, $3, 0);
1653                   $$ = build_new_loop (body);
1654                 }
1655 ;
1656
1657 while_statement:
1658         while_expression statement
1659                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1660 |       WHILE_TK error
1661                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1662 |       WHILE_TK OP_TK error
1663                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1664 |       WHILE_TK OP_TK expression error
1665                 {yyerror ("')' expected"); RECOVER;}
1666 ;
1667
1668 while_statement_nsi:
1669         while_expression statement_nsi
1670                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1671 ;
1672
1673 do_statement_begin:
1674         DO_TK
1675                 {
1676                   tree body = build_loop_body (0, NULL_TREE, 1);
1677                   $$ = build_new_loop (body);
1678                 }
1679         /* Need error handing here. FIXME */
1680 ;
1681
1682 do_statement:
1683         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1684                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1685 ;
1686
1687 for_statement:
1688         for_begin SC_TK expression SC_TK for_update CP_TK statement
1689                 {
1690                   if (CONSTANT_CLASS_P ($3))
1691                     $3 = build_wfl_node ($3);
1692                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1693                 }
1694 |       for_begin SC_TK SC_TK for_update CP_TK statement
1695                 {
1696                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1697                   /* We have not condition, so we get rid of the EXIT_EXPR */
1698                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1699                     build_java_empty_stmt ();
1700                 }
1701 |       for_begin SC_TK error
1702                 {yyerror ("Invalid control expression"); RECOVER;}
1703 |       for_begin SC_TK expression SC_TK error
1704                 {yyerror ("Invalid update expression"); RECOVER;}
1705 |       for_begin SC_TK SC_TK error
1706                 {yyerror ("Invalid update expression"); RECOVER;}
1707 ;
1708
1709 for_statement_nsi:
1710         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1711                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1712 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1713                 {
1714                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1715                   /* We have not condition, so we get rid of the EXIT_EXPR */
1716                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1717                     build_java_empty_stmt ();
1718                 }
1719 ;
1720
1721 for_header:
1722         FOR_TK OP_TK
1723                 {
1724                   /* This scope defined for local variable that may be
1725                      defined within the scope of the for loop */
1726                   enter_block ();
1727                 }
1728 |       FOR_TK error
1729                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1730 |       FOR_TK OP_TK error
1731                 {yyerror ("Invalid init statement"); RECOVER;}
1732 ;
1733
1734 for_begin:
1735         for_header for_init
1736                 {
1737                   /* We now declare the loop body. The loop is
1738                      declared as a for loop. */
1739                   tree body = build_loop_body (0, NULL_TREE, 0);
1740                   $$ =  build_new_loop (body);
1741                   FOR_LOOP_P ($$) = 1;
1742                   /* The loop is added to the current block the for
1743                      statement is defined within */
1744                   java_method_add_stmt (current_function_decl, $$);
1745                 }
1746 ;
1747 for_init:                       /* Can be empty */
1748                 { $$ = build_java_empty_stmt (); }
1749 |       statement_expression_list
1750                 {
1751                   /* Init statement recorded within the previously
1752                      defined block scope */
1753                   $$ = java_method_add_stmt (current_function_decl, $1);
1754                 }
1755 |       local_variable_declaration
1756                 {
1757                   /* Local variable are recorded within the previously
1758                      defined block scope */
1759                   $$ = NULL_TREE;
1760                 }
1761 |       statement_expression_list error
1762                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1763 ;
1764
1765 for_update:                     /* Can be empty */
1766                 {$$ = build_java_empty_stmt ();}
1767 |       statement_expression_list
1768                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1769 ;
1770
1771 statement_expression_list:
1772         statement_expression
1773                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1774 |       statement_expression_list C_TK statement_expression
1775                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1776 |       statement_expression_list C_TK error
1777                 {yyerror ("Missing term"); RECOVER;}
1778 ;
1779
1780 break_statement:
1781         BREAK_TK SC_TK
1782                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1783 |       BREAK_TK identifier SC_TK
1784                 { $$ = build_bc_statement ($1.location, 1, $2); }
1785 |       BREAK_TK error
1786                 {yyerror ("Missing term"); RECOVER;}
1787 |       BREAK_TK identifier error
1788                 {yyerror ("';' expected"); RECOVER;}
1789 ;
1790
1791 continue_statement:
1792         CONTINUE_TK SC_TK
1793                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1794 |       CONTINUE_TK identifier SC_TK
1795                 { $$ = build_bc_statement ($1.location, 0, $2); }
1796 |       CONTINUE_TK error
1797                 {yyerror ("Missing term"); RECOVER;}
1798 |       CONTINUE_TK identifier error
1799                 {yyerror ("';' expected"); RECOVER;}
1800 ;
1801
1802 return_statement:
1803         RETURN_TK SC_TK
1804                 { $$ = build_return ($1.location, NULL_TREE); }
1805 |       RETURN_TK expression SC_TK
1806                 { $$ = build_return ($1.location, $2); }
1807 |       RETURN_TK error
1808                 {yyerror ("Missing term"); RECOVER;}
1809 |       RETURN_TK expression error
1810                 {yyerror ("';' expected"); RECOVER;}
1811 ;
1812
1813 throw_statement:
1814         THROW_TK expression SC_TK
1815                 {
1816                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1817                   EXPR_WFL_LINECOL ($$) = $1.location;
1818                 }
1819 |       THROW_TK error
1820                 {yyerror ("Missing term"); RECOVER;}
1821 |       THROW_TK expression error
1822                 {yyerror ("';' expected"); RECOVER;}
1823 ;
1824
1825 assert_statement:
1826         ASSERT_TK expression REL_CL_TK expression SC_TK
1827                 {
1828                   $$ = build_assertion ($1.location, $2, $4);
1829                 }
1830 |       ASSERT_TK expression SC_TK
1831                 {
1832                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1833                 }
1834 |       ASSERT_TK error
1835                 {yyerror ("Missing term"); RECOVER;}
1836 |       ASSERT_TK expression error
1837                 {yyerror ("';' expected"); RECOVER;}
1838 ;
1839
1840 synchronized_statement:
1841         synchronized OP_TK expression CP_TK block
1842                 {
1843                   $$ = build2 (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1844                   EXPR_WFL_LINECOL ($$) =
1845                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1846                 }
1847 |       synchronized OP_TK expression CP_TK error
1848                 {yyerror ("'{' expected"); RECOVER;}
1849 |       synchronized error
1850                 {yyerror ("'(' expected"); RECOVER;}
1851 |       synchronized OP_TK error CP_TK
1852                 {yyerror ("Missing term"); RECOVER;}
1853 |       synchronized OP_TK error
1854                 {yyerror ("Missing term"); RECOVER;}
1855 ;
1856
1857 synchronized:
1858         modifiers
1859                 {
1860                   check_modifiers (
1861              "Illegal modifier `%s'. Only `synchronized' was expected here",
1862                                    $1, ACC_SYNCHRONIZED);
1863                   if ($1 != ACC_SYNCHRONIZED)
1864                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1865                       build_wfl_node (NULL_TREE);
1866                 }
1867 ;
1868
1869 try_statement:
1870         TRY_TK block catches
1871                 { $$ = build_try_statement ($1.location, $2, $3); }
1872 |       TRY_TK block finally
1873                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1874 |       TRY_TK block catches finally
1875                 { $$ = build_try_finally_statement
1876                     ($1.location, build_try_statement ($1.location,
1877                                                        $2, $3), $4);
1878                 }
1879 |       TRY_TK error
1880                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1881 ;
1882
1883 catches:
1884         catch_clause
1885 |       catches catch_clause
1886                 {
1887                   TREE_CHAIN ($2) = $1;
1888                   $$ = $2;
1889                 }
1890 ;
1891
1892 catch_clause:
1893         catch_clause_parameter block
1894                 {
1895                   java_method_add_stmt (current_function_decl, $2);
1896                   exit_block ();
1897                   $$ = $1;
1898                 }
1899 ;
1900
1901 catch_clause_parameter:
1902         CATCH_TK OP_TK formal_parameter CP_TK
1903                 {
1904                   /* We add a block to define a scope for
1905                      formal_parameter (CCBP). The formal parameter is
1906                      declared initialized by the appropriate function
1907                      call */
1908                   tree ccpb;
1909                   tree init;
1910                   if ($3)
1911                     {
1912                       ccpb = enter_block ();
1913                       init = build_assignment
1914                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1915                          build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1916                       declare_local_variables (0, TREE_VALUE ($3),
1917                                                build_tree_list
1918                                                (TREE_PURPOSE ($3), init));
1919                       $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1920                       EXPR_WFL_LINECOL ($$) = $1.location;
1921                     }
1922                   else
1923                     {
1924                       $$ = error_mark_node;
1925                     }
1926                 }
1927 |       CATCH_TK error
1928                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1929 |       CATCH_TK OP_TK error
1930                 {
1931                   yyerror ("Missing term or ')' expected");
1932                   RECOVER; $$ = NULL_TREE;
1933                 }
1934 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1935                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1936 ;
1937
1938 finally:
1939         FINALLY_TK block
1940                 { $$ = $2; }
1941 |       FINALLY_TK error
1942                 {yyerror ("'{' expected"); RECOVER; }
1943 ;
1944
1945 /* 19.12 Production from 15: Expressions  */
1946 primary:
1947         primary_no_new_array
1948 |       array_creation_uninitialized
1949 |       array_creation_initialized
1950 ;
1951
1952 primary_no_new_array:
1953         literal
1954 |       THIS_TK
1955                 { $$ = build_this ($1.location); }
1956 |       OP_TK expression CP_TK
1957                 {$$ = $2;}
1958 |       class_instance_creation_expression
1959 |       field_access
1960 |       method_invocation
1961 |       array_access
1962 |       type_literals
1963         /* Added, JDK1.1 inner classes. Documentation is wrong
1964            refering to a 'ClassName' (class_name) rule that doesn't
1965            exist. Used name: instead.  */
1966 |       name DOT_TK THIS_TK
1967                 {
1968                   tree wfl = build_wfl_node (this_identifier_node);
1969                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1970                 }
1971 |       OP_TK expression error
1972                 {yyerror ("')' expected"); RECOVER;}
1973 |       name DOT_TK error
1974                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1975 |       primitive_type DOT_TK error
1976                 {yyerror ("'class' expected" ); RECOVER;}
1977 |       VOID_TK DOT_TK error
1978                 {yyerror ("'class' expected" ); RECOVER;}
1979 ;
1980
1981 type_literals:
1982         name DOT_TK CLASS_TK
1983                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1984 |       array_type DOT_TK CLASS_TK
1985                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1986 |       primitive_type DOT_TK CLASS_TK
1987                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1988 |       VOID_TK DOT_TK CLASS_TK
1989                 {
1990                    $$ = build_incomplete_class_ref ($2.location,
1991                                                    void_type_node);
1992                 }
1993 ;
1994
1995 class_instance_creation_expression:
1996         NEW_TK class_type OP_TK argument_list CP_TK
1997                 { $$ = build_new_invocation ($2, $4); }
1998 |       NEW_TK class_type OP_TK CP_TK
1999                 { $$ = build_new_invocation ($2, NULL_TREE); }
2000 |       anonymous_class_creation
2001         /* Added, JDK1.1 inner classes, modified to use name or
2002            primary instead of primary solely which couldn't work in
2003            all situations.  */
2004 |       something_dot_new identifier OP_TK CP_TK
2005                 {
2006                   tree ctor = build_new_invocation ($2, NULL_TREE);
2007                   $$ = make_qualified_primary ($1, ctor,
2008                                                EXPR_WFL_LINECOL ($1));
2009                 }
2010 |       something_dot_new identifier OP_TK CP_TK class_body
2011 |       something_dot_new identifier OP_TK argument_list CP_TK
2012                 {
2013                   tree ctor = build_new_invocation ($2, $4);
2014                   $$ = make_qualified_primary ($1, ctor,
2015                                                EXPR_WFL_LINECOL ($1));
2016                 }
2017 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2018 |       NEW_TK error SC_TK
2019                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2020 |       NEW_TK class_type error
2021                 {yyerror ("'(' expected"); RECOVER;}
2022 |       NEW_TK class_type OP_TK error
2023                 {yyerror ("')' or term expected"); RECOVER;}
2024 |       NEW_TK class_type OP_TK argument_list error
2025                 {yyerror ("')' expected"); RECOVER;}
2026 |       something_dot_new error
2027                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2028 |       something_dot_new identifier error
2029                 {yyerror ("'(' expected"); RECOVER;}
2030 ;
2031
2032 /* Created after JDK1.1 rules originally added to
2033    class_instance_creation_expression, but modified to use
2034    'class_type' instead of 'TypeName' (type_name) which is mentioned
2035    in the documentation but doesn't exist. */
2036
2037 anonymous_class_creation:
2038         NEW_TK class_type OP_TK argument_list CP_TK
2039                 { create_anonymous_class ($2); }
2040         class_body
2041                 {
2042                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2043                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2044
2045                   end_class_declaration (1);
2046
2047                   /* Now we can craft the new expression */
2048                   $$ = build_new_invocation (id, $4);
2049
2050                   /* Note that we can't possibly be here if
2051                      `class_type' is an interface (in which case the
2052                      anonymous class extends Object and implements
2053                      `class_type', hence its constructor can't have
2054                      arguments.) */
2055
2056                   /* Otherwise, the innerclass must feature a
2057                      constructor matching `argument_list'. Anonymous
2058                      classes are a bit special: it's impossible to
2059                      define constructor for them, hence constructors
2060                      must be generated following the hints provided by
2061                      the `new' expression. Whether a super constructor
2062                      of that nature exists or not is to be verified
2063                      later on in verify_constructor_super.
2064
2065                      It's during the expansion of a `new' statement
2066                      refering to an anonymous class that a ctor will
2067                      be generated for the anonymous class, with the
2068                      right arguments. */
2069
2070                 }
2071 |       NEW_TK class_type OP_TK CP_TK
2072                 { create_anonymous_class ($2); }
2073         class_body
2074                 {
2075                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2076                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2077
2078                   end_class_declaration (1);
2079
2080                   /* Now we can craft the new expression. The
2081                      statement doesn't need to be remember so that a
2082                      constructor can be generated, since its signature
2083                      is already known. */
2084                   $$ = build_new_invocation (id, NULL_TREE);
2085                 }
2086 ;
2087
2088 something_dot_new:              /* Added, not part of the specs. */
2089         name DOT_TK NEW_TK
2090                 { $$ = $1; }
2091 |       primary DOT_TK NEW_TK
2092                 { $$ = $1; }
2093 ;
2094
2095 argument_list:
2096         expression
2097                 {
2098                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2099                   ctxp->formal_parameter_number = 1;
2100                 }
2101 |       argument_list C_TK expression
2102                 {
2103                   ctxp->formal_parameter_number += 1;
2104                   $$ = tree_cons (NULL_TREE, $3, $1);
2105                 }
2106 |       argument_list C_TK error
2107                 {yyerror ("Missing term"); RECOVER;}
2108 ;
2109
2110 array_creation_uninitialized:
2111         NEW_TK primitive_type dim_exprs
2112                 { $$ = build_newarray_node ($2, $3, 0); }
2113 |       NEW_TK class_or_interface_type dim_exprs
2114                 { $$ = build_newarray_node ($2, $3, 0); }
2115 |       NEW_TK primitive_type dim_exprs dims
2116                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2117 |       NEW_TK class_or_interface_type dim_exprs dims
2118                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2119 |       NEW_TK error CSB_TK
2120                 {yyerror ("'[' expected"); DRECOVER ("]");}
2121 |       NEW_TK error OSB_TK
2122                 {yyerror ("']' expected"); RECOVER;}
2123 ;
2124
2125 array_creation_initialized:
2126         /* Added, JDK1.1 anonymous array. Initial documentation rule
2127            modified */
2128         NEW_TK class_or_interface_type dims array_initializer
2129                 {
2130                   char *sig;
2131                   int osb = pop_current_osb (ctxp);
2132                   while (osb--)
2133                     obstack_grow (&temporary_obstack, "[]", 2);
2134                   obstack_1grow (&temporary_obstack, '\0');
2135                   sig = obstack_finish (&temporary_obstack);
2136                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2137                                $2, get_identifier (sig), $4);
2138                 }
2139 |       NEW_TK primitive_type dims array_initializer
2140                 {
2141                   int osb = pop_current_osb (ctxp);
2142                   tree type = $2;
2143                   while (osb--)
2144                     type = build_java_array_type (type, -1);
2145                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2146                                build_pointer_type (type), NULL_TREE, $4);
2147                 }
2148 |       NEW_TK error CSB_TK
2149                 {yyerror ("'[' expected"); DRECOVER ("]");}
2150 |       NEW_TK error OSB_TK
2151                 {yyerror ("']' expected"); RECOVER;}
2152 ;
2153
2154 dim_exprs:
2155         dim_expr
2156                 { $$ = build_tree_list (NULL_TREE, $1); }
2157 |       dim_exprs dim_expr
2158                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2159 ;
2160
2161 dim_expr:
2162         OSB_TK expression CSB_TK
2163                 {
2164                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2165                     {
2166                       $2 = build_wfl_node ($2);
2167                       TREE_TYPE ($2) = NULL_TREE;
2168                     }
2169                   EXPR_WFL_LINECOL ($2) = $1.location;
2170                   $$ = $2;
2171                 }
2172 |       OSB_TK expression error
2173                 {yyerror ("']' expected"); RECOVER;}
2174 |       OSB_TK error
2175                 {
2176                   yyerror ("Missing term");
2177                   yyerror ("']' expected");
2178                   RECOVER;
2179                 }
2180 ;
2181
2182 dims:
2183         OSB_TK CSB_TK
2184                 {
2185                   int allocate = 0;
2186                   /* If not initialized, allocate memory for the osb
2187                      numbers stack */
2188                   if (!ctxp->osb_limit)
2189                     {
2190                       allocate = ctxp->osb_limit = 32;
2191                       ctxp->osb_depth = -1;
2192                     }
2193                   /* If capacity overflown, reallocate a bigger chunk */
2194                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2195                     allocate = ctxp->osb_limit << 1;
2196
2197                   if (allocate)
2198                     {
2199                       allocate *= sizeof (int);
2200                       if (ctxp->osb_number)
2201                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2202                                                      allocate);
2203                       else
2204                         ctxp->osb_number = xmalloc (allocate);
2205                     }
2206                   ctxp->osb_depth++;
2207                   CURRENT_OSB (ctxp) = 1;
2208                 }
2209 |       dims OSB_TK CSB_TK
2210                 { CURRENT_OSB (ctxp)++; }
2211 |       dims OSB_TK error
2212                 { yyerror ("']' expected"); RECOVER;}
2213 ;
2214
2215 field_access:
2216         primary DOT_TK identifier
2217                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2218                 /*  FIXME - REWRITE TO:
2219                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2220 |       SUPER_TK DOT_TK identifier
2221                 {
2222                   tree super_wfl = build_wfl_node (super_identifier_node);
2223                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2224                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2225                 }
2226 |       SUPER_TK error
2227                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2228 ;
2229
2230 method_invocation:
2231         name OP_TK CP_TK
2232                 { $$ = build_method_invocation ($1, NULL_TREE); }
2233 |       name OP_TK argument_list CP_TK
2234                 { $$ = build_method_invocation ($1, $3); }
2235 |       primary DOT_TK identifier OP_TK CP_TK
2236                 {
2237                   if (TREE_CODE ($1) == THIS_EXPR)
2238                     $$ = build_this_super_qualified_invocation
2239                       (1, $3, NULL_TREE, 0, $2.location);
2240                   else
2241                     {
2242                       tree invok = build_method_invocation ($3, NULL_TREE);
2243                       $$ = make_qualified_primary ($1, invok, $2.location);
2244                     }
2245                 }
2246 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2247                 {
2248                   if (TREE_CODE ($1) == THIS_EXPR)
2249                     $$ = build_this_super_qualified_invocation
2250                       (1, $3, $5, 0, $2.location);
2251                   else
2252                     {
2253                       tree invok = build_method_invocation ($3, $5);
2254                       $$ = make_qualified_primary ($1, invok, $2.location);
2255                     }
2256                 }
2257 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2258                 {
2259                   $$ = build_this_super_qualified_invocation
2260                     (0, $3, NULL_TREE, $1.location, $2.location);
2261                 }
2262 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2263                 {
2264                   $$ = build_this_super_qualified_invocation
2265                     (0, $3, $5, $1.location, $2.location);
2266                 }
2267         /* Screws up thing. I let it here until I'm convinced it can
2268            be removed. FIXME
2269 |       primary DOT_TK error
2270                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2271 |       SUPER_TK DOT_TK error CP_TK
2272                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2273 |       SUPER_TK DOT_TK error DOT_TK
2274                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2275 ;
2276
2277 array_access:
2278         name OSB_TK expression CSB_TK
2279                 { $$ = build_array_ref ($2.location, $1, $3); }
2280 |       primary_no_new_array OSB_TK expression CSB_TK
2281                 { $$ = build_array_ref ($2.location, $1, $3); }
2282 |       array_creation_initialized OSB_TK expression CSB_TK
2283                 { $$ = build_array_ref ($2.location, $1, $3); }
2284 |       name OSB_TK error
2285                 {
2286                   yyerror ("Missing term and ']' expected");
2287                   DRECOVER(array_access);
2288                 }
2289 |       name OSB_TK expression error
2290                 {
2291                   yyerror ("']' expected");
2292                   DRECOVER(array_access);
2293                 }
2294 |       primary_no_new_array OSB_TK error
2295                 {
2296                   yyerror ("Missing term and ']' expected");
2297                   DRECOVER(array_access);
2298                 }
2299 |       primary_no_new_array OSB_TK expression error
2300                 {
2301                   yyerror ("']' expected");
2302                   DRECOVER(array_access);
2303                 }
2304 |       array_creation_initialized OSB_TK error
2305                 {
2306                   yyerror ("Missing term and ']' expected");
2307                   DRECOVER(array_access);
2308                 }
2309 |       array_creation_initialized OSB_TK expression error
2310                 {
2311                   yyerror ("']' expected");
2312                   DRECOVER(array_access);
2313                 }
2314 ;
2315
2316 postfix_expression:
2317         primary
2318 |       name
2319 |       post_increment_expression
2320 |       post_decrement_expression
2321 ;
2322
2323 post_increment_expression:
2324         postfix_expression INCR_TK
2325                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2326 ;
2327
2328 post_decrement_expression:
2329         postfix_expression DECR_TK
2330                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2331 ;
2332
2333 trap_overflow_corner_case:
2334         pre_increment_expression
2335 |       pre_decrement_expression
2336 |       PLUS_TK unary_expression
2337                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2338 |       unary_expression_not_plus_minus
2339 |       PLUS_TK error
2340                 {yyerror ("Missing term"); RECOVER}
2341 ;
2342
2343 unary_expression:
2344         trap_overflow_corner_case
2345                 {
2346                   error_if_numeric_overflow ($1);
2347                   $$ = $1;
2348                 }
2349 |       MINUS_TK trap_overflow_corner_case
2350                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2351 |       MINUS_TK error
2352                 {yyerror ("Missing term"); RECOVER}
2353 ;
2354
2355 pre_increment_expression:
2356         INCR_TK unary_expression
2357                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2358 |       INCR_TK error
2359                 {yyerror ("Missing term"); RECOVER}
2360 ;
2361
2362 pre_decrement_expression:
2363         DECR_TK unary_expression
2364                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2365 |       DECR_TK error
2366                 {yyerror ("Missing term"); RECOVER}
2367 ;
2368
2369 unary_expression_not_plus_minus:
2370         postfix_expression
2371 |       NOT_TK unary_expression
2372                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2373 |       NEG_TK unary_expression
2374                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2375 |       cast_expression
2376 |       NOT_TK error
2377                 {yyerror ("Missing term"); RECOVER}
2378 |       NEG_TK error
2379                 {yyerror ("Missing term"); RECOVER}
2380 ;
2381
2382 cast_expression:                /* Error handling here is potentially weak */
2383         OP_TK primitive_type dims CP_TK unary_expression
2384                 {
2385                   tree type = $2;
2386                   int osb = pop_current_osb (ctxp);
2387                   while (osb--)
2388                     type = build_java_array_type (type, -1);
2389                   $$ = build_cast ($1.location, type, $5);
2390                 }
2391 |       OP_TK primitive_type CP_TK unary_expression
2392                 { $$ = build_cast ($1.location, $2, $4); }
2393 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2394                 { $$ = build_cast ($1.location, $2, $4); }
2395 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2396                 {
2397                   const char *ptr;
2398                   int osb = pop_current_osb (ctxp);
2399                   obstack_grow (&temporary_obstack,
2400                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2401                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2402                   while (osb--)
2403                     obstack_grow (&temporary_obstack, "[]", 2);
2404                   obstack_1grow (&temporary_obstack, '\0');
2405                   ptr = obstack_finish (&temporary_obstack);
2406                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2407                   $$ = build_cast ($1.location, $2, $5);
2408                 }
2409 |       OP_TK primitive_type OSB_TK error
2410                 {yyerror ("']' expected, invalid type expression");}
2411 |       OP_TK error
2412                 {
2413                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2414                   RECOVER;
2415                 }
2416 |       OP_TK primitive_type dims CP_TK error
2417                 {yyerror ("Missing term"); RECOVER;}
2418 |       OP_TK primitive_type CP_TK error
2419                 {yyerror ("Missing term"); RECOVER;}
2420 |       OP_TK name dims CP_TK error
2421                 {yyerror ("Missing term"); RECOVER;}
2422 ;
2423
2424 multiplicative_expression:
2425         unary_expression
2426 |       multiplicative_expression MULT_TK unary_expression
2427                 {
2428                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2429                                     $2.location, $1, $3);
2430                 }
2431 |       multiplicative_expression DIV_TK unary_expression
2432                 {
2433                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2434                                     $1, $3);
2435                 }
2436 |       multiplicative_expression REM_TK unary_expression
2437                 {
2438                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2439                                     $1, $3);
2440                 }
2441 |       multiplicative_expression MULT_TK error
2442                 {yyerror ("Missing term"); RECOVER;}
2443 |       multiplicative_expression DIV_TK error
2444                 {yyerror ("Missing term"); RECOVER;}
2445 |       multiplicative_expression REM_TK error
2446                 {yyerror ("Missing term"); RECOVER;}
2447 ;
2448
2449 additive_expression:
2450         multiplicative_expression
2451 |       additive_expression PLUS_TK multiplicative_expression
2452                 {
2453                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2454                                     $1, $3);
2455                 }
2456 |       additive_expression MINUS_TK multiplicative_expression
2457                 {
2458                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2459                                     $1, $3);
2460                 }
2461 |       additive_expression PLUS_TK error
2462                 {yyerror ("Missing term"); RECOVER;}
2463 |       additive_expression MINUS_TK error
2464                 {yyerror ("Missing term"); RECOVER;}
2465 ;
2466
2467 shift_expression:
2468         additive_expression
2469 |       shift_expression LS_TK additive_expression
2470                 {
2471                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2472                                     $1, $3);
2473                 }
2474 |       shift_expression SRS_TK additive_expression
2475                 {
2476                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2477                                     $1, $3);
2478                 }
2479 |       shift_expression ZRS_TK additive_expression
2480                 {
2481                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2482                                     $1, $3);
2483                 }
2484 |       shift_expression LS_TK error
2485                 {yyerror ("Missing term"); RECOVER;}
2486 |       shift_expression SRS_TK error
2487                 {yyerror ("Missing term"); RECOVER;}
2488 |       shift_expression ZRS_TK error
2489                 {yyerror ("Missing term"); RECOVER;}
2490 ;
2491
2492 relational_expression:
2493         shift_expression
2494 |       relational_expression LT_TK shift_expression
2495                 {
2496                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2497                                     $1, $3);
2498                 }
2499 |       relational_expression GT_TK shift_expression
2500                 {
2501                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2502                                     $1, $3);
2503                 }
2504 |       relational_expression LTE_TK shift_expression
2505                 {
2506                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2507                                     $1, $3);
2508                 }
2509 |       relational_expression GTE_TK shift_expression
2510                 {
2511                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2512                                     $1, $3);
2513                 }
2514 |       relational_expression INSTANCEOF_TK reference_type
2515                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2516 |       relational_expression LT_TK error
2517                 {yyerror ("Missing term"); RECOVER;}
2518 |       relational_expression GT_TK error
2519                 {yyerror ("Missing term"); RECOVER;}
2520 |       relational_expression LTE_TK error
2521                 {yyerror ("Missing term"); RECOVER;}
2522 |       relational_expression GTE_TK error
2523                 {yyerror ("Missing term"); RECOVER;}
2524 |       relational_expression INSTANCEOF_TK error
2525                 {yyerror ("Invalid reference type"); RECOVER;}
2526 ;
2527
2528 equality_expression:
2529         relational_expression
2530 |       equality_expression EQ_TK relational_expression
2531                 {
2532                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2533                                     $1, $3);
2534                 }
2535 |       equality_expression NEQ_TK relational_expression
2536                 {
2537                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2538                                     $1, $3);
2539                 }
2540 |       equality_expression EQ_TK error
2541                 {yyerror ("Missing term"); RECOVER;}
2542 |       equality_expression NEQ_TK error
2543                 {yyerror ("Missing term"); RECOVER;}
2544 ;
2545
2546 and_expression:
2547         equality_expression
2548 |       and_expression AND_TK equality_expression
2549                 {
2550                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2551                                     $1, $3);
2552                 }
2553 |       and_expression AND_TK error
2554                 {yyerror ("Missing term"); RECOVER;}
2555 ;
2556
2557 exclusive_or_expression:
2558         and_expression
2559 |       exclusive_or_expression XOR_TK and_expression
2560                 {
2561                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2562                                     $1, $3);
2563                 }
2564 |       exclusive_or_expression XOR_TK error
2565                 {yyerror ("Missing term"); RECOVER;}
2566 ;
2567
2568 inclusive_or_expression:
2569         exclusive_or_expression
2570 |       inclusive_or_expression OR_TK exclusive_or_expression
2571                 {
2572                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2573                                     $1, $3);
2574                 }
2575 |       inclusive_or_expression OR_TK error
2576                 {yyerror ("Missing term"); RECOVER;}
2577 ;
2578
2579 conditional_and_expression:
2580         inclusive_or_expression
2581 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2582                 {
2583                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2584                                     $1, $3);
2585                 }
2586 |       conditional_and_expression BOOL_AND_TK error
2587                 {yyerror ("Missing term"); RECOVER;}
2588 ;
2589
2590 conditional_or_expression:
2591         conditional_and_expression
2592 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2593                 {
2594                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2595                                     $1, $3);
2596                 }
2597 |       conditional_or_expression BOOL_OR_TK error
2598                 {yyerror ("Missing term"); RECOVER;}
2599 ;
2600
2601 conditional_expression:         /* Error handling here is weak */
2602         conditional_or_expression
2603 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2604                 {
2605                   $$ = build3 (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2606                   EXPR_WFL_LINECOL ($$) = $2.location;
2607                 }
2608 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2609                 {
2610                   YYERROR_NOW;
2611                   yyerror ("Missing term");
2612                   DRECOVER (1);
2613                 }
2614 |       conditional_or_expression REL_QM_TK error
2615                 {yyerror ("Missing term"); DRECOVER (2);}
2616 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2617                 {yyerror ("Missing term"); DRECOVER (3);}
2618 ;
2619
2620 assignment_expression:
2621         conditional_expression
2622 |       assignment
2623 ;
2624
2625 assignment:
2626         left_hand_side assignment_operator assignment_expression
2627                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2628 |       left_hand_side assignment_operator error
2629                 {
2630                   YYNOT_TWICE yyerror ("Missing term");
2631                   DRECOVER (assign);
2632                 }
2633 ;
2634
2635 left_hand_side:
2636         name
2637 |       field_access
2638 |       array_access
2639 ;
2640
2641 assignment_operator:
2642         ASSIGN_ANY_TK
2643 |       ASSIGN_TK
2644 ;
2645
2646 expression:
2647         assignment_expression
2648 ;
2649
2650 constant_expression:
2651         expression
2652 ;
2653
2654 %%
2655
2656 /* Helper function to retrieve an OSB count. Should be used when the
2657    `dims:' rule is being used.  */
2658
2659 static int
2660 pop_current_osb (struct parser_ctxt *ctxp)
2661 {
2662   int to_return;
2663
2664   if (ctxp->osb_depth < 0)
2665     abort ();
2666
2667   to_return = CURRENT_OSB (ctxp);
2668   ctxp->osb_depth--;
2669
2670   return to_return;
2671 }
2672
2673 \f
2674
2675 /* This section of the code deal with save/restoring parser contexts.
2676    Add mode documentation here. FIXME */
2677
2678 /* Helper function. Create a new parser context. With
2679    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2680    context is copied, otherwise, the new context is zeroed. The newly
2681    created context becomes the current one.  */
2682
2683 static void
2684 create_new_parser_context (int copy_from_previous)
2685 {
2686   struct parser_ctxt *new;
2687
2688   new = ggc_alloc (sizeof (struct parser_ctxt));
2689   if (copy_from_previous)
2690     {
2691       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2692       /* This flag, indicating the context saves global values,
2693          should only be set by java_parser_context_save_global.  */
2694       new->saved_data_ctx = 0;
2695     }
2696   else
2697     memset (new, 0, sizeof (struct parser_ctxt));
2698
2699   new->next = ctxp;
2700   ctxp = new;
2701 }
2702
2703 /* Create a new parser context and make it the current one. */
2704
2705 void
2706 java_push_parser_context (void)
2707 {
2708   create_new_parser_context (0);
2709 }
2710
2711 void
2712 java_pop_parser_context (int generate)
2713 {
2714   tree current;
2715   struct parser_ctxt *toFree, *next;
2716
2717   if (!ctxp)
2718     return;
2719
2720   toFree = ctxp;
2721   next = ctxp->next;
2722   if (next)
2723     {
2724       input_line = ctxp->lineno;
2725       current_class = ctxp->class_type;
2726     }
2727
2728   /* If the old and new lexers differ, then free the old one.  */
2729   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2730     java_destroy_lexer (ctxp->lexer);
2731
2732   /* Set the single import class file flag to 0 for the current list
2733      of imported things */
2734   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2735     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2736
2737   /* And restore those of the previous context */
2738   if ((ctxp = next))            /* Assignment is really meant here */
2739     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2740       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2741
2742   /* If we pushed a context to parse a class intended to be generated,
2743      we keep it so we can remember the class. What we could actually
2744      do is to just update a list of class names.  */
2745   if (generate)
2746     {
2747       toFree->next = ctxp_for_generation;
2748       ctxp_for_generation = toFree;
2749     }
2750 }
2751
2752 /* Create a parser context for the use of saving some global
2753    variables.  */
2754
2755 void
2756 java_parser_context_save_global (void)
2757 {
2758   if (!ctxp)
2759     {
2760       java_push_parser_context ();
2761       ctxp->saved_data_ctx = 1;
2762     }
2763
2764   /* If this context already stores data, create a new one suitable
2765      for data storage. */
2766   else if (ctxp->saved_data)
2767     {
2768       create_new_parser_context (1);
2769       ctxp->saved_data_ctx = 1;
2770     }
2771
2772   ctxp->lineno = input_line;
2773   ctxp->class_type = current_class;
2774   ctxp->filename = input_filename;
2775   ctxp->function_decl = current_function_decl;
2776   ctxp->saved_data = 1;
2777 }
2778
2779 /* Restore some global variables from the previous context. Make the
2780    previous context the current one.  */
2781
2782 void
2783 java_parser_context_restore_global (void)
2784 {
2785   input_line = ctxp->lineno;
2786   current_class = ctxp->class_type;
2787   input_filename = ctxp->filename;
2788   if (wfl_operator)
2789     EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
2790   current_function_decl = ctxp->function_decl;
2791   ctxp->saved_data = 0;
2792   if (ctxp->saved_data_ctx)
2793     java_pop_parser_context (0);
2794 }
2795
2796 /* Suspend vital data for the current class/function being parsed so
2797    that an other class can be parsed. Used to let local/anonymous
2798    classes be parsed.  */
2799
2800 static void
2801 java_parser_context_suspend (void)
2802 {
2803   /* This makes debugging through java_debug_context easier */
2804   static const char *const name = "<inner buffer context>";
2805
2806   /* Duplicate the previous context, use it to save the globals we're
2807      interested in */
2808   create_new_parser_context (1);
2809   ctxp->function_decl = current_function_decl;
2810   ctxp->class_type = current_class;
2811
2812   /* Then create a new context which inherits all data from the
2813      previous one. This will be the new current context  */
2814   create_new_parser_context (1);
2815
2816   /* Help debugging */
2817   ctxp->next->filename = name;
2818 }
2819
2820 /* Resume vital data for the current class/function being parsed so
2821    that an other class can be parsed. Used to let local/anonymous
2822    classes be parsed.  The trick is the data storing file position
2823    informations must be restored to their current value, so parsing
2824    can resume as if no context was ever saved. */
2825
2826 static void
2827 java_parser_context_resume (void)
2828 {
2829   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2830   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2831   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2832
2833   /* We need to inherit the list of classes to complete/generate */
2834   restored->classd_list = old->classd_list;
2835   restored->class_list = old->class_list;
2836
2837   /* Restore the current class and function from the saver */
2838   current_class = saver->class_type;
2839   current_function_decl = saver->function_decl;
2840
2841   /* Retrieve the restored context */
2842   ctxp = restored;
2843
2844   /* Re-installed the data for the parsing to carry on */
2845   memcpy (&ctxp->marker_begining, &old->marker_begining,
2846           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2847 }
2848
2849 /* Add a new anchor node to which all statement(s) initializing static
2850    and non static initialized upon declaration field(s) will be
2851    linked.  */
2852
2853 static void
2854 java_parser_context_push_initialized_field (void)
2855 {
2856   tree node;
2857
2858   node = build_tree_list (NULL_TREE, NULL_TREE);
2859   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2860   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2861
2862   node = build_tree_list (NULL_TREE, NULL_TREE);
2863   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2864   CPC_INITIALIZER_LIST (ctxp) = node;
2865
2866   node = build_tree_list (NULL_TREE, NULL_TREE);
2867   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2868   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2869 }
2870
2871 /* Pop the lists of initialized field. If this lists aren't empty,
2872    remember them so we can use it to create and populate the finit$
2873    or <clinit> functions. */
2874
2875 static void
2876 java_parser_context_pop_initialized_field (void)
2877 {
2878   tree stmts;
2879   tree class_type = TREE_TYPE (GET_CPC ());
2880
2881   if (CPC_INITIALIZER_LIST (ctxp))
2882     {
2883       stmts = CPC_INITIALIZER_STMT (ctxp);
2884       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2885       if (stmts && !java_error_count)
2886         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2887     }
2888
2889   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2890     {
2891       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2892       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2893         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2894       /* Keep initialization in order to enforce 8.5 */
2895       if (stmts && !java_error_count)
2896         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2897     }
2898
2899   /* JDK 1.1 instance initializers */
2900   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2901     {
2902       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2903       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2904         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2905       if (stmts && !java_error_count)
2906         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2907     }
2908 }
2909
2910 static tree
2911 reorder_static_initialized (tree list)
2912 {
2913   /* We have to keep things in order. The alias initializer have to
2914      come first, then the initialized regular field, in reverse to
2915      keep them in lexical order. */
2916   tree marker, previous = NULL_TREE;
2917   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2918     if (TREE_CODE (marker) == TREE_LIST
2919         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2920       break;
2921
2922   /* No static initialized, the list is fine as is */
2923   if (!previous)
2924     list = TREE_CHAIN (marker);
2925
2926   /* No marker? reverse the whole list */
2927   else if (!marker)
2928     list = nreverse (list);
2929
2930   /* Otherwise, reverse what's after the marker and the new reordered
2931      sublist will replace the marker. */
2932   else
2933     {
2934       TREE_CHAIN (previous) = NULL_TREE;
2935       list = nreverse (list);
2936       list = chainon (TREE_CHAIN (marker), list);
2937     }
2938   return list;
2939 }
2940
2941 /* Helper functions to dump the parser context stack.  */
2942
2943 #define TAB_CONTEXT(C) \
2944   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2945
2946 static void
2947 java_debug_context_do (int tab)
2948 {
2949   struct parser_ctxt *copy = ctxp;
2950   while (copy)
2951     {
2952       TAB_CONTEXT (tab);
2953       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2954       TAB_CONTEXT (tab);
2955       fprintf (stderr, "filename: %s\n", copy->filename);
2956       TAB_CONTEXT (tab);
2957       fprintf (stderr, "lineno: %d\n", copy->lineno);
2958       TAB_CONTEXT (tab);
2959       fprintf (stderr, "package: %s\n",
2960                (copy->package ?
2961                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2962       TAB_CONTEXT (tab);
2963       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2964       TAB_CONTEXT (tab);
2965       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2966       copy = copy->next;
2967       tab += 2;
2968     }
2969 }
2970
2971 /* Dump the stacked up parser contexts. Intended to be called from a
2972    debugger.  */
2973
2974 void
2975 java_debug_context (void)
2976 {
2977   java_debug_context_do (0);
2978 }
2979
2980 \f
2981
2982 /* Flag for the error report routine to issue the error the first time
2983    it's called (overriding the default behavior which is to drop the
2984    first invocation and honor the second one, taking advantage of a
2985    richer context.  */
2986 static int force_error = 0;
2987
2988 /* Reporting an constructor invocation error.  */
2989 static void
2990 parse_ctor_invocation_error (void)
2991 {
2992   if (DECL_CONSTRUCTOR_P (current_function_decl))
2993     yyerror ("Constructor invocation must be first thing in a constructor");
2994   else
2995     yyerror ("Only constructors can invoke constructors");
2996 }
2997
2998 /* Reporting JDK1.1 features not implemented.  */
2999
3000 static tree
3001 parse_jdk1_1_error (const char *msg)
3002 {
3003   sorry (": `%s' JDK1.1(TM) feature", msg);
3004   java_error_count++;
3005   return build_java_empty_stmt ();
3006 }
3007
3008 static int do_warning = 0;
3009
3010 void
3011 yyerror (const char *msg)
3012 {
3013   static java_lc elc;
3014   static int  prev_lineno;
3015   static const char *prev_msg;
3016
3017   int save_lineno;
3018   char *remainder, *code_from_source;
3019
3020   if (!force_error && prev_lineno == input_line)
3021     return;
3022
3023   /* Save current error location but report latter, when the context is
3024      richer.  */
3025   if (ctxp->java_error_flag == 0)
3026     {
3027       ctxp->java_error_flag = 1;
3028       elc = ctxp->elc;
3029       /* Do something to use the previous line if we're reaching the
3030          end of the file... */
3031 #ifdef VERBOSE_SKELETON
3032       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3033 #endif
3034       return;
3035     }
3036
3037   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3038   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3039     return;
3040
3041   ctxp->java_error_flag = 0;
3042   if (do_warning)
3043     java_warning_count++;
3044   else
3045     java_error_count++;
3046
3047   if (elc.col == 0 && msg && msg[1] == ';')
3048     {
3049       elc.col  = ctxp->p_line->char_col-1;
3050       elc.line = ctxp->p_line->lineno;
3051     }
3052
3053   save_lineno = input_line;
3054   prev_lineno = input_line = elc.line;
3055   prev_msg = msg;
3056
3057   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3058   obstack_grow0 (&temporary_obstack,
3059                  code_from_source, strlen (code_from_source));
3060   remainder = obstack_finish (&temporary_obstack);
3061   if (do_warning)
3062     warning ("%s.\n%s", msg, remainder);
3063   else
3064     error ("%s.\n%s", msg, remainder);
3065
3066   /* This allow us to cheaply avoid an extra 'Invalid expression
3067      statement' error report when errors have been already reported on
3068      the same line. This occurs when we report an error but don't have
3069      a synchronization point other than ';', which
3070      expression_statement is the only one to take care of.  */
3071   ctxp->prevent_ese = input_line = save_lineno;
3072 }
3073
3074 static void
3075 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3076 {
3077   const char *saved, *saved_input_filename;
3078   char buffer [4096];
3079   vsprintf (buffer, msg, ap);
3080   force_error = 1;
3081
3082   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3083   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3084                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3085
3086   /* We have a CL, that's a good reason for using it if it contains data */
3087   saved = ctxp->filename;
3088   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3089     ctxp->filename = EXPR_WFL_FILENAME (cl);
3090   saved_input_filename = input_filename;
3091   input_filename = ctxp->filename;
3092   java_error (NULL);
3093   java_error (buffer);
3094   ctxp->filename = saved;
3095   input_filename = saved_input_filename;
3096   force_error = 0;
3097 }
3098
3099 /* Issue an error message at a current source line CL */
3100
3101 void
3102 parse_error_context (tree cl, const char *msg, ...)
3103 {
3104   va_list ap;
3105   va_start (ap, msg);
3106   issue_warning_error_from_context (cl, msg, ap);
3107   va_end (ap);
3108 }
3109
3110 /* Issue a warning at a current source line CL */
3111
3112 static void
3113 parse_warning_context (tree cl, const char *msg, ...)
3114 {
3115   va_list ap;
3116   va_start (ap, msg);
3117
3118   force_error = do_warning = 1;
3119   issue_warning_error_from_context (cl, msg, ap);
3120   do_warning = force_error = 0;
3121   va_end (ap);
3122 }
3123
3124 static tree
3125 find_expr_with_wfl (tree node)
3126 {
3127   while (node)
3128     {
3129       enum tree_code_class code;
3130       tree to_return;
3131
3132       switch (TREE_CODE (node))
3133         {
3134         case BLOCK:
3135           node = BLOCK_EXPR_BODY (node);
3136           continue;
3137
3138         case COMPOUND_EXPR:
3139           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3140           if (to_return)
3141             return to_return;
3142           node = TREE_OPERAND (node, 1);
3143           continue;
3144
3145         case LOOP_EXPR:
3146           node = TREE_OPERAND (node, 0);
3147           continue;
3148
3149         case LABELED_BLOCK_EXPR:
3150           node = TREE_OPERAND (node, 1);
3151           continue;
3152
3153         default:
3154           code = TREE_CODE_CLASS (TREE_CODE (node));
3155           if (((code == tcc_unary) || (code == tcc_binary)
3156                || (code == tcc_expression))
3157               && EXPR_WFL_LINECOL (node))
3158             return node;
3159           return NULL_TREE;
3160         }
3161     }
3162   return NULL_TREE;
3163 }
3164
3165 /* Issue a missing return statement error. Uses METHOD to figure the
3166    last line of the method the error occurs in.  */
3167
3168 static void
3169 missing_return_error (tree method)
3170 {
3171   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3172   parse_error_context (wfl_operator, "Missing return statement");
3173 }
3174
3175 /* Issue an unreachable statement error. From NODE, find the next
3176    statement to report appropriately.  */
3177 static void
3178 unreachable_stmt_error (tree node)
3179 {
3180   /* Browse node to find the next expression node that has a WFL. Use
3181      the location to report the error */
3182   if (TREE_CODE (node) == COMPOUND_EXPR)
3183     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3184   else
3185     node = find_expr_with_wfl (node);
3186
3187   if (node)
3188     {
3189       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3190       parse_error_context (wfl_operator, "Unreachable statement");
3191     }
3192   else
3193     abort ();
3194 }
3195
3196 static int
3197 not_accessible_field_error (tree wfl, tree decl)
3198 {
3199   parse_error_context
3200     (wfl, "Can't access %s field `%s.%s' from `%s'",
3201      accessibility_string (get_access_flags_from_decl (decl)),
3202      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3203      IDENTIFIER_POINTER (DECL_NAME (decl)),
3204      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3205   return 1;
3206 }
3207
3208 int
3209 java_report_errors (void)
3210 {
3211   if (java_error_count)
3212     fprintf (stderr, "%d error%s",
3213              java_error_count, (java_error_count == 1 ? "" : "s"));
3214   if (java_warning_count)
3215     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3216              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3217   if (java_error_count || java_warning_count)
3218     putc ('\n', stderr);
3219   return java_error_count;
3220 }
3221
3222 static char *
3223 java_accstring_lookup (int flags)
3224 {
3225   static char buffer [80];
3226 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3227
3228   /* Access modifier looked-up first for easier report on forbidden
3229      access. */
3230   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3231   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3232   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3233   if (flags & ACC_STATIC) COPY_RETURN ("static");
3234   if (flags & ACC_FINAL) COPY_RETURN ("final");
3235   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3236   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3237   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3238   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3239   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3240   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3241
3242   buffer [0] = '\0';
3243   return buffer;
3244 #undef COPY_RETURN
3245 }
3246
3247 /* Returns a string denoting the accessibility of a class or a member as
3248    indicated by FLAGS.  We need a separate function from
3249    java_accstring_lookup, as the latter can return spurious "static", etc.
3250    if package-private access is defined (in which case none of the
3251    relevant access control bits in FLAGS is set).  */
3252
3253 static const char *
3254 accessibility_string (int flags)
3255 {
3256   if (flags & ACC_PRIVATE) return "private";
3257   if (flags & ACC_PROTECTED) return "protected";
3258   if (flags & ACC_PUBLIC) return "public";
3259
3260   return "package-private";
3261 }
3262
3263 /* Issuing error messages upon redefinition of classes, interfaces or
3264    variables. */
3265
3266 static void
3267 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3268 {
3269   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3270                        context, IDENTIFIER_POINTER (id),
3271                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3272   /* Here we should point out where its redefined. It's a unicode. FIXME */
3273 }
3274
3275 static void
3276 variable_redefinition_error (tree context, tree name, tree type, int line)
3277 {
3278   const char *type_name;
3279
3280   /* Figure a proper name for type. We might haven't resolved it */
3281   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3282     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3283   else
3284     type_name = lang_printable_name (type, 0);
3285
3286   parse_error_context (context,
3287                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3288                        IDENTIFIER_POINTER (name),
3289                        type_name, IDENTIFIER_POINTER (name), line);
3290 }
3291
3292 /* If ANAME is terminated with `[]', it indicates an array. This
3293    function returns the number of `[]' found and if this number is
3294    greater than zero, it extracts the array type name and places it in
3295    the node pointed to by TRIMMED unless TRIMMED is null.  */
3296
3297 static int
3298 build_type_name_from_array_name (tree aname, tree *trimmed)
3299 {
3300   const char *name = IDENTIFIER_POINTER (aname);
3301   int len = IDENTIFIER_LENGTH (aname);
3302   int array_dims;
3303
3304   STRING_STRIP_BRACKETS (name, len, array_dims);
3305
3306   if (array_dims && trimmed)
3307     *trimmed = get_identifier_with_length (name, len);
3308
3309   return array_dims;
3310 }
3311
3312 static tree
3313 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3314 {
3315   int more_dims = 0;
3316
3317   /* Eventually get more dims */
3318   more_dims = build_type_name_from_array_name (name, &name);
3319
3320   /* If we have, then craft a new type for this variable */
3321   if (more_dims)
3322     {
3323       tree save = type;
3324
3325       /* If we have a pointer, use its type */
3326       if (TREE_CODE (type) == POINTER_TYPE)
3327         type = TREE_TYPE (type);
3328
3329       /* Building the first dimension of a primitive type uses this
3330          function */
3331       if (JPRIMITIVE_TYPE_P (type))
3332         {
3333           type = build_java_array_type (type, -1);
3334           more_dims--;
3335         }
3336       /* Otherwise, if we have a WFL for this type, use it (the type
3337          is already an array on an unresolved type, and we just keep
3338          on adding dimensions) */
3339       else if (type_wfl)
3340         {
3341           type = type_wfl;
3342           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3343                                                         NULL);
3344         }
3345
3346       /* Add all the dimensions */
3347       while (more_dims--)
3348         type = build_unresolved_array_type (type);
3349
3350       /* The type may have been incomplete in the first place */
3351       if (type_wfl)
3352         type = obtain_incomplete_type (type);
3353     }
3354
3355   if (ret_name)
3356     *ret_name = name;
3357   return type;
3358 }
3359
3360 /* Build something that the type identifier resolver will identify as
3361    being an array to an unresolved type. TYPE_WFL is a WFL on a
3362    identifier. */
3363
3364 static tree
3365 build_unresolved_array_type (tree type_or_wfl)
3366 {
3367   const char *ptr;
3368   tree wfl;
3369
3370   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3371      just create a array type */
3372   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3373     return build_java_array_type (type_or_wfl, -1);
3374
3375   obstack_grow (&temporary_obstack,
3376                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3377                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3378   obstack_grow0 (&temporary_obstack, "[]", 2);
3379   ptr = obstack_finish (&temporary_obstack);
3380   wfl = build_expr_wfl (get_identifier (ptr),
3381                         EXPR_WFL_FILENAME (type_or_wfl),
3382                         EXPR_WFL_LINENO (type_or_wfl),
3383                         EXPR_WFL_COLNO (type_or_wfl));
3384   /* Re-install the existing qualifications so that the type can be
3385      resolved properly. */
3386   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3387   return wfl;
3388 }
3389
3390 static void
3391 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3392 {
3393   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3394     parse_error_context (wfl, "Interface `%s' repeated",
3395                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3396 }
3397
3398 /* Bulk of common class/interface checks. Return 1 if an error was
3399    encountered. TAG is 0 for a class, 1 for an interface.  */
3400
3401 static int
3402 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3403                                 tree qualified_name, tree decl, tree cl)
3404 {
3405   tree node;
3406   int sca = 0;                  /* Static class allowed */
3407   int icaf = 0;                 /* Inner class allowed flags */
3408   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3409
3410   if (!quiet_flag)
3411     fprintf (stderr, " %s%s %s",
3412              (CPC_INNER_P () ? "inner" : ""),
3413              (is_interface ? "interface" : "class"),
3414              IDENTIFIER_POINTER (qualified_name));
3415
3416   /* Scope of an interface/class type name:
3417        - Can't be imported by a single type import
3418        - Can't already exists in the package */
3419   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3420       && (node = find_name_in_single_imports (raw_name))
3421       && !CPC_INNER_P ())
3422     {
3423       parse_error_context
3424         (cl, "%s name `%s' clashes with imported type `%s'",
3425          (is_interface ? "Interface" : "Class"),
3426          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3427       return 1;
3428     }
3429   if (decl && CLASS_COMPLETE_P (decl))
3430     {
3431       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3432                                    qualified_name, decl, cl);
3433       return 1;
3434     }
3435
3436   if (check_inner_class_redefinition (raw_name, cl))
3437     return 1;
3438
3439   /* If public, file name should match class/interface name, except
3440      when dealing with an inner class */
3441   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3442     {
3443       const char *f;
3444
3445       for (f = &input_filename [strlen (input_filename)];
3446            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3447            f--)
3448         ;
3449       if (IS_DIR_SEPARATOR (f[0]))
3450         f++;
3451       if (strncmp (IDENTIFIER_POINTER (raw_name),
3452                    f , IDENTIFIER_LENGTH (raw_name)) ||
3453           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3454         parse_error_context
3455           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3456                              (is_interface ? "interface" : "class"),
3457                              IDENTIFIER_POINTER (qualified_name),
3458                              IDENTIFIER_POINTER (raw_name));
3459     }
3460
3461   /* Static classes can be declared only in top level classes. Note:
3462      once static, a inner class is a top level class. */
3463   if (flags & ACC_STATIC)
3464     {
3465       /* Catch the specific error of declaring an class inner class
3466          with no toplevel enclosing class. Prevent check_modifiers from
3467          complaining a second time */
3468       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3469         {
3470           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3471                                IDENTIFIER_POINTER (qualified_name));
3472           sca = ACC_STATIC;
3473         }
3474       /* Else, in the context of a top-level class declaration, let
3475          `check_modifiers' do its job, otherwise, give it a go */
3476       else
3477         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3478     }
3479
3480   /* Inner classes can be declared private or protected
3481      within their enclosing classes. */
3482   if (CPC_INNER_P ())
3483     {
3484       /* A class which is local to a block can't be public, private,
3485          protected or static. But it is created final, so allow this
3486          one. */
3487       if (current_function_decl)
3488         icaf = sca = uaaf = ACC_FINAL;
3489       else
3490         {
3491           check_modifiers_consistency (flags);
3492           icaf = ACC_PROTECTED;
3493           if (! CLASS_INTERFACE (GET_CPC ()))
3494             icaf |= ACC_PRIVATE;
3495         }
3496     }
3497
3498   if (is_interface)
3499     {
3500       if (CPC_INNER_P ())
3501         uaaf = INTERFACE_INNER_MODIFIERS;
3502       else
3503         uaaf = INTERFACE_MODIFIERS;
3504
3505       check_modifiers ("Illegal modifier `%s' for interface declaration",
3506                        flags, uaaf);
3507     }
3508   else
3509     check_modifiers ((current_function_decl ?
3510                       "Illegal modifier `%s' for local class declaration" :
3511                       "Illegal modifier `%s' for class declaration"),
3512                      flags, uaaf|sca|icaf);
3513   return 0;
3514 }
3515
3516 /* Construct a nested class name.  If the final component starts with
3517    a digit, return true.  Otherwise return false.  */
3518 static int
3519 make_nested_class_name (tree cpc_list)
3520 {
3521   tree name;
3522
3523   if (!cpc_list)
3524     return 0;
3525
3526   make_nested_class_name (TREE_CHAIN (cpc_list));
3527
3528   /* Pick the qualified name when dealing with the first upmost
3529      enclosing class */
3530   name = (TREE_CHAIN (cpc_list)
3531           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3532   obstack_grow (&temporary_obstack,
3533                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3534   obstack_1grow (&temporary_obstack, '$');
3535
3536   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3537 }
3538
3539 /* Can't redefine a class already defined in an earlier scope. */
3540
3541 static int
3542 check_inner_class_redefinition (tree raw_name, tree cl)
3543 {
3544   tree scope_list;
3545
3546   for (scope_list = GET_CPC_LIST (); scope_list;
3547        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3548     if (raw_name == GET_CPC_UN_NODE (scope_list))
3549       {
3550         parse_error_context
3551           (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",
3552            IDENTIFIER_POINTER (raw_name));
3553         return 1;
3554       }
3555   return 0;
3556 }
3557
3558 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3559    we remember ENCLOSING and SUPER.  */
3560
3561 static tree
3562 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3563                      tree *super, tree class_type)
3564 {
3565   tree local_enclosing = *enclosing;
3566   tree local_super = NULL_TREE;
3567
3568   while (local_enclosing)
3569     {
3570       tree intermediate, decl;
3571
3572       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3573         local_enclosing;
3574
3575       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3576         return decl;
3577
3578       intermediate = local_enclosing;
3579       /* Explore enclosing contexts. */
3580       while (INNER_CLASS_DECL_P (intermediate))
3581         {
3582           intermediate = DECL_CONTEXT (intermediate);
3583           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3584             return decl;
3585         }
3586
3587       /* Now go to the upper classes, bail out if necessary.  We will
3588          analyze the returned SUPER and act accordingly (see
3589          do_resolve_class).  */
3590       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3591           || TREE_TYPE (local_enclosing) == void_type_node)
3592         {
3593           parse_error_context (cl, "Qualifier must be a reference");
3594           local_enclosing = NULL_TREE;
3595           break;
3596         }
3597       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3598       if (!local_super || local_super == object_type_node)
3599         break;
3600
3601       if (TREE_CODE (local_super) == POINTER_TYPE)
3602         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3603       else
3604         local_super = TYPE_NAME (local_super);
3605
3606       /* We may not have checked for circular inheritance yet, so do so
3607          here to prevent an infinite loop. */
3608       if (htab_find (circularity_hash, local_super) != NULL)
3609         {
3610           if (!cl)
3611             cl = lookup_cl (local_enclosing);
3612
3613           parse_error_context
3614             (cl, "Cyclic inheritance involving %s",
3615              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3616           local_enclosing = NULL_TREE;
3617         }
3618       else
3619         local_enclosing = local_super;
3620     }
3621
3622   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3623   *super = local_super;
3624   *enclosing = local_enclosing;
3625
3626   return NULL_TREE;
3627 }
3628
3629 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3630    qualified. */
3631
3632 static tree
3633 find_as_inner_class (tree enclosing, tree name, tree cl)
3634 {
3635   tree qual, to_return;
3636   if (!enclosing)
3637     return NULL_TREE;
3638
3639   name = TYPE_NAME (name);
3640
3641   /* First search: within the scope of `enclosing', search for name */
3642   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3643     qual = EXPR_WFL_QUALIFICATION (cl);
3644   else if (cl)
3645     qual = build_tree_list (cl, NULL_TREE);
3646   else
3647     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3648
3649   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3650     return to_return;
3651
3652   /* We're dealing with a qualified name. Try to resolve thing until
3653      we get something that is an enclosing class. */
3654   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3655     {
3656       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3657
3658       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3659            qual = TREE_CHAIN (qual))
3660         {
3661           acc = merge_qualified_name (acc,
3662                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3663           BUILD_PTR_FROM_NAME (ptr, acc);
3664           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3665         }
3666
3667       /* A NULL qual and a decl means that the search ended
3668          successfully?!? We have to do something then. FIXME */
3669
3670       if (decl)
3671         enclosing = decl;
3672       else
3673         qual = EXPR_WFL_QUALIFICATION (cl);
3674     }
3675   /* Otherwise, create a qual for the other part of the resolution. */
3676   else
3677     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3678
3679   return find_as_inner_class_do (qual, enclosing);
3680 }
3681
3682 /* We go inside the list of sub classes and try to find a way
3683    through. */
3684
3685 static tree
3686 find_as_inner_class_do (tree qual, tree enclosing)
3687 {
3688   if (!qual)
3689     return NULL_TREE;
3690
3691   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3692     {
3693       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3694       tree next_enclosing = NULL_TREE;
3695       tree inner_list;
3696
3697       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3698            inner_list; inner_list = TREE_CHAIN (inner_list))
3699         {
3700           if (TREE_VALUE (inner_list) == name_to_match)
3701             {
3702               next_enclosing = TREE_PURPOSE (inner_list);
3703               break;
3704             }
3705         }
3706       enclosing = next_enclosing;
3707     }
3708
3709   return (!qual && enclosing ? enclosing : NULL_TREE);
3710 }
3711
3712 static void
3713 link_nested_class_to_enclosing (void)
3714 {
3715   if (GET_ENCLOSING_CPC ())
3716     {
3717       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3718       DECL_INNER_CLASS_LIST (enclosing) =
3719         tree_cons (GET_CPC (), GET_CPC_UN (),
3720                    DECL_INNER_CLASS_LIST (enclosing));
3721     }
3722 }
3723
3724 static tree
3725 maybe_make_nested_class_name (tree name)
3726 {
3727   tree id = NULL_TREE;
3728
3729   if (CPC_INNER_P ())
3730     {
3731       /* If we're in a function, we must append a number to create the
3732          nested class name.  However, we don't do this if the class we
3733          are constructing is anonymous, because in that case we'll
3734          already have a number as the class name.  */
3735       if (! make_nested_class_name (GET_CPC_LIST ())
3736           && current_function_decl != NULL_TREE
3737           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3738         {
3739           char buf[10];
3740           sprintf (buf, "%d", anonymous_class_counter);
3741           ++anonymous_class_counter;
3742           obstack_grow (&temporary_obstack, buf, strlen (buf));
3743           obstack_1grow (&temporary_obstack, '$');
3744         }
3745       obstack_grow0 (&temporary_obstack,
3746                      IDENTIFIER_POINTER (name),
3747                      IDENTIFIER_LENGTH (name));
3748       id = get_identifier (obstack_finish (&temporary_obstack));
3749       if (ctxp->package)
3750         QUALIFIED_P (id) = 1;
3751     }
3752   return id;
3753 }
3754
3755 /* If DECL is NULL, create and push a new DECL, record the current
3756    line CL and do other maintenance things.  */
3757
3758 static tree
3759 maybe_create_class_interface_decl (tree decl, tree raw_name,
3760                                    tree qualified_name, tree cl)
3761 {
3762   if (!decl)
3763     decl = push_class (make_class (), qualified_name);
3764
3765   /* Take care of the file and line business */
3766   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3767   /* If we're emitting xrefs, store the line/col number information */
3768   if (flag_emit_xref)
3769     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3770   else
3771     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3772   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3773   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3774   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3775     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3776
3777   PUSH_CPC (decl, raw_name);
3778   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3779
3780   /* Link the declaration to the already seen ones */
3781   TREE_CHAIN (decl) = ctxp->class_list;
3782   ctxp->class_list = decl;
3783
3784   /* Create a new nodes in the global lists */
3785   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3786   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3787
3788   /* Install a new dependency list element */
3789   create_jdep_list (ctxp);
3790
3791   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3792                           IDENTIFIER_POINTER (qualified_name)));
3793   return decl;
3794 }
3795
3796 static void
3797 add_superinterfaces (tree decl, tree interface_list)
3798 {
3799   tree node;
3800   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3801      takes care of ensuring that:
3802        - This is an accessible interface type,
3803        - Circularity detection.
3804    parser_add_interface is then called. If present but not defined,
3805    the check operation is delayed until the super interface gets
3806    defined.  */
3807   for (node = interface_list; node; node = TREE_CHAIN (node))
3808     {
3809       tree current = TREE_PURPOSE (node);
3810       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3811       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3812         {
3813           if (!parser_check_super_interface (idecl, decl, current))
3814             parser_add_interface (decl, idecl, current);
3815         }
3816       else
3817         register_incomplete_type (JDEP_INTERFACE,
3818                                   current, decl, NULL_TREE);
3819     }
3820 }
3821
3822 /* Create an interface in pass1 and return its decl. Return the
3823    interface's decl in pass 2.  */
3824
3825 static tree
3826 create_interface (int flags, tree id, tree super)
3827 {
3828   tree raw_name = EXPR_WFL_NODE (id);
3829   tree q_name = parser_qualified_classname (raw_name);
3830   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3831
3832   /* Certain syntax errors are making SUPER be like ID. Avoid this
3833      case. */
3834   if (ctxp->class_err && id == super)
3835     super = NULL;
3836
3837   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3838
3839   /* Basic checks: scope, redefinition, modifiers */
3840   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3841     {
3842       PUSH_ERROR ();
3843       return NULL_TREE;
3844     }
3845
3846   /* Suspend the current parsing context if we're parsing an inner
3847      interface */
3848   if (CPC_INNER_P ())
3849     {
3850       java_parser_context_suspend ();
3851       /* Interface members are public. */
3852       if (CLASS_INTERFACE (GET_CPC ()))
3853         flags |= ACC_PUBLIC;
3854     }
3855
3856   /* Push a new context for (static) initialized upon declaration fields */
3857   java_parser_context_push_initialized_field ();
3858
3859   /* Interface modifiers check
3860        - public/abstract allowed (already done at that point)
3861        - abstract is obsolete (comes first, it's a warning, or should be)
3862        - Can't use twice the same (checked in the modifier rule) */
3863   if ((flags & ACC_ABSTRACT) && flag_redundant)
3864     parse_warning_context
3865       (MODIFIER_WFL (ABSTRACT_TK),
3866        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3867
3868   /* Create a new decl if DECL is NULL, otherwise fix it */
3869   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3870
3871   /* Interfaces are always abstract. */
3872   flags |= ACC_ABSTRACT;
3873
3874   /* Inner interfaces are always static.  */
3875   if (INNER_CLASS_DECL_P (decl))
3876     flags |= ACC_STATIC;
3877
3878   /* Set super info and mark the class a complete */
3879   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3880                   object_type_node, ctxp->interface_number);
3881   ctxp->interface_number = 0;
3882   CLASS_COMPLETE_P (decl) = 1;
3883   add_superinterfaces (decl, super);
3884
3885   /* Eventually sets the @deprecated tag flag */
3886   CHECK_DEPRECATED (decl);
3887
3888   return decl;
3889 }
3890
3891 /* Patch anonymous class CLASS, by either extending or implementing
3892    DEP.  */
3893
3894 static void
3895 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3896 {
3897   tree class = TREE_TYPE (class_decl);
3898   tree type =  TREE_TYPE (type_decl);
3899   tree binfo = TYPE_BINFO (class);
3900
3901   /* If it's an interface, implement it */
3902   if (CLASS_INTERFACE (type_decl))
3903     {
3904       if (parser_check_super_interface (type_decl, class_decl, wfl))
3905         return;
3906
3907       if (!VEC_space (tree, BINFO_BASE_BINFOS (binfo), 1))
3908         {
3909            /* Extend the binfo - by reallocating and copying it. */
3910           tree new_binfo;
3911           tree base_binfo;
3912           int i;
3913
3914           new_binfo = make_tree_binfo ((BINFO_N_BASE_BINFOS (binfo) + 1) * 2);
3915           for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3916             BINFO_BASE_APPEND (new_binfo, base_binfo);
3917           CLASS_HAS_SUPER_FLAG (new_binfo) = CLASS_HAS_SUPER_FLAG (binfo);
3918           BINFO_VTABLE (new_binfo) = BINFO_VTABLE (binfo);
3919           TYPE_BINFO (class) = new_binfo;
3920         }
3921
3922       /* And add the interface */
3923       parser_add_interface (class_decl, type_decl, wfl);
3924     }
3925   /* Otherwise, it's a type we want to extend */
3926   else
3927     {
3928       if (parser_check_super (type_decl, class_decl, wfl))
3929         return;
3930       BINFO_TYPE (BINFO_BASE_BINFO (binfo, 0)) = type;
3931     }
3932 }
3933
3934 /* Create an anonymous class which extends/implements TYPE_NAME, and return
3935    its decl.  */
3936
3937 static tree
3938 create_anonymous_class (tree type_name)
3939 {
3940   char buffer [80];
3941   tree super = NULL_TREE, itf = NULL_TREE;
3942   tree id, type_decl, class;
3943
3944   /* The unqualified name of the anonymous class. It's just a number. */
3945   sprintf (buffer, "%d", anonymous_class_counter++);
3946   id = build_wfl_node (get_identifier (buffer));
3947   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
3948
3949   /* We know about the type to extend/implement. We go ahead */
3950   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3951     {
3952       /* Create a class which either implements on extends the designated
3953          class. The class bears an inaccessible name. */
3954       if (CLASS_INTERFACE (type_decl))
3955         {
3956           /* It's OK to modify it here. It's been already used and
3957              shouldn't be reused */
3958           ctxp->interface_number = 1;
3959           /* Interfaces should presented as a list of WFLs */
3960           itf = build_tree_list (type_name, NULL_TREE);
3961         }
3962       else
3963         super = type_name;
3964     }
3965
3966   class = create_class (ACC_FINAL, id, super, itf);
3967
3968   /* We didn't know anything about the stuff. We register a dependence. */
3969   if (!type_decl)
3970     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3971
3972   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3973   return class;
3974 }
3975
3976 /* Create a class in pass1 and return its decl. Return class
3977    interface's decl in pass 2.  */
3978
3979 static tree
3980 create_class (int flags, tree id, tree super, tree interfaces)
3981 {
3982   tree raw_name = EXPR_WFL_NODE (id);
3983   tree class_id, decl;
3984   tree super_decl_type;
3985
3986   /* Certain syntax errors are making SUPER be like ID. Avoid this
3987      case. */
3988   if (ctxp->class_err && id == super)
3989     super = NULL;
3990
3991   class_id = parser_qualified_classname (raw_name);
3992   decl = IDENTIFIER_CLASS_VALUE (class_id);
3993   EXPR_WFL_NODE (id) = class_id;
3994
3995   /* Basic check: scope, redefinition, modifiers */
3996   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3997     {
3998       PUSH_ERROR ();
3999       return NULL_TREE;
4000     }
4001
4002   /* Suspend the current parsing context if we're parsing an inner
4003      class or an anonymous class. */
4004   if (CPC_INNER_P ())
4005     {
4006       java_parser_context_suspend ();
4007       /* Interface members are public. */
4008       if (CLASS_INTERFACE (GET_CPC ()))
4009         flags |= ACC_PUBLIC;
4010     }
4011
4012   /* Push a new context for (static) initialized upon declaration fields */
4013   java_parser_context_push_initialized_field ();
4014
4015   /* Class modifier check:
4016        - Allowed modifier (already done at that point)
4017        - abstract AND final forbidden
4018        - Public classes defined in the correct file */
4019   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4020     parse_error_context
4021       (id, "Class `%s' can't be declared both abstract and final",
4022        IDENTIFIER_POINTER (raw_name));
4023
4024   /* Create a new decl if DECL is NULL, otherwise fix it */
4025   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4026
4027   /* If SUPER exists, use it, otherwise use Object */
4028   if (super)
4029     {
4030       /* java.lang.Object can't extend anything.  */
4031       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4032         {
4033           parse_error_context (id, "`java.lang.Object' can't extend anything");
4034           return NULL_TREE;
4035         }
4036
4037       super_decl_type =
4038         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4039     }
4040   else if (TREE_TYPE (decl) != object_type_node)
4041     super_decl_type = object_type_node;
4042   /* We're defining java.lang.Object */
4043   else
4044     super_decl_type = NULL_TREE;
4045
4046   /* A class nested in an interface is implicitly static. */
4047   if (INNER_CLASS_DECL_P (decl)
4048       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4049     {
4050       flags |= ACC_STATIC;
4051     }
4052
4053   /* Set super info and mark the class as complete. */
4054   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4055                   ctxp->interface_number);
4056   ctxp->interface_number = 0;
4057   CLASS_COMPLETE_P (decl) = 1;
4058   add_superinterfaces (decl, interfaces);
4059
4060   /* TYPE_VFIELD' is a compiler-generated field used to point to
4061      virtual function tables.  In gcj, every class has a common base
4062      virtual function table in java.lang.object.  */
4063   TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4064
4065   /* Add the private this$<n> field, Replicate final locals still in
4066      scope as private final fields mangled like val$<local_name>.
4067      This does not occur for top level (static) inner classes. */
4068   if (PURE_INNER_CLASS_DECL_P (decl))
4069     add_inner_class_fields (decl, current_function_decl);
4070
4071   /* If doing xref, store the location at which the inherited class
4072      (if any) was seen. */
4073   if (flag_emit_xref && super)
4074     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4075
4076   /* Eventually sets the @deprecated tag flag */
4077   CHECK_DEPRECATED (decl);
4078
4079   /* Reset the anonymous class counter when declaring non inner classes */
4080   if (!INNER_CLASS_DECL_P (decl))
4081     anonymous_class_counter = 1;
4082
4083   return decl;
4084 }
4085
4086 /* End a class declaration: register the statements used to create
4087    finit$ and <clinit>, pop the current class and resume the prior
4088    parser context if necessary.  */
4089
4090 static void
4091 end_class_declaration (int resume)
4092 {
4093   /* If an error occurred, context weren't pushed and won't need to be
4094      popped by a resume. */
4095   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4096
4097   if (GET_CPC () != error_mark_node)
4098     dump_java_tree (TDI_class, GET_CPC ());
4099
4100   java_parser_context_pop_initialized_field ();
4101   POP_CPC ();
4102   if (resume && no_error_occurred)
4103     java_parser_context_resume ();
4104
4105   /* We're ending a class declaration, this is a good time to reset
4106      the interface cout. Note that might have been already done in
4107      create_interface, but if at that time an inner class was being
4108      dealt with, the interface count was reset in a context created
4109      for the sake of handling inner classes declaration. */
4110   ctxp->interface_number = 0;
4111 }
4112
4113 static void
4114 add_inner_class_fields (tree class_decl, tree fct_decl)
4115 {
4116   tree block, marker, f;
4117
4118   f = add_field (TREE_TYPE (class_decl),
4119                  build_current_thisn (TREE_TYPE (class_decl)),
4120                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4121                  ACC_PRIVATE);
4122   FIELD_THISN (f) = 1;
4123
4124   if (!fct_decl)
4125     return;
4126
4127   for (block = GET_CURRENT_BLOCK (fct_decl);
4128        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4129     {
4130       tree decl;
4131       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4132         {
4133           tree name, pname;
4134           tree wfl, init, list;
4135
4136           /* Avoid non final arguments. */
4137           if (!LOCAL_FINAL_P (decl))
4138             continue;
4139
4140           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4141           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4142           wfl = build_wfl_node (name);
4143           init = build_wfl_node (pname);
4144           /* Build an initialization for the field: it will be
4145              initialized by a parameter added to finit$, bearing a
4146              mangled name of the field itself (param$<n>.) The
4147              parameter is provided to finit$ by the constructor
4148              invoking it (hence the constructor will also feature a
4149              hidden parameter, set to the value of the outer context
4150              local at the time the inner class is created.)
4151
4152              Note: we take into account all possible locals that can
4153              be accessed by the inner class. It's actually not trivial
4154              to minimize these aliases down to the ones really
4155              used. One way to do that would be to expand all regular
4156              methods first, then finit$ to get a picture of what's
4157              used.  It works with the exception that we would have to
4158              go back on all constructor invoked in regular methods to
4159              have their invocation reworked (to include the right amount
4160              of alias initializer parameters.)
4161
4162              The only real way around, I think, is a first pass to
4163              identify locals really used in the inner class. We leave
4164              the flag FIELD_LOCAL_ALIAS_USED around for that future
4165              use.
4166
4167              On the other hand, it only affect local inner classes,
4168              whose constructors (and finit$ call) will be featuring
4169              unnecessary arguments. It's easy for a developer to keep
4170              this number of parameter down by using the `final'
4171              keyword only when necessary. For the time being, we can
4172              issue a warning on unnecessary finals. FIXME */
4173           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4174                                    wfl, init);
4175
4176           /* Register the field. The TREE_LIST holding the part
4177              initialized/initializer will be marked ARG_FINAL_P so
4178              that the created field can be marked
4179              FIELD_LOCAL_ALIAS. */
4180           list = build_tree_list (wfl, init);
4181           ARG_FINAL_P (list) = 1;
4182           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4183         }
4184     }
4185
4186   if (!CPC_INITIALIZER_STMT (ctxp))
4187     return;
4188
4189   /* If we ever registered an alias field, insert and marker to
4190      remember where the list ends. The second part of the list (the one
4191      featuring initialized fields) so it can be later reversed to
4192      enforce 8.5. The marker will be removed during that operation. */
4193   marker = build_tree_list (NULL_TREE, NULL_TREE);
4194   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4195   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4196 }
4197
4198 /* Can't use lookup_field () since we don't want to load the class and
4199    can't set the CLASS_LOADED_P flag */
4200
4201 static tree
4202 find_field (tree class, tree name)
4203 {
4204   tree decl;
4205   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4206     {
4207       if (DECL_NAME (decl) == name)
4208         return decl;
4209     }
4210   return NULL_TREE;
4211 }
4212
4213 /* Wrap around lookup_field that doesn't potentially upset the value
4214    of CLASS */
4215
4216 static tree
4217 lookup_field_wrapper (tree class, tree name)
4218 {
4219   tree type = class;
4220   tree decl = NULL_TREE;
4221   java_parser_context_save_global ();
4222
4223   /* Last chance: if we're within the context of an inner class, we
4224      might be trying to access a local variable defined in an outer
4225      context. We try to look for it now. */
4226   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4227     {
4228       tree new_name;
4229       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4230       decl = lookup_field (&type, new_name);
4231       if (decl && decl != error_mark_node)
4232         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4233     }
4234   if (!decl || decl == error_mark_node)
4235     {
4236       type = class;
4237       decl = lookup_field (&type, name);
4238     }
4239
4240   /* If the field still hasn't been found, try the next enclosing context. */
4241   if (!decl && INNER_CLASS_TYPE_P (class))
4242     {
4243       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4244       decl = lookup_field_wrapper (outer_type, name);
4245     }
4246
4247   java_parser_context_restore_global ();
4248   return decl == error_mark_node ? NULL : decl;
4249 }
4250
4251 /* Find duplicate field within the same class declarations and report
4252    the error. Returns 1 if a duplicated field was found, 0
4253    otherwise.  */
4254
4255 static int
4256 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4257 {
4258   /* This might be modified to work with method decl as well */
4259   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4260   if (decl)
4261     {
4262       char *t1 = xstrdup (purify_type_name
4263                          ((TREE_CODE (new_type) == POINTER_TYPE
4264                            && TREE_TYPE (new_type) == NULL_TREE) ?
4265                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4266                           lang_printable_name (new_type, 1)));
4267       /* The type may not have been completed by the time we report
4268          the error */
4269       char *t2 = xstrdup (purify_type_name
4270                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4271                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4272                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4273                           lang_printable_name (TREE_TYPE (decl), 1)));
4274       parse_error_context
4275         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4276          t1, IDENTIFIER_POINTER (new_field_name),
4277          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4278          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4279       free (t1);
4280       free (t2);
4281       return 1;
4282     }
4283   return 0;
4284 }
4285
4286 /* Field registration routine. If TYPE doesn't exist, field
4287    declarations are linked to the undefined TYPE dependency list, to
4288    be later resolved in java_complete_class () */
4289
4290 static void
4291 register_fields (int flags, tree type, tree variable_list)
4292 {
4293   tree current, saved_type;
4294   tree class_type = NULL_TREE;
4295   int saved_lineno = input_line;
4296   int must_chain = 0;
4297   tree wfl = NULL_TREE;
4298
4299   if (GET_CPC ())
4300     class_type = TREE_TYPE (GET_CPC ());
4301
4302   if (!class_type || class_type == error_mark_node)
4303     return;
4304
4305   /* If we're adding fields to interfaces, those fields are public,
4306      static, final */
4307   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4308     {
4309       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4310                                  flags, ACC_PUBLIC, "interface field(s)");
4311       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4312                                  flags, ACC_STATIC, "interface field(s)");
4313       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4314                                  flags, ACC_FINAL, "interface field(s)");
4315       check_modifiers ("Illegal interface member modifier `%s'", flags,
4316                        INTERFACE_FIELD_MODIFIERS);
4317       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4318     }
4319
4320   /* Obtain a suitable type for resolution, if necessary */
4321   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4322
4323   /* If TYPE is fully resolved and we don't have a reference, make one */
4324   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4325
4326   for (current = variable_list, saved_type = type; current;
4327        current = TREE_CHAIN (current), type = saved_type)
4328     {
4329       tree real_type;
4330       tree field_decl;
4331       tree cl = TREE_PURPOSE (current);
4332       tree init = TREE_VALUE (current);
4333       tree current_name = EXPR_WFL_NODE (cl);
4334
4335       /* Can't declare non-final static fields in inner classes */
4336       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4337           && !(flags & ACC_FINAL))
4338         parse_error_context
4339           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4340            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4341            lang_printable_name (class_type, 0));
4342
4343       /* Process NAME, as it may specify extra dimension(s) for it */
4344       type = build_array_from_name (type, wfl, current_name, &current_name);
4345
4346       /* Type adjustment. We may have just readjusted TYPE because
4347          the variable specified more dimensions. Make sure we have
4348          a reference if we can and don't have one already. Also
4349          change the name if we have an init. */
4350       if (type != saved_type)
4351         {
4352           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4353           if (init)
4354             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4355         }
4356
4357       real_type = GET_REAL_TYPE (type);
4358       /* Check for redeclarations */
4359       if (duplicate_declaration_error_p (current_name, real_type, cl))
4360         continue;
4361
4362       /* Set input_line to the line the field was found and create a
4363          declaration for it. Eventually sets the @deprecated tag flag. */
4364       if (flag_emit_xref)
4365         input_line = EXPR_WFL_LINECOL (cl);
4366       else
4367         input_line = EXPR_WFL_LINENO (cl);
4368       field_decl = add_field (class_type, current_name, real_type, flags);
4369       CHECK_DEPRECATED_NO_RESET (field_decl);
4370
4371       /* If the field denotes a final instance variable, then we
4372          allocate a LANG_DECL_SPECIFIC part to keep track of its
4373          initialization. We also mark whether the field was
4374          initialized upon its declaration. We don't do that if the
4375          created field is an alias to a final local. */
4376       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4377         {
4378           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4379           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4380         }
4381
4382       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4383          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4384          hide parameters to this inner class finit$ and
4385          constructors. It also means that the field isn't final per
4386          say. */
4387       if (ARG_FINAL_P (current))
4388         {
4389           FIELD_LOCAL_ALIAS (field_decl) = 1;
4390           FIELD_FINAL (field_decl) = 0;
4391         }
4392
4393       /* Check if we must chain. */
4394       if (must_chain)
4395         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4396
4397       /* If we have an initialization value tied to the field */
4398       if (init)
4399         {
4400           /* The field is declared static */
4401           if (flags & ACC_STATIC)
4402             {
4403               /* We include the field and its initialization part into
4404                  a list used to generate <clinit>. After <clinit> is
4405                  walked, field initializations will be processed and
4406                  fields initialized with known constants will be taken
4407                  out of <clinit> and have their DECL_INITIAL set
4408                  appropriately. */
4409               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4410               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4411               if (TREE_OPERAND (init, 1)
4412                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4413                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4414             }
4415           /* A non-static field declared with an immediate initialization is
4416              to be initialized in <init>, if any.  This field is remembered
4417              to be processed at the time of the generation of <init>. */
4418           else
4419             {
4420               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4421               SET_CPC_INITIALIZER_STMT (ctxp, init);
4422             }
4423           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4424           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4425         }
4426     }
4427
4428   CLEAR_DEPRECATED;
4429   input_line = saved_lineno;
4430 }
4431
4432 /* Generate finit$, using the list of initialized fields to populate
4433    its body. finit$'s parameter(s) list is adjusted to include the
4434    one(s) used to initialized the field(s) caching outer context
4435    local(s).  */
4436
4437 static tree
4438 generate_finit (tree class_type)
4439 {
4440   int count = 0;
4441   tree list = TYPE_FINIT_STMT_LIST (class_type);
4442   tree mdecl, current, parms;
4443
4444   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4445                                                   class_type, NULL_TREE,
4446                                                   &count);
4447   CRAFTED_PARAM_LIST_FIXUP (parms);
4448   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4449                                     finit_identifier_node, parms);
4450   fix_method_argument_names (parms, mdecl);
4451   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4452                        mdecl, NULL_TREE);
4453   DECL_FUNCTION_NAP (mdecl) = count;
4454   start_artificial_method_body (mdecl);
4455
4456   for (current = list; current; current = TREE_CHAIN (current))
4457     java_method_add_stmt (mdecl,
4458                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4459                                                 current));
4460   end_artificial_method_body (mdecl);
4461   return mdecl;
4462 }
4463
4464 /* Generate a function to run the instance initialization code. The
4465    private method is called `instinit$'. Unless we're dealing with an
4466    anonymous class, we determine whether all ctors of CLASS_TYPE
4467    declare a checked exception in their `throws' clause in order to
4468    see whether it's necessary to encapsulate the instance initializer
4469    statements in a try/catch/rethrow sequence.  */
4470
4471 static tree
4472 generate_instinit (tree class_type)
4473 {
4474   tree current;
4475   tree compound = NULL_TREE;
4476   tree parms = tree_cons (this_identifier_node,
4477                           build_pointer_type (class_type), end_params_node);
4478   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4479                                          void_type_node,
4480                                          instinit_identifier_node, parms);
4481
4482   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4483                        mdecl, NULL_TREE);
4484
4485   /* Gather all the statements in a compound */
4486   for (current = TYPE_II_STMT_LIST (class_type);
4487        current; current = TREE_CHAIN (current))
4488     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4489
4490   /* We need to encapsulate COMPOUND by a try/catch statement to
4491      rethrow exceptions that might occur in the instance initializer.
4492      We do that only if all ctors of CLASS_TYPE are set to catch a
4493      checked exception. This doesn't apply to anonymous classes (since
4494      they don't have declared ctors.) */
4495   if (!ANONYMOUS_CLASS_P (class_type) &&
4496       ctors_unchecked_throws_clause_p (class_type))
4497     {
4498       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4499                                              build1 (THROW_EXPR, NULL_TREE,
4500                                                      build_wfl_node (wpv_id)));
4501       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4502                                                       exception_type_node);
4503     }
4504
4505   start_artificial_method_body (mdecl);
4506   java_method_add_stmt (mdecl, compound);
4507   end_artificial_method_body (mdecl);
4508
4509   return mdecl;
4510 }
4511
4512 /* FIXME */
4513 static tree
4514 build_instinit_invocation (tree class_type)
4515 {
4516   tree to_return = NULL_TREE;
4517
4518   if (TYPE_II_STMT_LIST (class_type))
4519     {
4520       tree parm = build_tree_list (NULL_TREE,
4521                                    build_wfl_node (this_identifier_node));
4522       to_return =
4523         build_method_invocation (build_wfl_node (instinit_identifier_node),
4524                                  parm);
4525     }
4526   return to_return;
4527 }
4528
4529 /* Shared across method_declarator and method_header to remember the
4530    patch stage that was reached during the declaration of the method.
4531    A method DECL is built differently is there is no patch
4532    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4533    pending on the currently defined method.  */
4534
4535 static int patch_stage;
4536
4537 /* Check the method declaration and add the method to its current
4538    class.  If the argument list is known to contain incomplete types,
4539    the method is partially added and the registration will be resume
4540    once the method arguments resolved. If TYPE is NULL, we're dealing
4541    with a constructor.  */
4542
4543 static tree
4544 method_header (int flags, tree type, tree mdecl, tree throws)
4545 {
4546   tree type_wfl = NULL_TREE;
4547   tree meth_name = NULL_TREE;
4548   tree current, orig_arg, this_class = NULL;
4549   tree id, meth;
4550   int saved_lineno;
4551   int constructor_ok = 0, must_chain;
4552   int count;
4553
4554   if (mdecl == error_mark_node)
4555     return error_mark_node;
4556   meth = TREE_VALUE (mdecl);
4557   id = TREE_PURPOSE (mdecl);
4558
4559   check_modifiers_consistency (flags);
4560
4561   if (GET_CPC ())
4562     this_class = TREE_TYPE (GET_CPC ());
4563
4564   if (!this_class || this_class == error_mark_node)
4565     return NULL_TREE;
4566
4567   /* There are some forbidden modifiers for an abstract method and its
4568      class must be abstract as well.  */
4569   if (type && (flags & ACC_ABSTRACT))
4570     {
4571       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4572       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4573       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4574       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4575       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4576       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4577       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4578           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4579         parse_error_context
4580           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4581            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4582            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4583     }
4584
4585   /* A native method can't be strictfp.  */
4586   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4587     parse_error_context (id, "native method `%s' can't be strictfp",
4588                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4589   /* No such thing as a transient or volatile method.  */
4590   if ((flags & ACC_TRANSIENT))
4591     parse_error_context (id, "method `%s' can't be transient",
4592                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4593   if ((flags & ACC_VOLATILE))
4594     parse_error_context (id, "method `%s' can't be volatile",
4595                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4596
4597   /* Things to be checked when declaring a constructor */
4598   if (!type)
4599     {
4600       int ec = java_error_count;
4601       /* 8.6: Constructor declarations: we might be trying to define a
4602          method without specifying a return type. */
4603       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4604         parse_error_context
4605           (id, "Invalid method declaration, return type required");
4606       /* 8.6.3: Constructor modifiers */
4607       else
4608         {
4609           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4610           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4611           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4612           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4613           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4614           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4615         }
4616       /* If we found error here, we don't consider it's OK to tread
4617          the method definition as a constructor, for the rest of this
4618          function */
4619       if (ec == java_error_count)
4620         constructor_ok = 1;
4621     }
4622
4623   /* Method declared within the scope of an interface are implicitly
4624      abstract and public. Conflicts with other erroneously provided
4625      modifiers are checked right after. */
4626
4627   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4628     {
4629       /* If FLAGS isn't set because of a modifier, turn the
4630          corresponding modifier WFL to NULL so we issue a warning on
4631          the obsolete use of the modifier */
4632       if (!(flags & ACC_PUBLIC))
4633         MODIFIER_WFL (PUBLIC_TK) = NULL;
4634       if (!(flags & ACC_ABSTRACT))
4635         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4636       flags |= ACC_PUBLIC;
4637       flags |= ACC_ABSTRACT;
4638     }
4639
4640   /* Inner class can't declare static methods */
4641   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4642     {
4643       parse_error_context
4644         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4645          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4646          lang_printable_name (this_class, 0));
4647     }
4648
4649   /* Modifiers context reset moved up, so abstract method declaration
4650      modifiers can be later checked.  */
4651
4652   /* Set constructor returned type to void and method name to <init>,
4653      unless we found an error identifier the constructor (in which
4654      case we retain the original name) */
4655   if (!type)
4656     {
4657       type = void_type_node;
4658       if (constructor_ok)
4659         meth_name = init_identifier_node;
4660     }
4661   else
4662     meth_name = EXPR_WFL_NODE (id);
4663
4664   /* Do the returned type resolution and registration if necessary */
4665   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4666
4667   if (meth_name)
4668     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4669   EXPR_WFL_NODE (id) = meth_name;
4670   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4671
4672   if (must_chain)
4673     {
4674       patch_stage = JDEP_METHOD_RETURN;
4675       register_incomplete_type (patch_stage, type_wfl, id, type);
4676       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4677     }
4678   else
4679     TREE_TYPE (meth) = type;
4680
4681   saved_lineno = input_line;
4682   /* When defining an abstract or interface method, the curly
4683      bracket at level 1 doesn't exist because there is no function
4684      body */
4685   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4686             EXPR_WFL_LINENO (id));
4687
4688   /* Remember the original argument list */
4689   orig_arg = TYPE_ARG_TYPES (meth);
4690
4691   if (patch_stage)              /* includes ret type and/or all args */
4692     {
4693       jdep *jdep;
4694       meth = add_method_1 (this_class, flags, meth_name, meth);
4695       /* Patch for the return type */
4696       if (patch_stage == JDEP_METHOD_RETURN)
4697         {
4698           jdep = CLASSD_LAST (ctxp->classd_list);
4699           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4700         }
4701       /* This is the stop JDEP. METH allows the function's signature
4702          to be computed. */
4703       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4704     }
4705   else
4706     meth = add_method (this_class, flags, meth_name,
4707                        build_java_signature (meth));
4708
4709   /* Remember final parameters */
4710   MARK_FINAL_PARMS (meth, orig_arg);
4711
4712   /* Fix the method argument list so we have the argument name
4713      information */
4714   fix_method_argument_names (orig_arg, meth);
4715
4716   /* Register the parameter number and re-install the current line
4717      number */
4718   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4719   input_line = saved_lineno;
4720
4721   /* Register exception specified by the `throws' keyword for
4722      resolution and set the method decl appropriate field to the list.
4723      Note: the grammar ensures that what we get here are class
4724      types. */
4725   if (throws)
4726     {
4727       throws = nreverse (throws);
4728       for (current = throws; current; current = TREE_CHAIN (current))
4729         {
4730           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4731                                     NULL_TREE, NULL_TREE);
4732           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4733             &TREE_VALUE (current);
4734         }
4735       DECL_FUNCTION_THROWS (meth) = throws;
4736     }
4737
4738   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4739     DECL_FUNCTION_WFL (meth) = id;
4740
4741   /* Set the flag if we correctly processed a constructor */
4742   if (constructor_ok)
4743     {
4744       DECL_CONSTRUCTOR_P (meth) = 1;
4745       /* Compute and store the number of artificial parameters declared
4746          for this constructor */
4747       for (count = 0, current = TYPE_FIELDS (this_class); current;
4748            current = TREE_CHAIN (current))
4749         if (FIELD_LOCAL_ALIAS (current))
4750           count++;
4751       DECL_FUNCTION_NAP (meth) = count;
4752     }
4753
4754   /* Eventually set the @deprecated tag flag */
4755   CHECK_DEPRECATED (meth);
4756
4757   /* If doing xref, store column and line number information instead
4758      of the line number only. */
4759   if (flag_emit_xref)
4760     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4761
4762   return meth;
4763 }
4764
4765 static void
4766 fix_method_argument_names (tree orig_arg, tree meth)
4767 {
4768   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4769   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4770     {
4771       TREE_PURPOSE (arg) = this_identifier_node;
4772       arg = TREE_CHAIN (arg);
4773     }
4774   while (orig_arg != end_params_node)
4775     {
4776       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4777       orig_arg = TREE_CHAIN (orig_arg);
4778       arg = TREE_CHAIN (arg);
4779     }
4780 }
4781
4782 /* Complete the method declaration with METHOD_BODY.  */
4783
4784 static void
4785 finish_method_declaration (tree method_body)
4786 {
4787   int flags;
4788
4789   if (!current_function_decl)
4790     return;
4791
4792   flags = get_access_flags_from_decl (current_function_decl);
4793
4794   /* 8.4.5 Method Body */
4795   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4796     {
4797       tree name = DECL_NAME (current_function_decl);
4798       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4799                            "%s method `%s' can't have a body defined",
4800                            (METHOD_NATIVE (current_function_decl) ?
4801                             "Native" : "Abstract"),
4802                            IDENTIFIER_POINTER (name));
4803       method_body = NULL_TREE;
4804     }
4805   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4806     {
4807       tree name = DECL_NAME (current_function_decl);
4808       parse_error_context
4809         (DECL_FUNCTION_WFL (current_function_decl),
4810          "Non native and non abstract method `%s' must have a body defined",
4811          IDENTIFIER_POINTER (name));
4812       method_body = NULL_TREE;
4813     }
4814
4815   if (flag_emit_class_files && method_body
4816       && TREE_CODE (method_body) == NOP_EXPR
4817       && TREE_TYPE (current_function_decl)
4818       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4819     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4820
4821   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4822   maybe_absorb_scoping_blocks ();
4823   /* Exit function's body */
4824   exit_block ();
4825   /* Merge last line of the function with first line, directly in the
4826      function decl. It will be used to emit correct debug info. */
4827   if (!flag_emit_xref)
4828     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4829
4830   /* Since function's argument's list are shared, reset the
4831      ARG_FINAL_P parameter that might have been set on some of this
4832      function parameters. */
4833   UNMARK_FINAL_PARMS (current_function_decl);
4834
4835   /* So we don't have an irrelevant function declaration context for
4836      the next static block we'll see. */
4837   current_function_decl = NULL_TREE;
4838 }
4839
4840 /* Build a an error message for constructor circularity errors.  */
4841
4842 static char *
4843 constructor_circularity_msg (tree from, tree to)
4844 {
4845   static char string [4096];
4846   char *t = xstrdup (lang_printable_name (from, 2));
4847   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 2));
4848   free (t);
4849   return string;
4850 }
4851
4852 /* Verify a circular call to METH. Return 1 if an error is found, 0
4853    otherwise.  */
4854
4855 static GTY(()) tree vcc_list;
4856 static int
4857 verify_constructor_circularity (tree meth, tree current)
4858 {
4859   tree c;
4860
4861   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4862     {
4863       if (TREE_VALUE (c) == meth)
4864         {
4865           char *t;
4866           if (vcc_list)
4867             {
4868               tree liste;
4869               vcc_list = nreverse (vcc_list);
4870               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4871                 {
4872                   parse_error_context
4873                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4874                      constructor_circularity_msg
4875                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4876                   java_error_count--;
4877                 }
4878             }
4879           t = xstrdup (lang_printable_name (meth, 2));
4880           parse_error_context (TREE_PURPOSE (c),
4881                                "%s: recursive invocation of constructor `%s'",
4882                                constructor_circularity_msg (current, meth), t);
4883           free (t);
4884           vcc_list = NULL_TREE;
4885           return 1;
4886         }
4887     }
4888   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4889     {
4890       vcc_list = tree_cons (c, current, vcc_list);
4891       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4892         return 1;
4893       vcc_list = TREE_CHAIN (vcc_list);
4894     }
4895   return 0;
4896 }
4897
4898 /* Check modifiers that can be declared but exclusively */
4899
4900 static void
4901 check_modifiers_consistency (int flags)
4902 {
4903   int acc_count = 0;
4904   tree cl = NULL_TREE;
4905
4906   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4907   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4908   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4909   if (acc_count > 1)
4910     parse_error_context
4911       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4912
4913   acc_count = 0;
4914   cl = NULL_TREE;
4915   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4916   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4917   if (acc_count > 1)
4918     parse_error_context (cl,
4919                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4920 }
4921
4922 /* Check the methode header METH for abstract specifics features */
4923
4924 static void
4925 check_abstract_method_header (tree meth)
4926 {
4927   int flags = get_access_flags_from_decl (meth);
4928
4929   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4930                               ACC_ABSTRACT, "abstract method",
4931                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4932   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4933                               ACC_PUBLIC, "abstract method",
4934                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4935
4936   check_modifiers ("Illegal modifier `%s' for interface method",
4937                   flags, INTERFACE_METHOD_MODIFIERS);
4938 }
4939
4940 /* Create a FUNCTION_TYPE node and start augmenting it with the
4941    declared function arguments. Arguments type that can't be resolved
4942    are left as they are, but the returned node is marked as containing
4943    incomplete types.  */
4944
4945 static tree
4946 method_declarator (tree id, tree list)
4947 {
4948   tree arg_types = NULL_TREE, current, node;
4949   tree meth = make_node (FUNCTION_TYPE);
4950   jdep *jdep;
4951
4952   patch_stage = JDEP_NO_PATCH;
4953
4954   if (GET_CPC () == error_mark_node)
4955     return error_mark_node;
4956
4957   /* If we're dealing with an inner class constructor, we hide the
4958      this$<n> decl in the name field of its parameter declaration.  We
4959      also might have to hide the outer context local alias
4960      initializers. Not done when the class is a toplevel class. */
4961   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4962       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4963     {
4964       tree aliases_list, type, thisn;
4965       /* First the aliases, linked to the regular parameters */
4966       aliases_list =
4967         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4968                                                 TREE_TYPE (GET_CPC ()),
4969                                                 NULL_TREE, NULL);
4970       list = chainon (nreverse (aliases_list), list);
4971
4972       /* Then this$<n> */
4973       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4974       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4975       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4976                         list);
4977     }
4978
4979   for (current = list; current; current = TREE_CHAIN (current))
4980     {
4981       int must_chain = 0;
4982       tree wfl_name = TREE_PURPOSE (current);
4983       tree type = TREE_VALUE (current);
4984       tree name = EXPR_WFL_NODE (wfl_name);
4985       tree already, arg_node;
4986       tree type_wfl = NULL_TREE;
4987       tree real_type;
4988
4989       /* Obtain a suitable type for resolution, if necessary */
4990       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4991
4992       /* Process NAME, as it may specify extra dimension(s) for it */
4993       type = build_array_from_name (type, type_wfl, name, &name);
4994       EXPR_WFL_NODE (wfl_name) = name;
4995
4996       real_type = GET_REAL_TYPE (type);
4997       if (TREE_CODE (real_type) == RECORD_TYPE)
4998         {
4999           real_type = promote_type (real_type);
5000           if (TREE_CODE (type) == TREE_LIST)
5001             TREE_PURPOSE (type) = real_type;
5002         }
5003
5004       /* Check redefinition */
5005       for (already = arg_types; already; already = TREE_CHAIN (already))
5006         if (TREE_PURPOSE (already) == name)
5007           {
5008             parse_error_context
5009               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
5010                IDENTIFIER_POINTER (name),
5011                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
5012             break;
5013           }
5014
5015       /* If we've an incomplete argument type, we know there is a location
5016          to patch when the type get resolved, later.  */
5017       jdep = NULL;
5018       if (must_chain)
5019         {
5020           patch_stage = JDEP_METHOD;
5021           type = register_incomplete_type (patch_stage,
5022                                            type_wfl, wfl_name, type);
5023           jdep = CLASSD_LAST (ctxp->classd_list);
5024           JDEP_MISC (jdep) = id;
5025         }
5026
5027       /* The argument node: a name and a (possibly) incomplete type.  */
5028       arg_node = build_tree_list (name, real_type);
5029       /* Remember arguments declared final. */
5030       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5031
5032       if (jdep)
5033         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5034       TREE_CHAIN (arg_node) = arg_types;
5035       arg_types = arg_node;
5036     }
5037   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5038   node = build_tree_list (id, meth);
5039   return node;
5040 }
5041
5042 static int
5043 unresolved_type_p (tree wfl, tree *returned)
5044 {
5045   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5046     {
5047       if (returned)
5048         {
5049           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5050           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5051             *returned = TREE_TYPE (decl);
5052           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5053             *returned = TREE_TYPE (GET_CPC ());
5054           else
5055             *returned = NULL_TREE;
5056         }
5057       return 1;
5058     }
5059   if (returned)
5060     *returned = wfl;
5061   return 0;
5062 }
5063
5064 /* From NAME, build a qualified identifier node using the
5065    qualification from the current package definition. */
5066
5067 static tree
5068 parser_qualified_classname (tree name)
5069 {
5070   tree nested_class_name;
5071
5072   if ((nested_class_name = maybe_make_nested_class_name (name)))
5073     return nested_class_name;
5074
5075   if (ctxp->package)
5076     return merge_qualified_name (ctxp->package, name);
5077   else
5078     return name;
5079 }
5080
5081 /* Called once the type a interface extends is resolved. Returns 0 if
5082    everything is OK.  */
5083
5084 static int
5085 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5086 {
5087   tree super_type = TREE_TYPE (super_decl);
5088
5089   /* Has to be an interface */
5090   if (!CLASS_INTERFACE (super_decl))
5091     {
5092       parse_error_context
5093         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5094          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5095           "Interface" : "Class"),
5096          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5097          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5098          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5099       return 1;
5100     }
5101
5102   /* Check top-level interface access. Inner classes are subject to member
5103      access rules (6.6.1). */
5104   if (! INNER_CLASS_P (super_type)
5105       && check_pkg_class_access (DECL_NAME (super_decl),
5106                                  NULL_TREE, true, this_decl))
5107     return 1;
5108
5109   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5110                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5111                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5112   return 0;
5113 }
5114
5115 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5116    0 if everything is OK.  */
5117
5118 static int
5119 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5120 {
5121   tree super_type = TREE_TYPE (super_decl);
5122
5123   /* SUPER should be a CLASS (neither an array nor an interface) */
5124   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5125     {
5126       parse_error_context
5127         (wfl, "Class `%s' can't subclass %s `%s'",
5128          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5129          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5130          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5131       return 1;
5132     }
5133
5134   if (CLASS_FINAL (TYPE_NAME (super_type)))
5135     {
5136       parse_error_context (wfl, "Can't subclass final classes: %s",
5137                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5138       return 1;
5139     }
5140
5141   /* Check top-level class scope. Inner classes are subject to member access
5142      rules (6.6.1). */
5143   if (! INNER_CLASS_P (super_type)
5144       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5145     return 1;
5146
5147   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5148                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5149                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5150   return 0;
5151 }
5152
5153 /* Create a new dependency list and link it (in a LIFO manner) to the
5154    CTXP list of type dependency list.  */
5155
5156 static void
5157 create_jdep_list (struct parser_ctxt *ctxp)
5158 {
5159   jdeplist *new = xmalloc (sizeof (jdeplist));
5160   new->first = new->last = NULL;
5161   new->next = ctxp->classd_list;
5162   ctxp->classd_list = new;
5163 }
5164
5165 static jdeplist *
5166 reverse_jdep_list (struct parser_ctxt *ctxp)
5167 {
5168   jdeplist *prev = NULL, *current, *next;
5169   for (current = ctxp->classd_list; current; current = next)
5170     {
5171       next = current->next;
5172       current->next = prev;
5173       prev = current;
5174     }
5175   return prev;
5176 }
5177
5178 /* Create a fake pointer based on the ID stored in
5179    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5180    registered again. */
5181
5182 static tree
5183 obtain_incomplete_type (tree type_name)
5184 {
5185   tree ptr = NULL_TREE, name;
5186
5187   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5188     name = EXPR_WFL_NODE (type_name);
5189   else if (INCOMPLETE_TYPE_P (type_name))
5190     name = TYPE_NAME (type_name);
5191   else
5192     abort ();
5193
5194   /* Workaround from build_pointer_type for incomplete types.  */
5195   BUILD_PTR_FROM_NAME (ptr, name);
5196   TYPE_MODE (ptr) = ptr_mode;
5197   layout_type (ptr);
5198
5199   return ptr;
5200 }
5201
5202 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5203    non NULL instead of computing a new fake type based on WFL. The new
5204    dependency is inserted in the current type dependency list, in FIFO
5205    manner.  */
5206
5207 static tree
5208 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5209 {
5210   jdep *new = xmalloc (sizeof (jdep));
5211
5212   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5213     ptr = obtain_incomplete_type (wfl);
5214
5215   JDEP_KIND (new) = kind;
5216   JDEP_DECL (new) = decl;
5217   JDEP_TO_RESOLVE (new) = ptr;
5218   JDEP_WFL (new) = wfl;
5219   JDEP_CHAIN (new) = NULL;
5220   JDEP_MISC (new) = NULL_TREE;
5221   /* For some dependencies, set the enclosing class of the current
5222      class to be the enclosing context */
5223   if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
5224       && GET_ENCLOSING_CPC ())
5225     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5226   else
5227     JDEP_ENCLOSING (new) = GET_CPC ();
5228   JDEP_GET_PATCH (new) = (tree *)NULL;
5229
5230   JDEP_INSERT (ctxp->classd_list, new);
5231
5232   return ptr;
5233 }
5234
5235 /* This checks for circular references with innerclasses. We start
5236    from SOURCE and should never reach TARGET. Extended/implemented
5237    types in SOURCE have their enclosing context checked not to reach
5238    TARGET. When the last enclosing context of SOURCE is reached, its
5239    extended/implemented types are also checked not to reach TARGET.
5240    In case of error, WFL of the offending type is returned; NULL_TREE
5241    otherwise.  */
5242
5243 static tree
5244 check_inner_circular_reference (tree source, tree target)
5245 {
5246   tree base_binfo;
5247   tree ctx, cl;
5248   int i;
5249
5250   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (source), i, base_binfo); i++)
5251     {
5252       tree su;
5253
5254       /* We can end up with a NULL_TREE or an incomplete type here if
5255          we encountered previous type resolution errors. It's safe to
5256          simply ignore these cases.  */
5257       su = BINFO_TYPE (base_binfo);
5258       if (INCOMPLETE_TYPE_P (su))
5259         continue;
5260
5261       if (inherits_from_p (su, target))
5262         return lookup_cl (TYPE_NAME (su));
5263
5264       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5265         {
5266           /* An enclosing context shouldn't be TARGET */
5267           if (ctx == TYPE_NAME (target))
5268             return lookup_cl (TYPE_NAME (su));
5269
5270           /* When we reach the enclosing last context, start a check
5271              on it, with the same target */
5272           if (! DECL_CONTEXT (ctx) &&
5273               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5274             return cl;
5275         }
5276     }
5277   return NULL_TREE;
5278 }
5279
5280 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5281    offending type if a circularity is detected. NULL_TREE is returned
5282    otherwise. TYPE can be an interface or a class.   */
5283
5284 static tree
5285 check_circular_reference (tree type)
5286 {
5287   tree base_binfo;
5288   int i;
5289
5290   if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
5291     return NULL_TREE;
5292
5293   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5294     {
5295       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5296         return lookup_cl (TYPE_NAME (type));
5297       return NULL_TREE;
5298     }
5299
5300   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo); i++)
5301     {
5302       if (BINFO_TYPE (base_binfo) != object_type_node
5303           && interface_of_p (type, BINFO_TYPE (base_binfo)))
5304         return lookup_cl (TYPE_NAME (BINFO_TYPE (base_binfo)));
5305     }
5306   return NULL_TREE;
5307 }
5308
5309 void
5310 java_check_circular_reference (void)
5311 {
5312   tree current;
5313   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5314     {
5315       tree type = TREE_TYPE (current);
5316       tree cl;
5317
5318       cl = check_circular_reference (type);
5319       if (! cl)
5320         cl = check_inner_circular_reference (type, type);
5321       if (cl)
5322         parse_error_context (cl, "Cyclic class inheritance%s",
5323                              (cyclic_inheritance_report ?
5324                               cyclic_inheritance_report : ""));
5325     }
5326 }
5327
5328 /* Augment the parameter list PARM with parameters crafted to
5329    initialize outer context locals aliases. Through ARTIFICIAL, a
5330    count is kept of the number of crafted parameters. MODE governs
5331    what eventually gets created: something suitable for a function
5332    creation or a function invocation, either the constructor or
5333    finit$.  */
5334
5335 static tree
5336 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5337                                         int *artificial)
5338 {
5339   tree field;
5340   tree additional_parms = NULL_TREE;
5341
5342   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5343     if (FIELD_LOCAL_ALIAS (field))
5344       {
5345         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5346         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5347         tree mangled_id;
5348
5349         switch (mode)
5350           {
5351           case AIPL_FUNCTION_DECLARATION:
5352             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5353                                                          &buffer [4]);
5354             purpose = build_wfl_node (mangled_id);
5355             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5356               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5357             else
5358               value = TREE_TYPE (field);
5359             break;
5360
5361           case AIPL_FUNCTION_CREATION:
5362             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5363                                                          &buffer [4]);
5364             value = TREE_TYPE (field);
5365             break;
5366
5367           case AIPL_FUNCTION_FINIT_INVOCATION:
5368             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5369                                                          &buffer [4]);
5370             /* Now, this is wrong. purpose should always be the NAME
5371                of something and value its matching value (decl, type,
5372                etc...) FIXME -- but there is a lot to fix. */
5373
5374             /* When invoked for this kind of operation, we already
5375                know whether a field is used or not. */
5376             purpose = TREE_TYPE (field);
5377             value = build_wfl_node (mangled_id);
5378             break;
5379
5380           case AIPL_FUNCTION_CTOR_INVOCATION:
5381             /* There are two case: the constructor invocation happens
5382                outside the local inner, in which case, locales from the outer
5383                context are directly used.
5384
5385                Otherwise, we fold to using the alias directly. */
5386             if (class_type == current_class)
5387               value = field;
5388             else
5389               {
5390                 name = get_identifier (&buffer[4]);
5391                 value = IDENTIFIER_LOCAL_VALUE (name);
5392               }
5393             break;
5394           }
5395         additional_parms = tree_cons (purpose, value, additional_parms);
5396         if (artificial)
5397           *artificial +=1;
5398       }
5399   if (additional_parms)
5400     {
5401       if (ANONYMOUS_CLASS_P (class_type)
5402           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5403         additional_parms = nreverse (additional_parms);
5404       parm = chainon (additional_parms, parm);
5405     }
5406
5407    return parm;
5408 }
5409
5410 /* Craft a constructor for CLASS_DECL -- what we should do when none
5411    where found. ARGS is non NULL when a special signature must be
5412    enforced. This is the case for anonymous classes.  */
5413
5414 static tree
5415 craft_constructor (tree class_decl, tree args)
5416 {
5417   tree class_type = TREE_TYPE (class_decl);
5418   tree parm = NULL_TREE;
5419   /* Inherit access flags for the constructor from its enclosing class. */
5420   int valid_ctor_flags = ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE;
5421   int flags = (get_access_flags_from_decl (class_decl) & valid_ctor_flags);
5422   int i = 0, artificial = 0;
5423   tree decl, ctor_name;
5424   char buffer [80];
5425
5426   ctor_name = init_identifier_node;
5427
5428   /* If we're dealing with an inner class constructor, we hide the
5429      this$<n> decl in the name field of its parameter declaration. */
5430   if (PURE_INNER_CLASS_TYPE_P (class_type))
5431     {
5432       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5433       parm = tree_cons (build_current_thisn (class_type),
5434                         build_pointer_type (type), parm);
5435
5436       /* Some more arguments to be hidden here. The values of the local
5437          variables of the outer context that the inner class needs to see. */
5438       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5439                                                      class_type, parm,
5440                                                      &artificial);
5441     }
5442
5443   /* Then if there are any args to be enforced, enforce them now */
5444   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5445     {
5446       sprintf (buffer, "parm%d", i++);
5447       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5448     }
5449
5450   CRAFTED_PARAM_LIST_FIXUP (parm);
5451   decl = create_artificial_method (class_type, flags, void_type_node,
5452                                    ctor_name, parm);
5453   fix_method_argument_names (parm, decl);
5454   /* Now, mark the artificial parameters. */
5455   DECL_FUNCTION_NAP (decl) = artificial;
5456   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5457   DECL_INLINE (decl) = 1;
5458   return decl;
5459 }
5460
5461
5462 /* Fix the constructors. This will be called right after circular
5463    references have been checked. It is necessary to fix constructors
5464    early even if no code generation will take place for that class:
5465    some generated constructor might be required by the class whose
5466    compilation triggered this one to be simply loaded.  */
5467
5468 void
5469 java_fix_constructors (void)
5470 {
5471   tree current;
5472
5473   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5474     {
5475       tree class_type = TREE_TYPE (current);
5476       int saw_ctor = 0;
5477       tree decl;
5478
5479       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5480         continue;
5481
5482       output_class = current_class = class_type;
5483       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5484         {
5485           if (DECL_CONSTRUCTOR_P (decl))
5486             {
5487               fix_constructors (decl);
5488               saw_ctor = 1;
5489             }
5490         }
5491
5492       /* Anonymous class constructor can't be generated that early. */
5493       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5494         craft_constructor (current, NULL_TREE);
5495     }
5496 }
5497
5498 /* safe_layout_class just makes sure that we can load a class without
5499    disrupting the current_class, input_file, input_line, etc, information
5500    about the class processed currently.  */
5501
5502 void
5503 safe_layout_class (tree class)
5504 {
5505   tree save_current_class = current_class;
5506   location_t save_location = input_location;
5507
5508   layout_class (class);
5509
5510   current_class = save_current_class;
5511   input_location = save_location;
5512 }
5513
5514 static tree
5515 jdep_resolve_class (jdep *dep)
5516 {
5517   tree decl;
5518
5519   if (JDEP_RESOLVED_P (dep))
5520     decl = JDEP_RESOLVED_DECL (dep);
5521   else
5522     {
5523       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5524                             JDEP_DECL (dep), JDEP_WFL (dep));
5525       JDEP_RESOLVED (dep, decl);
5526       /* If there is no WFL, that's ok.  We generate this warning
5527          elsewhere.  */
5528       if (decl && JDEP_WFL (dep) != NULL_TREE)
5529         check_deprecation (JDEP_WFL (dep), decl);
5530     }
5531
5532   if (!decl)
5533     complete_class_report_errors (dep);
5534   else if (INNER_CLASS_DECL_P (decl))
5535     {
5536       tree inner = TREE_TYPE (decl);
5537       if (! CLASS_LOADED_P (inner))
5538         {
5539           safe_layout_class (inner);
5540           if (TYPE_SIZE (inner) == error_mark_node)
5541             TYPE_SIZE (inner) = NULL_TREE;
5542         }
5543       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5544     }
5545   return decl;
5546 }
5547
5548 /* Complete unsatisfied class declaration and their dependencies */
5549
5550 void
5551 java_complete_class (void)
5552 {
5553   tree cclass;
5554   jdeplist *cclassd;
5555   int error_found;
5556   tree type;
5557
5558   /* Process imports */
5559   process_imports ();
5560
5561   /* Reverse things so we have the right order */
5562   ctxp->class_list = nreverse (ctxp->class_list);
5563   ctxp->classd_list = reverse_jdep_list (ctxp);
5564
5565   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5566        cclass && cclassd;
5567        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5568     {
5569       jdep *dep;
5570
5571       /* We keep the compilation unit imports in the class so that
5572          they can be used later to resolve type dependencies that
5573          aren't necessary to solve now. */
5574       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5575       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5576
5577       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5578         {
5579           tree decl;
5580           if (!(decl = jdep_resolve_class (dep)))
5581             continue;
5582
5583           /* Now it's time to patch */
5584           switch (JDEP_KIND (dep))
5585             {
5586             case JDEP_SUPER:
5587               /* Simply patch super */
5588               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5589                 continue;
5590               BINFO_TYPE (BINFO_BASE_BINFO
5591                           (TYPE_BINFO (TREE_TYPE (JDEP_DECL (dep))), 0))
5592                 = TREE_TYPE (decl);
5593               break;
5594
5595             case JDEP_FIELD:
5596               {
5597                 /* We do part of the job done in add_field */
5598                 tree field_decl = JDEP_DECL (dep);
5599                 tree field_type = TREE_TYPE (decl);
5600                 if (TREE_CODE (field_type) == RECORD_TYPE)
5601                   field_type = promote_type (field_type);
5602                 TREE_TYPE (field_decl) = field_type;
5603                 DECL_ALIGN (field_decl) = 0;
5604                 DECL_USER_ALIGN (field_decl) = 0;
5605                 layout_decl (field_decl, 0);
5606                 SOURCE_FRONTEND_DEBUG
5607                   (("Completed field/var decl `%s' with `%s'",
5608                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5609                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5610                 break;
5611               }
5612             case JDEP_METHOD:   /* We start patching a method */
5613             case JDEP_METHOD_RETURN:
5614               error_found = 0;
5615               while (1)
5616                 {
5617                   if (decl)
5618                     {
5619                       type = TREE_TYPE(decl);
5620                       if (TREE_CODE (type) == RECORD_TYPE)
5621                         type = promote_type (type);
5622                       JDEP_APPLY_PATCH (dep, type);
5623                       SOURCE_FRONTEND_DEBUG
5624                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5625                            "Completing fct `%s' with ret type `%s'":
5626                            "Completing arg `%s' with type `%s'"),
5627                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5628                                               (JDEP_DECL_WFL (dep))),
5629                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5630                     }
5631                   else
5632                     error_found = 1;
5633                   dep = JDEP_CHAIN (dep);
5634                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5635                     break;
5636                   else
5637                     decl = jdep_resolve_class (dep);
5638                 }
5639               if (!error_found)
5640                 {
5641                   tree mdecl = JDEP_DECL (dep), signature;
5642                   /* Recompute and reset the signature, check first that
5643                      all types are now defined. If they're not,
5644                      don't build the signature. */
5645                   if (check_method_types_complete (mdecl))
5646                     {
5647                       signature = build_java_signature (TREE_TYPE (mdecl));
5648                       set_java_signature (TREE_TYPE (mdecl), signature);
5649                     }
5650                 }
5651               else
5652                 continue;
5653               break;
5654
5655             case JDEP_INTERFACE:
5656               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5657                                                 JDEP_WFL (dep)))
5658                 continue;
5659               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5660               break;
5661
5662             case JDEP_PARM:
5663             case JDEP_VARIABLE:
5664               type = TREE_TYPE(decl);
5665               if (TREE_CODE (type) == RECORD_TYPE)
5666                 type = promote_type (type);
5667               JDEP_APPLY_PATCH (dep, type);
5668               break;
5669
5670             case JDEP_TYPE:
5671               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5672               SOURCE_FRONTEND_DEBUG
5673                 (("Completing a random type dependency on a '%s' node",
5674                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5675               break;
5676
5677             case JDEP_EXCEPTION:
5678               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5679               SOURCE_FRONTEND_DEBUG
5680                 (("Completing `%s' `throws' argument node",
5681                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5682               break;
5683
5684             case JDEP_ANONYMOUS:
5685               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5686               break;
5687
5688             default:
5689               abort ();
5690             }
5691         }
5692     }
5693   return;
5694 }
5695
5696 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5697    array.  */
5698
5699 static tree
5700 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5701 {
5702   tree tname = TYPE_NAME (class_type);
5703   tree resolved_type = TREE_TYPE (class_type);
5704   int array_dims = 0;
5705   tree resolved_type_decl;
5706
5707   if (resolved_type != NULL_TREE)
5708     {
5709       tree resolved_type_decl = TYPE_NAME (resolved_type);
5710       if (resolved_type_decl == NULL_TREE
5711           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5712         {
5713           resolved_type_decl = build_decl (TYPE_DECL,
5714                                            TYPE_NAME (class_type),
5715                                            resolved_type);
5716         }
5717       return resolved_type_decl;
5718     }
5719
5720   /* 1- Check to see if we have an array. If true, find what we really
5721      want to resolve  */
5722   if ((array_dims = build_type_name_from_array_name (tname,
5723                                                      &TYPE_NAME (class_type))))
5724     WFL_STRIP_BRACKET (cl, cl);
5725
5726   /* 2- Resolve the bare type */
5727   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5728                                                decl, cl)))
5729     return NULL_TREE;
5730   resolved_type = TREE_TYPE (resolved_type_decl);
5731
5732   /* 3- If we have an array, reconstruct the array down to its nesting */
5733   if (array_dims)
5734     {
5735       for (; array_dims; array_dims--)
5736         resolved_type = build_java_array_type (resolved_type, -1);
5737       resolved_type_decl = TYPE_NAME (resolved_type);
5738     }
5739   TREE_TYPE (class_type) = resolved_type;
5740   return resolved_type_decl;
5741 }
5742
5743 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5744    are used to report error messages; CL must either be NULL_TREE or a
5745    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5746    by a variable, since it is changed by find_in_imports{_on_demand}
5747    and (but it doesn't really matter) qualify_and_find.  */
5748
5749 tree
5750 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5751 {
5752   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5753   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5754   tree decl_result;
5755   htab_t circularity_hash;
5756
5757   if (QUALIFIED_P (TYPE_NAME (class_type)))
5758     {
5759       /* If the type name is of the form `Q . Id', then Q is either a
5760          package name or a class name.  First we try to find Q as a
5761          class and then treat Id as a member type.  If we can't find Q
5762          as a class then we fall through.  */
5763       tree q, left, left_type, right;
5764       if (split_qualified_name (&left, &right, TYPE_NAME (class_type)) == 0)
5765         {
5766           BUILD_PTR_FROM_NAME (left_type, left);
5767           q = do_resolve_class (enclosing, left_type, decl, cl);
5768           if (q)
5769             {
5770               enclosing = q;
5771               saved_enclosing_type = TREE_TYPE (q);
5772               BUILD_PTR_FROM_NAME (class_type, right);
5773             }
5774         }
5775     }
5776
5777   if (enclosing)
5778     {
5779       /* This hash table is used to register the classes we're going
5780          through when searching the current class as an inner class, in
5781          order to detect circular references. Remember to free it before
5782          returning the section 0- of this function. */
5783       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5784                                       NULL);
5785
5786       /* 0- Search in the current class as an inner class.
5787          Maybe some code here should be added to load the class or
5788          something, at least if the class isn't an inner class and ended
5789          being loaded from class file. FIXME. */
5790       while (enclosing)
5791         {
5792           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5793                                                 &super, class_type);
5794           if (new_class_decl)
5795             break;
5796
5797           /* If we haven't found anything because SUPER reached Object and
5798              ENCLOSING happens to be an innerclass, try the enclosing context. */
5799           if ((!super || super == object_type_node) &&
5800               enclosing && INNER_CLASS_DECL_P (enclosing))
5801             enclosing = DECL_CONTEXT (enclosing);
5802           else
5803             enclosing = NULL_TREE;
5804         }
5805
5806       htab_delete (circularity_hash);
5807
5808       if (new_class_decl)
5809         return new_class_decl;
5810     }
5811
5812   /* 1- Check for the type in single imports. This will change
5813      TYPE_NAME() if something relevant is found */
5814   find_in_imports (saved_enclosing_type, class_type);
5815
5816   /* 2- And check for the type in the current compilation unit */
5817   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5818     {
5819       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5820         load_class (TYPE_NAME (class_type), 0);
5821       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5822     }
5823
5824   /* 3- Search according to the current package definition */
5825   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5826     {
5827       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5828                                              TYPE_NAME (class_type))))
5829         return new_class_decl;
5830     }
5831
5832   /* 4- Check the import on demands. Don't allow bar.baz to be
5833      imported from foo.* */
5834   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5835     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5836       return NULL_TREE;
5837
5838   /* If found in find_in_imports_on_demand, the type has already been
5839      loaded. */
5840   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5841     return new_class_decl;
5842
5843   /* 5- Try with a name qualified with the package name we've seen so far */
5844   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5845     {
5846       tree package;
5847
5848       /* If there is a current package (ctxp->package), it's the first
5849          element of package_list and we can skip it. */
5850       for (package = (ctxp->package ?
5851                       TREE_CHAIN (package_list) : package_list);
5852            package; package = TREE_CHAIN (package))
5853         if ((new_class_decl = qualify_and_find (class_type,
5854                                                TREE_PURPOSE (package),
5855                                                TYPE_NAME (class_type))))
5856           return new_class_decl;
5857     }
5858
5859   /* 5- Check another compilation unit that bears the name of type */
5860   load_class (TYPE_NAME (class_type), 0);
5861
5862   if (!cl)
5863     cl = lookup_cl (decl);
5864
5865   /* If we don't have a value for CL, then we're being called recursively.
5866      We can't check package access just yet, but it will be taken care of
5867      by the caller. */
5868   if (cl)
5869     {
5870       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5871         return NULL_TREE;
5872     }
5873
5874   /* 6- Last call for a resolution */
5875   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5876
5877   /* The final lookup might have registered a.b.c into a.b$c If we
5878      failed at the first lookup, progressively change the name if
5879      applicable and use the matching DECL instead. */
5880   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5881     {
5882       char *separator;
5883       tree name = TYPE_NAME (class_type);
5884       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5885
5886       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5887
5888       do {
5889
5890        /* Reach the last '.', and if applicable, replace it by a `$' and
5891           see if this exists as a type. */
5892        if ((separator = strrchr (namebuffer, '.')))
5893          {
5894            *separator = '$';
5895            name = get_identifier (namebuffer);
5896            decl_result = IDENTIFIER_CLASS_VALUE (name);
5897          }
5898       } while (!decl_result && separator);
5899     }
5900   return decl_result;
5901 }
5902
5903 static tree
5904 qualify_and_find (tree class_type, tree package, tree name)
5905 {
5906   tree new_qualified = merge_qualified_name (package, name);
5907   tree new_class_decl;
5908
5909   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5910     load_class (new_qualified, 0);
5911   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5912     {
5913       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5914         load_class (TREE_TYPE (new_class_decl), 0);
5915       TYPE_NAME (class_type) = new_qualified;
5916       return IDENTIFIER_CLASS_VALUE (new_qualified);
5917     }
5918   return NULL_TREE;
5919 }
5920
5921 /* Resolve NAME and lay it out (if not done and if not the current
5922    parsed class). Return a decl node. This function is meant to be
5923    called when type resolution is necessary during the walk pass.  */
5924
5925 static tree
5926 resolve_and_layout (tree something, tree cl)
5927 {
5928   tree decl, decl_type;
5929
5930   /* Don't do that on the current class */
5931   if (something == current_class)
5932     return TYPE_NAME (current_class);
5933
5934   /* Don't do anything for void and other primitive types */
5935   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5936     return NULL_TREE;
5937
5938   /* Pointer types can be reall pointer types or fake pointers. When
5939      finding a real pointer, recheck for primitive types */
5940   if (TREE_CODE (something) == POINTER_TYPE)
5941     {
5942       if (TREE_TYPE (something))
5943         {
5944           something = TREE_TYPE (something);
5945           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5946             return NULL_TREE;
5947         }
5948       else
5949         something = TYPE_NAME (something);
5950     }
5951
5952   /* Don't do anything for arrays of primitive types */
5953   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5954       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5955     return NULL_TREE;
5956
5957   /* Something might be a WFL */
5958   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5959     something = EXPR_WFL_NODE (something);
5960
5961   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5962      TYPE_DECL or a real TYPE */
5963   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5964     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5965             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5966
5967   if (!(decl = resolve_no_layout (something, cl)))
5968     return NULL_TREE;
5969
5970   /* Resolve and layout if necessary */
5971   decl_type = TREE_TYPE (decl);
5972   layout_class_methods (decl_type);
5973   /* Check methods */
5974   if (CLASS_FROM_SOURCE_P (decl_type))
5975     java_check_methods (decl);
5976   /* Layout the type if necessary */
5977   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5978     safe_layout_class (decl_type);
5979
5980   return decl;
5981 }
5982
5983 /* Resolve a class, returns its decl but doesn't perform any
5984    layout. The current parsing context is saved and restored */
5985
5986 static tree
5987 resolve_no_layout (tree name, tree cl)
5988 {
5989   tree ptr, decl;
5990   BUILD_PTR_FROM_NAME (ptr, name);
5991   java_parser_context_save_global ();
5992   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5993   java_parser_context_restore_global ();
5994
5995   return decl;
5996 }
5997
5998 /* Called when reporting errors. Skip the '[]'s in a complex array
5999    type description that failed to be resolved. purify_type_name can't
6000    use an identifier tree.  */
6001
6002 static const char *
6003 purify_type_name (const char *name)
6004 {
6005   int len = strlen (name);
6006   int bracket_found;
6007
6008   STRING_STRIP_BRACKETS (name, len, bracket_found);
6009   if (bracket_found)
6010     {
6011       char *stripped_name = xmemdup (name, len, len+1);
6012       stripped_name [len] = '\0';
6013       return stripped_name;
6014     }
6015   return name;
6016 }
6017
6018 /* The type CURRENT refers to can't be found. We print error messages.  */
6019
6020 static void
6021 complete_class_report_errors (jdep *dep)
6022 {
6023   const char *name;
6024
6025   if (!JDEP_WFL (dep))
6026     return;
6027
6028   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6029   switch (JDEP_KIND (dep))
6030     {
6031     case JDEP_SUPER:
6032       parse_error_context
6033         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6034          purify_type_name (name),
6035          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6036       break;
6037     case JDEP_FIELD:
6038       parse_error_context
6039         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6040          purify_type_name (name),
6041          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6042       break;
6043     case JDEP_METHOD:           /* Covers arguments */
6044       parse_error_context
6045         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6046          purify_type_name (name),
6047          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6048          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6049       break;
6050     case JDEP_METHOD_RETURN:    /* Covers return type */
6051       parse_error_context
6052         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6053          purify_type_name (name),
6054          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6055       break;
6056     case JDEP_INTERFACE:
6057       parse_error_context
6058         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6059          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6060          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6061          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6062       break;
6063     case JDEP_VARIABLE:
6064       parse_error_context
6065         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6066          purify_type_name (IDENTIFIER_POINTER
6067                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6068          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6069       break;
6070     case JDEP_EXCEPTION:        /* As specified by `throws' */
6071       parse_error_context
6072           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6073          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6074       break;
6075     default:
6076       /* Fix for -Wall. Just break doing nothing. The error will be
6077          caught later */
6078       break;
6079     }
6080 }
6081
6082 /* Return a static string containing the DECL prototype string. If
6083    DECL is a constructor, use the class name instead of the form
6084    <init> */
6085
6086 static const char *
6087 get_printable_method_name (tree decl)
6088 {
6089   const char *to_return;
6090   tree name = NULL_TREE;
6091
6092   if (DECL_CONSTRUCTOR_P (decl))
6093     {
6094       name = DECL_NAME (decl);
6095       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6096     }
6097
6098   to_return = lang_printable_name (decl, 2);
6099   if (DECL_CONSTRUCTOR_P (decl))
6100     DECL_NAME (decl) = name;
6101
6102   return to_return;
6103 }
6104
6105 /* Track method being redefined inside the same class. As a side
6106    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6107    function it's a FWL, so we can track errors more accurately.)  */
6108
6109 static int
6110 check_method_redefinition (tree class, tree method)
6111 {
6112   tree redef, sig;
6113
6114   /* There's no need to verify <clinit> and finit$ and instinit$ */
6115   if (DECL_CLINIT_P (method)
6116       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6117     return 0;
6118
6119   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6120   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6121     {
6122       if (redef == method)
6123         break;
6124       if (DECL_NAME (redef) == DECL_NAME (method)
6125           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6126           && !DECL_ARTIFICIAL (method))
6127         {
6128           parse_error_context
6129             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6130              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6131              get_printable_method_name (redef));
6132           return 1;
6133         }
6134     }
6135   return 0;
6136 }
6137
6138 /* Return 1 if check went ok, 0 otherwise.  */
6139 static int
6140 check_abstract_method_definitions (int do_interface, tree class_decl,
6141                                    tree type)
6142 {
6143   tree class = TREE_TYPE (class_decl);
6144   tree method, end_type;
6145   int ok = 1;
6146
6147   end_type = (do_interface ? object_type_node : type);
6148   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6149     {
6150       tree other_super, other_method, method_sig, method_name;
6151       int found = 0;
6152       int end_type_reached = 0;
6153
6154       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6155         continue;
6156
6157       /* Now verify that somewhere in between TYPE and CLASS,
6158          abstract method METHOD gets a non abstract definition
6159          that is inherited by CLASS.  */
6160
6161       method_sig = build_java_signature (TREE_TYPE (method));
6162       method_name = DECL_NAME (method);
6163       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6164         method_name = EXPR_WFL_NODE (method_name);
6165
6166       other_super = class;
6167       do {
6168         if (other_super == end_type)
6169           end_type_reached = 1;
6170
6171         /* Method search */
6172         for (other_method = TYPE_METHODS (other_super); other_method;
6173             other_method = TREE_CHAIN (other_method))
6174           {
6175             tree s = build_java_signature (TREE_TYPE (other_method));
6176             tree other_name = DECL_NAME (other_method);
6177
6178             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6179               other_name = EXPR_WFL_NODE (other_name);
6180             if (!DECL_CLINIT_P (other_method)
6181                 && !DECL_CONSTRUCTOR_P (other_method)
6182                 && method_name == other_name
6183                 && method_sig == s
6184                 && !METHOD_ABSTRACT (other_method))
6185              {
6186                found = 1;
6187                break;
6188              }
6189           }
6190         other_super = CLASSTYPE_SUPER (other_super);
6191       } while (!end_type_reached);
6192
6193       /* Report that abstract METHOD didn't find an implementation
6194          that CLASS can use. */
6195       if (!found)
6196         {
6197           char *t = xstrdup (lang_printable_name
6198                             (TREE_TYPE (TREE_TYPE (method)), 0));
6199           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6200
6201           parse_error_context
6202             (lookup_cl (class_decl),
6203              "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
6204              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6205              t, lang_printable_name (method, 2),
6206              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6207               "interface" : "class"),
6208              IDENTIFIER_POINTER (ccn),
6209              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6210              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6211           ok = 0;
6212           free (t);
6213         }
6214     }
6215
6216   if (ok && do_interface)
6217     {
6218       /* Check for implemented interfaces. */
6219       int i;
6220       tree base_binfo;
6221
6222       for (i = 1;
6223            ok && BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo);
6224            i++)
6225         ok = check_abstract_method_definitions (1, class_decl,
6226                                                 BINFO_TYPE (base_binfo));
6227     }
6228
6229   return ok;
6230 }
6231
6232 /* Check that CLASS_DECL somehow implements all inherited abstract
6233    methods.  */
6234
6235 static void
6236 java_check_abstract_method_definitions (tree class_decl)
6237 {
6238   tree class = TREE_TYPE (class_decl);
6239   tree super, base_binfo;
6240   int i;
6241
6242   if (CLASS_ABSTRACT (class_decl))
6243     return;
6244
6245   /* Check for inherited types */
6246   super = class;
6247   do {
6248     super = CLASSTYPE_SUPER (super);
6249     check_abstract_method_definitions (0, class_decl, super);
6250   } while (super != object_type_node);
6251
6252   /* Check for implemented interfaces. */
6253   for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6254     check_abstract_method_definitions (1, class_decl, BINFO_TYPE (base_binfo));
6255 }
6256
6257 /* Check all the types method DECL uses and return 1 if all of them
6258    are now complete, 0 otherwise. This is used to check whether its
6259    safe to build a method signature or not.  */
6260
6261 static int
6262 check_method_types_complete (tree decl)
6263 {
6264   tree type = TREE_TYPE (decl);
6265   tree args;
6266
6267   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6268     return 0;
6269
6270   args = TYPE_ARG_TYPES (type);
6271   if (TREE_CODE (type) == METHOD_TYPE)
6272     args = TREE_CHAIN (args);
6273   for (; args != end_params_node; args = TREE_CHAIN (args))
6274     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6275       return 0;
6276
6277   return 1;
6278 }
6279
6280 /* Visible interface to check methods contained in CLASS_DECL */
6281
6282 void
6283 java_check_methods (tree class_decl)
6284 {
6285   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6286     return;
6287
6288   if (CLASS_INTERFACE (class_decl))
6289     java_check_abstract_methods (class_decl);
6290   else
6291     java_check_regular_methods (class_decl);
6292
6293   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6294 }
6295
6296 /* Like not_accessible_p, but doesn't refer to the current class at
6297    all.  */
6298 static bool
6299 hack_is_accessible_p (tree member, tree from_where)
6300 {
6301   int flags = get_access_flags_from_decl (member);
6302
6303   if (from_where == DECL_CONTEXT (member)
6304       || (flags & ACC_PUBLIC))
6305     return true;
6306
6307   if ((flags & ACC_PROTECTED))
6308     {
6309       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6310         return true;
6311     }
6312
6313   if ((flags & ACC_PRIVATE))
6314     return false;
6315
6316   /* Package private, or protected.  */
6317   return in_same_package (TYPE_NAME (from_where),
6318                           TYPE_NAME (DECL_CONTEXT (member)));
6319 }
6320
6321 /* Check all the methods of CLASS_DECL. Methods are first completed
6322    then checked according to regular method existence rules.  If no
6323    constructor for CLASS_DECL were encountered, then build its
6324    declaration.  */
6325 static void
6326 java_check_regular_methods (tree class_decl)
6327 {
6328   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6329   tree method;
6330   tree class = TREE_TYPE (class_decl);
6331   tree found = NULL_TREE;
6332   tree mthrows;
6333
6334   /* It is not necessary to check methods defined in java.lang.Object */
6335   if (class == object_type_node)
6336     return;
6337
6338   if (!TYPE_NVIRTUALS (class))
6339     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6340
6341   /* Should take interfaces into account. FIXME */
6342   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6343     {
6344       tree sig;
6345       tree method_wfl = DECL_FUNCTION_WFL (method);
6346       int aflags;
6347
6348       /* Check for redefinitions */
6349       if (check_method_redefinition (class, method))
6350         continue;
6351
6352       /* We verify things thrown by the method.  They must inherit from
6353          java.lang.Throwable.  */
6354       for (mthrows = DECL_FUNCTION_THROWS (method);
6355            mthrows; mthrows = TREE_CHAIN (mthrows))
6356         {
6357           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6358             parse_error_context
6359               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6360                IDENTIFIER_POINTER
6361                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6362         }
6363
6364       /* If we see one constructor a mark so we don't generate the
6365          default one.  Also skip other verifications: constructors
6366          can't be inherited hence hidden or overridden.  */
6367       if (DECL_CONSTRUCTOR_P (method))
6368         {
6369           saw_constructor = 1;
6370           continue;
6371         }
6372
6373       sig = build_java_argument_signature (TREE_TYPE (method));
6374       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6375                                               SEARCH_SUPER | SEARCH_INTERFACE);
6376
6377       /* Inner class can't declare static methods */
6378       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6379         {
6380           char *t = xstrdup (lang_printable_name (class, 0));
6381           parse_error_context
6382             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6383              lang_printable_name (method, 2), t);
6384           free (t);
6385         }
6386
6387       /* Nothing overrides or it's a private method. */
6388       if (!found)
6389         continue;
6390       if (METHOD_PRIVATE (found))
6391         {
6392           found = NULL_TREE;
6393           continue;
6394         }
6395
6396       /* If `found' is declared in an interface, make sure the
6397          modifier matches. */
6398       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6399           && clinit_identifier_node != DECL_NAME (found)
6400           && !METHOD_PUBLIC (method))
6401         {
6402           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6403           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6404                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6405                                lang_printable_name (method, 2),
6406                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6407         }
6408
6409       /* Can't override a method with the same name and different return
6410          types. */
6411       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6412         {
6413           char *t = xstrdup
6414             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6415           parse_error_context
6416             (method_wfl,
6417              "Method `%s' was defined with return type `%s' in class `%s'",
6418              lang_printable_name (found, 2), t,
6419              IDENTIFIER_POINTER
6420                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6421           free (t);
6422         }
6423
6424       aflags = get_access_flags_from_decl (found);
6425
6426       /* Can't override final. Can't override static. */
6427       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6428         {
6429           /* Static *can* override static */
6430           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6431             continue;
6432           parse_error_context
6433             (method_wfl,
6434              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6435              (METHOD_FINAL (found) ? "Final" : "Static"),
6436              lang_printable_name (found, 2),
6437              (METHOD_FINAL (found) ? "final" : "static"),
6438              IDENTIFIER_POINTER
6439                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6440           continue;
6441         }
6442
6443       /* Static method can't override instance method. */
6444       if (METHOD_STATIC (method))
6445         {
6446           parse_error_context
6447             (method_wfl,
6448              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6449              lang_printable_name (found, 2),
6450              IDENTIFIER_POINTER
6451                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6452           continue;
6453         }
6454
6455       /* - Overriding/hiding public must be public
6456          - Overriding/hiding protected must be protected or public
6457          - If the overridden or hidden method has default (package)
6458            access, then the overriding or hiding method must not be
6459            private; otherwise, a compile-time error occurs.  If
6460            `found' belongs to an interface, things have been already
6461            taken care of.  */
6462       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6463           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6464               || (METHOD_PROTECTED (found)
6465                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6466               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6467                   && METHOD_PRIVATE (method))))
6468         {
6469           parse_error_context
6470             (method_wfl,
6471              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 2),
6472              (METHOD_PUBLIC (method) ? "public" :
6473               (METHOD_PRIVATE (method) ? "private" : "protected")),
6474              IDENTIFIER_POINTER (DECL_NAME
6475                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6476           continue;
6477         }
6478
6479       /* Check this method against all the other implementations it
6480          overrides.  Here we only check the class hierarchy; the rest
6481          of the checking is done later.  If this method is just a
6482          Miranda method, we can skip the check.  */
6483       if (! METHOD_INVISIBLE (method))
6484         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6485     }
6486
6487   /* The above throws clause check only looked at superclasses.  Now
6488      we must also make sure that all methods declared in interfaces
6489      have compatible throws clauses.  FIXME: there are more efficient
6490      ways to organize this checking; we should implement one.  */
6491   check_interface_throws_clauses (class, class);
6492
6493   if (!TYPE_NVIRTUALS (class))
6494     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6495
6496   /* Search for inherited abstract method not yet implemented in this
6497      class.  */
6498   java_check_abstract_method_definitions (class_decl);
6499
6500   if (!saw_constructor)
6501     abort ();
6502 }
6503
6504 /* Check to make sure that all the methods in all the interfaces
6505    implemented by CLASS_DECL are compatible with the concrete
6506    implementations available in CHECK_CLASS_DECL.  */
6507 static void
6508 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6509 {
6510   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6511     {
6512       int i;
6513
6514       if (! CLASS_LOADED_P (class_decl))
6515         {
6516           if (CLASS_FROM_SOURCE_P (class_decl))
6517             safe_layout_class (class_decl);
6518           else
6519             load_class (class_decl, 1);
6520         }
6521
6522       for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (class_decl)) - 1; i > 0; --i)
6523         {
6524           tree interface
6525             = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (class_decl), i));
6526           tree iface_method;
6527
6528           for (iface_method = TYPE_METHODS (interface);
6529                iface_method != NULL_TREE;
6530                iface_method = TREE_CHAIN (iface_method))
6531             {
6532               tree sig, method;
6533
6534               /* First look for a concrete method implemented or
6535                  inherited by this class.  No need to search
6536                  interfaces here, since we're already looking through
6537                  all of them.  */
6538               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6539               method
6540                 = lookup_argument_method_generic (check_class_decl,
6541                                                   DECL_NAME (iface_method),
6542                                                   sig, SEARCH_VISIBLE);
6543               /* If we don't find an implementation, that is ok.  Any
6544                  potential errors from that are diagnosed elsewhere.
6545                  Also, multiple inheritance with conflicting throws
6546                  clauses is fine in the absence of a concrete
6547                  implementation.  */
6548               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6549                   && !METHOD_INVISIBLE (iface_method))
6550                 {
6551                   tree method_wfl = DECL_FUNCTION_WFL (method);
6552                   check_throws_clauses (method, method_wfl, iface_method);
6553                 }
6554             }
6555
6556           /* Now check superinterfaces.  */
6557           check_interface_throws_clauses (check_class_decl, interface);
6558         }
6559     }
6560 }
6561
6562 /* Check throws clauses of a method against the clauses of all the
6563    methods it overrides.  We do this by searching up the class
6564    hierarchy, examining all matching accessible methods.  */
6565 static void
6566 check_concrete_throws_clauses (tree class, tree self_method,
6567                                tree name, tree signature)
6568 {
6569   tree method = lookup_argument_method_generic (class, name, signature,
6570                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6571   while (method != NULL_TREE)
6572     {
6573       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6574         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6575                               method);
6576
6577       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6578                                                name, signature,
6579                                                SEARCH_SUPER | SEARCH_VISIBLE);
6580     }
6581 }
6582
6583 /* Generate an error if the `throws' clause of METHOD (if any) is
6584    incompatible with the `throws' clause of FOUND (if any).  */
6585 static void
6586 check_throws_clauses (tree method, tree method_wfl, tree found)
6587 {
6588   tree mthrows;
6589
6590   /* Can't check these things with class loaded from bytecode. FIXME */
6591   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6592     return;
6593
6594   for (mthrows = DECL_FUNCTION_THROWS (method);
6595        mthrows; mthrows = TREE_CHAIN (mthrows))
6596     {
6597       tree fthrows;
6598
6599       /* We don't verify unchecked expressions */
6600       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6601         continue;
6602       /* Checked expression must be compatible */
6603       for (fthrows = DECL_FUNCTION_THROWS (found);
6604            fthrows; fthrows = TREE_CHAIN (fthrows))
6605         {
6606           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6607             break;
6608         }
6609       if (!fthrows)
6610         {
6611           parse_error_context
6612             (method_wfl, "Invalid checked exception class `%s' in `throws' clause.  The exception must be a subclass of an exception thrown by `%s' from class `%s'",
6613              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6614              lang_printable_name (found, 2),
6615              IDENTIFIER_POINTER
6616              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6617         }
6618     }
6619 }
6620
6621 /* Check abstract method of interface INTERFACE */
6622 static void
6623 java_check_abstract_methods (tree interface_decl)
6624 {
6625   int i;
6626   tree method, found;
6627   tree interface = TREE_TYPE (interface_decl);
6628   tree base_binfo;
6629
6630   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6631     {
6632       /* 2- Check for double definition inside the defining interface */
6633       if (check_method_redefinition (interface, method))
6634         continue;
6635
6636       /* 3- Overriding is OK as far as we preserve the return type.  */
6637       found = lookup_java_interface_method2 (interface, method);
6638       if (found)
6639         {
6640           char *t;
6641           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6642           parse_error_context
6643             (DECL_FUNCTION_WFL (found),
6644              "Method `%s' was defined with return type `%s' in class `%s'",
6645              lang_printable_name (found, 2), t,
6646              IDENTIFIER_POINTER
6647                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6648           free (t);
6649           continue;
6650         }
6651     }
6652
6653   /* 4- Inherited methods can't differ by their returned types */
6654   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (interface), i, base_binfo); i++)
6655     {
6656       tree sub_interface_method, sub_interface;
6657
6658       sub_interface = BINFO_TYPE (base_binfo);
6659       for (sub_interface_method = TYPE_METHODS (sub_interface);
6660            sub_interface_method;
6661            sub_interface_method = TREE_CHAIN (sub_interface_method))
6662         {
6663           found = lookup_java_interface_method2 (interface,
6664                                                  sub_interface_method);
6665           if (found && (found != sub_interface_method))
6666             {
6667               parse_error_context
6668                 (lookup_cl (sub_interface_method),
6669                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6670                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6671                  lang_printable_name (found, 2),
6672                  IDENTIFIER_POINTER
6673                    (DECL_NAME (TYPE_NAME
6674                                (DECL_CONTEXT (sub_interface_method)))),
6675                  IDENTIFIER_POINTER
6676                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6677             }
6678         }
6679     }
6680 }
6681
6682 /* Lookup methods in interfaces using their name and partial
6683    signature. Return a matching method only if their types differ.  */
6684
6685 static tree
6686 lookup_java_interface_method2 (tree class, tree method_decl)
6687 {
6688   int i;
6689   tree base_binfo;
6690   tree to_return;
6691
6692   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6693     {
6694       if ((BINFO_TYPE (base_binfo) != object_type_node)
6695           && (to_return =
6696               lookup_java_method2 (BINFO_TYPE (base_binfo), method_decl, 1)))
6697         return to_return;
6698     }
6699   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6700     {
6701       to_return = lookup_java_interface_method2
6702         (BINFO_TYPE (base_binfo), method_decl);
6703       if (to_return)
6704         return to_return;
6705     }
6706
6707   return NULL_TREE;
6708 }
6709
6710 /* Lookup method using their name and partial signature. Return a
6711    matching method only if their types differ.  */
6712
6713 static tree
6714 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6715 {
6716   tree method, method_signature, method_name, method_type, name;
6717
6718   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6719   name = DECL_NAME (method_decl);
6720   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6721                  EXPR_WFL_NODE (name) : name);
6722   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6723
6724   while (clas != NULL_TREE)
6725     {
6726       for (method = TYPE_METHODS (clas);
6727            method != NULL_TREE;  method = TREE_CHAIN (method))
6728         {
6729           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6730           tree name = DECL_NAME (method);
6731           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6732                EXPR_WFL_NODE (name) : name) == method_name
6733               && method_sig == method_signature
6734               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6735             return method;
6736         }
6737       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6738     }
6739   return NULL_TREE;
6740 }
6741
6742 /* Return the line that matches DECL line number, and try its best to
6743    position the column number. Used during error reports.  */
6744
6745 static GTY(()) tree cl_v;
6746 static tree
6747 lookup_cl (tree decl)
6748 {
6749   char *line, *found;
6750
6751   if (!decl)
6752     return NULL_TREE;
6753
6754   if (cl_v == NULL_TREE)
6755     {
6756       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6757     }
6758
6759   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6760   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6761
6762   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6763                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6764
6765   found = strstr ((const char *)line,
6766                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6767   if (found)
6768     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6769
6770   return cl_v;
6771 }
6772
6773 /* Look for a simple name in the single-type import list */
6774
6775 static tree
6776 find_name_in_single_imports (tree name)
6777 {
6778   tree node;
6779
6780   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6781     if (TREE_VALUE (node) == name)
6782       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6783
6784   return NULL_TREE;
6785 }
6786
6787 /* Process all single-type import. */
6788
6789 static int
6790 process_imports (void)
6791 {
6792   tree import;
6793   int error_found;
6794
6795   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6796     {
6797       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6798       char *original_name;
6799
6800       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6801                                IDENTIFIER_LENGTH (to_be_found),
6802                                IDENTIFIER_LENGTH (to_be_found) + 1);
6803
6804       /* Don't load twice something already defined. */
6805       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6806         continue;
6807
6808       while (1)
6809         {
6810           tree left;
6811
6812           QUALIFIED_P (to_be_found) = 1;
6813           load_class (to_be_found, 0);
6814           error_found =
6815             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6816
6817           /* We found it, we can bail out */
6818           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6819             {
6820               check_deprecation (TREE_PURPOSE (import),
6821                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6822               break;
6823             }
6824
6825           /* We haven't found it. Maybe we're trying to access an
6826              inner class.  The only way for us to know is to try again
6827              after having dropped a qualifier. If we can't break it further,
6828              we have an error. */
6829           if (split_qualified_name (&left, NULL, to_be_found))
6830             break;
6831
6832           to_be_found = left;
6833         }
6834       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6835         {
6836           parse_error_context (TREE_PURPOSE (import),
6837                                "Class or interface `%s' not found in import",
6838                                original_name);
6839           error_found = 1;
6840         }
6841
6842       free (original_name);
6843       if (error_found)
6844         return 1;
6845     }
6846   return 0;
6847 }
6848
6849 /* Possibly find and mark a class imported by a single-type import
6850    statement.  */
6851
6852 static void
6853 find_in_imports (tree enclosing_type, tree class_type)
6854 {
6855   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6856                  ctxp->import_list);
6857   while (import)
6858     {
6859       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6860         {
6861           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6862           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6863           return;
6864         }
6865       import = TREE_CHAIN (import);
6866     }
6867 }
6868
6869 static int
6870 note_possible_classname (const char *name, int len)
6871 {
6872   tree node;
6873   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6874     len = len - 5;
6875   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6876     len = len - 6;
6877   else
6878     return 0;
6879   node = ident_subst (name, len, "", '/', '.', "");
6880   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6881   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6882   return 1;
6883 }
6884
6885 /* Read a import directory, gathering potential match for further type
6886    references. Indifferently reads a filesystem or a ZIP archive
6887    directory.  */
6888
6889 static void
6890 read_import_dir (tree wfl)
6891 {
6892   tree package_id = EXPR_WFL_NODE (wfl);
6893   const char *package_name = IDENTIFIER_POINTER (package_id);
6894   int package_length = IDENTIFIER_LENGTH (package_id);
6895   DIR *dirp = NULL;
6896   JCF *saved_jcf = current_jcf;
6897
6898   int found = 0;
6899   int k;
6900   void *entry;
6901   struct buffer filename[1];
6902
6903   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6904     return;
6905   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6906
6907   BUFFER_INIT (filename);
6908   buffer_grow (filename, package_length + 100);
6909
6910   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6911     {
6912       const char *entry_name = jcf_path_name (entry);
6913       int entry_length = strlen (entry_name);
6914       if (jcf_path_is_zipfile (entry))
6915         {
6916           ZipFile *zipf;
6917           buffer_grow (filename, entry_length);
6918           memcpy (filename->data, entry_name, entry_length - 1);
6919           filename->data[entry_length-1] = '\0';
6920           zipf = opendir_in_zip ((const char *) filename->data, jcf_path_is_system (entry));
6921           if (zipf == NULL)
6922             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6923           else
6924             {
6925               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6926               BUFFER_RESET (filename);
6927               for (k = 0; k < package_length; k++)
6928                 {
6929                   char ch = package_name[k];
6930                   *filename->ptr++ = ch == '.' ? '/' : ch;
6931                 }
6932               *filename->ptr++ = '/';
6933
6934               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6935                 {
6936                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6937                   int current_entry_len = zipd->filename_length;
6938
6939                   if (current_entry_len >= BUFFER_LENGTH (filename)
6940                       && strncmp ((const char *) filename->data, current_entry,
6941                                   BUFFER_LENGTH (filename)) != 0)
6942                     continue;
6943                   found |= note_possible_classname (current_entry,
6944                                                     current_entry_len);
6945                 }
6946             }
6947         }
6948       else
6949         {
6950           BUFFER_RESET (filename);
6951           buffer_grow (filename, entry_length + package_length + 4);
6952           strcpy ((char *) filename->data, entry_name);
6953           filename->ptr = filename->data + entry_length;
6954           for (k = 0; k < package_length; k++)
6955             {
6956               char ch = package_name[k];
6957               *filename->ptr++ = ch == '.' ? '/' : ch;
6958             }
6959           *filename->ptr = '\0';
6960
6961           dirp = opendir ((const char *) filename->data);
6962           if (dirp == NULL)
6963             continue;
6964           *filename->ptr++ = '/';
6965           for (;;)
6966             {
6967               int len;
6968               const char *d_name;
6969               struct dirent *direntp = readdir (dirp);
6970               if (!direntp)
6971                 break;
6972               d_name = direntp->d_name;
6973               len = strlen (direntp->d_name);
6974               buffer_grow (filename, len+1);
6975               strcpy ((char *) filename->ptr, d_name);
6976               found |= note_possible_classname ((const char *) filename->data + entry_length,
6977                                                 package_length+len+1);
6978             }
6979           if (dirp)
6980             closedir (dirp);
6981         }
6982     }
6983
6984   free (filename->data);
6985
6986   /* Here we should have a unified way of retrieving an entry, to be
6987      indexed. */
6988   if (!found)
6989     {
6990       static int first = 1;
6991       if (first)
6992         {
6993           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6994           java_error_count++;
6995           first = 0;
6996         }
6997       else
6998         parse_error_context (wfl, "Package `%s' not found in import",
6999                              package_name);
7000       current_jcf = saved_jcf;
7001       return;
7002     }
7003   current_jcf = saved_jcf;
7004 }
7005
7006 /* Possibly find a type in the import on demands specified
7007    types. Returns 1 if an error occurred, 0 otherwise. Run through the
7008    entire list, to detected potential double definitions.  */
7009
7010 static int
7011 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7012 {
7013   tree class_type_name = TYPE_NAME (class_type);
7014   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7015                   ctxp->import_demand_list);
7016   tree cl = NULL_TREE;
7017   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7018   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7019   tree node;
7020
7021   for (; import; import = TREE_CHAIN (import))
7022     {
7023       int saved_lineno = input_line;
7024       int access_check;
7025       const char *id_name;
7026       tree decl, type_name_copy;
7027
7028       obstack_grow (&temporary_obstack,
7029                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7030                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7031       obstack_1grow (&temporary_obstack, '.');
7032       obstack_grow0 (&temporary_obstack,
7033                      IDENTIFIER_POINTER (class_type_name),
7034                      IDENTIFIER_LENGTH (class_type_name));
7035       id_name = obstack_finish (&temporary_obstack);
7036
7037       if (! (node = maybe_get_identifier (id_name)))
7038         continue;
7039
7040       /* Setup input_line so that it refers to the line of the import (in
7041          case we parse a class file and encounter errors */
7042       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7043
7044       type_name_copy = TYPE_NAME (class_type);
7045       TYPE_NAME (class_type) = node;
7046       QUALIFIED_P (node) = 1;
7047       decl = IDENTIFIER_CLASS_VALUE (node);
7048       access_check = -1;
7049       /* If there is no DECL set for the class or if the class isn't
7050          loaded and not seen in source yet, then load */
7051       if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
7052         {
7053           load_class (node, 0);
7054           decl = IDENTIFIER_CLASS_VALUE (node);
7055         }
7056       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7057         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7058                                                false, NULL_TREE);
7059       else
7060         /* 6.6.1: Inner classes are subject to member access rules. */
7061         access_check = 0;
7062
7063       input_line = saved_lineno;
7064
7065       /* If the loaded class is not accessible or couldn't be loaded,
7066          we restore the original TYPE_NAME and process the next
7067          import. */
7068       if (access_check || !decl)
7069         {
7070           TYPE_NAME (class_type) = type_name_copy;
7071           continue;
7072         }
7073
7074       /* If the loaded class is accessible, we keep a tab on it to
7075          detect and report multiple inclusions. */
7076       if (IS_A_CLASSFILE_NAME (node))
7077         {
7078           if (seen_once < 0)
7079             {
7080               cl = TREE_PURPOSE (import);
7081               seen_once = 1;
7082             }
7083           else if (seen_once >= 0)
7084             {
7085               tree location = (cl ? cl : TREE_PURPOSE (import));
7086               tree package = (cl ? EXPR_WFL_NODE (cl) :
7087                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7088               seen_once++;
7089               parse_error_context
7090                 (location,
7091                  "Type `%s' also potentially defined in package `%s'",
7092                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7093                  IDENTIFIER_POINTER (package));
7094             }
7095         }
7096       to_return = access_check;
7097     }
7098
7099   if (seen_once == 1)
7100     return to_return;
7101   else
7102     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7103 }
7104
7105 /* Add package NAME to the list of packages encountered so far. To
7106    speed up class lookup in do_resolve_class, we make sure a
7107    particular package is added only once.  */
7108
7109 static void
7110 register_package (tree name)
7111 {
7112   static htab_t pht;
7113   void **e;
7114
7115   if (pht == NULL)
7116     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7117
7118   e = htab_find_slot (pht, name, INSERT);
7119   if (*e == NULL)
7120     {
7121       package_list = chainon (package_list, build_tree_list (name, NULL));
7122       *e = name;
7123     }
7124 }
7125
7126 static tree
7127 resolve_package (tree pkg, tree *next, tree *type_name)
7128 {
7129   tree current;
7130   tree decl = NULL_TREE;
7131   *type_name = NULL_TREE;
7132
7133   /* The trick is to determine when the package name stops and were
7134      the name of something contained in the package starts. Then we
7135      return a fully qualified name of what we want to get. */
7136
7137   *next = EXPR_WFL_QUALIFICATION (pkg);
7138
7139   /* Try to progressively construct a type name */
7140   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7141     for (current = EXPR_WFL_QUALIFICATION (pkg);
7142          current; current = TREE_CHAIN (current))
7143       {
7144         /* If we don't have what we're expecting, exit now. TYPE_NAME
7145            will be null and the error caught later. */
7146         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7147           break;
7148         *type_name =
7149           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7150         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7151           {
7152             /* resolve_package should be used in a loop, hence we
7153                point at this one to naturally process the next one at
7154                the next iteration. */
7155             *next = current;
7156             break;
7157           }
7158       }
7159   return decl;
7160 }
7161
7162
7163 /* Check accessibility of inner classes according to member access rules.
7164    DECL is the inner class, ENCLOSING_DECL is the class from which the
7165    access is being attempted. */
7166
7167 static void
7168 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7169 {
7170   const char *access;
7171   tree enclosing_decl_type;
7172
7173   /* We don't issue an error message when CL is null. CL can be null
7174      as a result of processing a JDEP crafted by source_start_java_method
7175      for the purpose of patching its parm decl. But the error would
7176      have been already trapped when fixing the method's signature.
7177      DECL can also be NULL in case of earlier errors. */
7178   if (!decl || !cl)
7179     return;
7180
7181   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7182
7183   if (CLASS_PRIVATE (decl))
7184     {
7185       /* Access is permitted only within the body of the top-level
7186          class in which DECL is declared. */
7187       tree top_level = decl;
7188       while (DECL_CONTEXT (top_level))
7189         top_level = DECL_CONTEXT (top_level);
7190       while (DECL_CONTEXT (enclosing_decl))
7191         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7192       if (top_level == enclosing_decl)
7193         return;
7194       access = "private";
7195     }
7196   else if (CLASS_PROTECTED (decl))
7197     {
7198       tree decl_context;
7199       /* Access is permitted from within the same package... */
7200       if (in_same_package (decl, enclosing_decl))
7201         return;
7202
7203       /* ... or from within the body of a subtype of the context in which
7204          DECL is declared. */
7205       decl_context = DECL_CONTEXT (decl);
7206       while (enclosing_decl)
7207         {
7208           if (CLASS_INTERFACE (decl))
7209             {
7210               if (interface_of_p (TREE_TYPE (decl_context),
7211                                   enclosing_decl_type))
7212                 return;
7213             }
7214           else
7215             {
7216               /* Eww. The order of the arguments is different!! */
7217               if (inherits_from_p (enclosing_decl_type,
7218                                    TREE_TYPE (decl_context)))
7219                 return;
7220             }
7221           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7222         }
7223       access = "protected";
7224     }
7225   else if (! CLASS_PUBLIC (decl))
7226     {
7227       /* Access is permitted only from within the same package as DECL. */
7228       if (in_same_package (decl, enclosing_decl))
7229         return;
7230       access = "non-public";
7231     }
7232   else
7233     /* Class is public. */
7234     return;
7235
7236   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7237                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7238                        lang_printable_name (decl, 2), access);
7239 }
7240
7241 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7242    foreign package, it must be PUBLIC. Return 0 if no access
7243    violations were found, 1 otherwise. If VERBOSE is true and an error
7244    was found, it is reported and accounted for.  If CL is NULL then
7245    look it up with THIS_DECL.  */
7246
7247 static int
7248 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7249 {
7250   tree type;
7251
7252   if (!IDENTIFIER_CLASS_VALUE (class_name))
7253     return 0;
7254
7255   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7256     return 0;
7257
7258   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7259     {
7260       /* Access to a private class within the same package is
7261          allowed. */
7262       tree l, r;
7263       split_qualified_name (&l, &r, class_name);
7264       if (!QUALIFIED_P (class_name) && !ctxp->package)
7265         /* Both in the empty package. */
7266         return 0;
7267       if (l == ctxp->package)
7268         /* Both in the same package. */
7269         return 0;
7270
7271       if (verbose)
7272         parse_error_context
7273           (cl == NULL ? lookup_cl (this_decl): cl,
7274            "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7275            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7276            IDENTIFIER_POINTER (class_name));
7277       return 1;
7278     }
7279   return 0;
7280 }
7281
7282 /* Local variable declaration. */
7283
7284 static void
7285 declare_local_variables (int modifier, tree type, tree vlist)
7286 {
7287   tree decl, current, saved_type;
7288   tree type_wfl = NULL_TREE;
7289   int must_chain = 0;
7290   int final_p = 0;
7291
7292   /* Push a new block if statements were seen between the last time we
7293      pushed a block and now. Keep a count of blocks to close */
7294   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7295     {
7296       tree b = enter_block ();
7297       BLOCK_IS_IMPLICIT (b) = 1;
7298     }
7299
7300   if (modifier)
7301     {
7302       size_t i;
7303       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7304         if (1 << i & modifier)
7305           break;
7306       if (modifier == ACC_FINAL)
7307         final_p = 1;
7308       else
7309         {
7310           parse_error_context
7311             (ctxp->modifier_ctx [i],
7312              "Only `final' is allowed as a local variables modifier");
7313           return;
7314         }
7315     }
7316
7317   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7318      hold the TYPE value if a new incomplete has to be created (as
7319      opposed to being found already existing and reused). */
7320   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7321
7322   /* If TYPE is fully resolved and we don't have a reference, make one */
7323   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7324
7325   /* Go through all the declared variables */
7326   for (current = vlist, saved_type = type; current;
7327        current = TREE_CHAIN (current), type = saved_type)
7328     {
7329       tree other, real_type;
7330       tree wfl  = TREE_PURPOSE (current);
7331       tree name = EXPR_WFL_NODE (wfl);
7332       tree init = TREE_VALUE (current);
7333
7334       /* Process NAME, as it may specify extra dimension(s) for it */
7335       type = build_array_from_name (type, type_wfl, name, &name);
7336
7337       /* Variable redefinition check */
7338       if ((other = lookup_name_in_blocks (name)))
7339         {
7340           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7341                                        DECL_SOURCE_LINE (other));
7342           continue;
7343         }
7344
7345       /* Type adjustment. We may have just readjusted TYPE because
7346          the variable specified more dimensions. Make sure we have
7347          a reference if we can and don't have one already. */
7348       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7349
7350       real_type = GET_REAL_TYPE (type);
7351       /* Never layout this decl. This will be done when its scope
7352          will be entered */
7353       decl = build_decl (VAR_DECL, name, real_type);
7354       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7355       DECL_FINAL (decl) = final_p;
7356       BLOCK_CHAIN_DECL (decl);
7357
7358       /* If doing xreferencing, replace the line number with the WFL
7359          compound value */
7360       if (flag_emit_xref)
7361         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7362
7363       /* Don't try to use an INIT statement when an error was found */
7364       if (init && java_error_count)
7365         init = NULL_TREE;
7366
7367       /* Remember it if this is an initialized-upon-declaration final
7368          variable.  */
7369       if (init && final_p)
7370         {
7371           DECL_LOCAL_FINAL_IUD (decl) = 1;
7372         }
7373
7374       /* Add the initialization function to the current function's code */
7375       if (init)
7376         {
7377           /* Name might have been readjusted */
7378           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7379           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7380           java_method_add_stmt (current_function_decl,
7381                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7382                                                       init));
7383         }
7384
7385       /* Setup dependency the type of the decl */
7386       if (must_chain)
7387         {
7388           jdep *dep;
7389           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7390           dep = CLASSD_LAST (ctxp->classd_list);
7391           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7392         }
7393     }
7394   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7395 }
7396
7397 /* Called during parsing. Build decls from argument list.  */
7398
7399 static void
7400 source_start_java_method (tree fndecl)
7401 {
7402   tree tem;
7403   tree parm_decl;
7404   int i;
7405
7406   if (!fndecl)
7407     return;
7408
7409   current_function_decl = fndecl;
7410
7411   /* New scope for the function */
7412   enter_block ();
7413   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7414        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7415     {
7416       tree type = TREE_VALUE (tem);
7417       tree name = TREE_PURPOSE (tem);
7418
7419       /* If type is incomplete. Create an incomplete decl and ask for
7420          the decl to be patched later */
7421       if (INCOMPLETE_TYPE_P (type))
7422         {
7423           jdep *jdep;
7424           tree real_type = GET_REAL_TYPE (type);
7425           parm_decl = build_decl (PARM_DECL, name, real_type);
7426           type = obtain_incomplete_type (type);
7427           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7428           jdep = CLASSD_LAST (ctxp->classd_list);
7429           JDEP_MISC (jdep) = name;
7430           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7431         }
7432       else
7433         parm_decl = build_decl (PARM_DECL, name, type);
7434
7435       /* Remember if a local variable was declared final (via its
7436          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7437       if (ARG_FINAL_P (tem))
7438         {
7439           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7440           DECL_FINAL (parm_decl) = 1;
7441         }
7442
7443       BLOCK_CHAIN_DECL (parm_decl);
7444     }
7445   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7446   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7447     nreverse (tem);
7448   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7449   DECL_MAX_LOCALS (current_function_decl) = i;
7450 }
7451
7452 /* Called during parsing. Creates an artificial method declaration.  */
7453
7454 static tree
7455 create_artificial_method (tree class, int flags, tree type,
7456                           tree name, tree args)
7457 {
7458   tree mdecl;
7459
7460   java_parser_context_save_global ();
7461   input_line = 0;
7462   mdecl = make_node (FUNCTION_TYPE);
7463   TREE_TYPE (mdecl) = type;
7464   TYPE_ARG_TYPES (mdecl) = args;
7465   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7466   java_parser_context_restore_global ();
7467   DECL_ARTIFICIAL (mdecl) = 1;
7468   return mdecl;
7469 }
7470
7471 /* Starts the body if an artificial method.  */
7472
7473 static void
7474 start_artificial_method_body (tree mdecl)
7475 {
7476   DECL_SOURCE_LINE (mdecl) = 1;
7477   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7478   source_start_java_method (mdecl);
7479   enter_block ();
7480 }
7481
7482 static void
7483 end_artificial_method_body (tree mdecl)
7484 {
7485   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7486      It has to be evaluated first. (if mdecl is current_function_decl,
7487      we have an undefined behavior if no temporary variable is used.) */
7488   tree b = exit_block ();
7489   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7490   exit_block ();
7491 }
7492
7493 /* Dump a tree of some kind.  This is a convenience wrapper for the
7494    dump_* functions in tree-dump.c.  */
7495 static void
7496 dump_java_tree (enum tree_dump_index phase, tree t)
7497 {
7498   FILE *stream;
7499   int flags;
7500
7501   stream = dump_begin (phase, &flags);
7502   flags |= TDF_SLIM;
7503   if (stream)
7504     {
7505       dump_node (t, flags, stream);
7506       dump_end (phase, stream);
7507     }
7508 }
7509
7510 /* Terminate a function and expand its body.  */
7511
7512 static void
7513 source_end_java_method (void)
7514 {
7515   tree fndecl = current_function_decl;
7516
7517   if (!fndecl)
7518     return;
7519
7520   java_parser_context_save_global ();
7521   input_line = ctxp->last_ccb_indent1;
7522
7523   /* Turn function bodies with only a NOP expr null, so they don't get
7524      generated at all and we won't get warnings when using the -W
7525      -Wall flags. */
7526   if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7527     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7528
7529   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7530       && ! flag_emit_class_files
7531       && ! flag_emit_xref)
7532     finish_method (fndecl);
7533
7534   current_function_decl = NULL_TREE;
7535   java_parser_context_restore_global ();
7536   current_function_decl = NULL_TREE;
7537 }
7538
7539 /* Record EXPR in the current function block. Complements compound
7540    expression second operand if necessary.  */
7541
7542 tree
7543 java_method_add_stmt (tree fndecl, tree expr)
7544 {
7545   if (!GET_CURRENT_BLOCK (fndecl))
7546     return NULL_TREE;
7547   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7548 }
7549
7550 static tree
7551 add_stmt_to_block (tree b, tree type, tree stmt)
7552 {
7553   tree body = BLOCK_EXPR_BODY (b), c;
7554
7555   if (java_error_count)
7556     return body;
7557
7558   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7559     return body;
7560
7561   BLOCK_EXPR_BODY (b) = c;
7562   TREE_SIDE_EFFECTS (c) = 1;
7563   return c;
7564 }
7565
7566 /* Lays out the methods for the classes seen so far.  */
7567
7568 void
7569 java_layout_seen_class_methods (void)
7570 {
7571   tree previous_list = all_class_list;
7572   tree end = NULL_TREE;
7573   tree current;
7574
7575   while (1)
7576     {
7577       for (current = previous_list;
7578            current != end; current = TREE_CHAIN (current))
7579         {
7580           tree cls = TREE_TYPE (TREE_VALUE (current));
7581
7582           if (! CLASS_LOADED_P (cls))
7583             load_class (cls, 0);
7584
7585           layout_class_methods (cls);
7586         }
7587
7588       /* Note that new classes might have been added while laying out
7589          methods, changing the value of all_class_list.  */
7590
7591       if (previous_list != all_class_list)
7592         {
7593           end = previous_list;
7594           previous_list = all_class_list;
7595         }
7596       else
7597         break;
7598     }
7599 }
7600
7601 static GTY(()) tree stop_reordering;
7602 void
7603 java_reorder_fields (void)
7604 {
7605   tree current;
7606
7607   for (current = gclass_list; current; current = TREE_CHAIN (current))
7608     {
7609       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7610
7611       if (current_class == stop_reordering)
7612         break;
7613
7614       /* Reverse the fields, but leave the dummy field in front.
7615          Fields are already ordered for Object and Class */
7616       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7617           && current_class != class_type_node)
7618       {
7619         /* If the dummy field is there, reverse the right fields and
7620            just layout the type for proper fields offset */
7621         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7622           {
7623             tree fields = TYPE_FIELDS (current_class);
7624             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7625             TYPE_SIZE (current_class) = NULL_TREE;
7626           }
7627         /* We don't have a dummy field, we need to layout the class,
7628            after having reversed the fields */
7629         else
7630           {
7631             TYPE_FIELDS (current_class) =
7632               nreverse (TYPE_FIELDS (current_class));
7633             TYPE_SIZE (current_class) = NULL_TREE;
7634           }
7635       }
7636     }
7637   /* There are cases were gclass_list will be empty. */
7638   if (gclass_list)
7639     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7640 }
7641
7642 /* Layout the methods of all classes loaded in one way or another.
7643    Check methods of source parsed classes. Then reorder the
7644    fields and layout the classes or the type of all source parsed
7645    classes */
7646
7647 void
7648 java_layout_classes (void)
7649 {
7650   tree current;
7651   int save_error_count = java_error_count;
7652
7653   /* Layout the methods of all classes seen so far */
7654   java_layout_seen_class_methods ();
7655   java_parse_abort_on_error ();
7656   all_class_list = NULL_TREE;
7657
7658   /* Then check the methods of all parsed classes */
7659   for (current = gclass_list; current; current = TREE_CHAIN (current))
7660     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7661       java_check_methods (TREE_VALUE (current));
7662   java_parse_abort_on_error ();
7663
7664   for (current = gclass_list; current; current = TREE_CHAIN (current))
7665     {
7666       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7667       layout_class (current_class);
7668
7669       /* Error reported by the caller */
7670       if (java_error_count)
7671         return;
7672     }
7673
7674   /* We might have reloaded classes durign the process of laying out
7675      classes for code generation. We must layout the methods of those
7676      late additions, as constructor checks might use them */
7677   java_layout_seen_class_methods ();
7678   java_parse_abort_on_error ();
7679 }
7680
7681 /* Expand methods in the current set of classes remembered for
7682    generation.  */
7683
7684 static void
7685 java_complete_expand_classes (void)
7686 {
7687   tree current;
7688
7689   do_not_fold = flag_emit_xref;
7690
7691   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7692     if (!INNER_CLASS_DECL_P (current))
7693       java_complete_expand_class (current);
7694 }
7695
7696 /* Expand the methods found in OUTER, starting first by OUTER's inner
7697    classes, if any.  */
7698
7699 static void
7700 java_complete_expand_class (tree outer)
7701 {
7702   tree inner_list;
7703
7704   /* We need to go after all inner classes and start expanding them,
7705      starting with most nested ones. We have to do that because nested
7706      classes might add functions to outer classes */
7707
7708   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7709        inner_list; inner_list = TREE_CHAIN (inner_list))
7710     java_complete_expand_class (TREE_PURPOSE (inner_list));
7711
7712   java_complete_expand_methods (outer);
7713 }
7714
7715 /* Expand methods registered in CLASS_DECL. The general idea is that
7716    we expand regular methods first. This allows us get an estimate on
7717    how outer context local alias fields are really used so we can add
7718    to the constructor just enough code to initialize them properly (it
7719    also lets us generate finit$ correctly.) Then we expand the
7720    constructors and then <clinit>.  */
7721
7722 static void
7723 java_complete_expand_methods (tree class_decl)
7724 {
7725   tree clinit, decl, first_decl;
7726
7727   output_class = current_class = TREE_TYPE (class_decl);
7728
7729   /* Pre-expand <clinit> to figure whether we really need it or
7730      not. If we do need it, we pre-expand the static fields so they're
7731      ready to be used somewhere else. <clinit> will be fully expanded
7732      after we processed the constructors. */
7733   first_decl = TYPE_METHODS (current_class);
7734   clinit = maybe_generate_pre_expand_clinit (current_class);
7735
7736   /* Then generate finit$ (if we need to) because constructors will
7737    try to use it.*/
7738   if (TYPE_FINIT_STMT_LIST (current_class))
7739     java_complete_expand_method (generate_finit (current_class));
7740
7741   /* Then generate instinit$ (if we need to) because constructors will
7742      try to use it. */
7743   if (TYPE_II_STMT_LIST (current_class))
7744     java_complete_expand_method (generate_instinit (current_class));
7745
7746   /* Now do the constructors */
7747   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7748     {
7749       if (!DECL_CONSTRUCTOR_P (decl))
7750         continue;
7751       java_complete_expand_method (decl);
7752     }
7753
7754   /* First, do the ordinary methods. */
7755   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7756     {
7757       /* Ctors aren't part of this batch. */
7758       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7759         continue;
7760
7761       /* Skip abstract or native methods -- but do handle native
7762          methods when generating JNI stubs.  */
7763       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7764         {
7765           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7766           continue;
7767         }
7768
7769       if (METHOD_NATIVE (decl))
7770         {
7771           tree body;
7772           current_function_decl = decl;
7773           body = build_jni_stub (decl);
7774           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7775         }
7776
7777       java_complete_expand_method (decl);
7778     }
7779
7780   /* If there is indeed a <clinit>, fully expand it now */
7781   if (clinit)
7782     {
7783       /* Prevent the use of `this' inside <clinit> */
7784       ctxp->explicit_constructor_p = 1;
7785       java_complete_expand_method (clinit);
7786       ctxp->explicit_constructor_p = 0;
7787     }
7788
7789   /* We might have generated a class$ that we now want to expand */
7790   if (TYPE_DOT_CLASS (current_class))
7791     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7792
7793   /* Now verify constructor circularity (stop after the first one we
7794      prove wrong.) */
7795   if (!CLASS_INTERFACE (class_decl))
7796     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7797       if (DECL_CONSTRUCTOR_P (decl)
7798           && verify_constructor_circularity (decl, decl))
7799         break;
7800 }
7801
7802 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7803    safely used in some other methods/constructors.  */
7804
7805 static tree
7806 maybe_generate_pre_expand_clinit (tree class_type)
7807 {
7808   tree current, mdecl;
7809
7810   if (!TYPE_CLINIT_STMT_LIST (class_type))
7811     return NULL_TREE;
7812
7813   /* Go through all static fields and pre expand them */
7814   for (current = TYPE_FIELDS (class_type); current;
7815        current = TREE_CHAIN (current))
7816     if (FIELD_STATIC (current))
7817       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7818
7819   /* Then build the <clinit> method */
7820   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7821                                     clinit_identifier_node, end_params_node);
7822   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7823                        mdecl, NULL_TREE);
7824   start_artificial_method_body (mdecl);
7825
7826   /* We process the list of assignment we produced as the result of
7827      the declaration of initialized static field and add them as
7828      statement to the <clinit> method. */
7829   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7830        current = TREE_CHAIN (current))
7831     {
7832       tree stmt = current;
7833       /* We build the assignment expression that will initialize the
7834          field to its value. There are strict rules on static
7835          initializers (8.5). FIXME */
7836       if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
7837         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7838       java_method_add_stmt (mdecl, stmt);
7839     }
7840
7841   end_artificial_method_body (mdecl);
7842
7843   /* Now we want to place <clinit> as the last method (because we need
7844      it at least for interface so that it doesn't interfere with the
7845      dispatch table based lookup. */
7846   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7847     {
7848       current = TREE_CHAIN (TYPE_METHODS (class_type));
7849       TYPE_METHODS (class_type) = current;
7850
7851       while (TREE_CHAIN (current))
7852         current = TREE_CHAIN (current);
7853
7854       TREE_CHAIN (current) = mdecl;
7855       TREE_CHAIN (mdecl) = NULL_TREE;
7856     }
7857
7858   return mdecl;
7859 }
7860
7861 /* Analyzes a method body and look for something that isn't a
7862    MODIFY_EXPR with a constant value.  */
7863
7864 static int
7865 analyze_clinit_body (tree this_class, tree bbody)
7866 {
7867   while (bbody)
7868     switch (TREE_CODE (bbody))
7869       {
7870       case BLOCK:
7871         bbody = BLOCK_EXPR_BODY (bbody);
7872         break;
7873
7874       case EXPR_WITH_FILE_LOCATION:
7875         bbody = EXPR_WFL_NODE (bbody);
7876         break;
7877
7878       case COMPOUND_EXPR:
7879         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7880           return 1;
7881         bbody = TREE_OPERAND (bbody, 1);
7882         break;
7883
7884       case MODIFY_EXPR:
7885         /* If we're generating to class file and we're dealing with an
7886            array initialization, we return 1 to keep <clinit> */
7887         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7888             && flag_emit_class_files)
7889           return 1;
7890
7891         /* There are a few cases where we're required to keep
7892            <clinit>:
7893            - If this is an assignment whose operand is not constant,
7894            - If this is an assignment to a non-initialized field,
7895            - If this field is not a member of the current class.
7896         */
7897         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7898                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7899                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7900
7901       default:
7902         return 1;
7903       }
7904   return 0;
7905 }
7906
7907
7908 /* See whether we could get rid of <clinit>. Criteria are: all static
7909    final fields have constant initial values and the body of <clinit>
7910    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7911
7912 static int
7913 maybe_yank_clinit (tree mdecl)
7914 {
7915   tree type, current;
7916   tree fbody, bbody;
7917
7918   if (!DECL_CLINIT_P (mdecl))
7919     return 0;
7920
7921   /* If the body isn't empty, then we keep <clinit>. Note that if
7922      we're emitting classfiles, this isn't enough not to rule it
7923      out. */
7924   fbody = DECL_FUNCTION_BODY (mdecl);
7925   bbody = BLOCK_EXPR_BODY (fbody);
7926   if (bbody && bbody != error_mark_node)
7927     bbody = BLOCK_EXPR_BODY (bbody);
7928   else
7929     return 0;
7930   if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
7931     return 0;
7932
7933   type = DECL_CONTEXT (mdecl);
7934   current = TYPE_FIELDS (type);
7935
7936   for (current = (current ? TREE_CHAIN (current) : current);
7937        current; current = TREE_CHAIN (current))
7938     {
7939       tree f_init;
7940
7941       /* We're not interested in non-static fields.  */
7942       if (!FIELD_STATIC (current))
7943         continue;
7944
7945       /* Nor in fields without initializers. */
7946       f_init = DECL_INITIAL (current);
7947       if (f_init == NULL_TREE)
7948         continue;
7949
7950       /* Anything that isn't String or a basic type is ruled out -- or
7951          if we know how to deal with it (when doing things natively) we
7952          should generated an empty <clinit> so that SUID are computed
7953          correctly. */
7954       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7955           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7956         return 0;
7957
7958       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7959         return 0;
7960     }
7961
7962   /* Now we analyze the method body and look for something that
7963      isn't a MODIFY_EXPR */
7964   if (!IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
7965     return 0;
7966
7967   /* Get rid of <clinit> in the class' list of methods */
7968   if (TYPE_METHODS (type) == mdecl)
7969     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7970   else
7971     for (current = TYPE_METHODS (type); current;
7972          current = TREE_CHAIN (current))
7973       if (TREE_CHAIN (current) == mdecl)
7974         {
7975           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7976           break;
7977         }
7978
7979   return 1;
7980 }
7981
7982 /* Install the argument from MDECL. Suitable to completion and
7983    expansion of mdecl's body.  */
7984
7985 void
7986 start_complete_expand_method (tree mdecl)
7987 {
7988   tree tem;
7989
7990   pushlevel (1);                /* Prepare for a parameter push */
7991   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7992   DECL_ARGUMENTS (mdecl) = tem;
7993
7994   for (; tem; tem = TREE_CHAIN (tem))
7995     {
7996       /* TREE_CHAIN (tem) will change after pushdecl. */
7997       tree next = TREE_CHAIN (tem);
7998       tree type = TREE_TYPE (tem);
7999       if (targetm.calls.promote_prototypes (type)
8000           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8001           && INTEGRAL_TYPE_P (type))
8002         type = integer_type_node;
8003       DECL_ARG_TYPE (tem) = type;
8004       layout_decl (tem, 0);
8005       pushdecl (tem);
8006       /* Re-install the next so that the list is kept and the loop
8007          advances. */
8008       TREE_CHAIN (tem) = next;
8009     }
8010   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8011   input_line = DECL_SOURCE_LINE (mdecl);
8012   build_result_decl (mdecl);
8013 }
8014
8015
8016 /* Complete and expand a method.  */
8017
8018 static void
8019 java_complete_expand_method (tree mdecl)
8020 {
8021   tree fbody, block_body, exception_copy;
8022
8023   current_function_decl = mdecl;
8024   /* Fix constructors before expanding them */
8025   if (DECL_CONSTRUCTOR_P (mdecl))
8026     fix_constructors (mdecl);
8027
8028   /* Expand functions that have a body */
8029   if (!DECL_FUNCTION_BODY (mdecl))
8030     return;
8031
8032   fbody = DECL_FUNCTION_BODY (mdecl);
8033   block_body = BLOCK_EXPR_BODY (fbody);
8034   exception_copy = NULL_TREE;
8035
8036   current_function_decl = mdecl;
8037
8038   if (! quiet_flag)
8039     fprintf (stderr, " [%s.",
8040              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8041   announce_function (mdecl);
8042   if (! quiet_flag)
8043     fprintf (stderr, "]");
8044
8045   /* Prepare the function for tree completion */
8046   start_complete_expand_method (mdecl);
8047
8048   /* Install the current this */
8049   current_this = (!METHOD_STATIC (mdecl) ?
8050                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8051
8052   /* Purge the `throws' list of unchecked exceptions (we save a copy
8053      of the list and re-install it later.) */
8054   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8055   purge_unchecked_exceptions (mdecl);
8056
8057   /* Install exceptions thrown with `throws' */
8058   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8059
8060   if (block_body != NULL_TREE)
8061     {
8062       block_body = java_complete_tree (block_body);
8063
8064       /* Before we check initialization, attached all class initialization
8065          variable to the block_body */
8066       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8067                      attach_init_test_initialization_flags, block_body);
8068
8069       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8070         {
8071           check_for_initialization (block_body, mdecl);
8072
8073           /* Go through all the flags marking the initialization of
8074              static variables and see whether they're definitively
8075              assigned, in which case the type is remembered as
8076              definitively initialized in MDECL. */
8077           if (STATIC_CLASS_INIT_OPT_P ())
8078             {
8079               /* Always register the context as properly initialized in
8080                  MDECL. This used with caution helps removing extra
8081                  initialization of self. */
8082               if (METHOD_STATIC (mdecl))
8083                 {
8084                   *(htab_find_slot
8085                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8086                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8087                 }
8088             }
8089         }
8090       ctxp->explicit_constructor_p = 0;
8091     }
8092
8093   BLOCK_EXPR_BODY (fbody) = block_body;
8094
8095   /* If we saw a return but couldn't evaluate it properly, we'll have
8096      an error_mark_node here. */
8097   if (block_body != error_mark_node
8098       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8099       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8100       && !flag_emit_xref)
8101     missing_return_error (current_function_decl);
8102
8103   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8104   maybe_yank_clinit (mdecl);
8105
8106   /* Pop the current level, with special measures if we found errors. */
8107   if (java_error_count)
8108     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8109   poplevel (1, 0, 1);
8110
8111   /* Pop the exceptions and sanity check */
8112   POP_EXCEPTIONS();
8113   if (currently_caught_type_list)
8114     abort ();
8115
8116   /* Restore the copy of the list of exceptions if emitting xrefs. */
8117   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8118 }
8119
8120 /* For with each class for which there's code to generate. */
8121
8122 static void
8123 java_expand_method_bodies (tree class)
8124 {
8125   tree decl;
8126   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8127     {
8128       tree block;
8129
8130       if (! DECL_FUNCTION_BODY (decl))
8131         continue;
8132
8133       current_function_decl = decl;
8134
8135       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8136
8137       /* Save the function body for gimplify and inlining.  */
8138       DECL_SAVED_TREE (decl) = block;
8139
8140       /* It's time to assign the variable flagging static class
8141          initialization based on which classes invoked static methods
8142          are definitely initializing. This should be flagged. */
8143       if (STATIC_CLASS_INIT_OPT_P ())
8144         {
8145           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8146           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8147             {
8148               /* Executed for each statement calling a static function.
8149                  LIST is a TREE_LIST whose PURPOSE is the called function
8150                  and VALUE is a compound whose second operand can be patched
8151                  with static class initialization flag assignments.  */
8152
8153               tree called_method = TREE_PURPOSE (list);
8154               tree compound = TREE_VALUE (list);
8155               tree assignment_compound_list
8156                 = build_tree_list (called_method, NULL);
8157
8158               /* For each class definitely initialized in
8159                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8160                  assignment to the class initialization flag. */
8161               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8162                              emit_test_initialization,
8163                              assignment_compound_list);
8164
8165               if (TREE_VALUE (assignment_compound_list))
8166                 TREE_OPERAND (compound, 1)
8167                   = TREE_VALUE (assignment_compound_list);
8168             }
8169         }
8170
8171       /* Expand the function body.  */
8172       source_end_java_method ();
8173     }
8174 }
8175
8176 \f
8177
8178 /* This section of the code deals with accessing enclosing context
8179    fields either directly by using the relevant access to this$<n> or
8180    by invoking an access method crafted for that purpose.  */
8181
8182 /* Build the necessary access from an inner class to an outer
8183    class. This routine could be optimized to cache previous result
8184    (decl, current_class and returned access).  When an access method
8185    needs to be generated, it always takes the form of a read. It might
8186    be later turned into a write by calling outer_field_access_fix.  */
8187
8188 static tree
8189 build_outer_field_access (tree id, tree decl)
8190 {
8191   tree access = NULL_TREE;
8192   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8193   tree decl_ctx = DECL_CONTEXT (decl);
8194
8195   /* If the immediate enclosing context of the current class is the
8196      field decl's class or inherits from it; build the access as
8197      `this$<n>.<field>'. Note that we will break the `private' barrier
8198      if we're not emitting bytecodes. */
8199   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8200       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8201     {
8202       tree thisn = build_current_thisn (current_class);
8203       access = make_qualified_primary (build_wfl_node (thisn),
8204                                        id, EXPR_WFL_LINECOL (id));
8205     }
8206   /* Otherwise, generate access methods to outer this and access the
8207      field (either using an access method or by direct access.) */
8208   else
8209     {
8210       int lc = EXPR_WFL_LINECOL (id);
8211
8212       /* Now we chain the required number of calls to the access$0 to
8213          get a hold to the enclosing instance we need, and then we
8214          build the field access. */
8215       access = build_access_to_thisn (current_class, decl_ctx, lc);
8216
8217       /* If the field is private and we're generating bytecode, then
8218          we generate an access method */
8219       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8220         {
8221           tree name = build_outer_field_access_methods (decl);
8222           access = build_outer_field_access_expr (lc, decl_ctx,
8223                                                   name, access, NULL_TREE);
8224         }
8225       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8226          Once again we break the `private' access rule from a foreign
8227          class. */
8228       else
8229         access = make_qualified_primary (access, id, lc);
8230     }
8231   return resolve_expression_name (access, NULL);
8232 }
8233
8234 /* Return a nonzero value if NODE describes an outer field inner
8235    access.  */
8236
8237 static int
8238 outer_field_access_p (tree type, tree decl)
8239 {
8240   if (!INNER_CLASS_TYPE_P (type)
8241       || TREE_CODE (decl) != FIELD_DECL
8242       || DECL_CONTEXT (decl) == type)
8243     return 0;
8244
8245   /* If the inner class extends the declaration context of the field
8246      we're trying to access, then this isn't an outer field access */
8247   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8248     return 0;
8249
8250   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8251        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8252     {
8253       if (type == DECL_CONTEXT (decl))
8254         return 1;
8255
8256       if (!DECL_CONTEXT (TYPE_NAME (type)))
8257         {
8258           /* Before we give up, see whether the field is inherited from
8259              the enclosing context we're considering. */
8260           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8261             return 1;
8262           break;
8263         }
8264     }
8265
8266   return 0;
8267 }
8268
8269 /* Return a nonzero value if NODE represents an outer field inner
8270    access that was been already expanded. As a side effect, it returns
8271    the name of the field being accessed and the argument passed to the
8272    access function, suitable for a regeneration of the access method
8273    call if necessary. */
8274
8275 static int
8276 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8277                                tree *arg)
8278 {
8279   int identified = 0;
8280
8281   if (TREE_CODE (node) != CALL_EXPR)
8282     return 0;
8283
8284   /* Well, gcj generates slightly different tree nodes when compiling
8285      to native or bytecodes. It's the case for function calls. */
8286
8287   if (flag_emit_class_files
8288       && TREE_CODE (node) == CALL_EXPR
8289       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8290     identified = 1;
8291   else if (!flag_emit_class_files)
8292     {
8293       node = TREE_OPERAND (node, 0);
8294
8295       if (node && TREE_OPERAND (node, 0)
8296           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8297         {
8298           node = TREE_OPERAND (node, 0);
8299           if (TREE_OPERAND (node, 0)
8300               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8301               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8302                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8303             identified = 1;
8304         }
8305     }
8306
8307   if (identified && name && arg_type && arg)
8308     {
8309       tree argument = TREE_OPERAND (node, 1);
8310       *name = DECL_NAME (TREE_OPERAND (node, 0));
8311       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8312       *arg = TREE_VALUE (argument);
8313     }
8314   return identified;
8315 }
8316
8317 /* Detect in NODE an outer field read access from an inner class and
8318    transform it into a write with RHS as an argument. This function is
8319    called from the java_complete_lhs when an assignment to a LHS can
8320    be identified. */
8321
8322 static tree
8323 outer_field_access_fix (tree wfl, tree node, tree rhs)
8324 {
8325   tree name, arg_type, arg;
8326
8327   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8328     {
8329       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8330                                             arg_type, name, arg, rhs);
8331       return java_complete_tree (node);
8332     }
8333   return NULL_TREE;
8334 }
8335
8336 /* Construct the expression that calls an access method:
8337      <type>.access$<n>(<arg1> [, <arg2>]);
8338
8339    ARG2 can be NULL and will be omitted in that case. It will denote a
8340    read access.  */
8341
8342 static tree
8343 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8344                                tree arg1, tree arg2)
8345 {
8346   tree args, cn, access;
8347
8348   args = arg1 ? arg1 :
8349     build_wfl_node (build_current_thisn (current_class));
8350   args = build_tree_list (NULL_TREE, args);
8351
8352   if (arg2)
8353     args = tree_cons (NULL_TREE, arg2, args);
8354
8355   access = build_method_invocation (build_wfl_node (access_method_name), args);
8356   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8357   return make_qualified_primary (cn, access, lc);
8358 }
8359
8360 static tree
8361 build_new_access_id (void)
8362 {
8363   static int access_n_counter = 1;
8364   char buffer [128];
8365
8366   sprintf (buffer, "access$%d", access_n_counter++);
8367   return get_identifier (buffer);
8368 }
8369
8370 /* Create the static access functions for the outer field DECL. We define a
8371    read:
8372      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8373        return inst$.field;
8374      }
8375    and a write access:
8376      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8377                                      TREE_TYPE (<field>) value$) {
8378        return inst$.field = value$;
8379      }
8380    We should have a usage flags on the DECL so we can lazily turn the ones
8381    we're using for code generation. FIXME.
8382 */
8383
8384 static tree
8385 build_outer_field_access_methods (tree decl)
8386 {
8387   tree id, args, stmt, mdecl;
8388
8389   if (FIELD_INNER_ACCESS_P (decl))
8390     return FIELD_INNER_ACCESS (decl);
8391
8392   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8393
8394   /* Create the identifier and a function named after it. */
8395   id = build_new_access_id ();
8396
8397   /* The identifier is marked as bearing the name of a generated write
8398      access function for outer field accessed from inner classes. */
8399   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8400
8401   /* Create the read access */
8402   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8403   TREE_CHAIN (args) = end_params_node;
8404   stmt = make_qualified_primary (build_wfl_node (inst_id),
8405                                  build_wfl_node (DECL_NAME (decl)), 0);
8406   stmt = build_return (0, stmt);
8407   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8408                                            TREE_TYPE (decl), id, args, stmt);
8409   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8410
8411   /* Create the write access method. No write access for final variable */
8412   if (!FIELD_FINAL (decl))
8413     {
8414       args = build_tree_list (inst_id,
8415                               build_pointer_type (DECL_CONTEXT (decl)));
8416       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8417       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8418       stmt = make_qualified_primary (build_wfl_node (inst_id),
8419                                      build_wfl_node (DECL_NAME (decl)), 0);
8420       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8421                                                 build_wfl_node (wpv_id)));
8422       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8423                                                TREE_TYPE (decl), id,
8424                                                args, stmt);
8425     }
8426   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8427
8428   /* Return the access name */
8429   return FIELD_INNER_ACCESS (decl) = id;
8430 }
8431
8432 /* Build an field access method NAME.  */
8433
8434 static tree
8435 build_outer_field_access_method (tree class, tree type, tree name,
8436                                  tree args, tree body)
8437 {
8438   tree saved_current_function_decl, mdecl;
8439
8440   /* Create the method */
8441   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8442   fix_method_argument_names (args, mdecl);
8443   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8444
8445   /* Attach the method body. */
8446   saved_current_function_decl = current_function_decl;
8447   start_artificial_method_body (mdecl);
8448   java_method_add_stmt (mdecl, body);
8449   end_artificial_method_body (mdecl);
8450   current_function_decl = saved_current_function_decl;
8451
8452   return mdecl;
8453 }
8454
8455 \f
8456 /* This section deals with building access function necessary for
8457    certain kinds of method invocation from inner classes.  */
8458
8459 static tree
8460 build_outer_method_access_method (tree decl)
8461 {
8462   tree saved_current_function_decl, mdecl;
8463   tree args = NULL_TREE, call_args = NULL_TREE;
8464   tree carg, id, body, class;
8465   char buffer [80];
8466   int parm_id_count = 0;
8467
8468   /* Test this abort with an access to a private field */
8469   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8470     abort ();
8471
8472   /* Check the cache first */
8473   if (DECL_FUNCTION_INNER_ACCESS (decl))
8474     return DECL_FUNCTION_INNER_ACCESS (decl);
8475
8476   class = DECL_CONTEXT (decl);
8477
8478   /* Obtain an access identifier and mark it */
8479   id = build_new_access_id ();
8480   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8481
8482   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8483   /* Create the arguments, as much as the original */
8484   for (; carg && carg != end_params_node;
8485        carg = TREE_CHAIN (carg))
8486     {
8487       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8488       args = chainon (args, build_tree_list (get_identifier (buffer),
8489                                              TREE_VALUE (carg)));
8490     }
8491   args = chainon (args, end_params_node);
8492
8493   /* Create the method */
8494   mdecl = create_artificial_method (class, ACC_STATIC,
8495                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8496   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8497   /* There is a potential bug here. We should be able to use
8498      fix_method_argument_names, but then arg names get mixed up and
8499      eventually a constructor will have its this$0 altered and the
8500      outer context won't be assignment properly. The testcase is
8501      stub.java FIXME */
8502   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8503
8504   /* Attach the method body. */
8505   saved_current_function_decl = current_function_decl;
8506   start_artificial_method_body (mdecl);
8507
8508   /* The actual method invocation uses the same args. When invoking a
8509      static methods that way, we don't want to skip the first
8510      argument. */
8511   carg = args;
8512   if (!METHOD_STATIC (decl))
8513     carg = TREE_CHAIN (carg);
8514   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8515     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8516                            call_args);
8517
8518   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8519                                   call_args);
8520   if (!METHOD_STATIC (decl))
8521     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8522                                    body, 0);
8523   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8524     body = build_return (0, body);
8525   java_method_add_stmt (mdecl,body);
8526   end_artificial_method_body (mdecl);
8527   current_function_decl = saved_current_function_decl;
8528
8529   /* Back tag the access function so it know what it accesses */
8530   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8531
8532   /* Tag the current method so it knows it has an access generated */
8533   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8534 }
8535
8536 \f
8537 /* This section of the code deals with building expressions to access
8538    the enclosing instance of an inner class. The enclosing instance is
8539    kept in a generated field called this$<n>, with <n> being the
8540    inner class nesting level (starting from 0.)  */
8541
8542 /* Build an access to a given this$<n>, always chaining access call to
8543    others. Access methods to this$<n> are build on the fly if
8544    necessary. This CAN'T be used to solely access this$<n-1> from
8545    this$<n> (which alway yield to special cases and optimization, see
8546    for example build_outer_field_access).  */
8547
8548 static tree
8549 build_access_to_thisn (tree from, tree to, int lc)
8550 {
8551   tree access = NULL_TREE;
8552
8553   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8554     {
8555       if (!access)
8556         {
8557           access = build_current_thisn (from);
8558           access = build_wfl_node (access);
8559         }
8560       else
8561         {
8562           tree access0_wfl, cn;
8563
8564           maybe_build_thisn_access_method (from);
8565           access0_wfl = build_wfl_node (access0_identifier_node);
8566           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8567           EXPR_WFL_LINECOL (access0_wfl) = lc;
8568           access = build_tree_list (NULL_TREE, access);
8569           access = build_method_invocation (access0_wfl, access);
8570           access = make_qualified_primary (cn, access, lc);
8571         }
8572
8573       /* If FROM isn't an inner class, that's fine, we've done enough.
8574          What we're looking for can be accessed from there.  */
8575       from = DECL_CONTEXT (TYPE_NAME (from));
8576       if (!from)
8577         break;
8578       from = TREE_TYPE (from);
8579     }
8580   return access;
8581 }
8582
8583 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8584    is returned if nothing needs to be generated. Otherwise, the method
8585    generated and a method decl is returned.
8586
8587    NOTE: These generated methods should be declared in a class file
8588    attribute so that they can't be referred to directly.  */
8589
8590 static tree
8591 maybe_build_thisn_access_method (tree type)
8592 {
8593   tree mdecl, args, stmt, rtype;
8594   tree saved_current_function_decl;
8595
8596   /* If TYPE is a top-level class, no access method is required.
8597      If there already is such an access method, bail out. */
8598   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8599     return NULL_TREE;
8600
8601   /* We generate the method. The method looks like:
8602      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8603   */
8604   args = build_tree_list (inst_id, build_pointer_type (type));
8605   TREE_CHAIN (args) = end_params_node;
8606   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8607   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8608                                     access0_identifier_node, args);
8609   fix_method_argument_names (args, mdecl);
8610   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8611   stmt = build_current_thisn (type);
8612   stmt = make_qualified_primary (build_wfl_node (inst_id),
8613                                  build_wfl_node (stmt), 0);
8614   stmt = build_return (0, stmt);
8615
8616   saved_current_function_decl = current_function_decl;
8617   start_artificial_method_body (mdecl);
8618   java_method_add_stmt (mdecl, stmt);
8619   end_artificial_method_body (mdecl);
8620   current_function_decl = saved_current_function_decl;
8621
8622   CLASS_ACCESS0_GENERATED_P (type) = 1;
8623
8624   return mdecl;
8625 }
8626
8627 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8628    the first level of innerclassing. this$1 for the next one, etc...
8629    This function can be invoked with TYPE to NULL, available and then
8630    has to count the parser context.  */
8631
8632 static GTY(()) tree saved_thisn;
8633 static GTY(()) tree saved_type;
8634
8635 static tree
8636 build_current_thisn (tree type)
8637 {
8638   static int saved_i = -1;
8639   static int saved_type_i = 0;
8640   tree decl;
8641   char buffer [24];
8642   int i = 0;
8643
8644   if (type)
8645     {
8646       if (type == saved_type)
8647         i = saved_type_i;
8648       else
8649         {
8650           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8651                decl; decl = DECL_CONTEXT (decl), i++)
8652             ;
8653
8654           saved_type = type;
8655           saved_type_i = i;
8656         }
8657     }
8658   else
8659     i = list_length (GET_CPC_LIST ())-2;
8660
8661   if (i == saved_i)
8662     return saved_thisn;
8663
8664   sprintf (buffer, "this$%d", i);
8665   saved_i = i;
8666   saved_thisn = get_identifier (buffer);
8667   return saved_thisn;
8668 }
8669
8670 /* Return the assignment to the hidden enclosing context `this$<n>'
8671    by the second incoming parameter to the innerclass constructor. The
8672    form used is `this.this$<n> = this$<n>;'.  */
8673
8674 static tree
8675 build_thisn_assign (void)
8676 {
8677   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8678     {
8679       tree thisn = build_current_thisn (current_class);
8680       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8681                                          build_wfl_node (thisn), 0);
8682       tree rhs = build_wfl_node (thisn);
8683       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8684       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8685     }
8686   return NULL_TREE;
8687 }
8688
8689 \f
8690 /* Building the synthetic `class$' used to implement the `.class' 1.1
8691    extension for non primitive types. This method looks like:
8692
8693     static Class class$(String type) throws NoClassDefFoundError
8694     {
8695       try {return (java.lang.Class.forName (String));}
8696       catch (ClassNotFoundException e) {
8697         throw new NoClassDefFoundError(e.getMessage());}
8698     } */
8699
8700 static GTY(()) tree get_message_wfl;
8701 static GTY(()) tree type_parm_wfl;
8702
8703 static tree
8704 build_dot_class_method (tree class)
8705 {
8706 #define BWF(S) build_wfl_node (get_identifier ((S)))
8707 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8708   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8709   tree stmt, throw_stmt;
8710
8711   if (!get_message_wfl)
8712     {
8713       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8714       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8715     }
8716
8717   /* Build the arguments */
8718   args = build_tree_list (get_identifier ("type$"),
8719                           build_pointer_type (string_type_node));
8720   TREE_CHAIN (args) = end_params_node;
8721
8722   /* Build the qualified name java.lang.Class.forName */
8723   tmp = MQN (MQN (MQN (BWF ("java"),
8724                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8725
8726   /* Create the "class$" function */
8727   mdecl = create_artificial_method (class, ACC_STATIC,
8728                                     build_pointer_type (class_type_node),
8729                                     classdollar_identifier_node, args);
8730   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8731                    BWF ("NoClassDefFoundError"));
8732   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8733   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8734   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8735     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8736
8737   /* We start by building the try block. We need to build:
8738        return (java.lang.Class.forName (type)); */
8739   stmt = build_method_invocation (tmp,
8740                                   build_tree_list (NULL_TREE, type_parm_wfl));
8741   stmt = build_return (0, stmt);
8742
8743   /* Now onto the catch block. We start by building the expression
8744      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8745   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8746                                     get_message_wfl, 0);
8747   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8748
8749   /* Build new NoClassDefFoundError (_.getMessage) */
8750   throw_stmt = build_new_invocation
8751     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8752      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8753
8754   /* Build the throw, (it's too early to use BUILD_THROW) */
8755   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8756
8757   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8758   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8759                    BWF ("ClassNotFoundException"));
8760   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8761
8762   fix_method_argument_names (args, mdecl);
8763   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8764   saved_current_function_decl = current_function_decl;
8765   start_artificial_method_body (mdecl);
8766   java_method_add_stmt (mdecl, stmt);
8767   end_artificial_method_body (mdecl);
8768   current_function_decl = saved_current_function_decl;
8769   TYPE_DOT_CLASS (class) = mdecl;
8770
8771   return mdecl;
8772 }
8773
8774 static tree
8775 build_dot_class_method_invocation (tree this_class, tree type)
8776 {
8777   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8778   tree sig_id, s, t;
8779
8780   if (TYPE_ARRAY_P (type))
8781     sig_id = build_java_signature (type);
8782   else
8783     sig_id = DECL_NAME (TYPE_NAME (type));
8784
8785   /* Ensure that the proper name separator is used */
8786   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8787                                IDENTIFIER_LENGTH (sig_id));
8788
8789   s = build_string (IDENTIFIER_LENGTH (sig_id),
8790                     IDENTIFIER_POINTER (sig_id));
8791   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8792                                build_tree_list (NULL_TREE, s));
8793   if (DECL_CONTEXT (dot_class_method) != this_class)
8794     {
8795       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8796       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8797     }
8798   return t;
8799 }
8800
8801 /* This section of the code deals with constructor.  */
8802
8803 /* Craft a body for default constructor. Patch existing constructor
8804    bodies with call to super() and field initialization statements if
8805    necessary.  */
8806
8807 static void
8808 fix_constructors (tree mdecl)
8809 {
8810   tree iii;                     /* Instance Initializer Invocation */
8811   tree body = DECL_FUNCTION_BODY (mdecl);
8812   tree thisn_assign, compound = NULL_TREE;
8813   tree class_type = DECL_CONTEXT (mdecl);
8814
8815   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8816     return;
8817   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8818
8819   if (!body)
8820     {
8821       /* It is an error for the compiler to generate a default
8822          constructor if the superclass doesn't have a constructor that
8823          takes no argument, or the same args for an anonymous class */
8824       if (verify_constructor_super (mdecl))
8825         {
8826           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8827           tree save = DECL_NAME (mdecl);
8828           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8829           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8830           parse_error_context
8831             (lookup_cl (TYPE_NAME (class_type)),
8832              "No constructor matching `%s' found in class `%s'",
8833              lang_printable_name (mdecl, 2), n);
8834           DECL_NAME (mdecl) = save;
8835         }
8836
8837       /* The constructor body must be crafted by hand. It's the
8838          constructor we defined when we realize we didn't have the
8839          CLASSNAME() constructor */
8840       start_artificial_method_body (mdecl);
8841
8842       /* Insert an assignment to the this$<n> hidden field, if
8843          necessary */
8844       if ((thisn_assign = build_thisn_assign ()))
8845         java_method_add_stmt (mdecl, thisn_assign);
8846
8847       /* We don't generate a super constructor invocation if we're
8848          compiling java.lang.Object. build_super_invocation takes care
8849          of that. */
8850       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8851
8852       /* FIXME */
8853       if ((iii = build_instinit_invocation (class_type)))
8854         java_method_add_stmt (mdecl, iii);
8855
8856       end_artificial_method_body (mdecl);
8857     }
8858   /* Search for an explicit constructor invocation */
8859   else
8860     {
8861       int found = 0;
8862       int invokes_this = 0;
8863       tree found_call = NULL_TREE;
8864       tree main_block = BLOCK_EXPR_BODY (body);
8865
8866       while (body)
8867         switch (TREE_CODE (body))
8868           {
8869           case CALL_EXPR:
8870             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8871             if (CALL_THIS_CONSTRUCTOR_P (body))
8872               invokes_this = 1;
8873             body = NULL_TREE;
8874             break;
8875           case COMPOUND_EXPR:
8876           case EXPR_WITH_FILE_LOCATION:
8877             found_call = body;
8878             body = TREE_OPERAND (body, 0);
8879             break;
8880           case BLOCK:
8881             found_call = body;
8882             body = BLOCK_EXPR_BODY (body);
8883             break;
8884           default:
8885             found = 0;
8886             body = NULL_TREE;
8887           }
8888
8889       /* Generate the assignment to this$<n>, if necessary */
8890       if ((thisn_assign = build_thisn_assign ()))
8891         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8892
8893       /* The constructor is missing an invocation of super() */
8894       if (!found)
8895         compound = add_stmt_to_compound (compound, NULL_TREE,
8896                                          build_super_invocation (mdecl));
8897       /* Explicit super() invocation should take place before the
8898          instance initializer blocks. */
8899       else
8900         {
8901           compound = add_stmt_to_compound (compound, NULL_TREE,
8902                                            TREE_OPERAND (found_call, 0));
8903           TREE_OPERAND (found_call, 0) = build_java_empty_stmt ();
8904         }
8905
8906       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8907
8908       /* Insert the instance initializer block right after. */
8909       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8910         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8911
8912       /* Fix the constructor main block if we're adding extra stmts */
8913       if (compound)
8914         {
8915           compound = add_stmt_to_compound (compound, NULL_TREE,
8916                                            BLOCK_EXPR_BODY (main_block));
8917           BLOCK_EXPR_BODY (main_block) = compound;
8918         }
8919     }
8920 }
8921
8922 /* Browse constructors in the super class, searching for a constructor
8923    that doesn't take any argument. Return 0 if one is found, 1
8924    otherwise.  If the current class is an anonymous inner class, look
8925    for something that has the same signature. */
8926
8927 static int
8928 verify_constructor_super (tree mdecl)
8929 {
8930   tree class = CLASSTYPE_SUPER (current_class);
8931   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8932   tree sdecl;
8933
8934   if (!class)
8935     return 0;
8936
8937   if (ANONYMOUS_CLASS_P (current_class))
8938     {
8939       tree mdecl_arg_type;
8940       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8941       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8942         if (DECL_CONSTRUCTOR_P (sdecl))
8943           {
8944             tree m_arg_type;
8945             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8946             if (super_inner)
8947               arg_type = TREE_CHAIN (arg_type);
8948             for (m_arg_type = mdecl_arg_type;
8949                  (arg_type != end_params_node
8950                   && m_arg_type != end_params_node);
8951                  arg_type = TREE_CHAIN (arg_type),
8952                    m_arg_type = TREE_CHAIN (m_arg_type))
8953               if (!valid_method_invocation_conversion_p
8954                      (TREE_VALUE (arg_type),
8955                       TREE_VALUE (m_arg_type)))
8956                 break;
8957
8958             if (arg_type == end_params_node && m_arg_type == end_params_node)
8959               return 0;
8960           }
8961     }
8962   else
8963     {
8964       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8965         {
8966           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8967           if (super_inner)
8968             arg = TREE_CHAIN (arg);
8969           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8970             return 0;
8971         }
8972     }
8973   return 1;
8974 }
8975
8976 /* Generate code for all context remembered for code generation.  */
8977
8978 static GTY(()) tree reversed_class_list;
8979 void
8980 java_expand_classes (void)
8981 {
8982   int save_error_count = 0;
8983   static struct parser_ctxt *cur_ctxp = NULL;
8984
8985   java_parse_abort_on_error ();
8986   if (!(ctxp = ctxp_for_generation))
8987     return;
8988   java_layout_classes ();
8989   java_parse_abort_on_error ();
8990
8991   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8992     {
8993       tree current;
8994       for (current = cur_ctxp->class_list;
8995            current;
8996            current = TREE_CHAIN (current))
8997         gen_indirect_dispatch_tables (TREE_TYPE (current));
8998     }
8999
9000   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9001     {
9002       ctxp = cur_ctxp;
9003       input_filename = ctxp->filename;
9004       lang_init_source (2);            /* Error msgs have method prototypes */
9005       java_complete_expand_classes (); /* Complete and expand classes */
9006       java_parse_abort_on_error ();
9007     }
9008   input_filename = main_input_filename;
9009
9010   /* Find anonymous classes and expand their constructor. This extra pass is
9011      necessary because the constructor itself is only generated when the
9012      method in which it is defined is expanded. */
9013   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9014     {
9015       tree current;
9016       ctxp = cur_ctxp;
9017       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9018         {
9019           output_class = current_class = TREE_TYPE (current);
9020           if (ANONYMOUS_CLASS_P (current_class))
9021             {
9022               tree d;
9023               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9024                 {
9025                   if (DECL_CONSTRUCTOR_P (d))
9026                     {
9027                       java_complete_expand_method (d);
9028                       break;    /* There is only one constructor. */
9029                     }
9030                 }
9031             }
9032         }
9033     }
9034
9035   /* Expanding the constructors of anonymous classes generates access
9036      methods.  Scan all the methods looking for null DECL_RESULTs --
9037      this will be the case if a method hasn't been expanded.  */
9038   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9039     {
9040       tree current;
9041       ctxp = cur_ctxp;
9042       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9043         {
9044           tree d;
9045           output_class = current_class = TREE_TYPE (current);
9046           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9047             {
9048               if (DECL_RESULT (d) == NULL_TREE)
9049                 java_complete_expand_method (d);
9050             }
9051         }
9052     }
9053
9054   /* ???  Instead of all this we could iterate around the list of
9055      classes until there were no more un-expanded methods.  It would
9056      take a little longer -- one pass over the whole list of methods
9057      -- but it would be simpler.  Like this:  */
9058 #if 0
9059     {
9060       int something_changed;
9061
9062       do
9063         {
9064           something_changed = 0;
9065           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9066             {
9067               tree current;
9068               ctxp = cur_ctxp;
9069               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9070                 {
9071                   tree d;
9072                   output_class = current_class = TREE_TYPE (current);
9073                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9074                     {
9075                       if (DECL_RESULT (d) == NULL_TREE)
9076                         {
9077                           something_changed = 1;
9078                           java_complete_expand_method (d);
9079                         }
9080                     }
9081                 }
9082             }
9083         }
9084       while (something_changed);
9085     }
9086 #endif
9087
9088   /* If we've found error at that stage, don't try to generate
9089      anything, unless we're emitting xrefs or checking the syntax only
9090      (but not using -fsyntax-only for the purpose of generating
9091      bytecode. */
9092   if (java_error_count && !flag_emit_xref
9093       && (!flag_syntax_only && !flag_emit_class_files))
9094     return;
9095
9096   /* Now things are stable, go for generation of the class data. */
9097
9098   /* We pessimistically marked all methods and fields external until
9099      we knew what set of classes we were planning to compile.  Now mark
9100      those that will be generated locally as not external.  */
9101   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9102     {
9103       tree current;
9104       ctxp = cur_ctxp;
9105       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9106         java_mark_class_local (TREE_TYPE (current));
9107     }
9108
9109   /* Compile the classes.  */
9110   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9111     {
9112       tree current;
9113       reversed_class_list = NULL;
9114
9115       ctxp = cur_ctxp;
9116
9117       /* We write out the classes in reverse order.  This ensures that
9118          inner classes are written before their containing classes,
9119          which is important for parallel builds.  Otherwise, the
9120          class file for the outer class may be found, but the class
9121          file for the inner class may not be present.  In that
9122          situation, the compiler cannot fall back to the original
9123          source, having already read the outer class, so we must
9124          prevent that situation.  */
9125       for (current = ctxp->class_list;
9126            current;
9127            current = TREE_CHAIN (current))
9128         reversed_class_list
9129           = tree_cons (NULL_TREE, current, reversed_class_list);
9130
9131       for (current = reversed_class_list;
9132            current;
9133            current = TREE_CHAIN (current))
9134         {
9135           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9136           if (flag_emit_class_files)
9137             write_classfile (current_class);
9138           if (flag_emit_xref)
9139             expand_xref (current_class);
9140           else if (! flag_syntax_only)
9141             java_expand_method_bodies (current_class);
9142         }
9143     }
9144 }
9145
9146 void
9147 java_finish_classes (void)
9148 {
9149   static struct parser_ctxt *cur_ctxp = NULL;
9150   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9151     {
9152       tree current;
9153       ctxp = cur_ctxp;
9154       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9155         {
9156           output_class = current_class = TREE_TYPE (current);
9157           finish_class ();
9158         }
9159     }
9160 }
9161
9162 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9163    a tree list node containing RIGHT. Fore coming RIGHTs will be
9164    chained to this hook. LOCATION contains the location of the
9165    separating `.' operator.  */
9166
9167 static tree
9168 make_qualified_primary (tree primary, tree right, int location)
9169 {
9170   tree wfl;
9171
9172   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9173     wfl = build_wfl_wrap (primary, location);
9174   else
9175     {
9176       wfl = primary;
9177       /* If wfl wasn't qualified, we build a first anchor */
9178       if (!EXPR_WFL_QUALIFICATION (wfl))
9179         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9180     }
9181
9182   /* And chain them */
9183   EXPR_WFL_LINECOL (right) = location;
9184   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9185   PRIMARY_P (wfl) =  1;
9186   return wfl;
9187 }
9188
9189 /* Simple merge of two name separated by a `.' */
9190
9191 static tree
9192 merge_qualified_name (tree left, tree right)
9193 {
9194   tree node;
9195   if (!left && !right)
9196     return NULL_TREE;
9197
9198   if (!left)
9199     return right;
9200
9201   if (!right)
9202     return left;
9203
9204   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9205                 IDENTIFIER_LENGTH (left));
9206   obstack_1grow (&temporary_obstack, '.');
9207   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9208                  IDENTIFIER_LENGTH (right));
9209   node =  get_identifier (obstack_base (&temporary_obstack));
9210   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9211   QUALIFIED_P (node) = 1;
9212   return node;
9213 }
9214
9215 /* Merge the two parts of a qualified name into LEFT.  Set the
9216    location information of the resulting node to LOCATION, usually
9217    inherited from the location information of the `.' operator. */
9218
9219 static tree
9220 make_qualified_name (tree left, tree right, int location)
9221 {
9222 #ifdef USE_COMPONENT_REF
9223   tree node = build3 (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9224   EXPR_WFL_LINECOL (node) = location;
9225   return node;
9226 #else
9227   tree left_id = EXPR_WFL_NODE (left);
9228   tree right_id = EXPR_WFL_NODE (right);
9229   tree wfl, merge;
9230
9231   merge = merge_qualified_name (left_id, right_id);
9232
9233   /* Left wasn't qualified and is now qualified */
9234   if (!QUALIFIED_P (left_id))
9235     {
9236       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9237       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9238       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9239     }
9240
9241   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9242   EXPR_WFL_LINECOL (wfl) = location;
9243   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9244
9245   EXPR_WFL_NODE (left) = merge;
9246   return left;
9247 #endif
9248 }
9249
9250 /* Extract the last identifier component of the qualified in WFL. The
9251    last identifier is removed from the linked list */
9252
9253 static tree
9254 cut_identifier_in_qualified (tree wfl)
9255 {
9256   tree q;
9257   tree previous = NULL_TREE;
9258   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9259     if (!TREE_CHAIN (q))
9260       {
9261         if (!previous)
9262           /* Operating on a non qualified qualified WFL.  */
9263           abort ();
9264
9265         TREE_CHAIN (previous) = NULL_TREE;
9266         return TREE_PURPOSE (q);
9267       }
9268 }
9269
9270 /* Resolve the expression name NAME. Return its decl.  */
9271
9272 static tree
9273 resolve_expression_name (tree id, tree *orig)
9274 {
9275   tree name = EXPR_WFL_NODE (id);
9276   tree decl;
9277
9278   /* 6.5.5.1: Simple expression names */
9279   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9280     {
9281       /* 15.13.1: NAME can appear within the scope of a local variable
9282          declaration */
9283       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9284         return decl;
9285
9286       /* 15.13.1: NAME can appear within a class declaration */
9287       else
9288         {
9289           decl = lookup_field_wrapper (current_class, name);
9290           if (decl)
9291             {
9292               tree access = NULL_TREE;
9293               int fs = FIELD_STATIC (decl);
9294
9295               /* If we're accessing an outer scope local alias, make
9296                  sure we change the name of the field we're going to
9297                  build access to. */
9298               if (FIELD_LOCAL_ALIAS_USED (decl))
9299                 name = DECL_NAME (decl);
9300
9301               check_deprecation (id, decl);
9302
9303               /* Instance variable (8.3.1.1) can't appear within
9304                  static method, static initializer or initializer for
9305                  a static variable. */
9306               if (!fs && METHOD_STATIC (current_function_decl))
9307                 {
9308                   static_ref_err (id, name, current_class);
9309                   return error_mark_node;
9310                 }
9311               /* Instance variables can't appear as an argument of
9312                  an explicit constructor invocation */
9313               if (!fs && ctxp->explicit_constructor_p
9314                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9315                 {
9316                   parse_error_context
9317                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9318                   return error_mark_node;
9319                 }
9320
9321               /* If we're processing an inner class and we're trying
9322                  to access a field belonging to an outer class, build
9323                  the access to the field */
9324               if (!fs && outer_field_access_p (current_class, decl))
9325                 {
9326                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9327                     {
9328                       static_ref_err (id, DECL_NAME (decl), current_class);
9329                       return error_mark_node;
9330                     }
9331                   access = build_outer_field_access (id, decl);
9332                   if (orig)
9333                     *orig = access;
9334                   return access;
9335                 }
9336
9337               /* Otherwise build what it takes to access the field */
9338               access = build_field_ref ((fs ? NULL_TREE : current_this),
9339                                         DECL_CONTEXT (decl), name);
9340               if (fs)
9341                 access = maybe_build_class_init_for_field (decl, access);
9342               /* We may be asked to save the real field access node */
9343               if (orig)
9344                 *orig = access;
9345               /* Last check: can we access the field? */
9346               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9347                 {
9348                   not_accessible_field_error (id, decl);
9349                   return error_mark_node;
9350                 }
9351               /* And we return what we got */
9352               return access;
9353             }
9354           /* Fall down to error report on undefined variable */
9355         }
9356     }
9357   /* 6.5.5.2 Qualified Expression Names */
9358   else
9359     {
9360       if (orig)
9361         *orig = NULL_TREE;
9362       qualify_ambiguous_name (id);
9363       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9364       /* 15.10.2: Accessing Superclass Members using super */
9365       return resolve_field_access (id, orig, NULL);
9366     }
9367
9368   /* We've got an error here */
9369   if (INNER_CLASS_TYPE_P (current_class))
9370     parse_error_context (id,
9371                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9372                          IDENTIFIER_POINTER (name),
9373                          IDENTIFIER_POINTER (DECL_NAME
9374                                              (TYPE_NAME (current_class))));
9375   else
9376     parse_error_context (id, "Undefined variable `%s'",
9377                          IDENTIFIER_POINTER (name));
9378
9379   return error_mark_node;
9380 }
9381
9382 static void
9383 static_ref_err (tree wfl, tree field_id, tree class_type)
9384 {
9385   parse_error_context
9386     (wfl,
9387      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9388      IDENTIFIER_POINTER (field_id),
9389      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9390 }
9391
9392 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9393    We return something suitable to generate the field access. We also
9394    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9395    recipient's address can be null. */
9396
9397 static tree
9398 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9399 {
9400   int is_static = 0;
9401   tree field_ref;
9402   tree decl = NULL_TREE, where_found, type_found;
9403
9404   if (resolve_qualified_expression_name (qual_wfl, &decl,
9405                                          &where_found, &type_found))
9406     return error_mark_node;
9407
9408   /* Resolve the LENGTH field of an array here */
9409   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9410       && type_found && TYPE_ARRAY_P (type_found)
9411       && ! flag_emit_class_files && ! flag_emit_xref)
9412     {
9413       tree length = build_java_array_length_access (where_found);
9414       field_ref = length;
9415
9416       /* In case we're dealing with a static array, we need to
9417          initialize its class before the array length can be fetched.
9418          It's also a good time to create a DECL_RTL for the field if
9419          none already exists, otherwise if the field was declared in a
9420          class found in an external file and hasn't been (and won't
9421          be) accessed for its value, none will be created. */
9422       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9423         {
9424           build_static_field_ref (where_found);
9425           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9426         }
9427     }
9428   /* We might have been trying to resolve field.method(). In which
9429      case, the resolution is over and decl is the answer */
9430   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9431     field_ref = decl;
9432   else if (JDECL_P (decl))
9433     {
9434       if (!type_found)
9435         type_found = DECL_CONTEXT (decl);
9436       is_static = FIELD_STATIC (decl);
9437       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9438                                     NULL_TREE : where_found),
9439                                    type_found, DECL_NAME (decl));
9440       if (field_ref == error_mark_node)
9441         return error_mark_node;
9442       if (is_static)
9443         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9444
9445       /* If we're looking at a static field, we may need to generate a
9446          class initialization for it.  This can happen when the access
9447          looks like `field.ref', where `field' is a static field in an
9448          interface we implement.  */
9449       if (!flag_emit_class_files
9450           && !flag_emit_xref
9451           && TREE_CODE (where_found) == VAR_DECL
9452           && FIELD_STATIC (where_found))
9453         {
9454           build_static_field_ref (where_found);
9455           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9456         }
9457     }
9458   else
9459     field_ref = decl;
9460
9461   if (field_decl)
9462     *field_decl = decl;
9463   if (field_type)
9464     *field_type = (QUAL_DECL_TYPE (decl) ?
9465                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9466   return field_ref;
9467 }
9468
9469 /* If NODE is an access to f static field, strip out the class
9470    initialization part and return the field decl, otherwise, return
9471    NODE. */
9472
9473 static tree
9474 strip_out_static_field_access_decl (tree node)
9475 {
9476   if (TREE_CODE (node) == COMPOUND_EXPR)
9477     {
9478       tree op1 = TREE_OPERAND (node, 1);
9479       if (TREE_CODE (op1) == COMPOUND_EXPR)
9480          {
9481            tree call = TREE_OPERAND (op1, 0);
9482            if (TREE_CODE (call) == CALL_EXPR
9483                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9484                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9485                == soft_initclass_node)
9486              return TREE_OPERAND (op1, 1);
9487          }
9488       else if (JDECL_P (op1))
9489         return op1;
9490     }
9491   return node;
9492 }
9493
9494 /* 6.5.5.2: Qualified Expression Names */
9495
9496 static int
9497 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9498                                    tree *where_found, tree *type_found)
9499 {
9500   int from_type = 0;            /* Field search initiated from a type */
9501   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9502   int previous_call_static = 0;
9503   int is_static;
9504   tree decl = NULL_TREE, type = NULL_TREE, q;
9505   /* For certain for of inner class instantiation */
9506   tree saved_current, saved_this;
9507 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9508   { current_class = saved_current; current_this = saved_this;}
9509
9510   *type_found = *where_found = NULL_TREE;
9511
9512   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9513     {
9514       tree qual_wfl = QUAL_WFL (q);
9515       tree ret_decl;            /* for EH checking */
9516       int location;             /* for EH checking */
9517
9518       /* 15.10.1 Field Access Using a Primary */
9519       switch (TREE_CODE (qual_wfl))
9520         {
9521         case CALL_EXPR:
9522         case NEW_CLASS_EXPR:
9523           /* If the access to the function call is a non static field,
9524              build the code to access it. */
9525           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9526             {
9527               decl = maybe_access_field (decl, *where_found,
9528                                          DECL_CONTEXT (decl));
9529               if (decl == error_mark_node)
9530                 return 1;
9531             }
9532
9533           /* And code for the function call */
9534           if (complete_function_arguments (qual_wfl))
9535             return 1;
9536
9537           /* We might have to setup a new current class and a new this
9538              for the search of an inner class, relative to the type of
9539              a expression resolved as `decl'. The current values are
9540              saved and restored shortly after */
9541           saved_current = current_class;
9542           saved_this = current_this;
9543           if (decl
9544               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9545                   || from_qualified_this))
9546             {
9547               /* If we still have `from_qualified_this', we have the form
9548                  <T>.this.f() and we need to build <T>.this */
9549               if (from_qualified_this)
9550                 {
9551                   decl = build_access_to_thisn (current_class, type, 0);
9552                   decl = java_complete_tree (decl);
9553                   type = TREE_TYPE (TREE_TYPE (decl));
9554                 }
9555               current_class = type;
9556               current_this = decl;
9557               from_qualified_this = 0;
9558             }
9559
9560           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9561             CALL_USING_SUPER (qual_wfl) = 1;
9562           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9563                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9564           *where_found = patch_method_invocation (qual_wfl, decl, type,
9565                                                   from_super,
9566                                                   &is_static, &ret_decl);
9567           from_super = 0;
9568           if (*where_found == error_mark_node)
9569             {
9570               RESTORE_THIS_AND_CURRENT_CLASS;
9571               return 1;
9572             }
9573           *type_found = type = QUAL_DECL_TYPE (*where_found);
9574
9575           *where_found = force_evaluation_order (*where_found);
9576
9577           /* If we're creating an inner class instance, check for that
9578              an enclosing instance is in scope */
9579           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9580               && INNER_ENCLOSING_SCOPE_CHECK (type))
9581             {
9582               parse_error_context
9583                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9584                  lang_printable_name (type, 0),
9585                  (!current_this ? "" :
9586                   "; an explicit one must be provided when creating this inner class"));
9587               RESTORE_THIS_AND_CURRENT_CLASS;
9588               return 1;
9589             }
9590
9591           /* In case we had to change then to resolve a inner class
9592              instantiation using a primary qualified by a `new' */
9593           RESTORE_THIS_AND_CURRENT_CLASS;
9594
9595           if (location)
9596             {
9597               tree arguments = NULL_TREE;
9598               if (TREE_CODE (qual_wfl) == CALL_EXPR
9599                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9600                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9601               check_thrown_exceptions (location, ret_decl, arguments);
9602             }
9603
9604           /* If the previous call was static and this one is too,
9605              build a compound expression to hold the two (because in
9606              that case, previous function calls aren't transported as
9607              forcoming function's argument. */
9608           if (previous_call_static && is_static)
9609             {
9610               decl = build2 (COMPOUND_EXPR, TREE_TYPE (*where_found),
9611                              decl, *where_found);
9612               TREE_SIDE_EFFECTS (decl) = 1;
9613             }
9614           else
9615             {
9616               previous_call_static = is_static;
9617               decl = *where_found;
9618             }
9619           from_type = 0;
9620           continue;
9621
9622         case NEW_ARRAY_EXPR:
9623         case NEW_ANONYMOUS_ARRAY_EXPR:
9624           *where_found = decl = java_complete_tree (qual_wfl);
9625           if (decl == error_mark_node)
9626             return 1;
9627           *type_found = type = QUAL_DECL_TYPE (decl);
9628           continue;
9629
9630         case CONVERT_EXPR:
9631           *where_found = decl = java_complete_tree (qual_wfl);
9632           if (decl == error_mark_node)
9633             return 1;
9634           *type_found = type = QUAL_DECL_TYPE (decl);
9635           from_cast = 1;
9636           continue;
9637
9638         case CONDITIONAL_EXPR:
9639         case STRING_CST:
9640         case MODIFY_EXPR:
9641           *where_found = decl = java_complete_tree (qual_wfl);
9642           if (decl == error_mark_node)
9643             return 1;
9644           *type_found = type = QUAL_DECL_TYPE (decl);
9645           continue;
9646
9647         case ARRAY_REF:
9648           /* If the access to the function call is a non static field,
9649              build the code to access it. */
9650           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9651             {
9652               decl = maybe_access_field (decl, *where_found, type);
9653               if (decl == error_mark_node)
9654                 return 1;
9655             }
9656           /* And code for the array reference expression */
9657           decl = java_complete_tree (qual_wfl);
9658           if (decl == error_mark_node)
9659             return 1;
9660           type = QUAL_DECL_TYPE (decl);
9661           continue;
9662
9663         case PLUS_EXPR:
9664           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9665             return 1;
9666           if ((type = patch_string (decl)))
9667             decl = type;
9668           *where_found = QUAL_RESOLUTION (q) = decl;
9669           *type_found = type = TREE_TYPE (decl);
9670           break;
9671
9672         case CLASS_LITERAL:
9673           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9674             return 1;
9675           *where_found = QUAL_RESOLUTION (q) = decl;
9676           *type_found = type = TREE_TYPE (decl);
9677           break;
9678
9679         default:
9680           /* Fix for -Wall Just go to the next statement. Don't
9681              continue */
9682           break;
9683         }
9684
9685       /* If we fall here, we weren't processing a (static) function call. */
9686       previous_call_static = 0;
9687
9688       /* It can be the keyword THIS */
9689       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9690           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9691         {
9692           if (!current_this)
9693             {
9694               parse_error_context
9695                 (wfl, "Keyword `this' used outside allowed context");
9696               return 1;
9697             }
9698           if (ctxp->explicit_constructor_p
9699               && type == current_class)
9700             {
9701               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9702               return 1;
9703             }
9704           /* We have to generate code for intermediate access */
9705           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9706             {
9707               *where_found = decl = current_this;
9708               *type_found = type = QUAL_DECL_TYPE (decl);
9709             }
9710           /* We're trying to access the this from somewhere else. Make sure
9711              it's allowed before doing so. */
9712           else
9713             {
9714               if (!enclosing_context_p (type, current_class))
9715                 {
9716                   char *p  = xstrdup (lang_printable_name (type, 0));
9717                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9718                                        p, p,
9719                                        lang_printable_name (current_class, 0));
9720                   free (p);
9721                   return 1;
9722                 }
9723               from_qualified_this = 1;
9724               /* If there's nothing else after that, we need to
9725                  produce something now, otherwise, the section of the
9726                  code that needs to produce <T>.this will generate
9727                  what is necessary. */
9728               if (!TREE_CHAIN (q))
9729                 {
9730                   decl = build_access_to_thisn (current_class, type, 0);
9731                   *where_found = decl = java_complete_tree (decl);
9732                   *type_found = type = TREE_TYPE (decl);
9733                 }
9734             }
9735
9736           from_type = 0;
9737           continue;
9738         }
9739
9740       /* 15.10.2 Accessing Superclass Members using SUPER */
9741       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9742           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9743         {
9744           tree node;
9745           /* Check on the restricted use of SUPER */
9746           if (METHOD_STATIC (current_function_decl)
9747               || current_class == object_type_node)
9748             {
9749               parse_error_context
9750                 (wfl, "Keyword `super' used outside allowed context");
9751               return 1;
9752             }
9753           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9754           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9755                              CLASSTYPE_SUPER (current_class),
9756                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9757           *where_found = decl = java_complete_tree (node);
9758           if (decl == error_mark_node)
9759             return 1;
9760           *type_found = type = QUAL_DECL_TYPE (decl);
9761           from_super = from_type = 1;
9762           continue;
9763         }
9764
9765       /* 15.13.1: Can't search for field name in packages, so we
9766          assume a variable/class name was meant. */
9767       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9768         {
9769           tree name;
9770           if ((decl = resolve_package (wfl, &q, &name)))
9771             {
9772               tree list;
9773               *where_found = decl;
9774
9775               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9776
9777               /* We want to be absolutely sure that the class is laid
9778                  out. We're going to search something inside it. */
9779               *type_found = type = TREE_TYPE (decl);
9780               layout_class (type);
9781               from_type = 1;
9782
9783               /* Fix them all the way down, if any are left. */
9784               if (q)
9785                 {
9786                   list = TREE_CHAIN (q);
9787                   while (list)
9788                     {
9789                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9790                       list = TREE_CHAIN (list);
9791                     }
9792                 }
9793             }
9794           else
9795             {
9796               if (from_super || from_cast)
9797                 parse_error_context
9798                   ((from_cast ? qual_wfl : wfl),
9799                    "No variable `%s' defined in class `%s'",
9800                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9801                    lang_printable_name (type, 0));
9802               else
9803                 parse_error_context
9804                   (qual_wfl, "Undefined variable or class name: `%s'",
9805                    IDENTIFIER_POINTER (name));
9806               return 1;
9807             }
9808         }
9809
9810       /* We have a type name. It's been already resolved when the
9811          expression was qualified. */
9812       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9813         {
9814           decl = QUAL_RESOLUTION (q);
9815
9816           /* Sneak preview. If next we see a `new', we're facing a
9817              qualification which resulted in a type being selected
9818              instead of a field.  Report the error.  */
9819           if(TREE_CHAIN (q)
9820              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9821             {
9822               parse_error_context (qual_wfl, "Undefined variable `%s'",
9823                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9824               return 1;
9825             }
9826
9827           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9828
9829           check_deprecation (qual_wfl, decl);
9830
9831           type = TREE_TYPE (decl);
9832           from_type = 1;
9833         }
9834       /* We resolve an expression name */
9835       else
9836         {
9837           tree field_decl = NULL_TREE;
9838
9839           /* If there exists an early resolution, use it. That occurs
9840              only once and we know that there are more things to
9841              come. Don't do that when processing something after SUPER
9842              (we need more thing to be put in place below */
9843           if (!from_super && QUAL_RESOLUTION (q))
9844             {
9845               decl = QUAL_RESOLUTION (q);
9846               if (!type)
9847                 {
9848                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9849                     {
9850                       if (current_this)
9851                         *where_found = current_this;
9852                       else
9853                         {
9854                           static_ref_err (qual_wfl, DECL_NAME (decl),
9855                                           current_class);
9856                           return 1;
9857                         }
9858                       if (outer_field_access_p (current_class, decl))
9859                         decl = build_outer_field_access (qual_wfl, decl);
9860                     }
9861                   else
9862                     {
9863                       *where_found = TREE_TYPE (decl);
9864                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9865                         *where_found = TREE_TYPE (*where_found);
9866                     }
9867                 }
9868             }
9869
9870           /* Report and error if we're using a numerical literal as a
9871              qualifier. It can only be an INTEGER_CST. */
9872           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9873             {
9874               parse_error_context
9875                 (wfl, "Can't use type `%s' as a qualifier",
9876                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9877               return 1;
9878             }
9879
9880           /* We have to search for a field, knowing the type of its
9881              container. The flag FROM_TYPE indicates that we resolved
9882              the last member of the expression as a type name, which
9883              means that for the resolution of this field, we'll look
9884              for other errors than if it was resolved as a member of
9885              an other field. */
9886           else
9887             {
9888               int is_static;
9889               tree field_decl_type; /* For layout */
9890
9891               if (!from_type && !JREFERENCE_TYPE_P (type))
9892                 {
9893                   parse_error_context
9894                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9895                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9896                      lang_printable_name (type, 0),
9897                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9898                   return 1;
9899                 }
9900
9901               field_decl = lookup_field_wrapper (type,
9902                                                  EXPR_WFL_NODE (qual_wfl));
9903
9904               /* Maybe what we're trying to access to is an inner
9905                  class, only if decl is a TYPE_DECL. */
9906               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9907                 {
9908                   tree ptr, inner_decl;
9909
9910                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9911                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9912                   if (inner_decl)
9913                     {
9914                       check_inner_class_access (inner_decl, decl, qual_wfl);
9915                       type = TREE_TYPE (inner_decl);
9916                       decl = inner_decl;
9917                       from_type = 1;
9918                       continue;
9919                     }
9920                 }
9921
9922               if (field_decl == NULL_TREE)
9923                 {
9924                   parse_error_context
9925                     (qual_wfl, "No variable `%s' defined in type `%s'",
9926                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9927                      GET_TYPE_NAME (type));
9928                   return 1;
9929                 }
9930               if (field_decl == error_mark_node)
9931                 return 1;
9932
9933               /* Layout the type of field_decl, since we may need
9934                  it. Don't do primitive types or loaded classes. The
9935                  situation of non primitive arrays may not handled
9936                  properly here. FIXME */
9937               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9938                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9939               else
9940                 field_decl_type = TREE_TYPE (field_decl);
9941               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9942                   && !CLASS_LOADED_P (field_decl_type)
9943                   && !TYPE_ARRAY_P (field_decl_type))
9944                 resolve_and_layout (field_decl_type, NULL_TREE);
9945
9946               /* Check on accessibility here */
9947               if (not_accessible_p (current_class, field_decl,
9948                                     *type_found, from_super))
9949                 return not_accessible_field_error (qual_wfl,field_decl);
9950               check_deprecation (qual_wfl, field_decl);
9951
9952               /* There are things to check when fields are accessed
9953                  from type. There are no restrictions on a static
9954                  declaration of the field when it is accessed from an
9955                  interface */
9956               is_static = FIELD_STATIC (field_decl);
9957               if (!from_super && from_type
9958                   && !TYPE_INTERFACE_P (type)
9959                   && !is_static
9960                   && (current_function_decl
9961                       && METHOD_STATIC (current_function_decl)))
9962                 {
9963                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9964                   return 1;
9965                 }
9966               from_cast = from_super = 0;
9967
9968               /* It's an access from a type but it isn't static, we
9969                  make it relative to `this'. */
9970               if (!is_static && from_type)
9971                 decl = current_this;
9972
9973               /* If we need to generate something to get a proper
9974                  handle on what this field is accessed from, do it
9975                  now. */
9976               if (!is_static)
9977                 {
9978                   decl = maybe_access_field (decl, *where_found, *type_found);
9979                   if (decl == error_mark_node)
9980                     return 1;
9981                 }
9982
9983               /* We want to keep the location were found it, and the type
9984                  we found. */
9985               *where_found = decl;
9986               *type_found = type;
9987
9988               /* Generate the correct expression for field access from
9989                  qualified this */
9990               if (from_qualified_this)
9991                 {
9992                   field_decl = build_outer_field_access (qual_wfl, field_decl);
9993                   from_qualified_this = 0;
9994                 }
9995
9996               /* This is the decl found and eventually the next one to
9997                  search from */
9998               decl = field_decl;
9999             }
10000           from_type = 0;
10001           type = QUAL_DECL_TYPE (decl);
10002
10003           /* Sneak preview. If decl is qualified by a `new', report
10004              the error here to be accurate on the peculiar construct */
10005           if (TREE_CHAIN (q)
10006               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10007               && !JREFERENCE_TYPE_P (type))
10008             {
10009               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10010                                    lang_printable_name (type, 0));
10011               return 1;
10012             }
10013         }
10014       /* `q' might have changed due to a after package resolution
10015          re-qualification */
10016       if (!q)
10017         break;
10018     }
10019   *found_decl = decl;
10020   return 0;
10021 }
10022
10023 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10024    can't be accessed from REFERENCE (a record type). If MEMBER
10025    features a protected access, we then use WHERE which, if non null,
10026    holds the type of MEMBER's access that is checked against
10027    6.6.2.1. This function should be used when decl is a field or a
10028    method.  */
10029
10030 static int
10031 not_accessible_p (tree reference, tree member, tree where, int from_super)
10032 {
10033   int access_flag = get_access_flags_from_decl (member);
10034   bool is_static = false;
10035
10036   if (TREE_CODE (member) == FIELD_DECL ||
10037       TREE_CODE (member) == VAR_DECL)
10038     is_static = FIELD_STATIC (member);
10039   else
10040     is_static = METHOD_STATIC (member);
10041
10042   /* Access always granted for members declared public */
10043   if (access_flag & ACC_PUBLIC)
10044     return 0;
10045
10046   /* Check access on protected members */
10047   if (access_flag & ACC_PROTECTED)
10048     {
10049       /* Access granted if it occurs from within the package
10050          containing the class in which the protected member is
10051          declared */
10052       if (class_in_current_package (DECL_CONTEXT (member)))
10053         return 0;
10054
10055       /* If accessed with the form `super.member', then access is granted */
10056       if (from_super)
10057         return 0;
10058
10059       /* If WHERE is active, access was made through a qualifier. For
10060          non-static members, access is granted if the type of the qualifier
10061          is or is a sublass of the type the access is made from (6.6.2.1.)  */
10062       if (where && !is_static)
10063         {
10064           while (reference)
10065             {
10066               if (inherits_from_p (where, reference))
10067                 return 0;
10068               if (INNER_CLASS_TYPE_P (reference))
10069                 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10070               else
10071                 break;
10072             }
10073           return 1;
10074         }
10075
10076       /* Otherwise, access is granted if occurring from within the class
10077          where member is declared, or a subclass of it.  */
10078       while (reference)
10079         {
10080           if (inherits_from_p (reference, DECL_CONTEXT (member)))
10081             return 0;
10082           if (INNER_CLASS_TYPE_P (reference))
10083             reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10084           else
10085             break;
10086         }
10087       return 1;
10088     }
10089
10090   /* Check access on private members. Access is granted only if it
10091      occurs from within the class in which it is declared -- that does
10092      it for innerclasses too. */
10093   if (access_flag & ACC_PRIVATE)
10094     {
10095       if (reference == DECL_CONTEXT (member) ||
10096           common_enclosing_context_p (DECL_CONTEXT (member), reference))
10097         return 0;
10098       return 1;
10099     }
10100
10101   /* Default access is permitted only when occurring from within the
10102      package in which the context (MEMBER) is declared.  */
10103   return !class_in_current_package (DECL_CONTEXT (member));
10104 }
10105
10106 /* Test deprecated decl access.  */
10107 static void
10108 check_deprecation (tree wfl, tree decl)
10109 {
10110   const char *file;
10111   tree elt;
10112
10113   if (! warn_deprecated)
10114     return;
10115
10116   /* We want to look at the element type of arrays here, so we strip
10117      all surrounding array types.  */
10118   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10119     {
10120       elt = TREE_TYPE (decl);
10121       while (TYPE_ARRAY_P (elt))
10122         elt = TYPE_ARRAY_ELEMENT (elt);
10123       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10124          to the record.  */
10125       decl = TYPE_NAME (TREE_TYPE (elt));
10126     }
10127   file = DECL_SOURCE_FILE (decl);
10128
10129   /* Complain if the field is deprecated and the file it was defined
10130      in isn't compiled at the same time the file which contains its
10131      use is */
10132   if (DECL_DEPRECATED (decl)
10133       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10134     {
10135       const char *the;
10136       switch (TREE_CODE (decl))
10137         {
10138         case FUNCTION_DECL:
10139           the = "method";
10140           break;
10141         case FIELD_DECL:
10142         case VAR_DECL:
10143           the = "field";
10144           break;
10145         case TYPE_DECL:
10146           parse_warning_context (wfl, "The class `%s' has been deprecated",
10147                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10148           return;
10149         default:
10150           abort ();
10151         }
10152       /* Don't issue a message if the context as been deprecated as a
10153          whole. */
10154       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10155         parse_warning_context
10156           (wfl, "The %s `%s' in class `%s' has been deprecated",
10157            the, lang_printable_name (decl, 0),
10158            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10159     }
10160 }
10161
10162 /* Returns 1 if class was declared in the current package, 0 otherwise */
10163
10164 static GTY(()) tree cicp_cache;
10165 static int
10166 class_in_current_package (tree class)
10167 {
10168   int qualified_flag;
10169   tree left;
10170
10171   if (cicp_cache == class)
10172     return 1;
10173
10174   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10175
10176   /* If the current package is empty and the name of CLASS is
10177      qualified, class isn't in the current package.  If there is a
10178      current package and the name of the CLASS is not qualified, class
10179      isn't in the current package */
10180   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10181     return 0;
10182
10183   /* If there is not package and the name of CLASS isn't qualified,
10184      they belong to the same unnamed package */
10185   if (!ctxp->package && !qualified_flag)
10186     return 1;
10187
10188   /* Compare the left part of the name of CLASS with the package name */
10189   split_qualified_name (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10190   if (ctxp->package == left)
10191     {
10192       cicp_cache = class;
10193       return 1;
10194     }
10195   return 0;
10196 }
10197
10198 /* This function may generate code to access DECL from WHERE. This is
10199    done only if certain conditions meet.  */
10200
10201 static tree
10202 maybe_access_field (tree decl, tree where, tree type)
10203 {
10204   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10205       && !FIELD_STATIC (decl))
10206     decl = build_field_ref (where ? where : current_this,
10207                             (type ? type : DECL_CONTEXT (decl)),
10208                             DECL_NAME (decl));
10209   return decl;
10210 }
10211
10212 /* Build a method invocation, by patching PATCH. If non NULL
10213    and according to the situation, PRIMARY and WHERE may be
10214    used. IS_STATIC is set to 1 if the invoked function is static. */
10215
10216 static tree
10217 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10218                          int *is_static, tree *ret_decl)
10219 {
10220   tree wfl = TREE_OPERAND (patch, 0);
10221   tree args = TREE_OPERAND (patch, 1);
10222   tree name = EXPR_WFL_NODE (wfl);
10223   tree list;
10224   int is_static_flag = 0;
10225   int is_super_init = 0;
10226   tree this_arg = NULL_TREE;
10227   int is_array_clone_call = 0;
10228
10229   /* Should be overridden if everything goes well. Otherwise, if
10230      something fails, it should keep this value. It stop the
10231      evaluation of a bogus assignment. See java_complete_tree,
10232      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10233      evaluating an assignment */
10234   TREE_TYPE (patch) = error_mark_node;
10235
10236   /* Since lookup functions are messing with line numbers, save the
10237      context now.  */
10238   java_parser_context_save_global ();
10239
10240   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10241
10242   /* Resolution of qualified name, excluding constructors */
10243   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10244     {
10245       tree identifier, identifier_wfl, type, resolved;
10246       /* Extract the last IDENTIFIER of the qualified
10247          expression. This is a wfl and we will use it's location
10248          data during error report. */
10249       identifier_wfl = cut_identifier_in_qualified (wfl);
10250       identifier = EXPR_WFL_NODE (identifier_wfl);
10251
10252       /* Given the context, IDENTIFIER is syntactically qualified
10253          as a MethodName. We need to qualify what's before */
10254       qualify_ambiguous_name (wfl);
10255       resolved = resolve_field_access (wfl, NULL, NULL);
10256
10257       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10258          && FIELD_FINAL (resolved)
10259          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10260          && !flag_emit_class_files && !flag_emit_xref)
10261        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10262
10263       if (resolved == error_mark_node)
10264         PATCH_METHOD_RETURN_ERROR ();
10265
10266       type = GET_SKIP_TYPE (resolved);
10267       resolve_and_layout (type, NULL_TREE);
10268
10269       if (JPRIMITIVE_TYPE_P (type))
10270         {
10271           parse_error_context
10272             (identifier_wfl,
10273              "Can't invoke a method on primitive type `%s'",
10274              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10275           PATCH_METHOD_RETURN_ERROR ();
10276         }
10277
10278       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10279       args = nreverse (args);
10280
10281       /* We're resolving a call from a type */
10282       if (TREE_CODE (resolved) == TYPE_DECL)
10283         {
10284           if (CLASS_INTERFACE (resolved))
10285             {
10286               parse_error_context
10287                 (identifier_wfl,
10288                 "Can't make static reference to method `%s' in interface `%s'",
10289                  IDENTIFIER_POINTER (identifier),
10290                  IDENTIFIER_POINTER (name));
10291               PATCH_METHOD_RETURN_ERROR ();
10292             }
10293           if (list && !METHOD_STATIC (list))
10294             {
10295               char *fct_name = xstrdup (lang_printable_name (list, 2));
10296               parse_error_context
10297                 (identifier_wfl,
10298                  "Can't make static reference to method `%s %s' in class `%s'",
10299                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10300                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10301               free (fct_name);
10302               PATCH_METHOD_RETURN_ERROR ();
10303             }
10304         }
10305       else
10306         this_arg = primary = resolved;
10307
10308       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10309         is_array_clone_call = 1;
10310
10311       /* IDENTIFIER_WFL will be used to report any problem further */
10312       wfl = identifier_wfl;
10313     }
10314   /* Resolution of simple names, names generated after a primary: or
10315      constructors */
10316   else
10317     {
10318       tree class_to_search = NULL_TREE;
10319       int lc;                   /* Looking for Constructor */
10320
10321       /* We search constructor in their target class */
10322       if (CALL_CONSTRUCTOR_P (patch))
10323         {
10324           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10325             class_to_search = EXPR_WFL_NODE (wfl);
10326           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10327                    this_identifier_node)
10328             class_to_search = NULL_TREE;
10329           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10330                    super_identifier_node)
10331             {
10332               is_super_init = 1;
10333               if (CLASSTYPE_SUPER (current_class))
10334                 class_to_search =
10335                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10336               else
10337                 {
10338                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10339                   PATCH_METHOD_RETURN_ERROR ();
10340                 }
10341             }
10342
10343           /* Class to search is NULL if we're searching the current one */
10344           if (class_to_search)
10345             {
10346               class_to_search = resolve_and_layout (class_to_search, wfl);
10347
10348               if (!class_to_search)
10349                 {
10350                   parse_error_context
10351                     (wfl, "Class `%s' not found in type declaration",
10352                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10353                   PATCH_METHOD_RETURN_ERROR ();
10354                 }
10355
10356               /* Can't instantiate an abstract class, but we can
10357                  invoke it's constructor. It's use within the `new'
10358                  context is denied here. */
10359               if (CLASS_ABSTRACT (class_to_search)
10360                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10361                 {
10362                   parse_error_context
10363                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10364                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10365                   PATCH_METHOD_RETURN_ERROR ();
10366                 }
10367
10368               class_to_search = TREE_TYPE (class_to_search);
10369             }
10370           else
10371             class_to_search = current_class;
10372           lc = 1;
10373         }
10374       /* This is a regular search in the local class, unless an
10375          alternate class is specified. */
10376       else
10377         {
10378           if (where != NULL_TREE)
10379             class_to_search = where;
10380           else if (QUALIFIED_P (name))
10381             class_to_search = current_class;
10382           else
10383             {
10384               class_to_search = current_class;
10385
10386               for (;;)
10387                 {
10388                   if (has_method (class_to_search, name))
10389                     break;
10390                   if (! INNER_CLASS_TYPE_P (class_to_search))
10391                     {
10392                       parse_error_context (wfl,
10393                                            "No method named `%s' in scope",
10394                                            IDENTIFIER_POINTER (name));
10395                       PATCH_METHOD_RETURN_ERROR ();
10396                     }
10397                   class_to_search
10398                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10399                 }
10400             }
10401           lc = 0;
10402         }
10403
10404       /* NAME is a simple identifier or comes from a primary. Search
10405          in the class whose declaration contain the method being
10406          invoked. */
10407       resolve_and_layout (class_to_search, NULL_TREE);
10408
10409       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10410       /* Don't continue if no method were found, as the next statement
10411          can't be executed then. */
10412       if (!list)
10413         PATCH_METHOD_RETURN_ERROR ();
10414
10415       if (TYPE_ARRAY_P (class_to_search)
10416           && DECL_NAME (list) == get_identifier ("clone"))
10417         is_array_clone_call = 1;
10418
10419       /* Check for static reference if non static methods */
10420       if (check_for_static_method_reference (wfl, patch, list,
10421                                              class_to_search, primary))
10422         PATCH_METHOD_RETURN_ERROR ();
10423
10424       /* Check for inner classes creation from illegal contexts */
10425       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10426                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10427           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10428           && !DECL_INIT_P (current_function_decl))
10429         {
10430           parse_error_context
10431             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10432              lang_printable_name (class_to_search, 0),
10433              (!current_this ? "" :
10434               "; an explicit one must be provided when creating this inner class"));
10435           PATCH_METHOD_RETURN_ERROR ();
10436         }
10437
10438       /* Non static methods are called with the current object extra
10439          argument. If patch a `new TYPE()', the argument is the value
10440          returned by the object allocator. If method is resolved as a
10441          primary, use the primary otherwise use the current THIS. */
10442       args = nreverse (args);
10443       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10444         {
10445           this_arg = primary ? primary : current_this;
10446
10447           /* If we're using an access method, things are different.
10448              There are two family of cases:
10449
10450              1) We're not generating bytecodes:
10451
10452              - LIST is non static. It's invocation is transformed from
10453                x(a1,...,an) into this$<n>.x(a1,....an).
10454              - LIST is static. It's invocation is transformed from
10455                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10456
10457              2) We're generating bytecodes:
10458
10459              - LIST is non static. It's invocation is transformed from
10460                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10461              - LIST is static. It's invocation is transformed from
10462                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10463
10464              Of course, this$<n> can be arbitrarily complex, ranging from
10465              this$0 (the immediate outer context) to
10466              access$0(access$0(...(this$0))).
10467
10468              maybe_use_access_method returns a nonzero value if the
10469              this_arg has to be moved into the (then generated) stub
10470              argument list. In the meantime, the selected function
10471              might have be replaced by a generated stub. */
10472           if (!primary &&
10473               maybe_use_access_method (is_super_init, &list, &this_arg))
10474             {
10475               args = tree_cons (NULL_TREE, this_arg, args);
10476               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10477             }
10478         }
10479     }
10480
10481   /* Merge point of all resolution schemes. If we have nothing, this
10482      is an error, already signaled */
10483   if (!list)
10484     PATCH_METHOD_RETURN_ERROR ();
10485
10486   /* Check accessibility, position the is_static flag, build and
10487      return the call */
10488   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10489                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10490                          NULL_TREE), from_super)
10491       /* Calls to clone() on array types are permitted as a special-case. */
10492       && !is_array_clone_call)
10493     {
10494       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10495       const char *const access =
10496         accessibility_string (get_access_flags_from_decl (list));
10497       const char *const klass =
10498         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10499       const char *const refklass =
10500         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10501       const char *const what = (DECL_CONSTRUCTOR_P (list)
10502                                 ? "constructor" : "method");
10503       parse_error_context (wfl,
10504                            "Can't access %s %s `%s.%s' from `%s'",
10505                            access, what, klass, fct_name, refklass);
10506       PATCH_METHOD_RETURN_ERROR ();
10507     }
10508
10509   /* Deprecation check: check whether the method being invoked or the
10510      instance-being-created's type are deprecated.  */
10511   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10512     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10513   check_deprecation (wfl, list);
10514
10515   /* If invoking a innerclass constructor, there are hidden parameters
10516      to pass */
10517   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10518       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10519     {
10520       /* And make sure we add the accessed local variables to be saved
10521          in field aliases. */
10522       args = build_alias_initializer_parameter_list
10523         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10524
10525       /* Secretly pass the current_this/primary as a second argument */
10526       if (primary || current_this)
10527         {
10528           tree extra_arg;
10529           tree this_type = (current_this ?
10530                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10531           /* Method's (list) enclosing context */
10532           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10533           /* If we have a primary, use it. */
10534           if (primary)
10535             extra_arg = primary;
10536           /* The current `this' is an inner class but isn't a direct
10537              enclosing context for the inner class we're trying to
10538              create. Build an access to the proper enclosing context
10539              and use it. */
10540           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10541                    && this_type != TREE_TYPE (mec))
10542             {
10543
10544               extra_arg = build_access_to_thisn (current_class,
10545                                                  TREE_TYPE (mec), 0);
10546               extra_arg = java_complete_tree (extra_arg);
10547             }
10548           /* Otherwise, just use the current `this' as an enclosing
10549              context. */
10550           else
10551             extra_arg = current_this;
10552           args = tree_cons (NULL_TREE, extra_arg, args);
10553         }
10554       else
10555         args = tree_cons (NULL_TREE, integer_zero_node, args);
10556     }
10557
10558   /* This handles the situation where a constructor invocation needs
10559      to have an enclosing context passed as a second parameter (the
10560      constructor is one of an inner class). */
10561   if ((is_super_init ||
10562        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10563       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10564     {
10565       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10566       tree extra_arg =
10567         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10568       extra_arg = java_complete_tree (extra_arg);
10569       args = tree_cons (NULL_TREE, extra_arg, args);
10570     }
10571
10572   is_static_flag = METHOD_STATIC (list);
10573   if (! is_static_flag && this_arg != NULL_TREE)
10574     args = tree_cons (NULL_TREE, this_arg, args);
10575
10576   /* In the context of an explicit constructor invocation, we can't
10577      invoke any method relying on `this'. Exceptions are: we're
10578      invoking a static function, primary exists and is not the current
10579      this, we're creating a new object. */
10580   if (ctxp->explicit_constructor_p
10581       && !is_static_flag
10582       && (!primary || primary == current_this)
10583       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10584     {
10585       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10586       PATCH_METHOD_RETURN_ERROR ();
10587     }
10588   java_parser_context_restore_global ();
10589   if (is_static)
10590     *is_static = is_static_flag;
10591   /* Sometimes, we want the decl of the selected method. Such as for
10592      EH checking */
10593   if (ret_decl)
10594     *ret_decl = list;
10595   patch = patch_invoke (patch, list, args);
10596
10597   /* Now is a good time to insert the call to finit$ */
10598   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10599     {
10600       tree finit_parms, finit_call;
10601
10602       /* Prepare to pass hidden parameters to finit$, if any. */
10603       finit_parms = build_alias_initializer_parameter_list
10604         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10605
10606       finit_call =
10607         build_method_invocation (build_wfl_node (finit_identifier_node),
10608                                  finit_parms);
10609
10610       /* Generate the code used to initialize fields declared with an
10611          initialization statement and build a compound statement along
10612          with the super constructor invocation. */
10613       CAN_COMPLETE_NORMALLY (patch) = 1;
10614       patch = build2 (COMPOUND_EXPR, void_type_node, patch,
10615                       java_complete_tree (finit_call));
10616     }
10617   return patch;
10618 }
10619
10620 /* Check that we're not trying to do a static reference to a method in
10621    non static method. Return 1 if it's the case, 0 otherwise. */
10622
10623 static int
10624 check_for_static_method_reference (tree wfl, tree node, tree method,
10625                                    tree where, tree primary)
10626 {
10627   if (METHOD_STATIC (current_function_decl)
10628       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10629     {
10630       char *fct_name = xstrdup (lang_printable_name (method, 0));
10631       parse_error_context
10632         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10633          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10634          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10635       free (fct_name);
10636       return 1;
10637     }
10638   return 0;
10639 }
10640
10641 /* Fix the invocation of *MDECL if necessary in the case of a
10642    invocation from an inner class. *THIS_ARG might be modified
10643    appropriately and an alternative access to *MDECL might be
10644    returned.  */
10645
10646 static int
10647 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10648 {
10649   tree ctx;
10650   tree md = *mdecl, ta = *this_arg;
10651   int to_return = 0;
10652   int non_static_context = !METHOD_STATIC (md);
10653
10654   if (is_super_init
10655       || DECL_CONTEXT (md) == current_class
10656       || !PURE_INNER_CLASS_TYPE_P (current_class)
10657       || DECL_FINIT_P (md)
10658       || DECL_INSTINIT_P (md))
10659     return 0;
10660
10661   /* If we're calling a method found in an enclosing class, generate
10662      what it takes to retrieve the right this. Don't do that if we're
10663      invoking a static method. Note that if MD's type is unrelated to
10664      CURRENT_CLASS, then the current this can be used. */
10665
10666   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10667     {
10668       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10669       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10670         {
10671           ta = build_current_thisn (current_class);
10672           ta = build_wfl_node (ta);
10673         }
10674       else
10675         {
10676           tree type = ctx;
10677           while (type)
10678             {
10679               maybe_build_thisn_access_method (type);
10680               if (inherits_from_p (type, DECL_CONTEXT (md)))
10681                 {
10682                   ta = build_access_to_thisn (ctx, type, 0);
10683                   break;
10684                 }
10685               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10686                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10687             }
10688         }
10689       ta = java_complete_tree (ta);
10690     }
10691
10692   /* We might have to use an access method to get to MD. We can
10693      break the method access rule as far as we're not generating
10694      bytecode */
10695   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10696     {
10697       md = build_outer_method_access_method (md);
10698       to_return = 1;
10699     }
10700
10701   *mdecl = md;
10702   *this_arg = ta;
10703
10704   /* Returning a nonzero value indicates we were doing a non static
10705      method invocation that is now a static invocation. It will have
10706      callee displace `this' to insert it in the regular argument
10707      list. */
10708   return (non_static_context && to_return);
10709 }
10710
10711 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10712    mode.  */
10713
10714 static tree
10715 patch_invoke (tree patch, tree method, tree args)
10716 {
10717   tree dtable, func;
10718   tree original_call, t, ta;
10719   tree check = NULL_TREE;
10720
10721   /* Last step for args: convert build-in types. If we're dealing with
10722      a new TYPE() type call, the first argument to the constructor
10723      isn't found in the incoming argument list, but delivered by
10724      `new' */
10725   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10726   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10727     t = TREE_CHAIN (t);
10728   for (ta = args; t != end_params_node && ta;
10729        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10730     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10731         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10732       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10733
10734   /* Resolve unresolved returned type issues */
10735   t = TREE_TYPE (TREE_TYPE (method));
10736   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10737     resolve_and_layout (TREE_TYPE (t), NULL);
10738
10739   if (flag_emit_class_files || flag_emit_xref)
10740     func = method;
10741   else
10742     {
10743       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10744         {
10745         case INVOKE_VIRTUAL:
10746           dtable = invoke_build_dtable (0, args);
10747           func = build_invokevirtual (dtable, method);
10748           break;
10749
10750         case INVOKE_NONVIRTUAL:
10751           /* If the object for the method call is null, we throw an
10752              exception.  We don't do this if the object is the current
10753              method's `this'.  In other cases we just rely on an
10754              optimization pass to eliminate redundant checks.  */
10755           if (TREE_VALUE (args) != current_this)
10756             {
10757               /* We use a save_expr here to make sure we only evaluate
10758                  the new `self' expression once.  */
10759               tree save_arg = save_expr (TREE_VALUE (args));
10760               TREE_VALUE (args) = save_arg;
10761               check = java_check_reference (save_arg, 1);
10762             }
10763           /* Fall through.  */
10764
10765         case INVOKE_SUPER:
10766         case INVOKE_STATIC:
10767           {
10768             tree signature = build_java_signature (TREE_TYPE (method));
10769             func = build_known_method_ref (method, TREE_TYPE (method),
10770                                            DECL_CONTEXT (method),
10771                                            signature, args);
10772           }
10773           break;
10774
10775         case INVOKE_INTERFACE:
10776           dtable = invoke_build_dtable (1, args);
10777           func = build_invokeinterface (dtable, method);
10778           break;
10779
10780         default:
10781           abort ();
10782         }
10783
10784       /* Ensure self_type is initialized, (invokestatic). FIXME */
10785       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10786     }
10787
10788   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10789   TREE_OPERAND (patch, 0) = func;
10790   TREE_OPERAND (patch, 1) = args;
10791   patch = check_for_builtin (method, patch);
10792   original_call = patch;
10793
10794   /* We're processing a `new TYPE ()' form. New is called and its
10795      returned value is the first argument to the constructor. We build
10796      a COMPOUND_EXPR and use saved expression so that the overall NEW
10797      expression value is a pointer to a newly created and initialized
10798      class. */
10799   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10800     {
10801       tree class = DECL_CONTEXT (method);
10802       tree c1, saved_new, size, new;
10803       tree alloc_node;
10804
10805       if (flag_emit_class_files || flag_emit_xref)
10806         {
10807           TREE_TYPE (patch) = build_pointer_type (class);
10808           return patch;
10809         }
10810       if (!TYPE_SIZE (class))
10811         safe_layout_class (class);
10812       size = size_in_bytes (class);
10813       alloc_node =
10814         (class_has_finalize_method (class) ? alloc_object_node
10815                                            : alloc_no_finalizer_node);
10816       new = build3 (CALL_EXPR, promote_type (class),
10817                     build_address_of (alloc_node),
10818                     build_tree_list (NULL_TREE, build_class_ref (class)),
10819                     NULL_TREE);
10820       saved_new = save_expr (new);
10821       c1 = build_tree_list (NULL_TREE, saved_new);
10822       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10823       TREE_OPERAND (original_call, 1) = c1;
10824       TREE_SET_CODE (original_call, CALL_EXPR);
10825       patch = build2 (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10826     }
10827
10828   /* If CHECK is set, then we are building a check to see if the object
10829      is NULL.  */
10830   if (check != NULL_TREE)
10831     {
10832       /* We have to call force_evaluation_order now because creating a
10833          COMPOUND_EXPR wraps the arg list in a way that makes it
10834          unrecognizable by force_evaluation_order later.  Yuk.  */
10835       patch = build2 (COMPOUND_EXPR, TREE_TYPE (patch), check,
10836                       force_evaluation_order (patch));
10837       TREE_SIDE_EFFECTS (patch) = 1;
10838     }
10839
10840   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10841      put it as the first expression of a COMPOUND_EXPR. The second
10842      expression being an empty statement to be later patched if
10843      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10844      the VALUE is the compound) in a hashtable and return a
10845      COMPOUND_EXPR built so that the result of the evaluation of the
10846      original PATCH node is returned. */
10847   if (STATIC_CLASS_INIT_OPT_P ()
10848       && current_function_decl && METHOD_STATIC (method))
10849     {
10850       tree list;
10851       tree fndecl = current_function_decl;
10852       /* We have to call force_evaluation_order now because creating a
10853          COMPOUND_EXPR wraps the arg list in a way that makes it
10854          unrecognizable by force_evaluation_order later.  Yuk.  */
10855       tree save = force_evaluation_order (patch);
10856       tree type = TREE_TYPE (patch);
10857
10858       patch = build2 (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
10859       list = tree_cons (method, patch,
10860                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10861
10862       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10863
10864       patch = build2 (COMPOUND_EXPR, type, patch, save);
10865     }
10866
10867   return patch;
10868 }
10869
10870 static int
10871 invocation_mode (tree method, int super)
10872 {
10873   int access = get_access_flags_from_decl (method);
10874
10875   if (super)
10876     return INVOKE_SUPER;
10877
10878   if (access & ACC_STATIC)
10879     return INVOKE_STATIC;
10880
10881   /* We have to look for a constructor before we handle nonvirtual
10882      calls; otherwise the constructor will look nonvirtual.  */
10883   if (DECL_CONSTRUCTOR_P (method))
10884     return INVOKE_STATIC;
10885
10886   if (access & ACC_FINAL || access & ACC_PRIVATE)
10887     return INVOKE_NONVIRTUAL;
10888
10889   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10890     return INVOKE_NONVIRTUAL;
10891
10892   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10893     return INVOKE_INTERFACE;
10894
10895   return INVOKE_VIRTUAL;
10896 }
10897
10898 /* Retrieve a refined list of matching methods. It covers the step
10899    15.11.2 (Compile-Time Step 2) */
10900
10901 static tree
10902 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10903 {
10904   tree atl = end_params_node;           /* Arg Type List */
10905   tree method, signature, list, node;
10906   const char *candidates;               /* Used for error report */
10907   char *dup;
10908
10909   /* Fix the arguments */
10910   for (node = arg_list; node; node = TREE_CHAIN (node))
10911     {
10912       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10913       /* Non primitive type may have to be resolved */
10914       if (!JPRIMITIVE_TYPE_P (current_arg))
10915         resolve_and_layout (current_arg, NULL_TREE);
10916       /* And promoted */
10917       if (TREE_CODE (current_arg) == RECORD_TYPE)
10918         current_arg = promote_type (current_arg);
10919       atl = tree_cons (NULL_TREE, current_arg, atl);
10920     }
10921
10922   /* Presto. If we're dealing with an anonymous class and a
10923      constructor call, generate the right constructor now, since we
10924      know the arguments' types. */
10925
10926   if (lc && ANONYMOUS_CLASS_P (class))
10927     {
10928       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10929       /* The anonymous class may have already been laid out, so make sure
10930          the new constructor is laid out here.  */
10931       layout_class_method (class, CLASSTYPE_SUPER (class), mdecl, NULL_TREE);
10932     }
10933
10934   /* Find all candidates and then refine the list, searching for the
10935      most specific method. */
10936   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10937   list = find_most_specific_methods_list (list);
10938   if (list && !TREE_CHAIN (list))
10939     return TREE_VALUE (list);
10940
10941   /* Issue an error. List candidates if any. Candidates are listed
10942      only if accessible (non accessible methods may end-up here for
10943      the sake of a better error report). */
10944   candidates = NULL;
10945   if (list)
10946     {
10947       tree current;
10948       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10949       for (current = list; current; current = TREE_CHAIN (current))
10950         {
10951           tree cm = TREE_VALUE (current);
10952           char string [4096];
10953           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10954             continue;
10955           sprintf
10956             (string, "  `%s' in `%s'%s",
10957              get_printable_method_name (cm),
10958              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10959              (TREE_CHAIN (current) ? "\n" : ""));
10960           obstack_grow (&temporary_obstack, string, strlen (string));
10961         }
10962       obstack_1grow (&temporary_obstack, '\0');
10963       candidates = obstack_finish (&temporary_obstack);
10964     }
10965   /* Issue the error message */
10966   method = make_node (FUNCTION_TYPE);
10967   TYPE_ARG_TYPES (method) = atl;
10968   signature = build_java_argument_signature (method);
10969   dup = xstrdup (lang_printable_name (class, 0));
10970   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10971                        (lc ? "constructor" : "method"),
10972                        (lc ? dup : IDENTIFIER_POINTER (name)),
10973                        IDENTIFIER_POINTER (signature), dup,
10974                        (candidates ? candidates : ""));
10975   free (dup);
10976   return NULL_TREE;
10977 }
10978
10979 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10980    when we're looking for a constructor. */
10981
10982 static tree
10983 find_applicable_accessible_methods_list (int lc, tree class, tree name,
10984                                          tree arglist)
10985 {
10986   static htab_t searched_classes;
10987   static int search_not_done = 0;
10988   tree list = NULL_TREE, all_list = NULL_TREE;
10989   tree base_binfo;
10990   int i;
10991
10992   /* Check the hash table to determine if this class has been searched
10993      already. */
10994   if (searched_classes)
10995     {
10996       if (htab_find (searched_classes, class) != NULL)
10997         return NULL;
10998     }
10999   else
11000     {
11001       searched_classes = htab_create (10, htab_hash_pointer,
11002                                       htab_eq_pointer, NULL);
11003     }
11004
11005   search_not_done++;
11006   *htab_find_slot (searched_classes, class, INSERT) = class;
11007
11008   if (!CLASS_LOADED_P (class))
11009     {
11010       load_class (class, 1);
11011       safe_layout_class (class);
11012     }
11013
11014   /* Search interfaces */
11015   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11016       && CLASS_INTERFACE (TYPE_NAME (class)))
11017     {
11018       search_applicable_methods_list (lc, TYPE_METHODS (class),
11019                                       name, arglist, &list, &all_list);
11020       for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11021         {
11022           tree t = BINFO_TYPE (base_binfo);
11023           tree rlist;
11024
11025           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11026                                                            arglist);
11027           list = chainon (rlist, list);
11028         }
11029     }
11030   /* Search classes */
11031   else
11032     {
11033       search_applicable_methods_list (lc, TYPE_METHODS (class),
11034                                       name, arglist, &list, &all_list);
11035
11036       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11037          that we only search in class. Note that we should have found
11038          something at this point. */
11039       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11040         {
11041           lc = 1;
11042           if (!list)
11043             abort ();
11044         }
11045
11046       /* We must search all interfaces of this class */
11047       if (!lc)
11048         {
11049           for (i = 1;
11050                BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11051             {
11052               tree t = BINFO_TYPE (base_binfo);
11053               if (t != object_type_node)
11054                 {
11055                   tree rlist
11056                     = find_applicable_accessible_methods_list (lc, t,
11057                                                                name, arglist);
11058                   list = chainon (rlist, list);
11059                 }
11060             }
11061         }
11062
11063       /* Search superclass */
11064       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11065         {
11066           tree rlist;
11067           class = CLASSTYPE_SUPER (class);
11068           rlist = find_applicable_accessible_methods_list (lc, class,
11069                                                            name, arglist);
11070           list = chainon (rlist, list);
11071         }
11072     }
11073
11074   search_not_done--;
11075
11076   /* We're done. Reset the searched classes list and finally search
11077      java.lang.Object if it wasn't searched already. */
11078   if (!search_not_done)
11079     {
11080       if (!lc
11081           && TYPE_METHODS (object_type_node)
11082           && htab_find (searched_classes, object_type_node) == NULL)
11083         {
11084           search_applicable_methods_list (lc,
11085                                           TYPE_METHODS (object_type_node),
11086                                           name, arglist, &list, &all_list);
11087         }
11088       htab_delete (searched_classes);
11089       searched_classes = NULL;
11090     }
11091
11092   /* Either return the list obtained or all selected (but
11093      inaccessible) methods for better error report. */
11094   return (!list ? all_list : list);
11095 }
11096
11097 /* Effectively search for the appropriate method in method */
11098
11099 static void
11100 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11101                                 tree *list, tree *all_list)
11102 {
11103   for (; method; method = TREE_CHAIN (method))
11104     {
11105       /* When dealing with constructor, stop here, otherwise search
11106          other classes */
11107       if (lc && !DECL_CONSTRUCTOR_P (method))
11108         continue;
11109       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11110                        || (DECL_NAME (method) != name)))
11111         continue;
11112
11113       if (argument_types_convertible (method, arglist))
11114         {
11115           /* Retain accessible methods only */
11116           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11117                                  method, NULL_TREE, 0))
11118             *list = tree_cons (NULL_TREE, method, *list);
11119           else
11120             /* Also retain all selected method here */
11121             *all_list = tree_cons (NULL_TREE, method, *list);
11122         }
11123     }
11124 }
11125
11126 /* 15.11.2.2 Choose the Most Specific Method */
11127
11128 static tree
11129 find_most_specific_methods_list (tree list)
11130 {
11131   int max = 0;
11132   int abstract, candidates;
11133   tree current, new_list = NULL_TREE;
11134   for (current = list; current; current = TREE_CHAIN (current))
11135     {
11136       tree method;
11137       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11138
11139       for (method = list; method; method = TREE_CHAIN (method))
11140         {
11141           tree method_v, current_v;
11142           /* Don't test a method against itself */
11143           if (method == current)
11144             continue;
11145
11146           method_v = TREE_VALUE (method);
11147           current_v = TREE_VALUE (current);
11148
11149           /* Compare arguments and location where methods where declared */
11150           if (argument_types_convertible (method_v, current_v))
11151             {
11152               if (valid_method_invocation_conversion_p
11153                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11154                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11155                       && enclosing_context_p (DECL_CONTEXT (method_v),
11156                                               DECL_CONTEXT (current_v))))
11157                 {
11158                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11159                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11160                   max = (v > max ? v : max);
11161                 }
11162             }
11163         }
11164     }
11165
11166   /* Review the list and select the maximally specific methods */
11167   for (current = list, abstract = -1, candidates = -1;
11168        current; current = TREE_CHAIN (current))
11169     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11170       {
11171         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11172         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11173         candidates++;
11174       }
11175
11176   /* If we have several and they're all abstract, just pick the
11177      closest one. */
11178   if (candidates > 0 && candidates == abstract)
11179     {
11180       /* FIXME: merge the throws clauses.  There is no convenient way
11181          to do this in gcj right now, since ideally we'd like to
11182          introduce a new METHOD_DECL here, but that is really not
11183          possible.  */
11184       new_list = nreverse (new_list);
11185       TREE_CHAIN (new_list) = NULL_TREE;
11186       return new_list;
11187     }
11188
11189   /* We have several (we couldn't find a most specific), all but one
11190      are abstract, we pick the only non abstract one. */
11191   if (candidates > 0 && (candidates == abstract+1))
11192     {
11193       for (current = new_list; current; current = TREE_CHAIN (current))
11194         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11195           {
11196             TREE_CHAIN (current) = NULL_TREE;
11197             new_list = current;
11198           }
11199     }
11200
11201   /* If we can't find one, lower expectations and try to gather multiple
11202      maximally specific methods */
11203   while (!new_list && max)
11204     {
11205       while (--max > 0)
11206         {
11207           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11208             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11209         }
11210     }
11211
11212   return new_list;
11213 }
11214
11215 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11216    converted by method invocation conversion (5.3) to the type of the
11217    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11218    to change less often than M1. */
11219
11220 static GTY(()) tree m2_arg_value;
11221 static GTY(()) tree m2_arg_cache;
11222
11223 static int
11224 argument_types_convertible (tree m1, tree m2_or_arglist)
11225 {
11226   tree m1_arg, m2_arg;
11227
11228   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11229
11230   if (m2_arg_value == m2_or_arglist)
11231     m2_arg = m2_arg_cache;
11232   else
11233     {
11234       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11235          argument types */
11236       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11237         {
11238           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11239           if (!METHOD_STATIC (m2_or_arglist))
11240             m2_arg = TREE_CHAIN (m2_arg);
11241         }
11242       else
11243         m2_arg = m2_or_arglist;
11244
11245       m2_arg_value = m2_or_arglist;
11246       m2_arg_cache = m2_arg;
11247     }
11248
11249   while (m1_arg != end_params_node && m2_arg != end_params_node)
11250     {
11251       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11252       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11253                                                  TREE_VALUE (m2_arg)))
11254         break;
11255       m1_arg = TREE_CHAIN (m1_arg);
11256       m2_arg = TREE_CHAIN (m2_arg);
11257     }
11258   return m1_arg == end_params_node && m2_arg == end_params_node;
11259 }
11260
11261 /* Qualification routines */
11262
11263 /* Given a name x.y.z, look up x locally.  If it's found, save the
11264    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11265    so that we later try and load the appropriate classes.  */
11266 static void
11267 qualify_ambiguous_name (tree id)
11268 {
11269   tree name, decl;
11270
11271   /* We inspect the first item of the qualification list.  As a sanity
11272      check, make sure that it is an identfier node.  */
11273   tree qual = EXPR_WFL_QUALIFICATION (id);
11274   tree qual_wfl = QUAL_WFL (qual);
11275
11276   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11277     return;
11278
11279   name = EXPR_WFL_NODE (qual_wfl);
11280
11281   /* If we don't have an identifier, or we have a 'this' or 'super',
11282      then field access processing is all we need : there is nothing
11283      for us to do.  */
11284   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11285       name == this_identifier_node ||
11286       name == super_identifier_node)
11287     return;
11288
11289   /* If name appears within the scope of a local variable declaration
11290      or parameter declaration, or is a field within an enclosing
11291      class, then it is an expression name.  Save the decl and let
11292      resolve_field_access do it's work.  */
11293   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11294       (decl = lookup_field_wrapper (current_class, name)))
11295     {
11296       QUAL_RESOLUTION (qual) = decl;
11297       return;
11298     }
11299
11300   /* If name is a known class name (either declared or imported), mark
11301      us as a type name.  */
11302   if ((decl = resolve_and_layout (name, NULL_TREE)))
11303     {
11304       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11305       QUAL_RESOLUTION (qual) = decl;
11306     }
11307
11308   /* Check here that NAME isn't declared by more than one
11309      type-import-on-demand declaration of the compilation unit
11310      containing NAME. FIXME */
11311
11312   /* We couldn't find a declaration for the name.  Assume for now that
11313      we have a qualified class name that needs to be loaded from an
11314      external class file.  */
11315   else
11316     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11317
11318   /* Propagate the qualification across other components of the
11319      qualified name */
11320   for (qual = TREE_CHAIN (qual); qual;
11321        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11322     {
11323       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11324         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11325     }
11326
11327   /* Store the global qualification for the ambiguous part of ID back
11328      into ID fields */
11329   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11330     RESOLVE_TYPE_NAME_P (id) = 1;
11331   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11332     RESOLVE_PACKAGE_NAME_P (id) = 1;
11333 }
11334
11335 /* Patch tree nodes in a function body. When a BLOCK is found, push
11336    local variable decls if present.
11337    Same as java_complete_lhs, but does resolve static finals to values. */
11338
11339 static tree
11340 java_complete_tree (tree node)
11341 {
11342   node = java_complete_lhs (node);
11343   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11344       && DECL_INITIAL (node) != NULL_TREE
11345       && !flag_emit_xref)
11346     {
11347       tree value = fold_constant_for_init (node, node);
11348       if (value != NULL_TREE)
11349         return value;
11350     }
11351   return node;
11352 }
11353
11354 static tree
11355 java_stabilize_reference (tree node)
11356 {
11357   if (TREE_CODE (node) == COMPOUND_EXPR)
11358     {
11359       tree op0 = TREE_OPERAND (node, 0);
11360       tree op1 = TREE_OPERAND (node, 1);
11361       TREE_OPERAND (node, 0) = save_expr (op0);
11362       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11363       return node;
11364     }
11365   return stabilize_reference (node);
11366 }
11367
11368 /* Patch tree nodes in a function body. When a BLOCK is found, push
11369    local variable decls if present.
11370    Same as java_complete_tree, but does not resolve static finals to values. */
11371
11372 static tree
11373 java_complete_lhs (tree node)
11374 {
11375   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11376   int flag;
11377
11378   /* CONVERT_EXPR always has its type set, even though it needs to be
11379      worked out. */
11380   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11381     return node;
11382
11383   /* The switch block implements cases processing container nodes
11384      first.  Contained nodes are always written back. Leaves come
11385      next and return a value. */
11386   switch (TREE_CODE (node))
11387     {
11388     case BLOCK:
11389
11390       /* 1- Block section.
11391          Set the local values on decl names so we can identify them
11392          faster when they're referenced. At that stage, identifiers
11393          are legal so we don't check for declaration errors. */
11394       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11395         {
11396           DECL_CONTEXT (cn) = current_function_decl;
11397           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11398         }
11399       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11400           CAN_COMPLETE_NORMALLY (node) = 1;
11401       else
11402         {
11403           tree stmt = BLOCK_EXPR_BODY (node);
11404           tree *ptr;
11405           int error_seen = 0;
11406           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11407             {
11408               /* Re-order from (((A; B); C); ...; Z) to
11409                  (A; (B; (C ; (...; Z)))).
11410                  This makes it easier to scan the statements left-to-right
11411                  without using recursion (which might overflow the stack
11412                  if the block has many statements. */
11413               for (;;)
11414                 {
11415                   tree left = TREE_OPERAND (stmt, 0);
11416                   if (TREE_CODE (left) != COMPOUND_EXPR)
11417                     break;
11418                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11419                   TREE_OPERAND (left, 1) = stmt;
11420                   stmt = left;
11421                 }
11422               BLOCK_EXPR_BODY (node) = stmt;
11423             }
11424
11425           /* Now do the actual complete, without deep recursion for
11426              long blocks. */
11427           ptr = &BLOCK_EXPR_BODY (node);
11428           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11429                  && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11430             {
11431               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11432               tree *next = &TREE_OPERAND (*ptr, 1);
11433               TREE_OPERAND (*ptr, 0) = cur;
11434               if (IS_EMPTY_STMT (cur))
11435                 {
11436                   /* Optimization;  makes it easier to detect empty bodies.
11437                      Most useful for <clinit> with all-constant initializer. */
11438                   *ptr = *next;
11439                   continue;
11440                 }
11441               if (TREE_CODE (cur) == ERROR_MARK)
11442                 error_seen++;
11443               else if (! CAN_COMPLETE_NORMALLY (cur))
11444                 {
11445                   wfl_op2 = *next;
11446                   for (;;)
11447                     {
11448                       if (TREE_CODE (wfl_op2) == BLOCK)
11449                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11450                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11451                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11452                       else
11453                         break;
11454                     }
11455                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11456                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11457                     unreachable_stmt_error (*ptr);
11458                 }
11459               if (TREE_TYPE (*ptr) == NULL_TREE)
11460                 TREE_TYPE (*ptr) = void_type_node;
11461               ptr = next;
11462             }
11463           *ptr = java_complete_tree (*ptr);
11464
11465           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11466             return error_mark_node;
11467           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11468         }
11469       /* Turn local bindings to null */
11470       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11471         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11472
11473       TREE_TYPE (node) = void_type_node;
11474       break;
11475
11476       /* 2- They are expressions but ultimately deal with statements */
11477
11478     case THROW_EXPR:
11479       wfl_op1 = TREE_OPERAND (node, 0);
11480       COMPLETE_CHECK_OP_0 (node);
11481       /* 14.19 A throw statement cannot complete normally. */
11482       CAN_COMPLETE_NORMALLY (node) = 0;
11483       return patch_throw_statement (node, wfl_op1);
11484
11485     case SYNCHRONIZED_EXPR:
11486       wfl_op1 = TREE_OPERAND (node, 0);
11487       return patch_synchronized_statement (node, wfl_op1);
11488
11489     case TRY_EXPR:
11490       return patch_try_statement (node);
11491
11492     case TRY_FINALLY_EXPR:
11493       COMPLETE_CHECK_OP_0 (node);
11494       COMPLETE_CHECK_OP_1 (node);
11495       if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11496         /* Reduce try/finally nodes with an empty try block.  */
11497         return TREE_OPERAND (node, 1);
11498       if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11499         /* Likewise for an empty finally block.  */
11500         return TREE_OPERAND (node, 0);
11501       CAN_COMPLETE_NORMALLY (node)
11502         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11503            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11504       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11505       return node;
11506
11507     case LABELED_BLOCK_EXPR:
11508       PUSH_LABELED_BLOCK (node);
11509       if (LABELED_BLOCK_BODY (node))
11510         COMPLETE_CHECK_OP_1 (node);
11511       TREE_TYPE (node) = void_type_node;
11512       POP_LABELED_BLOCK ();
11513
11514       if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11515         {
11516           LABELED_BLOCK_BODY (node) = NULL_TREE;
11517           CAN_COMPLETE_NORMALLY (node) = 1;
11518         }
11519       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11520         CAN_COMPLETE_NORMALLY (node) = 1;
11521       return node;
11522
11523     case EXIT_BLOCK_EXPR:
11524       /* We don't complete operand 1, because it's the return value of
11525          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11526       return patch_bc_statement (node);
11527
11528     case CASE_EXPR:
11529       cn = java_complete_tree (TREE_OPERAND (node, 0));
11530       if (cn == error_mark_node)
11531         return cn;
11532
11533       /* First, the case expression must be constant. Values of final
11534          fields are accepted. */
11535       cn = fold (cn);
11536       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11537           && JDECL_P (TREE_OPERAND (cn, 1))
11538           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11539           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11540         {
11541           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11542                                        TREE_OPERAND (cn, 1));
11543         }
11544       /* Accept final locals too. */
11545       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11546                && DECL_INITIAL (cn))
11547         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11548
11549       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11550         {
11551           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11552           parse_error_context (node, "Constant expression required");
11553           return error_mark_node;
11554         }
11555
11556       nn = ctxp->current_loop;
11557
11558       /* It must be assignable to the type of the switch expression. */
11559       if (!try_builtin_assignconv (NULL_TREE,
11560                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11561         {
11562           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11563           parse_error_context
11564             (wfl_operator,
11565              "Incompatible type for case. Can't convert `%s' to `int'",
11566              lang_printable_name (TREE_TYPE (cn), 0));
11567           return error_mark_node;
11568         }
11569
11570       cn = fold (convert (int_type_node, cn));
11571       TREE_CONSTANT_OVERFLOW (cn) = 0;
11572       CAN_COMPLETE_NORMALLY (cn) = 1;
11573
11574       /* Save the label on a list so that we can later check for
11575          duplicates.  */
11576       case_label_list = tree_cons (node, cn, case_label_list);
11577
11578       /* Multiple instance of a case label bearing the same value is
11579          checked later. The case expression is all right so far. */
11580       if (TREE_CODE (cn) == VAR_DECL)
11581         cn = DECL_INITIAL (cn);
11582       TREE_OPERAND (node, 0) = cn;
11583       TREE_TYPE (node) = void_type_node;
11584       CAN_COMPLETE_NORMALLY (node) = 1;
11585       TREE_SIDE_EFFECTS (node) = 1;
11586       break;
11587
11588     case DEFAULT_EXPR:
11589       nn = ctxp->current_loop;
11590       /* Only one default label is allowed per switch statement */
11591       if (SWITCH_HAS_DEFAULT (nn))
11592         {
11593           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11594           parse_error_context (wfl_operator,
11595                                "Duplicate case label: `default'");
11596           return error_mark_node;
11597         }
11598       else
11599         SWITCH_HAS_DEFAULT (nn) = 1;
11600       TREE_TYPE (node) = void_type_node;
11601       TREE_SIDE_EFFECTS (node) = 1;
11602       CAN_COMPLETE_NORMALLY (node) = 1;
11603       break;
11604
11605     case SWITCH_EXPR:
11606     case LOOP_EXPR:
11607       PUSH_LOOP (node);
11608       /* Check whether the loop was enclosed in a labeled
11609          statement. If not, create one, insert the loop in it and
11610          return the node */
11611       nn = patch_loop_statement (node);
11612
11613       /* Anyways, walk the body of the loop */
11614       if (TREE_CODE (node) == LOOP_EXPR)
11615         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11616       /* Switch statement: walk the switch expression and the cases */
11617       else
11618         node = patch_switch_statement (node);
11619
11620       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11621         nn = error_mark_node;
11622       else
11623         {
11624           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11625           /* If we returned something different, that's because we
11626              inserted a label. Pop the label too. */
11627           if (nn != node)
11628             {
11629               if (CAN_COMPLETE_NORMALLY (node))
11630                 CAN_COMPLETE_NORMALLY (nn) = 1;
11631               POP_LABELED_BLOCK ();
11632             }
11633         }
11634       POP_LOOP ();
11635       return nn;
11636
11637     case EXIT_EXPR:
11638       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11639       return patch_exit_expr (node);
11640
11641     case COND_EXPR:
11642       /* Condition */
11643       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11644       if (TREE_OPERAND (node, 0) == error_mark_node)
11645         return error_mark_node;
11646       /* then-else branches */
11647       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11648       if (TREE_OPERAND (node, 1) == error_mark_node)
11649         return error_mark_node;
11650       {
11651         /* This is a special case due to build_assertion().  When
11652            assertions are disabled we build a COND_EXPR in which
11653            Operand 1 is the body of the assertion.  If that happens to
11654            be a string concatenation we'll need to patch it here.  */
11655         tree patched = patch_string (TREE_OPERAND (node, 1));
11656         if (patched)
11657           TREE_OPERAND (node, 1) = patched;
11658       }
11659      TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11660       if (TREE_OPERAND (node, 2) == error_mark_node)
11661         return error_mark_node;
11662       return patch_if_else_statement (node);
11663       break;
11664
11665     case CONDITIONAL_EXPR:
11666       /* Condition */
11667       wfl_op1 = TREE_OPERAND (node, 0);
11668       COMPLETE_CHECK_OP_0 (node);
11669       wfl_op2 = TREE_OPERAND (node, 1);
11670       COMPLETE_CHECK_OP_1 (node);
11671       wfl_op3 = TREE_OPERAND (node, 2);
11672       COMPLETE_CHECK_OP_2 (node);
11673       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11674
11675       /* 3- Expression section */
11676     case COMPOUND_EXPR:
11677       wfl_op2 = TREE_OPERAND (node, 1);
11678       TREE_OPERAND (node, 0) = nn =
11679         java_complete_tree (TREE_OPERAND (node, 0));
11680       if (IS_EMPTY_STMT (wfl_op2))
11681         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11682       else
11683         {
11684           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11685             {
11686               /* An unreachable condition in a do-while statement
11687                  is *not* (technically) an unreachable statement. */
11688               nn = wfl_op2;
11689               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11690                 nn = EXPR_WFL_NODE (nn);
11691               /* NN can be NULL_TREE exactly when UPDATE is, in
11692                  finish_for_loop.  */
11693               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11694                 {
11695                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11696                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11697                     {
11698                       /* Perhaps this warning should have an
11699                          associated flag.  The code being compiled is
11700                          pedantically correct, but useless.  */
11701                       parse_warning_context (wfl_operator,
11702                                              "Unreachable statement");
11703                     }
11704                   else
11705                     parse_error_context (wfl_operator,
11706                                          "Unreachable statement");
11707                 }
11708             }
11709           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11710           if (TREE_OPERAND (node, 1) == error_mark_node)
11711             return error_mark_node;
11712           /* Even though we might allow the case where the first
11713              operand doesn't return normally, we still should compute
11714              CAN_COMPLETE_NORMALLY correctly.  */
11715           CAN_COMPLETE_NORMALLY (node)
11716             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11717                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11718         }
11719       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11720       break;
11721
11722     case RETURN_EXPR:
11723       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11724       return patch_return (node);
11725
11726     case EXPR_WITH_FILE_LOCATION:
11727       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11728           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11729         {
11730           tree wfl = node;
11731           node = resolve_expression_name (node, NULL);
11732           if (node == error_mark_node)
11733             return node;
11734           /* Keep line number information somewhere were it doesn't
11735              disrupt the completion process. */
11736           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11737             {
11738               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11739               TREE_OPERAND (node, 1) = wfl;
11740             }
11741           CAN_COMPLETE_NORMALLY (node) = 1;
11742         }
11743       else
11744         {
11745           tree body;
11746           int save_lineno = input_line;
11747           input_line = EXPR_WFL_LINENO (node);
11748           body = java_complete_tree (EXPR_WFL_NODE (node));
11749           input_line = save_lineno;
11750           EXPR_WFL_NODE (node) = body;
11751           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11752           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11753           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11754             {
11755               /* Makes it easier to constant fold, detect empty bodies. */
11756               return body;
11757             }
11758           if (body == error_mark_node)
11759             {
11760               /* Its important for the evaluation of assignment that
11761                  this mark on the TREE_TYPE is propagated. */
11762               TREE_TYPE (node) = error_mark_node;
11763               return error_mark_node;
11764             }
11765           else
11766             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11767
11768         }
11769       break;
11770
11771     case NEW_ARRAY_EXPR:
11772       /* Patch all the dimensions */
11773       flag = 0;
11774       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11775         {
11776           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11777           tree dim = convert (int_type_node,
11778                               java_complete_tree (TREE_VALUE (cn)));
11779           if (dim == error_mark_node)
11780             {
11781               flag = 1;
11782               continue;
11783             }
11784           else
11785             {
11786               TREE_VALUE (cn) = dim;
11787               /* Setup the location of the current dimension, for
11788                  later error report. */
11789               TREE_PURPOSE (cn) =
11790                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11791               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11792             }
11793         }
11794       /* They complete the array creation expression, if no errors
11795          were found. */
11796       CAN_COMPLETE_NORMALLY (node) = 1;
11797       return (flag ? error_mark_node
11798               : force_evaluation_order (patch_newarray (node)));
11799
11800     case NEW_ANONYMOUS_ARRAY_EXPR:
11801       /* Create the array type if necessary. */
11802       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11803         {
11804           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11805           if (!(type = resolve_type_during_patch (type)))
11806             return error_mark_node;
11807           type = build_array_from_name (type, NULL_TREE,
11808                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11809           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11810         }
11811       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11812                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11813       if (node == error_mark_node)
11814         return error_mark_node;
11815       CAN_COMPLETE_NORMALLY (node) = 1;
11816       return node;
11817
11818     case NEW_CLASS_EXPR:
11819     case CALL_EXPR:
11820       /* Complete function's argument(s) first */
11821       if (complete_function_arguments (node))
11822         return error_mark_node;
11823       else
11824         {
11825           tree decl, wfl = TREE_OPERAND (node, 0);
11826           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11827           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11828                            super_identifier_node);
11829           tree arguments;
11830           int location = EXPR_WFL_LINECOL (node);
11831
11832           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11833                                           from_super, 0, &decl);
11834           if (node == error_mark_node)
11835             return error_mark_node;
11836
11837           if (TREE_CODE (node) == CALL_EXPR
11838               && TREE_OPERAND (node, 1) != NULL_TREE)
11839             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11840           else
11841             arguments = NULL_TREE;
11842           check_thrown_exceptions (location, decl, arguments);
11843           /* If we call this(...), register signature and positions */
11844           if (in_this)
11845             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11846               tree_cons (wfl, decl,
11847                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11848           CAN_COMPLETE_NORMALLY (node) = 1;
11849           return force_evaluation_order (node);
11850         }
11851
11852     case MODIFY_EXPR:
11853       /* Save potential wfls */
11854       wfl_op1 = TREE_OPERAND (node, 0);
11855       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11856
11857       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11858           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11859           && DECL_INITIAL (nn) != NULL_TREE)
11860         {
11861           tree value;
11862
11863           value = fold_constant_for_init (nn, nn);
11864
11865           /* When we have a primitype type, or a string and we're not
11866              emitting a class file, we actually don't want to generate
11867              anything for the assignment. */
11868           if (value != NULL_TREE &&
11869               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11870                (TREE_TYPE (value) == string_ptr_type_node &&
11871                 ! flag_emit_class_files)))
11872             {
11873               /* Prepare node for patch_assignment */
11874               TREE_OPERAND (node, 1) = value;
11875               /* Call patch assignment to verify the assignment */
11876               if (patch_assignment (node, wfl_op1) == error_mark_node)
11877                 return error_mark_node;
11878               /* Set DECL_INITIAL properly (a conversion might have
11879                  been decided by patch_assignment) and return the
11880                  empty statement. */
11881               else
11882                 {
11883                   tree patched = patch_string (TREE_OPERAND (node, 1));
11884                   if (patched)
11885                     DECL_INITIAL (nn) = patched;
11886                   else
11887                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11888                   DECL_FIELD_FINAL_IUD (nn) = 1;
11889                   return build_java_empty_stmt ();
11890                 }
11891             }
11892           if (! flag_emit_class_files)
11893             DECL_INITIAL (nn) = NULL_TREE;
11894         }
11895       wfl_op2 = TREE_OPERAND (node, 1);
11896
11897       if (TREE_OPERAND (node, 0) == error_mark_node)
11898         return error_mark_node;
11899
11900       flag = COMPOUND_ASSIGN_P (wfl_op2);
11901       if (flag)
11902         {
11903           /* This might break when accessing outer field from inner
11904              class. TESTME, FIXME */
11905           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11906
11907           /* Hand stabilize the lhs on both places */
11908           TREE_OPERAND (node, 0) = lvalue;
11909           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11910             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11911
11912           /* 15.25.2.a: Left hand is not an array access. FIXME */
11913           /* Now complete the RHS. We write it back later on. */
11914           nn = java_complete_tree (TREE_OPERAND (node, 1));
11915
11916           if ((cn = patch_string (nn)))
11917             nn = cn;
11918
11919           /* The last part of the rewrite for E1 op= E2 is to have
11920              E1 = (T)(E1 op E2), with T being the type of E1. */
11921           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11922                                                TREE_TYPE (lvalue), nn));
11923
11924           /* If the assignment is compound and has reference type,
11925              then ensure the LHS has type String and nothing else.  */
11926           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
11927               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
11928             parse_error_context (wfl_op2,
11929                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
11930                                  lang_printable_name (TREE_TYPE (lvalue), 0));
11931
11932           /* 15.25.2.b: Left hand is an array access. FIXME */
11933         }
11934
11935       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11936          function to complete this RHS. Note that a NEW_ARRAY_INIT
11937          might have been already fully expanded if created as a result
11938          of processing an anonymous array initializer. We avoid doing
11939          the operation twice by testing whether the node already bears
11940          a type. */
11941       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
11942         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
11943                                    TREE_OPERAND (node, 1));
11944       /* Otherwise we simply complete the RHS */
11945       else
11946         nn = java_complete_tree (TREE_OPERAND (node, 1));
11947
11948       if (nn == error_mark_node)
11949         return error_mark_node;
11950
11951       /* Write back the RHS as we evaluated it. */
11952       TREE_OPERAND (node, 1) = nn;
11953
11954       /* In case we're handling = with a String as a RHS, we need to
11955          produce a String out of the RHS (it might still be a
11956          STRING_CST or a StringBuffer at this stage */
11957       if ((nn = patch_string (TREE_OPERAND (node, 1))))
11958         TREE_OPERAND (node, 1) = nn;
11959
11960       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11961                                         TREE_OPERAND (node, 1))))
11962         {
11963           /* We return error_mark_node if outer_field_access_fix
11964              detects we write into a final. */
11965           if (nn == error_mark_node)
11966             return error_mark_node;
11967           node = nn;
11968         }
11969       else
11970         {
11971           node = patch_assignment (node, wfl_op1);
11972           if (node == error_mark_node)
11973             return error_mark_node;
11974           /* Reorganize the tree if necessary. */
11975           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11976                        || JSTRING_P (TREE_TYPE (node))))
11977             node = java_refold (node);
11978         }
11979
11980       /* Seek to set DECL_INITIAL to a proper value, since it might have
11981          undergone a conversion in patch_assignment. We do that only when
11982          it's necessary to have DECL_INITIAL properly set. */
11983       nn = TREE_OPERAND (node, 0);
11984       if (TREE_CODE (nn) == VAR_DECL
11985           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
11986           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
11987           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
11988               || TREE_TYPE (nn) == string_ptr_type_node))
11989         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11990
11991       CAN_COMPLETE_NORMALLY (node) = 1;
11992       return node;
11993
11994     case MULT_EXPR:
11995     case PLUS_EXPR:
11996     case MINUS_EXPR:
11997     case LSHIFT_EXPR:
11998     case RSHIFT_EXPR:
11999     case URSHIFT_EXPR:
12000     case BIT_AND_EXPR:
12001     case BIT_XOR_EXPR:
12002     case BIT_IOR_EXPR:
12003     case TRUNC_MOD_EXPR:
12004     case TRUNC_DIV_EXPR:
12005     case RDIV_EXPR:
12006     case TRUTH_ANDIF_EXPR:
12007     case TRUTH_ORIF_EXPR:
12008     case EQ_EXPR:
12009     case NE_EXPR:
12010     case GT_EXPR:
12011     case GE_EXPR:
12012     case LT_EXPR:
12013     case LE_EXPR:
12014       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12015          knows how to handle those cases. */
12016       wfl_op1 = TREE_OPERAND (node, 0);
12017       wfl_op2 = TREE_OPERAND (node, 1);
12018
12019       CAN_COMPLETE_NORMALLY (node) = 1;
12020       /* Don't complete string nodes if dealing with the PLUS operand. */
12021       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12022         {
12023           nn = java_complete_tree (wfl_op1);
12024           if (nn == error_mark_node)
12025             return error_mark_node;
12026
12027           TREE_OPERAND (node, 0) = nn;
12028         }
12029       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12030         {
12031           nn = java_complete_tree (wfl_op2);
12032           if (nn == error_mark_node)
12033             return error_mark_node;
12034
12035           TREE_OPERAND (node, 1) = nn;
12036         }
12037       return patch_binop (node, wfl_op1, wfl_op2);
12038
12039     case INSTANCEOF_EXPR:
12040       wfl_op1 = TREE_OPERAND (node, 0);
12041       COMPLETE_CHECK_OP_0 (node);
12042       if (flag_emit_xref)
12043         {
12044           TREE_TYPE (node) = boolean_type_node;
12045           return node;
12046         }
12047       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12048
12049     case UNARY_PLUS_EXPR:
12050     case NEGATE_EXPR:
12051     case TRUTH_NOT_EXPR:
12052     case BIT_NOT_EXPR:
12053     case PREDECREMENT_EXPR:
12054     case PREINCREMENT_EXPR:
12055     case POSTDECREMENT_EXPR:
12056     case POSTINCREMENT_EXPR:
12057     case CONVERT_EXPR:
12058       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12059          how to handle those cases. */
12060       wfl_op1 = TREE_OPERAND (node, 0);
12061       CAN_COMPLETE_NORMALLY (node) = 1;
12062       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12063       if (TREE_OPERAND (node, 0) == error_mark_node)
12064         return error_mark_node;
12065       node = patch_unaryop (node, wfl_op1);
12066       CAN_COMPLETE_NORMALLY (node) = 1;
12067       break;
12068
12069     case ARRAY_REF:
12070       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12071          how to handle those cases. */
12072       wfl_op1 = TREE_OPERAND (node, 0);
12073       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12074       if (TREE_OPERAND (node, 0) == error_mark_node)
12075         return error_mark_node;
12076       if (!flag_emit_class_files && !flag_emit_xref)
12077         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12078       /* The same applies to wfl_op2 */
12079       wfl_op2 = TREE_OPERAND (node, 1);
12080       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12081       if (TREE_OPERAND (node, 1) == error_mark_node)
12082         return error_mark_node;
12083       if (!flag_emit_class_files && !flag_emit_xref)
12084         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12085       return patch_array_ref (node);
12086
12087     case RECORD_TYPE:
12088       return node;;
12089
12090     case COMPONENT_REF:
12091       /* The first step in the re-write of qualified name handling.  FIXME.
12092          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12093       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12094       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12095         {
12096           tree name = TREE_OPERAND (node, 1);
12097           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12098           if (field == NULL_TREE)
12099             {
12100               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12101               return error_mark_node;
12102             }
12103           if (! FIELD_STATIC (field))
12104             {
12105               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12106               return error_mark_node;
12107             }
12108           return field;
12109         }
12110       else
12111         abort ();
12112       break;
12113
12114     case THIS_EXPR:
12115       /* Can't use THIS in a static environment */
12116       if (!current_this)
12117         {
12118           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12119           parse_error_context (wfl_operator,
12120                                "Keyword `this' used outside allowed context");
12121           TREE_TYPE (node) = error_mark_node;
12122           return error_mark_node;
12123         }
12124       if (ctxp->explicit_constructor_p)
12125         {
12126           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12127           parse_error_context
12128             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12129           TREE_TYPE (node) = error_mark_node;
12130           return error_mark_node;
12131         }
12132       return current_this;
12133
12134     case CLASS_LITERAL:
12135       CAN_COMPLETE_NORMALLY (node) = 1;
12136       node = patch_incomplete_class_ref (node);
12137       if (node == error_mark_node)
12138         return error_mark_node;
12139       break;
12140
12141     default:
12142       CAN_COMPLETE_NORMALLY (node) = 1;
12143       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12144          and it's time to turn it into the appropriate String object */
12145       if ((nn = patch_string (node)))
12146         node = nn;
12147       else
12148         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12149     }
12150   return node;
12151 }
12152
12153 /* Complete function call's argument. Return a nonzero value is an
12154    error was found.  */
12155
12156 static int
12157 complete_function_arguments (tree node)
12158 {
12159   int flag = 0;
12160   tree cn;
12161
12162   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12163   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12164     {
12165       tree wfl = TREE_VALUE (cn), parm, temp;
12166       parm = java_complete_tree (wfl);
12167
12168       if (parm == error_mark_node)
12169         {
12170           flag = 1;
12171           continue;
12172         }
12173       /* If we have a string literal that we haven't transformed yet or a
12174          crafted string buffer, as a result of the use of the String
12175          `+' operator. Build `parm.toString()' and expand it. */
12176       if ((temp = patch_string (parm)))
12177         parm = temp;
12178
12179       TREE_VALUE (cn) = parm;
12180     }
12181   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12182   return flag;
12183 }
12184
12185 /* Sometimes (for loops and variable initialized during their
12186    declaration), we want to wrap a statement around a WFL and turn it
12187    debugable.  */
12188
12189 static tree
12190 build_debugable_stmt (int location, tree stmt)
12191 {
12192   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12193     {
12194       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12195       EXPR_WFL_LINECOL (stmt) = location;
12196     }
12197   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12198   return stmt;
12199 }
12200
12201 static tree
12202 build_expr_block (tree body, tree decls)
12203 {
12204   tree node = make_node (BLOCK);
12205   BLOCK_EXPR_DECLS (node) = decls;
12206   BLOCK_EXPR_BODY (node) = body;
12207   if (body)
12208     TREE_TYPE (node) = TREE_TYPE (body);
12209   TREE_SIDE_EFFECTS (node) = 1;
12210   return node;
12211 }
12212
12213 /* Create a new function block and link it appropriately to current
12214    function block chain */
12215
12216 static tree
12217 enter_block (void)
12218 {
12219   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12220
12221   /* Link block B supercontext to the previous block. The current
12222      function DECL is used as supercontext when enter_a_block is called
12223      for the first time for a given function. The current function body
12224      (DECL_FUNCTION_BODY) is set to be block B.  */
12225
12226   tree fndecl = current_function_decl;
12227
12228   if (!fndecl) {
12229     BLOCK_SUPERCONTEXT (b) = current_static_block;
12230     current_static_block = b;
12231   }
12232
12233   else if (!DECL_FUNCTION_BODY (fndecl))
12234     {
12235       BLOCK_SUPERCONTEXT (b) = fndecl;
12236       DECL_FUNCTION_BODY (fndecl) = b;
12237     }
12238   else
12239     {
12240       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12241       DECL_FUNCTION_BODY (fndecl) = b;
12242     }
12243   return b;
12244 }
12245
12246 /* Exit a block by changing the current function body
12247    (DECL_FUNCTION_BODY) to the current block super context, only if
12248    the block being exited isn't the method's top level one.  */
12249
12250 static tree
12251 exit_block (void)
12252 {
12253   tree b;
12254   if (current_function_decl)
12255     {
12256       b = DECL_FUNCTION_BODY (current_function_decl);
12257       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12258         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12259     }
12260   else
12261     {
12262       b = current_static_block;
12263
12264       if (BLOCK_SUPERCONTEXT (b))
12265         current_static_block = BLOCK_SUPERCONTEXT (b);
12266     }
12267   return b;
12268 }
12269
12270 /* Lookup for NAME in the nested function's blocks, all the way up to
12271    the current toplevel one. It complies with Java's local variable
12272    scoping rules.  */
12273
12274 static tree
12275 lookup_name_in_blocks (tree name)
12276 {
12277   tree b = GET_CURRENT_BLOCK (current_function_decl);
12278
12279   while (b != current_function_decl)
12280     {
12281       tree current;
12282
12283       /* Paranoid sanity check. To be removed */
12284       if (TREE_CODE (b) != BLOCK)
12285         abort ();
12286
12287       for (current = BLOCK_EXPR_DECLS (b); current;
12288            current = TREE_CHAIN (current))
12289         if (DECL_NAME (current) == name)
12290           return current;
12291       b = BLOCK_SUPERCONTEXT (b);
12292     }
12293   return NULL_TREE;
12294 }
12295
12296 static void
12297 maybe_absorb_scoping_blocks (void)
12298 {
12299   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12300     {
12301       tree b = exit_block ();
12302       java_method_add_stmt (current_function_decl, b);
12303       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12304     }
12305 }
12306
12307 \f
12308 /* This section of the source is reserved to build_* functions that
12309    are building incomplete tree nodes and the patch_* functions that
12310    are completing them.  */
12311
12312 /* Wrap a non WFL node around a WFL.  */
12313
12314 static tree
12315 build_wfl_wrap (tree node, int location)
12316 {
12317   tree wfl, node_to_insert = node;
12318
12319   /* We want to process THIS . xxx symbolically, to keep it consistent
12320      with the way we're processing SUPER. A THIS from a primary as a
12321      different form than a SUPER. Turn THIS into something symbolic */
12322   if (TREE_CODE (node) == THIS_EXPR)
12323     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12324   else
12325     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12326
12327   EXPR_WFL_LINECOL (wfl) = location;
12328   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12329   return wfl;
12330 }
12331
12332 /* Build a super() constructor invocation. Returns an empty statement if
12333    we're currently dealing with the class java.lang.Object. */
12334
12335 static tree
12336 build_super_invocation (tree mdecl)
12337 {
12338   if (DECL_CONTEXT (mdecl) == object_type_node)
12339     return build_java_empty_stmt ();
12340   else
12341     {
12342       tree super_wfl = build_wfl_node (super_identifier_node);
12343       tree a = NULL_TREE, t;
12344
12345       /* This is called after parsing is done, so the parser context
12346          won't be accurate. Set location info from current_class decl. */
12347       tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12348       EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12349
12350       /* If we're dealing with an anonymous class, pass the arguments
12351          of the crafted constructor along. */
12352       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12353         {
12354           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12355           for (; t != end_params_node; t = TREE_CHAIN (t))
12356             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12357         }
12358       return build_method_invocation (super_wfl, a);
12359     }
12360 }
12361
12362 /* Build a SUPER/THIS qualified method invocation.  */
12363
12364 static tree
12365 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12366                                        int lloc, int rloc)
12367 {
12368   tree invok;
12369   tree wfl =
12370     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12371   EXPR_WFL_LINECOL (wfl) = lloc;
12372   invok = build_method_invocation (name, args);
12373   return make_qualified_primary (wfl, invok, rloc);
12374 }
12375
12376 /* Build an incomplete CALL_EXPR node. */
12377
12378 static tree
12379 build_method_invocation (tree name, tree args)
12380 {
12381   tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12382   TREE_SIDE_EFFECTS (call) = 1;
12383   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12384   return call;
12385 }
12386
12387 /* Build an incomplete new xxx(...) node. */
12388
12389 static tree
12390 build_new_invocation (tree name, tree args)
12391 {
12392   tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12393   TREE_SIDE_EFFECTS (call) = 1;
12394   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12395   return call;
12396 }
12397
12398 /* Build an incomplete assignment expression. */
12399
12400 static tree
12401 build_assignment (int op, int op_location, tree lhs, tree rhs)
12402 {
12403   tree assignment;
12404   /* Build the corresponding binop if we deal with a Compound
12405      Assignment operator. Mark the binop sub-tree as part of a
12406      Compound Assignment expression */
12407   if (op != ASSIGN_TK)
12408     {
12409       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12410       COMPOUND_ASSIGN_P (rhs) = 1;
12411     }
12412   assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12413   TREE_SIDE_EFFECTS (assignment) = 1;
12414   EXPR_WFL_LINECOL (assignment) = op_location;
12415   return assignment;
12416 }
12417
12418 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12419    the buffer.  This is used only for string conversion.  */
12420 static char *
12421 string_convert_int_cst (tree node)
12422 {
12423   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12424   static char buffer[21];
12425
12426   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12427   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12428   char *p = buffer + sizeof (buffer);
12429   int neg = 0;
12430
12431   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12432                                   << (HOST_BITS_PER_WIDE_INT - 1));
12433
12434   *--p = '\0';
12435
12436   /* If negative, note the fact and negate the value.  */
12437   if ((hi & hibit))
12438     {
12439       lo = ~lo;
12440       hi = ~hi;
12441       if (++lo == 0)
12442         ++hi;
12443       neg = 1;
12444     }
12445
12446   /* Divide by 10 until there are no bits left.  */
12447   do
12448     {
12449       unsigned HOST_WIDE_INT acc = 0;
12450       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12451       unsigned int i;
12452
12453       /* Use long division to compute the result and the remainder.  */
12454       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12455         {
12456           /* Shift a bit into accumulator.  */
12457           acc <<= 1;
12458           if ((hi & hibit))
12459             acc |= 1;
12460
12461           /* Shift the value.  */
12462           hi <<= 1;
12463           if ((lo & hibit))
12464             hi |= 1;
12465           lo <<= 1;
12466
12467           /* Shift the correct bit into the result.  */
12468           outhi <<= 1;
12469           if ((outlo & hibit))
12470             outhi |= 1;
12471           outlo <<= 1;
12472           if (acc >= 10)
12473             {
12474               acc -= 10;
12475               outlo |= 1;
12476             }
12477         }
12478
12479       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12480       *--p = '\060' + acc;
12481
12482       hi = outhi;
12483       lo = outlo;
12484     }
12485   while (hi || lo);
12486
12487   if (neg)
12488     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12489
12490   return p;
12491 }
12492
12493 /* Print an INTEGER_CST node in a static buffer, and return the
12494    buffer.  This is used only for error handling.  */
12495 char *
12496 print_int_node (tree node)
12497 {
12498   static char buffer [80];
12499   if (TREE_CONSTANT_OVERFLOW (node))
12500     sprintf (buffer, "<overflow>");
12501
12502   if (TREE_INT_CST_HIGH (node) == 0)
12503     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12504              TREE_INT_CST_LOW (node));
12505   else if (TREE_INT_CST_HIGH (node) == -1
12506            && TREE_INT_CST_LOW (node) != 0)
12507     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12508              -TREE_INT_CST_LOW (node));
12509   else
12510     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12511              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12512
12513   return buffer;
12514 }
12515
12516 \f
12517 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12518    context.  */
12519
12520 /* 15.25 Assignment operators. */
12521
12522 static tree
12523 patch_assignment (tree node, tree wfl_op1)
12524 {
12525   tree rhs = TREE_OPERAND (node, 1);
12526   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12527   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12528   int error_found = 0;
12529   int lvalue_from_array = 0;
12530   int is_return = 0;
12531
12532   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12533
12534   /* Lhs can be a named variable */
12535   if (JDECL_P (lvalue))
12536     {
12537       lhs_type = TREE_TYPE (lvalue);
12538     }
12539   /* Or Lhs can be an array access. */
12540   else if (TREE_CODE (lvalue) == ARRAY_REF)
12541     {
12542       lhs_type = TREE_TYPE (lvalue);
12543       lvalue_from_array = 1;
12544     }
12545   /* Or a field access */
12546   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12547     lhs_type = TREE_TYPE (lvalue);
12548   /* Or a function return slot */
12549   else if (TREE_CODE (lvalue) == RESULT_DECL)
12550     {
12551       /* If the return type is an integral type, then we create the
12552          RESULT_DECL with a promoted type, but we need to do these
12553          checks against the unpromoted type to ensure type safety.  So
12554          here we look at the real type, not the type of the decl we
12555          are modifying.  */
12556       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12557       is_return = 1;
12558     }
12559   /* Otherwise, we might want to try to write into an optimized static
12560      final, this is an of a different nature, reported further on. */
12561   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12562            && resolve_expression_name (wfl_op1, &llvalue))
12563     {
12564       lhs_type = TREE_TYPE (lvalue);
12565     }
12566   else
12567     {
12568       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12569       error_found = 1;
12570     }
12571
12572   rhs_type = TREE_TYPE (rhs);
12573
12574   /* 5.1 Try the assignment conversion for builtin type. */
12575   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12576
12577   /* 5.2 If it failed, try a reference conversion */
12578   if (!new_rhs)
12579     new_rhs = try_reference_assignconv (lhs_type, rhs);
12580
12581   /* 15.25.2 If we have a compound assignment, convert RHS into the
12582      type of the LHS */
12583   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12584     new_rhs = convert (lhs_type, rhs);
12585
12586   /* Explicit cast required. This is an error */
12587   if (!new_rhs)
12588     {
12589       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12590       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12591       tree wfl;
12592       char operation [32];      /* Max size known */
12593
12594       /* If the assignment is part of a declaration, we use the WFL of
12595          the declared variable to point out the error and call it a
12596          declaration problem. If the assignment is a genuine =
12597          operator, we call is a operator `=' problem, otherwise we
12598          call it an assignment problem. In both of these last cases,
12599          we use the WFL of the operator to indicate the error. */
12600
12601       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12602         {
12603           wfl = wfl_op1;
12604           strcpy (operation, "declaration");
12605         }
12606       else
12607         {
12608           wfl = wfl_operator;
12609           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12610             strcpy (operation, "assignment");
12611           else if (is_return)
12612             strcpy (operation, "`return'");
12613           else
12614             strcpy (operation, "`='");
12615         }
12616
12617       if (!valid_cast_to_p (rhs_type, lhs_type))
12618         parse_error_context
12619           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12620            operation, t1, t2);
12621       else
12622         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12623                              operation, t1, t2);
12624       free (t1); free (t2);
12625       error_found = 1;
12626     }
12627
12628   if (error_found)
12629     return error_mark_node;
12630
12631   /* If we're processing a `return' statement, promote the actual type
12632      to the promoted type.  */
12633   if (is_return)
12634     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12635
12636   /* 10.10: Array Store Exception runtime check */
12637   if (!flag_emit_class_files
12638       && !flag_emit_xref
12639       && lvalue_from_array
12640       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12641     {
12642       tree array, store_check, base, index_expr;
12643
12644       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12645       new_rhs = save_expr (new_rhs);
12646
12647       /* Get the INDIRECT_REF. */
12648       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12649       /* Get the array pointer expr. */
12650       array = TREE_OPERAND (array, 0);
12651       store_check = build_java_arraystore_check (array, new_rhs);
12652
12653       index_expr = TREE_OPERAND (lvalue, 1);
12654
12655       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12656         {
12657           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12658              happen before the store check, so prepare to insert the store
12659              check within the second operand of the existing COMPOUND_EXPR. */
12660           base = index_expr;
12661         }
12662       else
12663         base = lvalue;
12664
12665       index_expr = TREE_OPERAND (base, 1);
12666       TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
12667                                        store_check, index_expr);
12668     }
12669
12670   /* Final locals can be used as case values in switch
12671      statement. Prepare them for this eventuality. */
12672   if (TREE_CODE (lvalue) == VAR_DECL
12673       && DECL_FINAL (lvalue)
12674       && TREE_CONSTANT (new_rhs)
12675       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12676       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12677       )
12678     {
12679       TREE_CONSTANT (lvalue) = 1;
12680       TREE_INVARIANT (lvalue) = 1;
12681       DECL_INITIAL (lvalue) = new_rhs;
12682     }
12683
12684   /* Copy the rhs if it's a reference.  */
12685   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12686     {
12687       switch (TREE_CODE (new_rhs))
12688         {
12689         case ARRAY_REF:
12690         case INDIRECT_REF:
12691         case COMPONENT_REF:
12692           /* Transform a = foo.bar
12693              into a = ({int tmp; tmp = foo.bar;}).
12694              We need to ensure that if a read from memory fails
12695              because of a NullPointerException, a destination variable
12696              will remain unchanged.  An explicit temporary does what
12697              we need.
12698
12699              If flag_check_references is set, this is unnecessary
12700              because we'll check each reference before doing any
12701              reads.  If optimize is not set the result will never be
12702              written to a stack slot that contains the LHS.  */
12703           {
12704             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12705                                    TREE_TYPE (new_rhs));
12706             tree block = make_node (BLOCK);
12707             tree assignment
12708               = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12709             DECL_CONTEXT (tmp) = current_function_decl;
12710             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12711             BLOCK_VARS (block) = tmp;
12712             BLOCK_EXPR_BODY (block) = assignment;
12713             TREE_SIDE_EFFECTS (block) = 1;
12714             new_rhs = block;
12715           }
12716           break;
12717         default:
12718           break;
12719         }
12720     }
12721
12722   TREE_OPERAND (node, 0) = lvalue;
12723   TREE_OPERAND (node, 1) = new_rhs;
12724   TREE_TYPE (node) = lhs_type;
12725   return node;
12726 }
12727
12728 /* Check that type SOURCE can be cast into type DEST. If the cast
12729    can't occur at all, return NULL; otherwise, return a possibly
12730    modified rhs.  */
12731
12732 static tree
12733 try_reference_assignconv (tree lhs_type, tree rhs)
12734 {
12735   tree new_rhs = NULL_TREE;
12736   tree rhs_type = TREE_TYPE (rhs);
12737
12738   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12739     {
12740       /* `null' may be assigned to any reference type */
12741       if (rhs == null_pointer_node)
12742         new_rhs = null_pointer_node;
12743       /* Try the reference assignment conversion */
12744       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12745         new_rhs = rhs;
12746       /* This is a magic assignment that we process differently */
12747       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12748         new_rhs = rhs;
12749     }
12750   return new_rhs;
12751 }
12752
12753 /* Check that RHS can be converted into LHS_TYPE by the assignment
12754    conversion (5.2), for the cases of RHS being a builtin type. Return
12755    NULL_TREE if the conversion fails or if because RHS isn't of a
12756    builtin type. Return a converted RHS if the conversion is possible.  */
12757
12758 static tree
12759 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12760 {
12761   tree new_rhs = NULL_TREE;
12762   tree rhs_type = TREE_TYPE (rhs);
12763
12764   /* Handle boolean specially.  */
12765   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12766       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12767     {
12768       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12769           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12770         new_rhs = rhs;
12771     }
12772
12773   /* 5.1.1 Try Identity Conversion,
12774      5.1.2 Try Widening Primitive Conversion */
12775   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12776     new_rhs = convert (lhs_type, rhs);
12777
12778   /* Try a narrowing primitive conversion (5.1.3):
12779        - expression is a constant expression of type byte, short, char,
12780          or int, AND
12781        - variable is byte, short or char AND
12782        - The value of the expression is representable in the type of the
12783          variable */
12784   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12785             || rhs_type == char_type_node || rhs_type == int_type_node)
12786             && TREE_CONSTANT (rhs)
12787            && (lhs_type == byte_type_node || lhs_type == char_type_node
12788                || lhs_type == short_type_node))
12789     {
12790       if (int_fits_type_p (rhs, lhs_type))
12791         new_rhs = convert (lhs_type, rhs);
12792       else if (wfl_op1)         /* Might be called with a NULL */
12793         parse_warning_context
12794           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12795            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12796       /* Reported a warning that will turn into an error further
12797          down, so we don't return */
12798     }
12799
12800   return new_rhs;
12801 }
12802
12803 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12804    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12805    0 is the conversion test fails.  This implements parts the method
12806    invocation conversion (5.3).  */
12807
12808 static int
12809 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12810 {
12811   /* 5.1.1: This is the identity conversion part. */
12812   if (lhs_type == rhs_type)
12813     return 1;
12814
12815   /* Reject non primitive types and boolean conversions.  */
12816   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12817     return 0;
12818
12819   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12820      than a char can't be converted into a char. Short can't too, but
12821      the < test below takes care of that */
12822   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12823     return 0;
12824
12825   /* Accept all promoted type here. Note, we can't use <= in the test
12826      below, because we still need to bounce out assignments of short
12827      to char and the likes */
12828   if (lhs_type == int_type_node
12829       && (rhs_type == promoted_byte_type_node
12830           || rhs_type == promoted_short_type_node
12831           || rhs_type == promoted_char_type_node
12832           || rhs_type == promoted_boolean_type_node))
12833     return 1;
12834
12835   /* From here, an integral is widened if its precision is smaller
12836      than the precision of the LHS or if the LHS is a floating point
12837      type, or the RHS is a float and the RHS a double. */
12838   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12839        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12840       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12841       || (rhs_type == float_type_node && lhs_type == double_type_node))
12842     return 1;
12843
12844   return 0;
12845 }
12846
12847 /* Check that something of SOURCE type can be assigned or cast to
12848    something of DEST type at runtime. Return 1 if the operation is
12849    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12850    were SOURCE is cast into DEST, which borrows a lot of the
12851    assignment check. */
12852
12853 static int
12854 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12855 {
12856   /* SOURCE or DEST might be null if not from a declared entity. */
12857   if (!source || !dest)
12858     return 0;
12859   if (JNULLP_TYPE_P (source))
12860     return 1;
12861   if (TREE_CODE (source) == POINTER_TYPE)
12862     source = TREE_TYPE (source);
12863   if (TREE_CODE (dest) == POINTER_TYPE)
12864     dest = TREE_TYPE (dest);
12865
12866   /* If source and dest are being compiled from bytecode, they may need to
12867      be loaded. */
12868   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12869     {
12870       load_class (source, 1);
12871       safe_layout_class (source);
12872     }
12873   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12874     {
12875       load_class (dest, 1);
12876       safe_layout_class (dest);
12877     }
12878
12879   /* Case where SOURCE is a class type */
12880   if (TYPE_CLASS_P (source))
12881     {
12882       if (TYPE_CLASS_P (dest))
12883         return  (source == dest
12884                  || inherits_from_p (source, dest)
12885                  || (cast && inherits_from_p (dest, source)));
12886       if (TYPE_INTERFACE_P (dest))
12887         {
12888           /* If doing a cast and SOURCE is final, the operation is
12889              always correct a compile time (because even if SOURCE
12890              does not implement DEST, a subclass of SOURCE might). */
12891           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12892             return 1;
12893           /* Otherwise, SOURCE must implement DEST */
12894           return interface_of_p (dest, source);
12895         }
12896       /* DEST is an array, cast permitted if SOURCE is of Object type */
12897       return (cast && source == object_type_node ? 1 : 0);
12898     }
12899   if (TYPE_INTERFACE_P (source))
12900     {
12901       if (TYPE_CLASS_P (dest))
12902         {
12903           /* If not casting, DEST must be the Object type */
12904           if (!cast)
12905             return dest == object_type_node;
12906           /* We're doing a cast. The cast is always valid is class
12907              DEST is not final, otherwise, DEST must implement SOURCE */
12908           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12909             return 1;
12910           else
12911             return interface_of_p (source, dest);
12912         }
12913       if (TYPE_INTERFACE_P (dest))
12914         {
12915           /* If doing a cast, then if SOURCE and DEST contain method
12916              with the same signature but different return type, then
12917              this is a (compile time) error */
12918           if (cast)
12919             {
12920               tree method_source, method_dest;
12921               tree source_type;
12922               tree source_sig;
12923               tree source_name;
12924               for (method_source = TYPE_METHODS (source); method_source;
12925                    method_source = TREE_CHAIN (method_source))
12926                 {
12927                   source_sig =
12928                     build_java_argument_signature (TREE_TYPE (method_source));
12929                   source_type = TREE_TYPE (TREE_TYPE (method_source));
12930                   source_name = DECL_NAME (method_source);
12931                   for (method_dest = TYPE_METHODS (dest);
12932                        method_dest; method_dest = TREE_CHAIN (method_dest))
12933                     if (source_sig ==
12934                         build_java_argument_signature (TREE_TYPE (method_dest))
12935                         && source_name == DECL_NAME (method_dest)
12936                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12937                       return 0;
12938                 }
12939               return 1;
12940             }
12941           else
12942             return source == dest || interface_of_p (dest, source);
12943         }
12944       else
12945         {
12946           /* Array */
12947           return (cast
12948                   && (DECL_NAME (TYPE_NAME (source))
12949                       == java_lang_cloneable_identifier_node
12950                       || (DECL_NAME (TYPE_NAME (source))
12951                           == java_io_serializable_identifier_node)));
12952         }
12953     }
12954   if (TYPE_ARRAY_P (source))
12955     {
12956       if (TYPE_CLASS_P (dest))
12957         return dest == object_type_node;
12958       /* Can't cast an array to an interface unless the interface is
12959          java.lang.Cloneable or java.io.Serializable.  */
12960       if (TYPE_INTERFACE_P (dest))
12961         return (DECL_NAME (TYPE_NAME (dest))
12962                 == java_lang_cloneable_identifier_node
12963                 || (DECL_NAME (TYPE_NAME (dest))
12964                     == java_io_serializable_identifier_node));
12965       else                      /* Arrays */
12966         {
12967           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12968           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12969
12970           /* In case of severe errors, they turn out null */
12971           if (!dest_element_type || !source_element_type)
12972             return 0;
12973           if (source_element_type == dest_element_type)
12974             return 1;
12975           return valid_ref_assignconv_cast_p (source_element_type,
12976                                               dest_element_type, cast);
12977         }
12978       return 0;
12979     }
12980   return 0;
12981 }
12982
12983 static int
12984 valid_cast_to_p (tree source, tree dest)
12985 {
12986   if (TREE_CODE (source) == POINTER_TYPE)
12987     source = TREE_TYPE (source);
12988   if (TREE_CODE (dest) == POINTER_TYPE)
12989     dest = TREE_TYPE (dest);
12990
12991   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
12992     return valid_ref_assignconv_cast_p (source, dest, 1);
12993
12994   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
12995     return 1;
12996
12997   else if (TREE_CODE (source) == BOOLEAN_TYPE
12998            && TREE_CODE (dest) == BOOLEAN_TYPE)
12999     return 1;
13000
13001   return 0;
13002 }
13003
13004 static tree
13005 do_unary_numeric_promotion (tree arg)
13006 {
13007   tree type = TREE_TYPE (arg);
13008   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13009       || TREE_CODE (type) == CHAR_TYPE)
13010     arg = convert (int_type_node, arg);
13011   return arg;
13012 }
13013
13014 /* Return a nonzero value if SOURCE can be converted into DEST using
13015    the method invocation conversion rule (5.3).  */
13016 static int
13017 valid_method_invocation_conversion_p (tree dest, tree source)
13018 {
13019   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13020            && valid_builtin_assignconv_identity_widening_p (dest, source))
13021           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13022               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13023               && valid_ref_assignconv_cast_p (source, dest, 0)));
13024 }
13025
13026 /* Build an incomplete binop expression. */
13027
13028 static tree
13029 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13030 {
13031   tree binop = build2 (op, NULL_TREE, op1, op2);
13032   TREE_SIDE_EFFECTS (binop) = 1;
13033   /* Store the location of the operator, for better error report. The
13034      string of the operator will be rebuild based on the OP value. */
13035   EXPR_WFL_LINECOL (binop) = op_location;
13036   return binop;
13037 }
13038
13039 /* Build the string of the operator retained by NODE. If NODE is part
13040    of a compound expression, add an '=' at the end of the string. This
13041    function is called when an error needs to be reported on an
13042    operator. The string is returned as a pointer to a static character
13043    buffer. */
13044
13045 static char *
13046 operator_string (tree node)
13047 {
13048 #define BUILD_OPERATOR_STRING(S)                                        \
13049   {                                                                     \
13050     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13051     return buffer;                                                      \
13052   }
13053
13054   static char buffer [10];
13055   switch (TREE_CODE (node))
13056     {
13057     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13058     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13059     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13060     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13061     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13062     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13063     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13064     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13065     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13066     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13067     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13068     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13069     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13070     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13071     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13072     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13073     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13074     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13075     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13076     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13077     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13078     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13079     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13080     case PREINCREMENT_EXPR:     /* Fall through */
13081     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13082     case PREDECREMENT_EXPR:     /* Fall through */
13083     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13084     default:
13085       internal_error ("unregistered operator %s",
13086                       tree_code_name [TREE_CODE (node)]);
13087     }
13088   return NULL;
13089 #undef BUILD_OPERATOR_STRING
13090 }
13091
13092 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13093
13094 static int
13095 java_decl_equiv (tree var_acc1, tree var_acc2)
13096 {
13097   if (JDECL_P (var_acc1))
13098     return (var_acc1 == var_acc2);
13099
13100   return (TREE_CODE (var_acc1) == COMPONENT_REF
13101           && TREE_CODE (var_acc2) == COMPONENT_REF
13102           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13103              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13104           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13105 }
13106
13107 /* Return a nonzero value if CODE is one of the operators that can be
13108    used in conjunction with the `=' operator in a compound assignment.  */
13109
13110 static int
13111 binop_compound_p (enum tree_code code)
13112 {
13113   int i;
13114   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13115     if (binop_lookup [i] == code)
13116       break;
13117
13118   return i < BINOP_COMPOUND_CANDIDATES;
13119 }
13120
13121 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13122
13123 static tree
13124 java_refold (tree t)
13125 {
13126   tree c, b, ns, decl;
13127
13128   if (TREE_CODE (t) != MODIFY_EXPR)
13129     return t;
13130
13131   c = TREE_OPERAND (t, 1);
13132   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13133          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13134          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13135     return t;
13136
13137   /* Now the left branch of the binary operator. */
13138   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13139   if (! (b && TREE_CODE (b) == NOP_EXPR
13140          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13141     return t;
13142
13143   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13144   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13145          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13146     return t;
13147
13148   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13149   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13150       /* It's got to be the an equivalent decl */
13151       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13152     {
13153       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13154       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13155       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13156       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13157       /* Change the right part of the BINOP_EXPR */
13158       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13159     }
13160
13161   return t;
13162 }
13163
13164 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13165    errors but we modify NODE so that it contains the type computed
13166    according to the expression, when it's fixed. Otherwise, we write
13167    error_mark_node as the type. It allows us to further the analysis
13168    of remaining nodes and detects more errors in certain cases.  */
13169
13170 static tree
13171 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13172 {
13173   tree op1 = TREE_OPERAND (node, 0);
13174   tree op2 = TREE_OPERAND (node, 1);
13175   tree op1_type = TREE_TYPE (op1);
13176   tree op2_type = TREE_TYPE (op2);
13177   tree prom_type = NULL_TREE, cn;
13178   enum tree_code code = TREE_CODE (node);
13179
13180   /* If 1, tell the routine that we have to return error_mark_node
13181      after checking for the initialization of the RHS */
13182   int error_found = 0;
13183
13184   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13185
13186   /* If either op<n>_type are NULL, this might be early signs of an
13187      error situation, unless it's too early to tell (in case we're
13188      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13189      correctly so the error can be later on reported accurately. */
13190   if (! (code == PLUS_EXPR || code == NE_EXPR
13191          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13192     {
13193       tree n;
13194       if (! op1_type)
13195         {
13196           n = java_complete_tree (op1);
13197           op1_type = TREE_TYPE (n);
13198         }
13199       if (! op2_type)
13200         {
13201           n = java_complete_tree (op2);
13202           op2_type = TREE_TYPE (n);
13203         }
13204     }
13205
13206   switch (code)
13207     {
13208     /* 15.16 Multiplicative operators */
13209     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13210     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13211     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13212     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13213       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13214         {
13215           if (!JNUMERIC_TYPE_P (op1_type))
13216             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13217           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13218             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13219           TREE_TYPE (node) = error_mark_node;
13220           error_found = 1;
13221           break;
13222         }
13223       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13224
13225       /* Detect integral division by zero */
13226       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13227           && TREE_CODE (prom_type) == INTEGER_TYPE
13228           && (op2 == integer_zero_node || op2 == long_zero_node ||
13229               (TREE_CODE (op2) == INTEGER_CST &&
13230                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13231         {
13232           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13233           TREE_CONSTANT (node) = 0;
13234           TREE_INVARIANT (node) = 0;
13235         }
13236
13237       /* Change the division operator if necessary */
13238       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13239         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13240
13241       /* Before divisions as is disappear, try to simplify and bail if
13242          applicable, otherwise we won't perform even simple
13243          simplifications like (1-1)/3. We can't do that with floating
13244          point number, folds can't handle them at this stage. */
13245       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13246           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13247         {
13248           TREE_TYPE (node) = prom_type;
13249           node = fold (node);
13250           if (TREE_CODE (node) != code)
13251             return node;
13252         }
13253
13254       if (TREE_CODE (prom_type) == INTEGER_TYPE
13255           && flag_use_divide_subroutine
13256           && ! flag_emit_class_files
13257           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13258         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13259
13260       /* This one is more complicated. FLOATs are processed by a
13261          function call to soft_fmod. Duplicate the value of the
13262          COMPOUND_ASSIGN_P flag. */
13263       if (code == TRUNC_MOD_EXPR)
13264         {
13265           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13266           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13267           TREE_SIDE_EFFECTS (mod)
13268             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13269           return mod;
13270         }
13271       break;
13272
13273     /* 15.17 Additive Operators */
13274     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13275
13276       /* Operation is valid if either one argument is a string
13277          constant, a String object or a StringBuffer crafted for the
13278          purpose of the a previous usage of the String concatenation
13279          operator */
13280
13281       if (TREE_CODE (op1) == STRING_CST
13282           || TREE_CODE (op2) == STRING_CST
13283           || JSTRING_TYPE_P (op1_type)
13284           || JSTRING_TYPE_P (op2_type)
13285           || IS_CRAFTED_STRING_BUFFER_P (op1)
13286           || IS_CRAFTED_STRING_BUFFER_P (op2))
13287         return build_string_concatenation (op1, op2);
13288
13289     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13290                                    Numeric Types */
13291       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13292         {
13293           if (!JNUMERIC_TYPE_P (op1_type))
13294             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13295           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13296             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13297           TREE_TYPE (node) = error_mark_node;
13298           error_found = 1;
13299           break;
13300         }
13301       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13302       break;
13303
13304     /* 15.18 Shift Operators */
13305     case LSHIFT_EXPR:
13306     case RSHIFT_EXPR:
13307     case URSHIFT_EXPR:
13308       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13309         {
13310           if (!JINTEGRAL_TYPE_P (op1_type))
13311             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13312           else
13313             {
13314               if (JNUMERIC_TYPE_P (op2_type))
13315                 parse_error_context (wfl_operator,
13316                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13317                                      operator_string (node),
13318                                      lang_printable_name (op2_type, 0));
13319               else
13320                 parse_error_context (wfl_operator,
13321                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13322                                      operator_string (node),
13323                                      lang_printable_name (op2_type, 0));
13324             }
13325           TREE_TYPE (node) = error_mark_node;
13326           error_found = 1;
13327           break;
13328         }
13329
13330       /* Unary numeric promotion (5.6.1) is performed on each operand
13331          separately */
13332       op1 = do_unary_numeric_promotion (op1);
13333       op2 = do_unary_numeric_promotion (op2);
13334
13335       /* If the right hand side is of type `long', first cast it to
13336          `int'.  */
13337       if (TREE_TYPE (op2) == long_type_node)
13338         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13339
13340       /* The type of the shift expression is the type of the promoted
13341          type of the left-hand operand */
13342       prom_type = TREE_TYPE (op1);
13343
13344       /* Shift int only up to 0x1f and long up to 0x3f */
13345       if (prom_type == int_type_node)
13346         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13347                             build_int_cst (NULL_TREE, 0x1f)));
13348       else
13349         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13350                             build_int_cst (NULL_TREE, 0x3f)));
13351
13352       /* The >>> operator is a >> operating on unsigned quantities */
13353       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13354         {
13355           tree to_return;
13356           tree utype = java_unsigned_type (prom_type);
13357           op1 = convert (utype, op1);
13358           TREE_SET_CODE (node, RSHIFT_EXPR);
13359           TREE_OPERAND (node, 0) = op1;
13360           TREE_OPERAND (node, 1) = op2;
13361           TREE_TYPE (node) = utype;
13362           to_return = convert (prom_type, node);
13363           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13364           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13365           TREE_SIDE_EFFECTS (to_return)
13366             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13367           return to_return;
13368         }
13369       break;
13370
13371       /* 15.19.1 Type Comparison Operator instanceof */
13372     case INSTANCEOF_EXPR:
13373
13374       TREE_TYPE (node) = boolean_type_node;
13375
13376       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13377       if ((cn = patch_string (op1)))
13378         {
13379           op1 = cn;
13380           op1_type = TREE_TYPE (op1);
13381         }
13382       if (op1_type == NULL_TREE)
13383         abort ();
13384
13385       if (!(op2_type = resolve_type_during_patch (op2)))
13386         return error_mark_node;
13387
13388       /* The first operand must be a reference type or the null type */
13389       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13390         error_found = 1;        /* Error reported further below */
13391
13392       /* The second operand must be a reference type */
13393       if (!JREFERENCE_TYPE_P (op2_type))
13394         {
13395           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13396           parse_error_context
13397             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13398              lang_printable_name (op2_type, 0));
13399           error_found = 1;
13400         }
13401
13402       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13403         {
13404           /* If the first operand is null, the result is always false */
13405           if (op1 == null_pointer_node)
13406             return boolean_false_node;
13407           else if (flag_emit_class_files)
13408             {
13409               TREE_OPERAND (node, 1) = op2_type;
13410               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13411               return node;
13412             }
13413           /* Otherwise we have to invoke instance of to figure it out */
13414           else
13415             return build_instanceof (op1, op2_type);
13416         }
13417       /* There is no way the expression operand can be an instance of
13418          the type operand. This is a compile time error. */
13419       else
13420         {
13421           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13422           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13423           parse_error_context
13424             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13425              t1, lang_printable_name (op2_type, 0));
13426           free (t1);
13427           error_found = 1;
13428         }
13429
13430       break;
13431
13432       /* 15.21 Bitwise and Logical Operators */
13433     case BIT_AND_EXPR:
13434     case BIT_XOR_EXPR:
13435     case BIT_IOR_EXPR:
13436       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13437         /* Binary numeric promotion is performed on both operand and the
13438            expression retain that type */
13439         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13440
13441       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13442                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13443         /* The type of the bitwise operator expression is BOOLEAN */
13444         prom_type = boolean_type_node;
13445       else
13446         {
13447           if (!JINTEGRAL_TYPE_P (op1_type))
13448             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13449           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13450             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13451           TREE_TYPE (node) = error_mark_node;
13452           error_found = 1;
13453           /* Insert a break here if adding thing before the switch's
13454              break for this case */
13455         }
13456       break;
13457
13458       /* 15.22 Conditional-And Operator */
13459     case TRUTH_ANDIF_EXPR:
13460       /* 15.23 Conditional-Or Operator */
13461     case TRUTH_ORIF_EXPR:
13462       /* Operands must be of BOOLEAN type */
13463       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13464           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13465         {
13466           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13467             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13468           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13469             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13470           TREE_TYPE (node) = boolean_type_node;
13471           error_found = 1;
13472           break;
13473         }
13474       else if (integer_zerop (op1))
13475         {
13476           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13477         }
13478       else if (integer_onep (op1))
13479         {
13480           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13481         }
13482       /* The type of the conditional operators is BOOLEAN */
13483       prom_type = boolean_type_node;
13484       break;
13485
13486       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13487     case LT_EXPR:
13488     case GT_EXPR:
13489     case LE_EXPR:
13490     case GE_EXPR:
13491       /* The type of each of the operands must be a primitive numeric
13492          type */
13493       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13494         {
13495           if (!JNUMERIC_TYPE_P (op1_type))
13496             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13497           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13498             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13499           TREE_TYPE (node) = boolean_type_node;
13500           error_found = 1;
13501           break;
13502         }
13503       /* Binary numeric promotion is performed on the operands */
13504       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13505       /* The type of the relation expression is always BOOLEAN */
13506       prom_type = boolean_type_node;
13507       break;
13508
13509       /* 15.20 Equality Operator */
13510     case EQ_EXPR:
13511     case NE_EXPR:
13512       /* It's time for us to patch the strings. */
13513       if ((cn = patch_string (op1)))
13514        {
13515          op1 = cn;
13516          op1_type = TREE_TYPE (op1);
13517        }
13518       if ((cn = patch_string (op2)))
13519        {
13520          op2 = cn;
13521          op2_type = TREE_TYPE (op2);
13522        }
13523
13524       /* 15.20.1 Numerical Equality Operators == and != */
13525       /* Binary numeric promotion is performed on the operands */
13526       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13527         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13528
13529       /* 15.20.2 Boolean Equality Operators == and != */
13530       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13531           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13532         ;                       /* Nothing to do here */
13533
13534       /* 15.20.3 Reference Equality Operators == and != */
13535       /* Types have to be either references or the null type. If
13536          they're references, it must be possible to convert either
13537          type to the other by casting conversion. */
13538       else if (op1 == null_pointer_node || op2 == null_pointer_node
13539                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13540                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13541                        || valid_ref_assignconv_cast_p (op2_type,
13542                                                        op1_type, 1))))
13543         ;                       /* Nothing to do here */
13544
13545       /* Else we have an error figure what can't be converted into
13546          what and report the error */
13547       else
13548         {
13549           char *t1;
13550           t1 = xstrdup (lang_printable_name (op1_type, 0));
13551           parse_error_context
13552             (wfl_operator,
13553              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13554              operator_string (node), t1,
13555              lang_printable_name (op2_type, 0));
13556           free (t1);
13557           TREE_TYPE (node) = boolean_type_node;
13558           error_found = 1;
13559           break;
13560         }
13561       prom_type = boolean_type_node;
13562       break;
13563     default:
13564       abort ();
13565     }
13566
13567   if (error_found)
13568     return error_mark_node;
13569
13570   TREE_OPERAND (node, 0) = op1;
13571   TREE_OPERAND (node, 1) = op2;
13572   TREE_TYPE (node) = prom_type;
13573   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13574
13575   if (flag_emit_xref)
13576     return node;
13577
13578   /* fold does not respect side-effect order as required for Java but not C.
13579    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13580    * bytecode.
13581    */
13582   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13583       : ! TREE_SIDE_EFFECTS (node))
13584     node = fold (node);
13585   return node;
13586 }
13587
13588 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13589    zero value, the value of CSTE comes after the valude of STRING */
13590
13591 static tree
13592 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13593 {
13594   const char *old = TREE_STRING_POINTER (cste);
13595   int old_len = TREE_STRING_LENGTH (cste);
13596   int len = old_len + string_len;
13597   char *new = alloca (len+1);
13598
13599   if (after)
13600     {
13601       memcpy (new, string, string_len);
13602       memcpy (&new [string_len], old, old_len);
13603     }
13604   else
13605     {
13606       memcpy (new, old, old_len);
13607       memcpy (&new [old_len], string, string_len);
13608     }
13609   new [len] = '\0';
13610   return build_string (len, new);
13611 }
13612
13613 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13614    new STRING_CST on success, NULL_TREE on failure.  */
13615
13616 static tree
13617 merge_string_cste (tree op1, tree op2, int after)
13618 {
13619   /* Handle two string constants right away.  */
13620   if (TREE_CODE (op2) == STRING_CST)
13621     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13622                                  TREE_STRING_LENGTH (op2), after);
13623
13624   /* Reasonable integer constant can be treated right away.  */
13625   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13626     {
13627       static const char *const boolean_true = "true";
13628       static const char *const boolean_false = "false";
13629       static const char *const null_pointer = "null";
13630       char ch[4];
13631       const char *string;
13632
13633       if (op2 == boolean_true_node)
13634         string = boolean_true;
13635       else if (op2 == boolean_false_node)
13636         string = boolean_false;
13637       else if (op2 == null_pointer_node
13638                || (integer_zerop (op2)
13639                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13640         /* FIXME: null is not a compile-time constant, so it is only safe to
13641            merge if the overall expression is non-constant. However, this
13642            code always merges without checking the overall expression.  */
13643         string = null_pointer;
13644       else if (TREE_TYPE (op2) == char_type_node)
13645         {
13646           /* Convert the character into UTF-8.  */
13647           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13648           unsigned char *p = (unsigned char *) ch;
13649           if (0x01 <= c && c <= 0x7f)
13650             *p++ = (unsigned char) c;
13651           else if (c < 0x7ff)
13652             {
13653               *p++ = (unsigned char) (c >> 6 | 0xc0);
13654               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13655             }
13656           else
13657             {
13658               *p++ = (unsigned char) (c >> 12 | 0xe0);
13659               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13660               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13661             }
13662           *p = '\0';
13663
13664           string = ch;
13665         }
13666       else
13667         string = string_convert_int_cst (op2);
13668
13669       return do_merge_string_cste (op1, string, strlen (string), after);
13670     }
13671   return NULL_TREE;
13672 }
13673
13674 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13675    has to be a STRING_CST and the other part must be a STRING_CST or a
13676    INTEGRAL constant. Return a new STRING_CST if the operation
13677    succeed, NULL_TREE otherwise.
13678
13679    If the case we want to optimize for space, we might want to return
13680    NULL_TREE for each invocation of this routine. FIXME */
13681
13682 static tree
13683 string_constant_concatenation (tree op1, tree op2)
13684 {
13685   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13686     {
13687       tree string, rest;
13688       int invert;
13689
13690       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13691       rest   = (string == op1 ? op2 : op1);
13692       invert = (string == op1 ? 0 : 1 );
13693
13694       /* Walk REST, only if it looks reasonable */
13695       if (TREE_CODE (rest) != STRING_CST
13696           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13697           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13698           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13699         {
13700           rest = java_complete_tree (rest);
13701           if (rest == error_mark_node)
13702             return error_mark_node;
13703           rest = fold (rest);
13704         }
13705       return merge_string_cste (string, rest, invert);
13706     }
13707   return NULL_TREE;
13708 }
13709
13710 /* Implement the `+' operator. Does static optimization if possible,
13711    otherwise create (if necessary) and append elements to a
13712    StringBuffer. The StringBuffer will be carried around until it is
13713    used for a function call or an assignment. Then toString() will be
13714    called on it to turn it into a String object. */
13715
13716 static tree
13717 build_string_concatenation (tree op1, tree op2)
13718 {
13719   tree result;
13720   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13721
13722   if (flag_emit_xref)
13723     return build2 (PLUS_EXPR, string_type_node, op1, op2);
13724
13725   /* Try to do some static optimization */
13726   if ((result = string_constant_concatenation (op1, op2)))
13727     return result;
13728
13729   /* Discard empty strings on either side of the expression */
13730   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13731     {
13732       op1 = op2;
13733       op2 = NULL_TREE;
13734     }
13735   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13736     op2 = NULL_TREE;
13737
13738   /* If operands are string constant, turn then into object references */
13739   if (TREE_CODE (op1) == STRING_CST)
13740     op1 = patch_string_cst (op1);
13741   if (op2 && TREE_CODE (op2) == STRING_CST)
13742     op2 = patch_string_cst (op2);
13743
13744   /* If either one of the constant is null and the other non null
13745      operand is a String constant, return it. */
13746   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13747     return op1;
13748
13749   /* If OP1 isn't already a StringBuffer, create and
13750      initialize a new one */
13751   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13752     {
13753       /* Two solutions here:
13754          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13755          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13756       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13757         op1 = BUILD_STRING_BUFFER (op1);
13758       else
13759         {
13760           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13761           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13762         }
13763     }
13764
13765   if (op2)
13766     {
13767       /* OP1 is no longer the last node holding a crafted StringBuffer */
13768       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13769       /* Create a node for `{new...,xxx}.append (op2)' */
13770       if (op2)
13771         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13772     }
13773
13774   /* Mark the last node holding a crafted StringBuffer */
13775   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13776
13777   TREE_SIDE_EFFECTS (op1) = side_effects;
13778   return op1;
13779 }
13780
13781 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13782    StringBuffer. If no string were found to be patched, return
13783    NULL. */
13784
13785 static tree
13786 patch_string (tree node)
13787 {
13788   if (node == error_mark_node)
13789     return error_mark_node;
13790   if (TREE_CODE (node) == STRING_CST)
13791     return patch_string_cst (node);
13792   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13793     {
13794       int saved = ctxp->explicit_constructor_p;
13795       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13796       tree ret;
13797       /* Temporary disable forbid the use of `this'. */
13798       ctxp->explicit_constructor_p = 0;
13799       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13800       /* String concatenation arguments must be evaluated in order too. */
13801       ret = force_evaluation_order (ret);
13802       /* Restore it at its previous value */
13803       ctxp->explicit_constructor_p = saved;
13804       return ret;
13805     }
13806   return NULL_TREE;
13807 }
13808
13809 /* Build the internal representation of a string constant.  */
13810
13811 static tree
13812 patch_string_cst (tree node)
13813 {
13814   int location;
13815   if (! flag_emit_class_files)
13816     {
13817       node = get_identifier (TREE_STRING_POINTER (node));
13818       location = alloc_name_constant (CONSTANT_String, node);
13819       node = build_ref_from_constant_pool (location);
13820     }
13821   TREE_CONSTANT (node) = 1;
13822   TREE_INVARIANT (node) = 1;
13823
13824   /* ??? Guessing that the class file code can't handle casts.  */
13825   if (! flag_emit_class_files)
13826     node = convert (string_ptr_type_node, node);
13827   else
13828     TREE_TYPE (node) = string_ptr_type_node;
13829
13830   return node;
13831 }
13832
13833 /* Build an incomplete unary operator expression. */
13834
13835 static tree
13836 build_unaryop (int op_token, int op_location, tree op1)
13837 {
13838   enum tree_code op;
13839   tree unaryop;
13840   switch (op_token)
13841     {
13842     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13843     case MINUS_TK: op = NEGATE_EXPR; break;
13844     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13845     case NOT_TK: op = BIT_NOT_EXPR; break;
13846     default: abort ();
13847     }
13848
13849   unaryop = build1 (op, NULL_TREE, op1);
13850   TREE_SIDE_EFFECTS (unaryop) = 1;
13851   /* Store the location of the operator, for better error report. The
13852      string of the operator will be rebuild based on the OP value. */
13853   EXPR_WFL_LINECOL (unaryop) = op_location;
13854   return unaryop;
13855 }
13856
13857 /* Special case for the ++/-- operators, since they require an extra
13858    argument to build, which is set to NULL and patched
13859    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13860
13861 static tree
13862 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13863 {
13864   static const enum tree_code lookup [2][2] =
13865     {
13866       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13867       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13868     };
13869   tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
13870                       NULL_TREE, op1, NULL_TREE);
13871   TREE_SIDE_EFFECTS (node) = 1;
13872   /* Store the location of the operator, for better error report. The
13873      string of the operator will be rebuild based on the OP value. */
13874   EXPR_WFL_LINECOL (node) = op_location;
13875   return node;
13876 }
13877
13878 /* Build an incomplete cast operator, based on the use of the
13879    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13880    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13881    though its type is already set.  */
13882
13883 static tree
13884 build_cast (int location, tree type, tree exp)
13885 {
13886   tree node = build1 (CONVERT_EXPR, type, exp);
13887   EXPR_WFL_LINECOL (node) = location;
13888   return node;
13889 }
13890
13891 /* Build an incomplete class reference operator.  */
13892 static tree
13893 build_incomplete_class_ref (int location, tree class_name)
13894 {
13895   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13896   tree class_decl = GET_CPC ();
13897   tree this_class = TREE_TYPE (class_decl);
13898
13899   /* Generate the synthetic static method `class$'.  (Previously we
13900      deferred this, causing different method tables to be emitted
13901      for native code and bytecode.)  */
13902   if (!TYPE_DOT_CLASS (this_class)
13903       && !JPRIMITIVE_TYPE_P (class_name)
13904       && !(TREE_CODE (class_name) == VOID_TYPE))
13905     {
13906       tree cpc_list = GET_CPC_LIST();
13907       tree cpc = cpc_list;
13908       tree target_class;
13909
13910       /* For inner classes, add a 'class$' method to their outermost
13911          context, creating it if necessary.  */
13912
13913       while (GET_NEXT_ENCLOSING_CPC(cpc))
13914         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
13915       class_decl = TREE_VALUE (cpc);
13916
13917       target_class = TREE_TYPE (class_decl);
13918
13919       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
13920         {
13921           /* For interfaces, adding a static 'class$' method directly
13922              is illegal.  So create an inner class to contain the new
13923              method.  Empirically this matches the behavior of javac.  */
13924           tree t, inner;
13925           /* We want the generated inner class inside the outermost class. */
13926           GET_CPC_LIST() = cpc;
13927           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13928           inner = create_anonymous_class (t);
13929           target_class = TREE_TYPE (inner);
13930           end_class_declaration (1);
13931           GET_CPC_LIST() = cpc_list;
13932         }
13933
13934       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
13935         build_dot_class_method (target_class);
13936
13937       if (this_class != target_class)
13938         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
13939     }
13940
13941   EXPR_WFL_LINECOL (node) = location;
13942   return node;
13943 }
13944
13945 /* Complete an incomplete class reference operator.  */
13946 static tree
13947 patch_incomplete_class_ref (tree node)
13948 {
13949   tree type = TREE_OPERAND (node, 0);
13950   tree ref_type;
13951
13952   if (!(ref_type = resolve_type_during_patch (type)))
13953     return error_mark_node;
13954
13955   /* If we're not emitting class files and we know ref_type is a
13956      compiled class, build a direct reference.  */
13957   if ((! flag_emit_class_files && is_compiled_class (ref_type))
13958       || JPRIMITIVE_TYPE_P (ref_type)
13959       || TREE_CODE (ref_type) == VOID_TYPE)
13960     {
13961       tree dot = build_class_ref (ref_type);
13962       /* A class referenced by `foo.class' is initialized.  */
13963       if (!flag_emit_class_files)
13964        dot = build_class_init (ref_type, dot);
13965       return java_complete_tree (dot);
13966     }
13967
13968   /* If we're emitting class files and we have to deal with non
13969      primitive types, we invoke the synthetic static method `class$'.  */
13970   ref_type = build_dot_class_method_invocation (current_class, ref_type);
13971   return java_complete_tree (ref_type);
13972 }
13973
13974 /* 15.14 Unary operators. We return error_mark_node in case of error,
13975    but preserve the type of NODE if the type is fixed.  */
13976
13977 static tree
13978 patch_unaryop (tree node, tree wfl_op)
13979 {
13980   tree op = TREE_OPERAND (node, 0);
13981   tree op_type = TREE_TYPE (op);
13982   tree prom_type = NULL_TREE, value, decl;
13983   int outer_field_flag = 0;
13984   int code = TREE_CODE (node);
13985   int error_found = 0;
13986
13987   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13988
13989   switch (code)
13990     {
13991       /* 15.13.2 Postfix Increment Operator ++ */
13992     case POSTINCREMENT_EXPR:
13993       /* 15.13.3 Postfix Increment Operator -- */
13994     case POSTDECREMENT_EXPR:
13995       /* 15.14.1 Prefix Increment Operator ++ */
13996     case PREINCREMENT_EXPR:
13997       /* 15.14.2 Prefix Decrement Operator -- */
13998     case PREDECREMENT_EXPR:
13999       op = decl = strip_out_static_field_access_decl (op);
14000       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14001       /* We might be trying to change an outer field accessed using
14002          access method. */
14003       if (outer_field_flag)
14004         {
14005           /* Retrieve the decl of the field we're trying to access. We
14006              do that by first retrieving the function we would call to
14007              access the field. It has been already verified that this
14008              field isn't final */
14009           if (flag_emit_class_files)
14010             decl = TREE_OPERAND (op, 0);
14011           else
14012             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14013           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14014         }
14015       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14016       else if (!JDECL_P (decl)
14017           && TREE_CODE (decl) != COMPONENT_REF
14018           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14019           && TREE_CODE (decl) != INDIRECT_REF
14020           && !(TREE_CODE (decl) == COMPOUND_EXPR
14021                && TREE_OPERAND (decl, 1)
14022                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14023         {
14024           TREE_TYPE (node) = error_mark_node;
14025           error_found = 1;
14026         }
14027
14028       /* From now on, we know that op if a variable and that it has a
14029          valid wfl. We use wfl_op to locate errors related to the
14030          ++/-- operand. */
14031       if (!JNUMERIC_TYPE_P (op_type))
14032         {
14033           parse_error_context
14034             (wfl_op, "Invalid argument type `%s' to `%s'",
14035              lang_printable_name (op_type, 0), operator_string (node));
14036           TREE_TYPE (node) = error_mark_node;
14037           error_found = 1;
14038         }
14039       else
14040         {
14041           /* Before the addition, binary numeric promotion is performed on
14042              both operands, if really necessary */
14043           if (JINTEGRAL_TYPE_P (op_type))
14044             {
14045               value = build_int_cst (op_type, 1);
14046               TREE_TYPE (node) = op_type;
14047             }
14048           else
14049             {
14050               value = build_int_cst (NULL_TREE, 1);
14051               TREE_TYPE (node) =
14052                 binary_numeric_promotion (op_type,
14053                                           TREE_TYPE (value), &op, &value);
14054             }
14055
14056           /* We remember we might be accessing an outer field */
14057           if (outer_field_flag)
14058             {
14059               /* We re-generate an access to the field */
14060               value = build2 (PLUS_EXPR, TREE_TYPE (op),
14061                               build_outer_field_access (wfl_op, decl), value);
14062
14063               /* And we patch the original access$() into a write
14064                  with plus_op as a rhs */
14065               return outer_field_access_fix (node, op, value);
14066             }
14067
14068           /* And write back into the node. */
14069           TREE_OPERAND (node, 0) = op;
14070           TREE_OPERAND (node, 1) = value;
14071           /* Convert the overall back into its original type, if
14072              necessary, and return */
14073           if (JINTEGRAL_TYPE_P (op_type))
14074             return fold (node);
14075           else
14076             return fold (convert (op_type, node));
14077         }
14078       break;
14079
14080       /* 15.14.3 Unary Plus Operator + */
14081     case UNARY_PLUS_EXPR:
14082       /* 15.14.4 Unary Minus Operator - */
14083     case NEGATE_EXPR:
14084       if (!JNUMERIC_TYPE_P (op_type))
14085         {
14086           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14087           TREE_TYPE (node) = error_mark_node;
14088           error_found = 1;
14089         }
14090       /* Unary numeric promotion is performed on operand */
14091       else
14092         {
14093           op = do_unary_numeric_promotion (op);
14094           prom_type = TREE_TYPE (op);
14095           if (code == UNARY_PLUS_EXPR)
14096             return fold (op);
14097         }
14098       break;
14099
14100       /* 15.14.5 Bitwise Complement Operator ~ */
14101     case BIT_NOT_EXPR:
14102       if (!JINTEGRAL_TYPE_P (op_type))
14103         {
14104           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14105           TREE_TYPE (node) = error_mark_node;
14106           error_found = 1;
14107         }
14108       else
14109         {
14110           op = do_unary_numeric_promotion (op);
14111           prom_type = TREE_TYPE (op);
14112         }
14113       break;
14114
14115       /* 15.14.6 Logical Complement Operator ! */
14116     case TRUTH_NOT_EXPR:
14117       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14118         {
14119           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14120           /* But the type is known. We will report an error if further
14121              attempt of a assignment is made with this rhs */
14122           TREE_TYPE (node) = boolean_type_node;
14123           error_found = 1;
14124         }
14125       else
14126         prom_type = boolean_type_node;
14127       break;
14128
14129       /* 15.15 Cast Expression */
14130     case CONVERT_EXPR:
14131       value = patch_cast (node, wfl_operator);
14132       if (value == error_mark_node)
14133         {
14134           /* If this cast is part of an assignment, we tell the code
14135              that deals with it not to complain about a mismatch,
14136              because things have been cast, anyways */
14137           TREE_TYPE (node) = error_mark_node;
14138           error_found = 1;
14139         }
14140       else
14141         {
14142           value = fold (value);
14143           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14144           return value;
14145         }
14146       break;
14147     }
14148
14149   if (error_found)
14150     return error_mark_node;
14151
14152   /* There are cases where node has been replaced by something else
14153      and we don't end up returning here: UNARY_PLUS_EXPR,
14154      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14155   TREE_OPERAND (node, 0) = fold (op);
14156   TREE_TYPE (node) = prom_type;
14157   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14158   return fold (node);
14159 }
14160
14161 /* Generic type resolution that sometimes takes place during node
14162    patching. Returned the resolved type or generate an error
14163    message. Return the resolved type or NULL_TREE.  */
14164
14165 static tree
14166 resolve_type_during_patch (tree type)
14167 {
14168   if (unresolved_type_p (type, NULL))
14169     {
14170       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14171       if (!type_decl)
14172         {
14173           parse_error_context (type,
14174                                "Class `%s' not found in type declaration",
14175                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14176           return NULL_TREE;
14177         }
14178
14179       check_deprecation (type, type_decl);
14180
14181       return TREE_TYPE (type_decl);
14182     }
14183   return type;
14184 }
14185
14186 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14187    found. Otherwise NODE or something meant to replace it is returned.  */
14188
14189 static tree
14190 patch_cast (tree node, tree wfl_op)
14191 {
14192   tree op = TREE_OPERAND (node, 0);
14193   tree cast_type = TREE_TYPE (node);
14194   tree patched, op_type;
14195   char *t1;
14196
14197   /* Some string patching might be necessary at this stage */
14198   if ((patched = patch_string (op)))
14199     TREE_OPERAND (node, 0) = op = patched;
14200   op_type = TREE_TYPE (op);
14201
14202   /* First resolve OP_TYPE if unresolved */
14203   if (!(cast_type = resolve_type_during_patch (cast_type)))
14204     return error_mark_node;
14205
14206   /* Check on cast that are proven correct at compile time */
14207   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14208     {
14209       /* Same type */
14210       if (cast_type == op_type)
14211         return node;
14212
14213       /* A narrowing conversion from a floating-point number to an
14214          integral type requires special handling (5.1.3).  */
14215       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14216         if (cast_type != long_type_node)
14217           op = convert (integer_type_node, op);
14218
14219       /* Try widening/narrowing conversion.  Potentially, things need
14220          to be worked out in gcc so we implement the extreme cases
14221          correctly.  fold_convert() needs to be fixed.  */
14222       return convert (cast_type, op);
14223     }
14224
14225   /* It's also valid to cast a boolean into a boolean */
14226   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14227     return node;
14228
14229   /* null can be casted to references */
14230   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14231     return build_null_of_type (cast_type);
14232
14233   /* The remaining legal casts involve conversion between reference
14234      types. Check for their compile time correctness. */
14235   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14236       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14237     {
14238       TREE_TYPE (node) = promote_type (cast_type);
14239       /* Now, the case can be determined correct at compile time if
14240          OP_TYPE can be converted into CAST_TYPE by assignment
14241          conversion (5.2) */
14242
14243       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14244         {
14245           TREE_SET_CODE (node, NOP_EXPR);
14246           return node;
14247         }
14248
14249       if (flag_emit_class_files)
14250         {
14251           TREE_SET_CODE (node, CONVERT_EXPR);
14252           return node;
14253         }
14254
14255       /* The cast requires a run-time check */
14256       return build3 (CALL_EXPR, promote_type (cast_type),
14257                      build_address_of (soft_checkcast_node),
14258                      tree_cons (NULL_TREE, build_class_ref (cast_type),
14259                                 build_tree_list (NULL_TREE, op)),
14260                      NULL_TREE);
14261     }
14262
14263   /* Any other casts are proven incorrect at compile time */
14264   t1 = xstrdup (lang_printable_name (op_type, 0));
14265   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14266                        t1, lang_printable_name (cast_type, 0));
14267   free (t1);
14268   return error_mark_node;
14269 }
14270
14271 /* Build a null constant and give it the type TYPE.  */
14272
14273 static tree
14274 build_null_of_type (tree type)
14275 {
14276   tree node = build_int_cst (promote_type (type), 0);
14277   return node;
14278 }
14279
14280 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14281    a list of indices. */
14282 static tree
14283 build_array_ref (int location, tree array, tree index)
14284 {
14285   tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14286                       NULL_TREE, NULL_TREE);
14287   EXPR_WFL_LINECOL (node) = location;
14288   return node;
14289 }
14290
14291 /* 15.12 Array Access Expression */
14292
14293 static tree
14294 patch_array_ref (tree node)
14295 {
14296   tree array = TREE_OPERAND (node, 0);
14297   tree array_type  = TREE_TYPE (array);
14298   tree index = TREE_OPERAND (node, 1);
14299   tree index_type = TREE_TYPE (index);
14300   int error_found = 0;
14301
14302   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14303
14304   if (TREE_CODE (array_type) == POINTER_TYPE)
14305     array_type = TREE_TYPE (array_type);
14306
14307   /* The array reference must be an array */
14308   if (!TYPE_ARRAY_P (array_type))
14309     {
14310       parse_error_context
14311         (wfl_operator,
14312          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14313          lang_printable_name (array_type, 0));
14314       TREE_TYPE (node) = error_mark_node;
14315       error_found = 1;
14316     }
14317
14318   /* The array index undergoes unary numeric promotion. The promoted
14319      type must be int */
14320   index = do_unary_numeric_promotion (index);
14321   if (TREE_TYPE (index) != int_type_node)
14322     {
14323       if (valid_cast_to_p (index_type, int_type_node))
14324         parse_error_context (wfl_operator,
14325    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14326                              lang_printable_name (index_type, 0));
14327       else
14328         parse_error_context (wfl_operator,
14329           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14330                              lang_printable_name (index_type, 0));
14331       TREE_TYPE (node) = error_mark_node;
14332       error_found = 1;
14333     }
14334
14335   if (error_found)
14336     return error_mark_node;
14337
14338   array_type = TYPE_ARRAY_ELEMENT (array_type);
14339
14340   if (flag_emit_class_files || flag_emit_xref)
14341     {
14342       TREE_OPERAND (node, 0) = array;
14343       TREE_OPERAND (node, 1) = index;
14344     }
14345   else
14346     node = build_java_arrayaccess (array, array_type, index);
14347   TREE_TYPE (node) = array_type;
14348   return node;
14349 }
14350
14351 /* 15.9 Array Creation Expressions */
14352
14353 static tree
14354 build_newarray_node (tree type, tree dims, int extra_dims)
14355 {
14356   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14357                       nreverse (dims),
14358                       build_int_cst (NULL_TREE, extra_dims));
14359   return node;
14360 }
14361
14362 static tree
14363 patch_newarray (tree node)
14364 {
14365   tree type = TREE_OPERAND (node, 0);
14366   tree dims = TREE_OPERAND (node, 1);
14367   tree cdim, array_type;
14368   int error_found = 0;
14369   int ndims = 0;
14370   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14371
14372   /* Dimension types are verified. It's better for the types to be
14373      verified in order. */
14374   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14375     {
14376       int dim_error = 0;
14377       tree dim = TREE_VALUE (cdim);
14378
14379       /* Dim might have been saved during its evaluation */
14380       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14381
14382       /* The type of each specified dimension must be an integral type. */
14383       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14384         dim_error = 1;
14385
14386       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14387          promoted type must be int. */
14388       else
14389         {
14390           dim = do_unary_numeric_promotion (dim);
14391           if (TREE_TYPE (dim) != int_type_node)
14392             dim_error = 1;
14393         }
14394
14395       /* Report errors on types here */
14396       if (dim_error)
14397         {
14398           parse_error_context
14399             (TREE_PURPOSE (cdim),
14400              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14401              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14402               "Explicit cast needed to" : "Can't"),
14403              lang_printable_name (TREE_TYPE (dim), 0));
14404           error_found = 1;
14405         }
14406
14407       TREE_PURPOSE (cdim) = NULL_TREE;
14408     }
14409
14410   /* Resolve array base type if unresolved */
14411   if (!(type = resolve_type_during_patch (type)))
14412     error_found = 1;
14413
14414   if (error_found)
14415     {
14416       /* We don't want further evaluation of this bogus array creation
14417          operation */
14418       TREE_TYPE (node) = error_mark_node;
14419       return error_mark_node;
14420     }
14421
14422   /* Set array_type to the actual (promoted) array type of the result. */
14423   if (TREE_CODE (type) == RECORD_TYPE)
14424     type = build_pointer_type (type);
14425   while (--xdims >= 0)
14426     {
14427       type = promote_type (build_java_array_type (type, -1));
14428     }
14429   dims = nreverse (dims);
14430   array_type = type;
14431   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14432     {
14433       type = array_type;
14434       array_type
14435         = build_java_array_type (type,
14436                                  TREE_CODE (cdim) == INTEGER_CST
14437                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14438                                  : -1);
14439       array_type = promote_type (array_type);
14440     }
14441   dims = nreverse (dims);
14442
14443   /* The node is transformed into a function call. Things are done
14444      differently according to the number of dimensions. If the number
14445      of dimension is equal to 1, then the nature of the base type
14446      (primitive or not) matters. */
14447   if (ndims == 1)
14448     return build_new_array (type, TREE_VALUE (dims));
14449
14450   /* Can't reuse what's already written in expr.c because it uses the
14451      JVM stack representation. Provide a build_multianewarray. FIXME */
14452   return build3 (CALL_EXPR, array_type,
14453                  build_address_of (soft_multianewarray_node),
14454                  tree_cons (NULL_TREE,
14455                             build_class_ref (TREE_TYPE (array_type)),
14456                             tree_cons (NULL_TREE,
14457                                        build_int_cst (NULL_TREE, ndims),
14458                                        dims)),
14459                  NULL_TREE);
14460 }
14461
14462 /* 10.6 Array initializer.  */
14463
14464 /* Build a wfl for array element that don't have one, so we can
14465    pin-point errors.  */
14466
14467 static tree
14468 maybe_build_array_element_wfl (tree node)
14469 {
14470   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14471     return build_expr_wfl (NULL_TREE, ctxp->filename,
14472                            ctxp->elc.line, ctxp->elc.prev_col);
14473   else
14474     return NULL_TREE;
14475 }
14476
14477 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14478    identification of initialized arrays easier to detect during walk
14479    and expansion.  */
14480
14481 static tree
14482 build_new_array_init (int location, tree values)
14483 {
14484   tree constructor = build_constructor (NULL_TREE, values);
14485   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14486   EXPR_WFL_LINECOL (to_return) = location;
14487   return to_return;
14488 }
14489
14490 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14491    occurred.  Otherwise return NODE after having set its type
14492    appropriately.  */
14493
14494 static tree
14495 patch_new_array_init (tree type, tree node)
14496 {
14497   int error_seen = 0;
14498   tree current, element_type;
14499   HOST_WIDE_INT length;
14500   int all_constant = 1;
14501   tree init = TREE_OPERAND (node, 0);
14502
14503   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14504     {
14505       parse_error_context (node,
14506                            "Invalid array initializer for non-array type `%s'",
14507                            lang_printable_name (type, 1));
14508       return error_mark_node;
14509     }
14510   type = TREE_TYPE (type);
14511   element_type = TYPE_ARRAY_ELEMENT (type);
14512
14513   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14514
14515   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14516        current;  length++, current = TREE_CHAIN (current))
14517     {
14518       tree elt = TREE_VALUE (current);
14519       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14520         {
14521           error_seen |= array_constructor_check_entry (element_type, current);
14522           elt = TREE_VALUE (current);
14523           /* When compiling to native code, STRING_CST is converted to
14524              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14525           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14526             all_constant = 0;
14527         }
14528       else
14529         {
14530           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14531           TREE_PURPOSE (current) = NULL_TREE;
14532           all_constant = 0;
14533         }
14534       if (elt && TREE_CODE (elt) == TREE_LIST
14535           && TREE_VALUE (elt) == error_mark_node)
14536         error_seen = 1;
14537     }
14538
14539   if (error_seen)
14540     return error_mark_node;
14541
14542   /* Create a new type. We can't reuse the one we have here by
14543      patching its dimension because it originally is of dimension -1
14544      hence reused by gcc. This would prevent triangular arrays. */
14545   type = build_java_array_type (element_type, length);
14546   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14547   TREE_TYPE (node) = promote_type (type);
14548   TREE_CONSTANT (init) = all_constant;
14549   TREE_INVARIANT (init) = all_constant;
14550   TREE_CONSTANT (node) = all_constant;
14551   TREE_INVARIANT (node) = all_constant;
14552   return node;
14553 }
14554
14555 /* Verify that one entry of the initializer element list can be
14556    assigned to the array base type. Report 1 if an error occurred, 0
14557    otherwise.  */
14558
14559 static int
14560 array_constructor_check_entry (tree type, tree entry)
14561 {
14562   char *array_type_string = NULL;       /* For error reports */
14563   tree value, type_value, new_value, wfl_value, patched;
14564   int error_seen = 0;
14565
14566   new_value = NULL_TREE;
14567   wfl_value = TREE_VALUE (entry);
14568
14569   value = java_complete_tree (TREE_VALUE (entry));
14570   /* patch_string return error_mark_node if arg is error_mark_node */
14571   if ((patched = patch_string (value)))
14572     value = patched;
14573   if (value == error_mark_node)
14574     return 1;
14575
14576   type_value = TREE_TYPE (value);
14577
14578   /* At anytime, try_builtin_assignconv can report a warning on
14579      constant overflow during narrowing. */
14580   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14581   new_value = try_builtin_assignconv (wfl_operator, type, value);
14582   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14583     type_value = promote_type (type);
14584
14585   /* Check and report errors */
14586   if (!new_value)
14587     {
14588       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14589                    "Can't" : "Explicit cast needed to");
14590       if (!array_type_string)
14591         array_type_string = xstrdup (lang_printable_name (type, 1));
14592       parse_error_context
14593         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14594          msg, lang_printable_name (type_value, 1), array_type_string);
14595       error_seen = 1;
14596     }
14597
14598   if (new_value)
14599     TREE_VALUE (entry) = new_value;
14600
14601   if (array_type_string)
14602     free (array_type_string);
14603
14604   TREE_PURPOSE (entry) = NULL_TREE;
14605   return error_seen;
14606 }
14607
14608 static tree
14609 build_this (int location)
14610 {
14611   tree node = build_wfl_node (this_identifier_node);
14612   TREE_SET_CODE (node, THIS_EXPR);
14613   EXPR_WFL_LINECOL (node) = location;
14614   return node;
14615 }
14616
14617 /* 14.15 The return statement. It builds a modify expression that
14618    assigns the returned value to the RESULT_DECL that hold the value
14619    to be returned. */
14620
14621 static tree
14622 build_return (int location, tree op)
14623 {
14624   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14625   EXPR_WFL_LINECOL (node) = location;
14626   node = build_debugable_stmt (location, node);
14627   return node;
14628 }
14629
14630 static tree
14631 patch_return (tree node)
14632 {
14633   tree return_exp = TREE_OPERAND (node, 0);
14634   tree meth = current_function_decl;
14635   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14636   int error_found = 0;
14637
14638   TREE_TYPE (node) = error_mark_node;
14639   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14640
14641   /* It's invalid to have a return value within a function that is
14642      declared with the keyword void or that is a constructor */
14643   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14644     error_found = 1;
14645
14646   /* It's invalid to use a return statement in a static block */
14647   if (DECL_CLINIT_P (current_function_decl))
14648     error_found = 1;
14649
14650   /* It's invalid to have a no return value within a function that
14651      isn't declared with the keyword `void' */
14652   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14653     error_found = 2;
14654
14655   if (DECL_INSTINIT_P (current_function_decl))
14656     error_found = 1;
14657
14658   if (error_found)
14659     {
14660       if (DECL_INSTINIT_P (current_function_decl))
14661         parse_error_context (wfl_operator,
14662                              "`return' inside instance initializer");
14663
14664       else if (DECL_CLINIT_P (current_function_decl))
14665         parse_error_context (wfl_operator,
14666                              "`return' inside static initializer");
14667
14668       else if (!DECL_CONSTRUCTOR_P (meth))
14669         {
14670           char *t = xstrdup (lang_printable_name (mtype, 0));
14671           parse_error_context (wfl_operator,
14672                                "`return' with%s value from `%s %s'",
14673                                (error_found == 1 ? "" : "out"),
14674                                t, lang_printable_name (meth, 2));
14675           free (t);
14676         }
14677       else
14678         parse_error_context (wfl_operator,
14679                              "`return' with value from constructor `%s'",
14680                              lang_printable_name (meth, 2));
14681       return error_mark_node;
14682     }
14683
14684   /* If we have a return_exp, build a modify expression and expand
14685      it. Note: at that point, the assignment is declared valid, but we
14686      may want to carry some more hacks */
14687   if (return_exp)
14688     {
14689       tree exp = java_complete_tree (return_exp);
14690       tree modify, patched;
14691
14692       if ((patched = patch_string (exp)))
14693         exp = patched;
14694
14695       modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14696       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14697       modify = java_complete_tree (modify);
14698
14699       if (modify != error_mark_node)
14700         {
14701           TREE_SIDE_EFFECTS (modify) = 1;
14702           TREE_OPERAND (node, 0) = modify;
14703         }
14704       else
14705         return error_mark_node;
14706     }
14707   TREE_TYPE (node) = void_type_node;
14708   TREE_SIDE_EFFECTS (node) = 1;
14709   return node;
14710 }
14711
14712 /* 14.8 The if Statement */
14713
14714 static tree
14715 build_if_else_statement (int location, tree expression, tree if_body,
14716                          tree else_body)
14717 {
14718   tree node;
14719   if (!else_body)
14720     else_body = build_java_empty_stmt ();
14721   node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14722   EXPR_WFL_LINECOL (node) = location;
14723   node = build_debugable_stmt (location, node);
14724   return node;
14725 }
14726
14727 static tree
14728 patch_if_else_statement (tree node)
14729 {
14730   tree expression = TREE_OPERAND (node, 0);
14731   int can_complete_normally
14732     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14733        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14734
14735   TREE_TYPE (node) = error_mark_node;
14736   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14737
14738   /* The type of expression must be boolean */
14739   if (TREE_TYPE (expression) != boolean_type_node
14740       && TREE_TYPE (expression) != promoted_boolean_type_node)
14741     {
14742       parse_error_context
14743         (wfl_operator,
14744          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14745          lang_printable_name (TREE_TYPE (expression), 0));
14746       return error_mark_node;
14747     }
14748
14749   TREE_TYPE (node) = void_type_node;
14750   TREE_SIDE_EFFECTS (node) = 1;
14751   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14752   return node;
14753 }
14754
14755 /* 14.6 Labeled Statements */
14756
14757 /* Action taken when a labeled statement is parsed. a new
14758    LABELED_BLOCK_EXPR is created. No statement is attached to the
14759    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14760
14761 static tree
14762 build_labeled_block (int location, tree label)
14763 {
14764   tree label_name ;
14765   tree label_decl, node;
14766   if (label == NULL_TREE || label == continue_identifier_node)
14767     label_name = label;
14768   else
14769     {
14770       label_name = merge_qualified_name (label_id, label);
14771       /* Issue an error if we try to reuse a label that was previously
14772          declared */
14773       if (IDENTIFIER_LOCAL_VALUE (label_name))
14774         {
14775           EXPR_WFL_LINECOL (wfl_operator) = location;
14776           parse_error_context (wfl_operator,
14777             "Declaration of `%s' shadows a previous label declaration",
14778                                IDENTIFIER_POINTER (label));
14779           EXPR_WFL_LINECOL (wfl_operator) =
14780             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14781           parse_error_context (wfl_operator,
14782             "This is the location of the previous declaration of label `%s'",
14783                                IDENTIFIER_POINTER (label));
14784           java_error_count--;
14785         }
14786     }
14787
14788   label_decl = create_label_decl (label_name);
14789   node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14790   EXPR_WFL_LINECOL (node) = location;
14791   TREE_SIDE_EFFECTS (node) = 1;
14792   return node;
14793 }
14794
14795 /* A labeled statement LBE is attached a statement.  */
14796
14797 static tree
14798 finish_labeled_statement (tree lbe, /* Labeled block expr */
14799                           tree statement)
14800 {
14801   /* In anyways, tie the loop to its statement */
14802   LABELED_BLOCK_BODY (lbe) = statement;
14803   pop_labeled_block ();
14804   POP_LABELED_BLOCK ();
14805   return lbe;
14806 }
14807
14808 /* 14.10, 14.11, 14.12 Loop Statements */
14809
14810 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14811    list. */
14812
14813 static tree
14814 build_new_loop (tree loop_body)
14815 {
14816   tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
14817   TREE_SIDE_EFFECTS (loop) = 1;
14818   PUSH_LOOP (loop);
14819   return loop;
14820 }
14821
14822 /* Create a loop body according to the following structure:
14823      COMPOUND_EXPR
14824        COMPOUND_EXPR            (loop main body)
14825          EXIT_EXPR              (this order is for while/for loops.
14826          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14827            LABEL_DECL           (a continue occurring here branches at the
14828            BODY                  end of this labeled block)
14829        INCREMENT                (if any)
14830
14831   REVERSED, if nonzero, tells that the loop condition expr comes
14832   after the body, like in the do-while loop.
14833
14834   To obtain a loop, the loop body structure described above is
14835   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14836
14837    LABELED_BLOCK_EXPR
14838      LABEL_DECL                   (use this label to exit the loop)
14839      LOOP_EXPR
14840        <structure described above> */
14841
14842 static tree
14843 build_loop_body (int location, tree condition, int reversed)
14844 {
14845   tree first, second, body;
14846
14847   condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14848   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14849   condition = build_debugable_stmt (location, condition);
14850   TREE_SIDE_EFFECTS (condition) = 1;
14851
14852   body = build_labeled_block (0, continue_identifier_node);
14853   first = (reversed ? body : condition);
14854   second = (reversed ? condition : body);
14855   return build2 (COMPOUND_EXPR, NULL_TREE,
14856                  build2 (COMPOUND_EXPR, NULL_TREE, first, second),
14857                  build_java_empty_stmt ());
14858 }
14859
14860 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14861    their order) on the current loop. Unlink the current loop from the
14862    loop list.  */
14863
14864 static tree
14865 finish_loop_body (int location, tree condition, tree body, int reversed)
14866 {
14867   tree to_return = ctxp->current_loop;
14868   tree loop_body = LOOP_EXPR_BODY (to_return);
14869   if (condition)
14870     {
14871       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14872       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14873          The real EXIT_EXPR is one operand further. */
14874       EXPR_WFL_LINECOL (cnode) = location;
14875       /* This one is for accurate error reports */
14876       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14877       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14878     }
14879   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14880   POP_LOOP ();
14881   return to_return;
14882 }
14883
14884 /* Tailored version of finish_loop_body for FOR loops, when FOR
14885    loops feature the condition part */
14886
14887 static tree
14888 finish_for_loop (int location, tree condition, tree update, tree body)
14889 {
14890   /* Put the condition and the loop body in place */
14891   tree loop = finish_loop_body (location, condition, body, 0);
14892   /* LOOP is the current loop which has been now popped of the loop
14893      stack.  Mark the update block as reachable and install it.  We do
14894      this because the (current interpretation of the) JLS requires
14895      that the update expression be considered reachable even if the
14896      for loop's body doesn't complete normally.  */
14897   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
14898     {
14899       tree up2 = update;
14900       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14901         up2 = EXPR_WFL_NODE (up2);
14902       /* It is possible for the update expression to be an
14903          EXPR_WFL_NODE wrapping nothing.  */
14904       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
14905         {
14906           /* Try to detect constraint violations.  These would be
14907              programming errors somewhere.  */
14908           if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
14909             abort ();
14910           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14911         }
14912     }
14913   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14914   return loop;
14915 }
14916
14917 /* Try to find the loop a block might be related to. This comprises
14918    the case where the LOOP_EXPR is found as the second operand of a
14919    COMPOUND_EXPR, because the loop happens to have an initialization
14920    part, then expressed as the first operand of the COMPOUND_EXPR. If
14921    the search finds something, 1 is returned. Otherwise, 0 is
14922    returned. The search is assumed to start from a
14923    LABELED_BLOCK_EXPR's block.  */
14924
14925 static tree
14926 search_loop (tree statement)
14927 {
14928   if (TREE_CODE (statement) == LOOP_EXPR)
14929     return statement;
14930
14931   if (TREE_CODE (statement) == BLOCK)
14932     statement = BLOCK_SUBBLOCKS (statement);
14933   else
14934     return NULL_TREE;
14935
14936   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14937     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14938       statement = TREE_OPERAND (statement, 1);
14939
14940   return (TREE_CODE (statement) == LOOP_EXPR
14941           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14942 }
14943
14944 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14945    returned otherwise.  */
14946
14947 static int
14948 labeled_block_contains_loop_p (tree block, tree loop)
14949 {
14950   if (!block)
14951     return 0;
14952
14953   if (LABELED_BLOCK_BODY (block) == loop)
14954     return 1;
14955
14956   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
14957     return 1;
14958
14959   return 0;
14960 }
14961
14962 /* If the loop isn't surrounded by a labeled statement, create one and
14963    insert LOOP as its body.  */
14964
14965 static tree
14966 patch_loop_statement (tree loop)
14967 {
14968   tree loop_label;
14969
14970   TREE_TYPE (loop) = void_type_node;
14971   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14972     return loop;
14973
14974   loop_label = build_labeled_block (0, NULL_TREE);
14975   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14976      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
14977   LABELED_BLOCK_BODY (loop_label) = loop;
14978   PUSH_LABELED_BLOCK (loop_label);
14979   return loop_label;
14980 }
14981
14982 /* 14.13, 14.14: break and continue Statements */
14983
14984 /* Build a break or a continue statement. a null NAME indicates an
14985    unlabeled break/continue statement.  */
14986
14987 static tree
14988 build_bc_statement (int location, int is_break, tree name)
14989 {
14990   tree break_continue, label_block_expr = NULL_TREE;
14991
14992   if (name)
14993     {
14994       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
14995             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
14996         /* Null means that we don't have a target for this named
14997            break/continue. In this case, we make the target to be the
14998            label name, so that the error can be reported accurately in
14999            patch_bc_statement. */
15000         label_block_expr = EXPR_WFL_NODE (name);
15001     }
15002   /* Unlabeled break/continue will be handled during the
15003      break/continue patch operation */
15004   break_continue = build2 (EXIT_BLOCK_EXPR, NULL_TREE,
15005                            label_block_expr, NULL_TREE);
15006
15007   IS_BREAK_STMT_P (break_continue) = is_break;
15008   TREE_SIDE_EFFECTS (break_continue) = 1;
15009   EXPR_WFL_LINECOL (break_continue) = location;
15010   break_continue = build_debugable_stmt (location, break_continue);
15011   return break_continue;
15012 }
15013
15014 /* Verification of a break/continue statement. */
15015
15016 static tree
15017 patch_bc_statement (tree node)
15018 {
15019   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15020   tree labeled_block = ctxp->current_labeled_block;
15021   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15022
15023   /* Having an identifier here means that the target is unknown. */
15024   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15025     {
15026       parse_error_context (wfl_operator, "No label definition found for `%s'",
15027                            IDENTIFIER_POINTER (bc_label));
15028       return error_mark_node;
15029     }
15030   if (! IS_BREAK_STMT_P (node))
15031     {
15032       /* It's a continue statement. */
15033       for (;; labeled_block = TREE_CHAIN (labeled_block))
15034         {
15035           if (labeled_block == NULL_TREE)
15036             {
15037               if (bc_label == NULL_TREE)
15038                 parse_error_context (wfl_operator,
15039                                      "`continue' must be in loop");
15040               else
15041                 parse_error_context
15042                   (wfl_operator, "continue label `%s' does not name a loop",
15043                    IDENTIFIER_POINTER (bc_label));
15044               return error_mark_node;
15045             }
15046           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15047                == continue_identifier_node)
15048               && (bc_label == NULL_TREE
15049                   || TREE_CHAIN (labeled_block) == bc_label))
15050             {
15051               bc_label = labeled_block;
15052               break;
15053             }
15054         }
15055     }
15056   else if (!bc_label)
15057     {
15058       for (;; labeled_block = TREE_CHAIN (labeled_block))
15059         {
15060           if (labeled_block == NULL_TREE)
15061             {
15062               parse_error_context (wfl_operator,
15063                                      "`break' must be in loop or switch");
15064               return error_mark_node;
15065             }
15066           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15067           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15068               || search_loop (target_stmt))
15069             {
15070               bc_label = labeled_block;
15071               break;
15072             }
15073         }
15074     }
15075
15076   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15077   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15078
15079   /* Our break/continue don't return values. */
15080   TREE_TYPE (node) = void_type_node;
15081   /* Encapsulate the break within a compound statement so that it's
15082      expanded all the times by expand_expr (and not clobbered
15083      sometimes, like after a if statement) */
15084   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15085   TREE_SIDE_EFFECTS (node) = 1;
15086   return node;
15087 }
15088
15089 /* Process the exit expression belonging to a loop. Its type must be
15090    boolean.  */
15091
15092 static tree
15093 patch_exit_expr (tree node)
15094 {
15095   tree expression = TREE_OPERAND (node, 0);
15096   TREE_TYPE (node) = error_mark_node;
15097   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15098
15099   /* The type of expression must be boolean */
15100   if (TREE_TYPE (expression) != boolean_type_node)
15101     {
15102       parse_error_context
15103         (wfl_operator,
15104     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15105          lang_printable_name (TREE_TYPE (expression), 0));
15106       return error_mark_node;
15107     }
15108   /* Now we know things are allright, invert the condition, fold and
15109      return */
15110   TREE_OPERAND (node, 0) =
15111     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15112
15113   if (! integer_zerop (TREE_OPERAND (node, 0))
15114       && ctxp->current_loop != NULL_TREE
15115       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15116     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15117   if (! integer_onep (TREE_OPERAND (node, 0)))
15118     CAN_COMPLETE_NORMALLY (node) = 1;
15119
15120
15121   TREE_TYPE (node) = void_type_node;
15122   return node;
15123 }
15124
15125 /* 14.9 Switch statement */
15126
15127 static tree
15128 patch_switch_statement (tree node)
15129 {
15130   tree se = TREE_OPERAND (node, 0), se_type;
15131   tree save, iter;
15132
15133   /* Complete the switch expression */
15134   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15135   se_type = TREE_TYPE (se);
15136   /* The type of the switch expression must be char, byte, short or
15137      int */
15138   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15139     {
15140       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15141       parse_error_context (wfl_operator,
15142           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15143                            lang_printable_name (se_type, 0));
15144       /* This is what java_complete_tree will check */
15145       TREE_OPERAND (node, 0) = error_mark_node;
15146       return error_mark_node;
15147     }
15148
15149   /* Save and restore the outer case label list.  */
15150   save = case_label_list;
15151   case_label_list = NULL_TREE;
15152
15153   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15154
15155   /* See if we've found a duplicate label.  We can't leave this until
15156      code generation, because in `--syntax-only' and `-C' modes we
15157      don't do ordinary code generation.  */
15158   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15159     {
15160       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15161       tree subiter;
15162       for (subiter = TREE_CHAIN (iter);
15163            subiter != NULL_TREE;
15164            subiter = TREE_CHAIN (subiter))
15165         {
15166           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15167           if (val == subval)
15168             {
15169               EXPR_WFL_LINECOL (wfl_operator)
15170                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15171               /* The case_label_list is in reverse order, so print the
15172                  outer label first.  */
15173               parse_error_context (wfl_operator, "duplicate case label: `"
15174                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15175               EXPR_WFL_LINECOL (wfl_operator)
15176                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15177               parse_error_context (wfl_operator, "original label is here");
15178
15179               break;
15180             }
15181         }
15182     }
15183
15184   case_label_list = save;
15185
15186   /* Ready to return */
15187   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15188     {
15189       TREE_TYPE (node) = error_mark_node;
15190       return error_mark_node;
15191     }
15192   TREE_TYPE (node) = void_type_node;
15193   TREE_SIDE_EFFECTS (node) = 1;
15194   CAN_COMPLETE_NORMALLY (node)
15195     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15196       || ! SWITCH_HAS_DEFAULT (node);
15197   return node;
15198 }
15199
15200 /* Assertions.  */
15201
15202 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15203    might be NULL_TREE.  */
15204 static tree
15205 build_assertion (int location, tree condition, tree value)
15206 {
15207   tree node;
15208   tree klass = GET_CPC ();
15209
15210   if (! enable_assertions (klass))
15211     {
15212       condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15213                           boolean_false_node, condition);
15214       if (value == NULL_TREE)
15215         value = build_java_empty_stmt ();
15216       return build_if_else_statement (location, condition,
15217                                       value, NULL_TREE);
15218     }
15219
15220   if (! CLASS_USES_ASSERTIONS (klass))
15221     {
15222       tree field, classdollar, id, call;
15223       tree class_type = TREE_TYPE (klass);
15224
15225       field = add_field (class_type,
15226                          get_identifier ("$assertionsDisabled"),
15227                          boolean_type_node,
15228                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15229       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15230       FIELD_SYNTHETIC (field) = 1;
15231
15232       classdollar = build_incomplete_class_ref (location, class_type);
15233
15234       /* Call CLASS.desiredAssertionStatus().  */
15235       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15236       call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15237       call = make_qualified_primary (classdollar, call, location);
15238       TREE_SIDE_EFFECTS (call) = 1;
15239
15240       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15241          seem odd, but we do it to generate code identical to that of
15242          the JDK.  */
15243       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15244       TREE_SIDE_EFFECTS (call) = 1;
15245       DECL_INITIAL (field) = call;
15246
15247       /* Record the initializer in the initializer statement list.  */
15248       call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15249       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15250       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15251       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15252
15253       CLASS_USES_ASSERTIONS (klass) = 1;
15254     }
15255
15256   if (value != NULL_TREE)
15257     value = tree_cons (NULL_TREE, value, NULL_TREE);
15258
15259   node = build_wfl_node (get_identifier ("java"));
15260   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15261                               location);
15262   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15263                               location);
15264
15265   node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15266   TREE_SIDE_EFFECTS (node) = 1;
15267   /* It is too early to use BUILD_THROW.  */
15268   node = build1 (THROW_EXPR, NULL_TREE, node);
15269   TREE_SIDE_EFFECTS (node) = 1;
15270
15271   /* We invert the condition; if we just put NODE as the `else' part
15272      then we generate weird-looking bytecode.  */
15273   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15274   /* Check $assertionsDisabled.  */
15275   condition
15276     = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15277               build1 (TRUTH_NOT_EXPR, NULL_TREE,
15278                       build_wfl_node (get_identifier ("$assertionsDisabled"))),
15279               condition);
15280   node = build_if_else_statement (location, condition, node, NULL_TREE);
15281   return node;
15282 }
15283
15284 /* 14.18 The try/catch statements */
15285
15286 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15287    catches TYPE and executes CATCH_STMTS.  */
15288
15289 static tree
15290 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15291                             tree catch_stmts)
15292 {
15293   tree try_block, catch_clause_param, catch_block, catch;
15294
15295   /* First build a try block */
15296   try_block = build_expr_block (try_stmts, NULL_TREE);
15297
15298   /* Build a catch block: we need a catch clause parameter */
15299   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15300     {
15301       tree catch_type = obtain_incomplete_type (type_or_name);
15302       jdep *dep;
15303       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15304       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15305                                 catch_clause_param, catch_type);
15306       dep = CLASSD_LAST (ctxp->classd_list);
15307       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15308     }
15309   else
15310     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15311                                      build_pointer_type (type_or_name));
15312
15313   /* And a block */
15314   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15315
15316   /* Initialize the variable and store in the block */
15317   catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15318                   build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15319   add_stmt_to_block (catch_block, NULL_TREE, catch);
15320
15321   /* Add the catch statements */
15322   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15323
15324   /* Now we can build a JAVA_CATCH_EXPR */
15325   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15326
15327   return build_try_statement (location, try_block, catch_block);
15328 }
15329
15330 static tree
15331 build_try_statement (int location, tree try_block, tree catches)
15332 {
15333   tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15334   EXPR_WFL_LINECOL (node) = location;
15335   return node;
15336 }
15337
15338 static tree
15339 build_try_finally_statement (int location, tree try_block, tree finally)
15340 {
15341   tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15342   EXPR_WFL_LINECOL (node) = location;
15343   return node;
15344 }
15345
15346 static tree
15347 patch_try_statement (tree node)
15348 {
15349   int error_found = 0;
15350   tree try = TREE_OPERAND (node, 0);
15351   /* Exception handlers are considered in left to right order */
15352   tree catch = nreverse (TREE_OPERAND (node, 1));
15353   tree current, caught_type_list = NULL_TREE;
15354
15355   /* Check catch clauses, if any. Every time we find an error, we try
15356      to process the next catch clause. We process the catch clause before
15357      the try block so that when processing the try block we can check thrown
15358      exceptions againts the caught type list. */
15359   for (current = catch; current; current = TREE_CHAIN (current))
15360     {
15361       tree carg_decl, carg_type;
15362       tree sub_current, catch_block, catch_clause;
15363       int unreachable;
15364
15365       /* At this point, the structure of the catch clause is
15366            JAVA_CATCH_EXPR              (catch node)
15367              BLOCK              (with the decl of the parameter)
15368                COMPOUND_EXPR
15369                  MODIFY_EXPR   (assignment of the catch parameter)
15370                  BLOCK          (catch clause block)
15371        */
15372       catch_clause = TREE_OPERAND (current, 0);
15373       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15374       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15375
15376       /* Catch clauses can't have more than one parameter declared,
15377          but it's already enforced by the grammar. Make sure that the
15378          only parameter of the clause statement in of class Throwable
15379          or a subclass of Throwable, but that was done earlier. The
15380          catch clause parameter type has also been resolved. */
15381
15382       /* Just make sure that the catch clause parameter type inherits
15383          from java.lang.Throwable */
15384       if (!inherits_from_p (carg_type, throwable_type_node))
15385         {
15386           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15387           parse_error_context (wfl_operator,
15388                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15389                                lang_printable_name (carg_type, 0));
15390           error_found = 1;
15391           continue;
15392         }
15393
15394       /* Partial check for unreachable catch statement: The catch
15395          clause is reachable iff is no earlier catch block A in
15396          the try statement such that the type of the catch
15397          clause's parameter is the same as or a subclass of the
15398          type of A's parameter */
15399       unreachable = 0;
15400       for (sub_current = catch;
15401            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15402         {
15403           tree sub_catch_clause, decl;
15404           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15405           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15406
15407           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15408             {
15409               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15410               parse_error_context
15411                 (wfl_operator,
15412                  "`catch' not reached because of the catch clause at line %d",
15413                  EXPR_WFL_LINENO (sub_current));
15414               unreachable = error_found = 1;
15415               break;
15416             }
15417         }
15418       /* Complete the catch clause block */
15419       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15420       if (catch_block == error_mark_node)
15421         {
15422           error_found = 1;
15423           continue;
15424         }
15425       if (CAN_COMPLETE_NORMALLY (catch_block))
15426         CAN_COMPLETE_NORMALLY (node) = 1;
15427       TREE_OPERAND (current, 0) = catch_block;
15428
15429       if (unreachable)
15430         continue;
15431
15432       /* Things to do here: the exception must be thrown */
15433
15434       /* Link this type to the caught type list */
15435       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15436     }
15437
15438   PUSH_EXCEPTIONS (caught_type_list);
15439   if ((try = java_complete_tree (try)) == error_mark_node)
15440     error_found = 1;
15441   if (CAN_COMPLETE_NORMALLY (try))
15442     CAN_COMPLETE_NORMALLY (node) = 1;
15443   POP_EXCEPTIONS ();
15444
15445   /* Verification ends here */
15446   if (error_found)
15447     return error_mark_node;
15448
15449   TREE_OPERAND (node, 0) = try;
15450   TREE_OPERAND (node, 1) = catch;
15451   TREE_TYPE (node) = void_type_node;
15452   return node;
15453 }
15454
15455 /* 14.17 The synchronized Statement */
15456
15457 static tree
15458 patch_synchronized_statement (tree node, tree wfl_op1)
15459 {
15460   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15461   tree block = TREE_OPERAND (node, 1);
15462
15463   tree tmp, enter, exit, expr_decl, assignment;
15464
15465   if (expr == error_mark_node)
15466     {
15467       block = java_complete_tree (block);
15468       return expr;
15469     }
15470
15471   /* We might be trying to synchronize on a STRING_CST */
15472   if ((tmp = patch_string (expr)))
15473     expr = tmp;
15474
15475   /* The TYPE of expr must be a reference type */
15476   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15477     {
15478       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15479       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15480                            lang_printable_name (TREE_TYPE (expr), 0));
15481       return error_mark_node;
15482     }
15483
15484   if (flag_emit_xref)
15485     {
15486       TREE_OPERAND (node, 0) = expr;
15487       TREE_OPERAND (node, 1) = java_complete_tree (block);
15488       CAN_COMPLETE_NORMALLY (node) = 1;
15489       return node;
15490     }
15491
15492   /* Generate a try-finally for the synchronized statement, except
15493      that the handler that catches all throw exception calls
15494      _Jv_MonitorExit and then rethrow the exception.
15495      The synchronized statement is then implemented as:
15496      TRY
15497        {
15498          _Jv_MonitorEnter (expression)
15499          synchronized_block
15500          _Jv_MonitorExit (expression)
15501        }
15502      CATCH_ALL
15503        {
15504          e = _Jv_exception_info ();
15505          _Jv_MonitorExit (expression)
15506          Throw (e);
15507        } */
15508
15509   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15510   BUILD_MONITOR_ENTER (enter, expr_decl);
15511   BUILD_MONITOR_EXIT (exit, expr_decl);
15512   CAN_COMPLETE_NORMALLY (enter) = 1;
15513   CAN_COMPLETE_NORMALLY (exit) = 1;
15514   assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15515   TREE_SIDE_EFFECTS (assignment) = 1;
15516   node = build2 (COMPOUND_EXPR, NULL_TREE,
15517                  build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15518                  build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15519   node = build_expr_block (node, expr_decl);
15520
15521   return java_complete_tree (node);
15522 }
15523
15524 /* 14.16 The throw Statement */
15525
15526 static tree
15527 patch_throw_statement (tree node, tree wfl_op1)
15528 {
15529   tree expr = TREE_OPERAND (node, 0);
15530   tree type = TREE_TYPE (expr);
15531   int unchecked_ok = 0, tryblock_throws_ok = 0;
15532
15533   /* Thrown expression must be assignable to java.lang.Throwable */
15534   if (!try_reference_assignconv (throwable_type_node, expr))
15535     {
15536       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15537       parse_error_context (wfl_operator,
15538     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15539                            lang_printable_name (type, 0));
15540       /* If the thrown expression was a reference, we further the
15541          compile-time check. */
15542       if (!JREFERENCE_TYPE_P (type))
15543         return error_mark_node;
15544     }
15545
15546   /* At least one of the following must be true */
15547
15548   /* The type of the throw expression is a not checked exception,
15549      i.e. is a unchecked expression. */
15550   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15551
15552   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15553   /* An instance can't throw a checked exception unless that exception
15554      is explicitly declared in the `throws' clause of each
15555      constructor. This doesn't apply to anonymous classes, since they
15556      don't have declared constructors. */
15557   if (!unchecked_ok
15558       && DECL_INSTINIT_P (current_function_decl)
15559       && !ANONYMOUS_CLASS_P (current_class))
15560     {
15561       tree current;
15562       for (current = TYPE_METHODS (current_class); current;
15563            current = TREE_CHAIN (current))
15564         if (DECL_CONSTRUCTOR_P (current)
15565             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15566           {
15567             parse_error_context (wfl_operator, "Checked exception `%s' can't be thrown in instance initializer (not all declared constructor are declaring it in their `throws' clause)",
15568                                  lang_printable_name (TREE_TYPE (expr), 0));
15569             return error_mark_node;
15570           }
15571     }
15572
15573   /* Throw is contained in a try statement and at least one catch
15574      clause can receive the thrown expression or the current method is
15575      declared to throw such an exception. Or, the throw statement is
15576      contained in a method or constructor declaration and the type of
15577      the Expression is assignable to at least one type listed in the
15578      throws clause the declaration. */
15579   if (!unchecked_ok)
15580     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15581   if (!(unchecked_ok || tryblock_throws_ok))
15582     {
15583       /* If there is a surrounding try block that has no matching
15584          clatch clause, report it first. A surrounding try block exits
15585          only if there is something after the list of checked
15586          exception thrown by the current function (if any). */
15587       if (IN_TRY_BLOCK_P ())
15588         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15589                              lang_printable_name (type, 0));
15590       /* If we have no surrounding try statement and the method doesn't have
15591          any throws, report it now. FIXME */
15592
15593       /* We report that the exception can't be throw from a try block
15594          in all circumstances but when the `throw' is inside a static
15595          block. */
15596       else if (!EXCEPTIONS_P (currently_caught_type_list)
15597                && !tryblock_throws_ok)
15598         {
15599           if (DECL_CLINIT_P (current_function_decl))
15600             parse_error_context (wfl_operator,
15601                    "Checked exception `%s' can't be thrown in initializer",
15602                                  lang_printable_name (type, 0));
15603           else
15604             parse_error_context (wfl_operator,
15605                    "Checked exception `%s' isn't thrown from a `try' block",
15606                                  lang_printable_name (type, 0));
15607         }
15608       /* Otherwise, the current method doesn't have the appropriate
15609          throws declaration */
15610       else
15611         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15612                              lang_printable_name (type, 0));
15613       return error_mark_node;
15614     }
15615
15616   if (! flag_emit_class_files && ! flag_emit_xref)
15617     BUILD_THROW (node, expr);
15618
15619   /* If doing xrefs, keep the location where the `throw' was seen. */
15620   if (flag_emit_xref)
15621     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15622   return node;
15623 }
15624
15625 /* Check that exception said to be thrown by method DECL can be
15626    effectively caught from where DECL is invoked.  THIS_EXPR is the
15627    expression that computes `this' for the method call.  */
15628 static void
15629 check_thrown_exceptions (int location, tree decl, tree this_expr)
15630 {
15631   tree throws;
15632   int is_array_call = 0;
15633
15634   /* Skip check within generated methods, such as access$<n>.  */
15635   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15636     return;
15637
15638   if (this_expr != NULL_TREE
15639       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15640       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15641     is_array_call = 1;
15642
15643   /* For all the unchecked exceptions thrown by DECL.  */
15644   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15645        throws = TREE_CHAIN (throws))
15646     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15647       {
15648         /* Suppress errors about cloning arrays.  */
15649         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15650           continue;
15651
15652         EXPR_WFL_LINECOL (wfl_operator) = location;
15653         if (DECL_FINIT_P (current_function_decl))
15654           parse_error_context
15655             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15656              lang_printable_name (TREE_VALUE (throws), 0));
15657         else
15658           {
15659             parse_error_context
15660               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15661                lang_printable_name (TREE_VALUE (throws), 0),
15662                (DECL_INIT_P (current_function_decl) ?
15663                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15664                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15665           }
15666       }
15667 }
15668
15669 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15670    try-catch blocks, OR is listed in the `throws' clause of the
15671    current method.  */
15672
15673 static int
15674 check_thrown_exceptions_do (tree exception)
15675 {
15676   tree list = currently_caught_type_list;
15677   resolve_and_layout (exception, NULL_TREE);
15678   /* First, all the nested try-catch-finally at that stage. The
15679      last element contains `throws' clause exceptions, if any. */
15680   if (IS_UNCHECKED_EXCEPTION_P (exception))
15681     return 1;
15682   while (list)
15683     {
15684       tree caught;
15685       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15686         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15687           return 1;
15688       list = TREE_CHAIN (list);
15689     }
15690   return 0;
15691 }
15692
15693 static void
15694 purge_unchecked_exceptions (tree mdecl)
15695 {
15696   tree throws = DECL_FUNCTION_THROWS (mdecl);
15697   tree new = NULL_TREE;
15698
15699   while (throws)
15700     {
15701       tree next = TREE_CHAIN (throws);
15702       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15703         {
15704           TREE_CHAIN (throws) = new;
15705           new = throws;
15706         }
15707       throws = next;
15708     }
15709   /* List is inverted here, but it doesn't matter */
15710   DECL_FUNCTION_THROWS (mdecl) = new;
15711 }
15712
15713 /* This function goes over all of CLASS_TYPE ctors and checks whether
15714    each of them features at least one unchecked exception in its
15715    `throws' clause. If it's the case, it returns `true', `false'
15716    otherwise.  */
15717
15718 static bool
15719 ctors_unchecked_throws_clause_p (tree class_type)
15720 {
15721   tree current;
15722
15723   for (current = TYPE_METHODS (class_type); current;
15724        current = TREE_CHAIN (current))
15725     {
15726       bool ctu = false; /* Ctor Throws Unchecked */
15727       if (DECL_CONSTRUCTOR_P (current))
15728         {
15729           tree throws;
15730           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15731                throws = TREE_CHAIN (throws))
15732             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15733               ctu = true;
15734         }
15735       /* We return false as we found one ctor that is unfit. */
15736       if (!ctu && DECL_CONSTRUCTOR_P (current))
15737         return false;
15738     }
15739   /* All ctors feature at least one unchecked exception in their
15740      `throws' clause. */
15741   return true;
15742 }
15743
15744 /* 15.24 Conditional Operator ?: */
15745
15746 static tree
15747 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15748 {
15749   tree cond = TREE_OPERAND (node, 0);
15750   tree op1 = TREE_OPERAND (node, 1);
15751   tree op2 = TREE_OPERAND (node, 2);
15752   tree resulting_type = NULL_TREE;
15753   tree t1, t2, patched;
15754   int error_found = 0;
15755
15756   /* Operands of ?: might be StringBuffers crafted as a result of a
15757      string concatenation. Obtain a descent operand here.  */
15758   if ((patched = patch_string (op1)))
15759     TREE_OPERAND (node, 1) = op1 = patched;
15760   if ((patched = patch_string (op2)))
15761     TREE_OPERAND (node, 2) = op2 = patched;
15762
15763   t1 = TREE_TYPE (op1);
15764   t2 = TREE_TYPE (op2);
15765
15766   /* The first expression must be a boolean */
15767   if (TREE_TYPE (cond) != boolean_type_node)
15768     {
15769       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15770       parse_error_context (wfl_operator,
15771                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15772                            lang_printable_name (TREE_TYPE (cond), 0));
15773       error_found = 1;
15774     }
15775
15776   /* Second and third can be numeric, boolean (i.e. primitive),
15777      references or null. Anything else results in an error */
15778   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15779         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15780             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15781         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15782     error_found = 1;
15783
15784   /* Determine the type of the conditional expression. Same types are
15785      easy to deal with */
15786   else if (t1 == t2)
15787     resulting_type = t1;
15788
15789   /* There are different rules for numeric types */
15790   else if (JNUMERIC_TYPE_P (t1))
15791     {
15792       /* if byte/short found, the resulting type is short */
15793       if ((t1 == byte_type_node && t2 == short_type_node)
15794           || (t1 == short_type_node && t2 == byte_type_node))
15795         resulting_type = short_type_node;
15796
15797       /* If t1 is a constant int and t2 is of type byte, short or char
15798          and t1's value fits in t2, then the resulting type is t2 */
15799       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15800           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15801         resulting_type = t2;
15802
15803       /* If t2 is a constant int and t1 is of type byte, short or char
15804          and t2's value fits in t1, then the resulting type is t1 */
15805       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15806           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15807         resulting_type = t1;
15808
15809       /* Otherwise, binary numeric promotion is applied and the
15810          resulting type is the promoted type of operand 1 and 2 */
15811       else
15812         resulting_type = binary_numeric_promotion (t1, t2,
15813                                                    &TREE_OPERAND (node, 1),
15814                                                    &TREE_OPERAND (node, 2));
15815     }
15816
15817   /* Cases of a reference and a null type */
15818   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15819     resulting_type = t1;
15820
15821   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15822     resulting_type = t2;
15823
15824   /* Last case: different reference types. If a type can be converted
15825      into the other one by assignment conversion, the latter
15826      determines the type of the expression */
15827   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15828     resulting_type = promote_type (t1);
15829
15830   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15831     resulting_type = promote_type (t2);
15832
15833   /* If we don't have any resulting type, we're in trouble */
15834   if (!resulting_type)
15835     {
15836       char *t = xstrdup (lang_printable_name (t1, 0));
15837       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15838       parse_error_context (wfl_operator,
15839                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15840                            t, lang_printable_name (t2, 0));
15841       free (t);
15842       error_found = 1;
15843     }
15844
15845   if (error_found)
15846     {
15847       TREE_TYPE (node) = error_mark_node;
15848       return error_mark_node;
15849     }
15850
15851   TREE_TYPE (node) = resulting_type;
15852   TREE_SET_CODE (node, COND_EXPR);
15853   CAN_COMPLETE_NORMALLY (node) = 1;
15854   return node;
15855 }
15856
15857 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15858
15859 static tree
15860 maybe_build_class_init_for_field (tree decl, tree expr)
15861 {
15862   tree clas = DECL_CONTEXT (decl);
15863   if (flag_emit_class_files || flag_emit_xref)
15864     return expr;
15865
15866   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15867       && FIELD_FINAL (decl))
15868     {
15869       tree init = DECL_INITIAL (decl);
15870       if (init != NULL_TREE)
15871         init = fold_constant_for_init (init, decl);
15872       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15873         return expr;
15874     }
15875
15876   return build_class_init (clas, expr);
15877 }
15878
15879 /* Try to constant fold NODE.
15880    If NODE is not a constant expression, return NULL_EXPR.
15881    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15882
15883 static tree
15884 fold_constant_for_init (tree node, tree context)
15885 {
15886   tree op0, op1, val;
15887   enum tree_code code = TREE_CODE (node);
15888
15889   switch (code)
15890     {
15891     case INTEGER_CST:
15892       if (node == null_pointer_node)
15893         return NULL_TREE;
15894     case STRING_CST:
15895     case REAL_CST:
15896       return node;
15897
15898     case PLUS_EXPR:
15899     case MINUS_EXPR:
15900     case MULT_EXPR:
15901     case TRUNC_MOD_EXPR:
15902     case RDIV_EXPR:
15903     case LSHIFT_EXPR:
15904     case RSHIFT_EXPR:
15905     case URSHIFT_EXPR:
15906     case BIT_AND_EXPR:
15907     case BIT_XOR_EXPR:
15908     case BIT_IOR_EXPR:
15909     case TRUTH_ANDIF_EXPR:
15910     case TRUTH_ORIF_EXPR:
15911     case EQ_EXPR:
15912     case NE_EXPR:
15913     case GT_EXPR:
15914     case GE_EXPR:
15915     case LT_EXPR:
15916     case LE_EXPR:
15917       op0 = TREE_OPERAND (node, 0);
15918       op1 = TREE_OPERAND (node, 1);
15919       val = fold_constant_for_init (op0, context);
15920       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15921         return NULL_TREE;
15922       TREE_OPERAND (node, 0) = val;
15923       val = fold_constant_for_init (op1, context);
15924       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15925         return NULL_TREE;
15926       TREE_OPERAND (node, 1) = val;
15927       return patch_binop (node, op0, op1);
15928
15929     case UNARY_PLUS_EXPR:
15930     case NEGATE_EXPR:
15931     case TRUTH_NOT_EXPR:
15932     case BIT_NOT_EXPR:
15933     case CONVERT_EXPR:
15934       op0 = TREE_OPERAND (node, 0);
15935       val = fold_constant_for_init (op0, context);
15936       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15937         return NULL_TREE;
15938       TREE_OPERAND (node, 0) = val;
15939       val = patch_unaryop (node, op0);
15940       if (! TREE_CONSTANT (val))
15941         return NULL_TREE;
15942       return val;
15943
15944       break;
15945
15946     case COND_EXPR:
15947       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
15948       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15949         return NULL_TREE;
15950       TREE_OPERAND (node, 0) = val;
15951       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
15952       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15953         return NULL_TREE;
15954       TREE_OPERAND (node, 1) = val;
15955       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
15956       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15957         return NULL_TREE;
15958       TREE_OPERAND (node, 2) = val;
15959       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
15960         : TREE_OPERAND (node, 2);
15961
15962     case VAR_DECL:
15963     case FIELD_DECL:
15964       if (! FIELD_FINAL (node)
15965           || DECL_INITIAL (node) == NULL_TREE)
15966         return NULL_TREE;
15967       val = DECL_INITIAL (node);
15968       /* Guard against infinite recursion. */
15969       DECL_INITIAL (node) = NULL_TREE;
15970       val = fold_constant_for_init (val, node);
15971       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
15972         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
15973       DECL_INITIAL (node) = val;
15974       return val;
15975
15976     case EXPR_WITH_FILE_LOCATION:
15977       /* Compare java_complete_tree and resolve_expression_name. */
15978       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
15979           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15980         {
15981           tree name = EXPR_WFL_NODE (node);
15982           tree decl;
15983           if (PRIMARY_P (node))
15984             return NULL_TREE;
15985           else if (! QUALIFIED_P (name))
15986             {
15987               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
15988               if (decl == NULL_TREE
15989                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
15990                 return NULL_TREE;
15991               return fold_constant_for_init (decl, decl);
15992             }
15993           else
15994             {
15995               tree r = NULL_TREE;
15996               /* Install the proper context for the field resolution.  */
15997               tree saved_current_class = current_class;
15998               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
15999               current_class = DECL_CONTEXT (context);
16000               qualify_ambiguous_name (node);
16001               r = resolve_field_access (node, &decl, NULL);
16002               /* Restore prior context.  */
16003               current_class = saved_current_class;
16004               if (r != error_mark_node && decl != NULL_TREE)
16005                 return fold_constant_for_init (decl, decl);
16006               return NULL_TREE;
16007             }
16008         }
16009       else
16010         {
16011           op0 = TREE_OPERAND (node, 0);
16012           val = fold_constant_for_init (op0, context);
16013           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16014             return NULL_TREE;
16015           TREE_OPERAND (node, 0) = val;
16016           return val;
16017         }
16018
16019 #ifdef USE_COMPONENT_REF
16020     case IDENTIFIER:
16021     case COMPONENT_REF:
16022       ?;
16023 #endif
16024
16025     default:
16026       return NULL_TREE;
16027     }
16028 }
16029
16030 #ifdef USE_COMPONENT_REF
16031 /* Context is 'T' for TypeName, 'P' for PackageName,
16032    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16033
16034 tree
16035 resolve_simple_name (tree name, int context)
16036 {
16037 }
16038
16039 tree
16040 resolve_qualified_name (tree name, int context)
16041 {
16042 }
16043 #endif
16044
16045 void
16046 init_src_parse (void)
16047 {
16048   /* Sanity check; we've been bit by this before.  */
16049   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16050     abort ();
16051 }
16052
16053 \f
16054
16055 /* This section deals with the functions that are called when tables
16056    recording class initialization information are traversed.  */
16057
16058 /* Attach to PTR (a block) the declaration found in ENTRY. */
16059
16060 static int
16061 attach_init_test_initialization_flags (void **entry, void *ptr)
16062 {
16063   tree block = (tree)ptr;
16064   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16065
16066   if (block != error_mark_node)
16067     {
16068       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16069       BLOCK_EXPR_DECLS (block) = ite->value;
16070     }
16071   return true;
16072 }
16073
16074 /* This function is called for each class that is known definitely
16075    initialized when a given static method was called. This function
16076    augments a compound expression (INFO) storing all assignment to
16077    initialized static class flags if a flag already existed, otherwise
16078    a new one is created.  */
16079
16080 static int
16081 emit_test_initialization (void **entry_p, void *info)
16082 {
16083   tree l = (tree) info;
16084   tree decl, init;
16085   tree key = (tree) *entry_p;
16086   tree *ite;
16087   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16088
16089   /* If we haven't found a flag and we're dealing with self registered
16090      with current_function_decl, then don't do anything. Self is
16091      always added as definitely initialized but this information is
16092      valid only if used outside the current function. */
16093   if (current_function_decl == TREE_PURPOSE (l)
16094       && java_treetreehash_find (cf_ht, key) == NULL)
16095     return true;
16096
16097   ite = java_treetreehash_new (cf_ht, key);
16098
16099   /* If we don't have a variable, create one and install it. */
16100   if (*ite == NULL)
16101     {
16102       tree block;
16103
16104       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16105       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16106       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16107       DECL_CONTEXT (decl) = current_function_decl;
16108       DECL_INITIAL (decl) = boolean_true_node;
16109       /* Don't emit any symbolic debugging info for this decl.  */
16110       DECL_IGNORED_P (decl) = 1;
16111
16112       /* The trick is to find the right context for it. */
16113       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16114       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16115       BLOCK_EXPR_DECLS (block) = decl;
16116       *ite = decl;
16117     }
16118   else
16119     decl = *ite;
16120
16121   /* Now simply augment the compound that holds all the assignments
16122      pertaining to this method invocation. */
16123   init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16124   TREE_SIDE_EFFECTS (init) = 1;
16125   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16126   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16127
16128   return true;
16129 }
16130
16131 #include "gt-java-parse.h"
16132 #include "gtype-java.h"