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 (PURE_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 (PURE_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       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11651       if (TREE_OPERAND (node, 2) == error_mark_node)
11652         return error_mark_node;
11653       return patch_if_else_statement (node);
11654       break;
11655
11656     case CONDITIONAL_EXPR:
11657       /* Condition */
11658       wfl_op1 = TREE_OPERAND (node, 0);
11659       COMPLETE_CHECK_OP_0 (node);
11660       wfl_op2 = TREE_OPERAND (node, 1);
11661       COMPLETE_CHECK_OP_1 (node);
11662       wfl_op3 = TREE_OPERAND (node, 2);
11663       COMPLETE_CHECK_OP_2 (node);
11664       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11665
11666       /* 3- Expression section */
11667     case COMPOUND_EXPR:
11668       wfl_op2 = TREE_OPERAND (node, 1);
11669       TREE_OPERAND (node, 0) = nn =
11670         java_complete_tree (TREE_OPERAND (node, 0));
11671       if (IS_EMPTY_STMT (wfl_op2))
11672         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11673       else
11674         {
11675           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11676             {
11677               /* An unreachable condition in a do-while statement
11678                  is *not* (technically) an unreachable statement. */
11679               nn = wfl_op2;
11680               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11681                 nn = EXPR_WFL_NODE (nn);
11682               /* NN can be NULL_TREE exactly when UPDATE is, in
11683                  finish_for_loop.  */
11684               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11685                 {
11686                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11687                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11688                     {
11689                       /* Perhaps this warning should have an
11690                          associated flag.  The code being compiled is
11691                          pedantically correct, but useless.  */
11692                       parse_warning_context (wfl_operator,
11693                                              "Unreachable statement");
11694                     }
11695                   else
11696                     parse_error_context (wfl_operator,
11697                                          "Unreachable statement");
11698                 }
11699             }
11700           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11701           if (TREE_OPERAND (node, 1) == error_mark_node)
11702             return error_mark_node;
11703           /* Even though we might allow the case where the first
11704              operand doesn't return normally, we still should compute
11705              CAN_COMPLETE_NORMALLY correctly.  */
11706           CAN_COMPLETE_NORMALLY (node)
11707             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11708                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11709         }
11710       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11711       break;
11712
11713     case RETURN_EXPR:
11714       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11715       return patch_return (node);
11716
11717     case EXPR_WITH_FILE_LOCATION:
11718       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11719           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11720         {
11721           tree wfl = node;
11722           node = resolve_expression_name (node, NULL);
11723           if (node == error_mark_node)
11724             return node;
11725           /* Keep line number information somewhere were it doesn't
11726              disrupt the completion process. */
11727           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11728             {
11729               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11730               TREE_OPERAND (node, 1) = wfl;
11731             }
11732           CAN_COMPLETE_NORMALLY (node) = 1;
11733         }
11734       else
11735         {
11736           tree body;
11737           int save_lineno = input_line;
11738           input_line = EXPR_WFL_LINENO (node);
11739           body = java_complete_tree (EXPR_WFL_NODE (node));
11740           input_line = save_lineno;
11741           EXPR_WFL_NODE (node) = body;
11742           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11743           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11744           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11745             {
11746               /* Makes it easier to constant fold, detect empty bodies. */
11747               return body;
11748             }
11749           if (body == error_mark_node)
11750             {
11751               /* Its important for the evaluation of assignment that
11752                  this mark on the TREE_TYPE is propagated. */
11753               TREE_TYPE (node) = error_mark_node;
11754               return error_mark_node;
11755             }
11756           else
11757             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11758
11759         }
11760       break;
11761
11762     case NEW_ARRAY_EXPR:
11763       /* Patch all the dimensions */
11764       flag = 0;
11765       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11766         {
11767           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11768           tree dim = convert (int_type_node,
11769                               java_complete_tree (TREE_VALUE (cn)));
11770           if (dim == error_mark_node)
11771             {
11772               flag = 1;
11773               continue;
11774             }
11775           else
11776             {
11777               TREE_VALUE (cn) = dim;
11778               /* Setup the location of the current dimension, for
11779                  later error report. */
11780               TREE_PURPOSE (cn) =
11781                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11782               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11783             }
11784         }
11785       /* They complete the array creation expression, if no errors
11786          were found. */
11787       CAN_COMPLETE_NORMALLY (node) = 1;
11788       return (flag ? error_mark_node
11789               : force_evaluation_order (patch_newarray (node)));
11790
11791     case NEW_ANONYMOUS_ARRAY_EXPR:
11792       /* Create the array type if necessary. */
11793       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11794         {
11795           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11796           if (!(type = resolve_type_during_patch (type)))
11797             return error_mark_node;
11798           type = build_array_from_name (type, NULL_TREE,
11799                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11800           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11801         }
11802       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11803                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11804       if (node == error_mark_node)
11805         return error_mark_node;
11806       CAN_COMPLETE_NORMALLY (node) = 1;
11807       return node;
11808
11809     case NEW_CLASS_EXPR:
11810     case CALL_EXPR:
11811       /* Complete function's argument(s) first */
11812       if (complete_function_arguments (node))
11813         return error_mark_node;
11814       else
11815         {
11816           tree decl, wfl = TREE_OPERAND (node, 0);
11817           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11818           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11819                            super_identifier_node);
11820           tree arguments;
11821           int location = EXPR_WFL_LINECOL (node);
11822
11823           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11824                                           from_super, 0, &decl);
11825           if (node == error_mark_node)
11826             return error_mark_node;
11827
11828           if (TREE_CODE (node) == CALL_EXPR
11829               && TREE_OPERAND (node, 1) != NULL_TREE)
11830             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11831           else
11832             arguments = NULL_TREE;
11833           check_thrown_exceptions (location, decl, arguments);
11834           /* If we call this(...), register signature and positions */
11835           if (in_this)
11836             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11837               tree_cons (wfl, decl,
11838                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11839           CAN_COMPLETE_NORMALLY (node) = 1;
11840           return force_evaluation_order (node);
11841         }
11842
11843     case MODIFY_EXPR:
11844       /* Save potential wfls */
11845       wfl_op1 = TREE_OPERAND (node, 0);
11846       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11847
11848       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11849           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11850           && DECL_INITIAL (nn) != NULL_TREE)
11851         {
11852           tree value;
11853
11854           value = fold_constant_for_init (nn, nn);
11855
11856           /* When we have a primitype type, or a string and we're not
11857              emitting a class file, we actually don't want to generate
11858              anything for the assignment. */
11859           if (value != NULL_TREE &&
11860               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11861                (TREE_TYPE (value) == string_ptr_type_node &&
11862                 ! flag_emit_class_files)))
11863             {
11864               /* Prepare node for patch_assignment */
11865               TREE_OPERAND (node, 1) = value;
11866               /* Call patch assignment to verify the assignment */
11867               if (patch_assignment (node, wfl_op1) == error_mark_node)
11868                 return error_mark_node;
11869               /* Set DECL_INITIAL properly (a conversion might have
11870                  been decided by patch_assignment) and return the
11871                  empty statement. */
11872               else
11873                 {
11874                   tree patched = patch_string (TREE_OPERAND (node, 1));
11875                   if (patched)
11876                     DECL_INITIAL (nn) = patched;
11877                   else
11878                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11879                   DECL_FIELD_FINAL_IUD (nn) = 1;
11880                   return build_java_empty_stmt ();
11881                 }
11882             }
11883           if (! flag_emit_class_files)
11884             DECL_INITIAL (nn) = NULL_TREE;
11885         }
11886       wfl_op2 = TREE_OPERAND (node, 1);
11887
11888       if (TREE_OPERAND (node, 0) == error_mark_node)
11889         return error_mark_node;
11890
11891       flag = COMPOUND_ASSIGN_P (wfl_op2);
11892       if (flag)
11893         {
11894           /* This might break when accessing outer field from inner
11895              class. TESTME, FIXME */
11896           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11897
11898           /* Hand stabilize the lhs on both places */
11899           TREE_OPERAND (node, 0) = lvalue;
11900           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11901             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11902
11903           /* 15.25.2.a: Left hand is not an array access. FIXME */
11904           /* Now complete the RHS. We write it back later on. */
11905           nn = java_complete_tree (TREE_OPERAND (node, 1));
11906
11907           if ((cn = patch_string (nn)))
11908             nn = cn;
11909
11910           /* The last part of the rewrite for E1 op= E2 is to have
11911              E1 = (T)(E1 op E2), with T being the type of E1. */
11912           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11913                                                TREE_TYPE (lvalue), nn));
11914
11915           /* If the assignment is compound and has reference type,
11916              then ensure the LHS has type String and nothing else.  */
11917           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
11918               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
11919             parse_error_context (wfl_op2,
11920                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
11921                                  lang_printable_name (TREE_TYPE (lvalue), 0));
11922
11923           /* 15.25.2.b: Left hand is an array access. FIXME */
11924         }
11925
11926       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11927          function to complete this RHS. Note that a NEW_ARRAY_INIT
11928          might have been already fully expanded if created as a result
11929          of processing an anonymous array initializer. We avoid doing
11930          the operation twice by testing whether the node already bears
11931          a type. */
11932       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
11933         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
11934                                    TREE_OPERAND (node, 1));
11935       /* Otherwise we simply complete the RHS */
11936       else
11937         nn = java_complete_tree (TREE_OPERAND (node, 1));
11938
11939       if (nn == error_mark_node)
11940         return error_mark_node;
11941
11942       /* Write back the RHS as we evaluated it. */
11943       TREE_OPERAND (node, 1) = nn;
11944
11945       /* In case we're handling = with a String as a RHS, we need to
11946          produce a String out of the RHS (it might still be a
11947          STRING_CST or a StringBuffer at this stage */
11948       if ((nn = patch_string (TREE_OPERAND (node, 1))))
11949         TREE_OPERAND (node, 1) = nn;
11950
11951       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11952                                         TREE_OPERAND (node, 1))))
11953         {
11954           /* We return error_mark_node if outer_field_access_fix
11955              detects we write into a final. */
11956           if (nn == error_mark_node)
11957             return error_mark_node;
11958           node = nn;
11959         }
11960       else
11961         {
11962           node = patch_assignment (node, wfl_op1);
11963           if (node == error_mark_node)
11964             return error_mark_node;
11965           /* Reorganize the tree if necessary. */
11966           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11967                        || JSTRING_P (TREE_TYPE (node))))
11968             node = java_refold (node);
11969         }
11970
11971       /* Seek to set DECL_INITIAL to a proper value, since it might have
11972          undergone a conversion in patch_assignment. We do that only when
11973          it's necessary to have DECL_INITIAL properly set. */
11974       nn = TREE_OPERAND (node, 0);
11975       if (TREE_CODE (nn) == VAR_DECL
11976           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
11977           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
11978           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
11979               || TREE_TYPE (nn) == string_ptr_type_node))
11980         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11981
11982       CAN_COMPLETE_NORMALLY (node) = 1;
11983       return node;
11984
11985     case MULT_EXPR:
11986     case PLUS_EXPR:
11987     case MINUS_EXPR:
11988     case LSHIFT_EXPR:
11989     case RSHIFT_EXPR:
11990     case URSHIFT_EXPR:
11991     case BIT_AND_EXPR:
11992     case BIT_XOR_EXPR:
11993     case BIT_IOR_EXPR:
11994     case TRUNC_MOD_EXPR:
11995     case TRUNC_DIV_EXPR:
11996     case RDIV_EXPR:
11997     case TRUTH_ANDIF_EXPR:
11998     case TRUTH_ORIF_EXPR:
11999     case EQ_EXPR:
12000     case NE_EXPR:
12001     case GT_EXPR:
12002     case GE_EXPR:
12003     case LT_EXPR:
12004     case LE_EXPR:
12005       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12006          knows how to handle those cases. */
12007       wfl_op1 = TREE_OPERAND (node, 0);
12008       wfl_op2 = TREE_OPERAND (node, 1);
12009
12010       CAN_COMPLETE_NORMALLY (node) = 1;
12011       /* Don't complete string nodes if dealing with the PLUS operand. */
12012       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12013         {
12014           nn = java_complete_tree (wfl_op1);
12015           if (nn == error_mark_node)
12016             return error_mark_node;
12017
12018           TREE_OPERAND (node, 0) = nn;
12019         }
12020       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12021         {
12022           nn = java_complete_tree (wfl_op2);
12023           if (nn == error_mark_node)
12024             return error_mark_node;
12025
12026           TREE_OPERAND (node, 1) = nn;
12027         }
12028       return patch_binop (node, wfl_op1, wfl_op2);
12029
12030     case INSTANCEOF_EXPR:
12031       wfl_op1 = TREE_OPERAND (node, 0);
12032       COMPLETE_CHECK_OP_0 (node);
12033       if (flag_emit_xref)
12034         {
12035           TREE_TYPE (node) = boolean_type_node;
12036           return node;
12037         }
12038       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12039
12040     case UNARY_PLUS_EXPR:
12041     case NEGATE_EXPR:
12042     case TRUTH_NOT_EXPR:
12043     case BIT_NOT_EXPR:
12044     case PREDECREMENT_EXPR:
12045     case PREINCREMENT_EXPR:
12046     case POSTDECREMENT_EXPR:
12047     case POSTINCREMENT_EXPR:
12048     case CONVERT_EXPR:
12049       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12050          how to handle those cases. */
12051       wfl_op1 = TREE_OPERAND (node, 0);
12052       CAN_COMPLETE_NORMALLY (node) = 1;
12053       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12054       if (TREE_OPERAND (node, 0) == error_mark_node)
12055         return error_mark_node;
12056       node = patch_unaryop (node, wfl_op1);
12057       CAN_COMPLETE_NORMALLY (node) = 1;
12058       break;
12059
12060     case ARRAY_REF:
12061       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12062          how to handle those cases. */
12063       wfl_op1 = TREE_OPERAND (node, 0);
12064       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12065       if (TREE_OPERAND (node, 0) == error_mark_node)
12066         return error_mark_node;
12067       if (!flag_emit_class_files && !flag_emit_xref)
12068         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12069       /* The same applies to wfl_op2 */
12070       wfl_op2 = TREE_OPERAND (node, 1);
12071       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12072       if (TREE_OPERAND (node, 1) == error_mark_node)
12073         return error_mark_node;
12074       if (!flag_emit_class_files && !flag_emit_xref)
12075         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12076       return patch_array_ref (node);
12077
12078     case RECORD_TYPE:
12079       return node;;
12080
12081     case COMPONENT_REF:
12082       /* The first step in the re-write of qualified name handling.  FIXME.
12083          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12084       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12085       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12086         {
12087           tree name = TREE_OPERAND (node, 1);
12088           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12089           if (field == NULL_TREE)
12090             {
12091               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12092               return error_mark_node;
12093             }
12094           if (! FIELD_STATIC (field))
12095             {
12096               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12097               return error_mark_node;
12098             }
12099           return field;
12100         }
12101       else
12102         abort ();
12103       break;
12104
12105     case THIS_EXPR:
12106       /* Can't use THIS in a static environment */
12107       if (!current_this)
12108         {
12109           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12110           parse_error_context (wfl_operator,
12111                                "Keyword `this' used outside allowed context");
12112           TREE_TYPE (node) = error_mark_node;
12113           return error_mark_node;
12114         }
12115       if (ctxp->explicit_constructor_p)
12116         {
12117           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12118           parse_error_context
12119             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12120           TREE_TYPE (node) = error_mark_node;
12121           return error_mark_node;
12122         }
12123       return current_this;
12124
12125     case CLASS_LITERAL:
12126       CAN_COMPLETE_NORMALLY (node) = 1;
12127       node = patch_incomplete_class_ref (node);
12128       if (node == error_mark_node)
12129         return error_mark_node;
12130       break;
12131
12132     default:
12133       CAN_COMPLETE_NORMALLY (node) = 1;
12134       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12135          and it's time to turn it into the appropriate String object */
12136       if ((nn = patch_string (node)))
12137         node = nn;
12138       else
12139         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12140     }
12141   return node;
12142 }
12143
12144 /* Complete function call's argument. Return a nonzero value is an
12145    error was found.  */
12146
12147 static int
12148 complete_function_arguments (tree node)
12149 {
12150   int flag = 0;
12151   tree cn;
12152
12153   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12154   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12155     {
12156       tree wfl = TREE_VALUE (cn), parm, temp;
12157       parm = java_complete_tree (wfl);
12158
12159       if (parm == error_mark_node)
12160         {
12161           flag = 1;
12162           continue;
12163         }
12164       /* If we have a string literal that we haven't transformed yet or a
12165          crafted string buffer, as a result of the use of the String
12166          `+' operator. Build `parm.toString()' and expand it. */
12167       if ((temp = patch_string (parm)))
12168         parm = temp;
12169
12170       TREE_VALUE (cn) = parm;
12171     }
12172   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12173   return flag;
12174 }
12175
12176 /* Sometimes (for loops and variable initialized during their
12177    declaration), we want to wrap a statement around a WFL and turn it
12178    debugable.  */
12179
12180 static tree
12181 build_debugable_stmt (int location, tree stmt)
12182 {
12183   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12184     {
12185       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12186       EXPR_WFL_LINECOL (stmt) = location;
12187     }
12188   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12189   return stmt;
12190 }
12191
12192 static tree
12193 build_expr_block (tree body, tree decls)
12194 {
12195   tree node = make_node (BLOCK);
12196   BLOCK_EXPR_DECLS (node) = decls;
12197   BLOCK_EXPR_BODY (node) = body;
12198   if (body)
12199     TREE_TYPE (node) = TREE_TYPE (body);
12200   TREE_SIDE_EFFECTS (node) = 1;
12201   return node;
12202 }
12203
12204 /* Create a new function block and link it appropriately to current
12205    function block chain */
12206
12207 static tree
12208 enter_block (void)
12209 {
12210   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12211
12212   /* Link block B supercontext to the previous block. The current
12213      function DECL is used as supercontext when enter_a_block is called
12214      for the first time for a given function. The current function body
12215      (DECL_FUNCTION_BODY) is set to be block B.  */
12216
12217   tree fndecl = current_function_decl;
12218
12219   if (!fndecl) {
12220     BLOCK_SUPERCONTEXT (b) = current_static_block;
12221     current_static_block = b;
12222   }
12223
12224   else if (!DECL_FUNCTION_BODY (fndecl))
12225     {
12226       BLOCK_SUPERCONTEXT (b) = fndecl;
12227       DECL_FUNCTION_BODY (fndecl) = b;
12228     }
12229   else
12230     {
12231       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12232       DECL_FUNCTION_BODY (fndecl) = b;
12233     }
12234   return b;
12235 }
12236
12237 /* Exit a block by changing the current function body
12238    (DECL_FUNCTION_BODY) to the current block super context, only if
12239    the block being exited isn't the method's top level one.  */
12240
12241 static tree
12242 exit_block (void)
12243 {
12244   tree b;
12245   if (current_function_decl)
12246     {
12247       b = DECL_FUNCTION_BODY (current_function_decl);
12248       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12249         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12250     }
12251   else
12252     {
12253       b = current_static_block;
12254
12255       if (BLOCK_SUPERCONTEXT (b))
12256         current_static_block = BLOCK_SUPERCONTEXT (b);
12257     }
12258   return b;
12259 }
12260
12261 /* Lookup for NAME in the nested function's blocks, all the way up to
12262    the current toplevel one. It complies with Java's local variable
12263    scoping rules.  */
12264
12265 static tree
12266 lookup_name_in_blocks (tree name)
12267 {
12268   tree b = GET_CURRENT_BLOCK (current_function_decl);
12269
12270   while (b != current_function_decl)
12271     {
12272       tree current;
12273
12274       /* Paranoid sanity check. To be removed */
12275       if (TREE_CODE (b) != BLOCK)
12276         abort ();
12277
12278       for (current = BLOCK_EXPR_DECLS (b); current;
12279            current = TREE_CHAIN (current))
12280         if (DECL_NAME (current) == name)
12281           return current;
12282       b = BLOCK_SUPERCONTEXT (b);
12283     }
12284   return NULL_TREE;
12285 }
12286
12287 static void
12288 maybe_absorb_scoping_blocks (void)
12289 {
12290   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12291     {
12292       tree b = exit_block ();
12293       java_method_add_stmt (current_function_decl, b);
12294       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12295     }
12296 }
12297
12298 \f
12299 /* This section of the source is reserved to build_* functions that
12300    are building incomplete tree nodes and the patch_* functions that
12301    are completing them.  */
12302
12303 /* Wrap a non WFL node around a WFL.  */
12304
12305 static tree
12306 build_wfl_wrap (tree node, int location)
12307 {
12308   tree wfl, node_to_insert = node;
12309
12310   /* We want to process THIS . xxx symbolically, to keep it consistent
12311      with the way we're processing SUPER. A THIS from a primary as a
12312      different form than a SUPER. Turn THIS into something symbolic */
12313   if (TREE_CODE (node) == THIS_EXPR)
12314     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12315   else
12316     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12317
12318   EXPR_WFL_LINECOL (wfl) = location;
12319   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12320   return wfl;
12321 }
12322
12323 /* Build a super() constructor invocation. Returns an empty statement if
12324    we're currently dealing with the class java.lang.Object. */
12325
12326 static tree
12327 build_super_invocation (tree mdecl)
12328 {
12329   if (DECL_CONTEXT (mdecl) == object_type_node)
12330     return build_java_empty_stmt ();
12331   else
12332     {
12333       tree super_wfl = build_wfl_node (super_identifier_node);
12334       tree a = NULL_TREE, t;
12335
12336       /* This is called after parsing is done, so the parser context
12337          won't be accurate. Set location info from current_class decl. */
12338       tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12339       EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12340
12341       /* If we're dealing with an anonymous class, pass the arguments
12342          of the crafted constructor along. */
12343       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12344         {
12345           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12346           for (; t != end_params_node; t = TREE_CHAIN (t))
12347             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12348         }
12349       return build_method_invocation (super_wfl, a);
12350     }
12351 }
12352
12353 /* Build a SUPER/THIS qualified method invocation.  */
12354
12355 static tree
12356 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12357                                        int lloc, int rloc)
12358 {
12359   tree invok;
12360   tree wfl =
12361     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12362   EXPR_WFL_LINECOL (wfl) = lloc;
12363   invok = build_method_invocation (name, args);
12364   return make_qualified_primary (wfl, invok, rloc);
12365 }
12366
12367 /* Build an incomplete CALL_EXPR node. */
12368
12369 static tree
12370 build_method_invocation (tree name, tree args)
12371 {
12372   tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12373   TREE_SIDE_EFFECTS (call) = 1;
12374   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12375   return call;
12376 }
12377
12378 /* Build an incomplete new xxx(...) node. */
12379
12380 static tree
12381 build_new_invocation (tree name, tree args)
12382 {
12383   tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12384   TREE_SIDE_EFFECTS (call) = 1;
12385   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12386   return call;
12387 }
12388
12389 /* Build an incomplete assignment expression. */
12390
12391 static tree
12392 build_assignment (int op, int op_location, tree lhs, tree rhs)
12393 {
12394   tree assignment;
12395   /* Build the corresponding binop if we deal with a Compound
12396      Assignment operator. Mark the binop sub-tree as part of a
12397      Compound Assignment expression */
12398   if (op != ASSIGN_TK)
12399     {
12400       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12401       COMPOUND_ASSIGN_P (rhs) = 1;
12402     }
12403   assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12404   TREE_SIDE_EFFECTS (assignment) = 1;
12405   EXPR_WFL_LINECOL (assignment) = op_location;
12406   return assignment;
12407 }
12408
12409 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12410    the buffer.  This is used only for string conversion.  */
12411 static char *
12412 string_convert_int_cst (tree node)
12413 {
12414   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12415   static char buffer[21];
12416
12417   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12418   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12419   char *p = buffer + sizeof (buffer);
12420   int neg = 0;
12421
12422   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12423                                   << (HOST_BITS_PER_WIDE_INT - 1));
12424
12425   *--p = '\0';
12426
12427   /* If negative, note the fact and negate the value.  */
12428   if ((hi & hibit))
12429     {
12430       lo = ~lo;
12431       hi = ~hi;
12432       if (++lo == 0)
12433         ++hi;
12434       neg = 1;
12435     }
12436
12437   /* Divide by 10 until there are no bits left.  */
12438   do
12439     {
12440       unsigned HOST_WIDE_INT acc = 0;
12441       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12442       unsigned int i;
12443
12444       /* Use long division to compute the result and the remainder.  */
12445       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12446         {
12447           /* Shift a bit into accumulator.  */
12448           acc <<= 1;
12449           if ((hi & hibit))
12450             acc |= 1;
12451
12452           /* Shift the value.  */
12453           hi <<= 1;
12454           if ((lo & hibit))
12455             hi |= 1;
12456           lo <<= 1;
12457
12458           /* Shift the correct bit into the result.  */
12459           outhi <<= 1;
12460           if ((outlo & hibit))
12461             outhi |= 1;
12462           outlo <<= 1;
12463           if (acc >= 10)
12464             {
12465               acc -= 10;
12466               outlo |= 1;
12467             }
12468         }
12469
12470       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12471       *--p = '\060' + acc;
12472
12473       hi = outhi;
12474       lo = outlo;
12475     }
12476   while (hi || lo);
12477
12478   if (neg)
12479     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12480
12481   return p;
12482 }
12483
12484 /* Print an INTEGER_CST node in a static buffer, and return the
12485    buffer.  This is used only for error handling.  */
12486 char *
12487 print_int_node (tree node)
12488 {
12489   static char buffer [80];
12490   if (TREE_CONSTANT_OVERFLOW (node))
12491     sprintf (buffer, "<overflow>");
12492
12493   if (TREE_INT_CST_HIGH (node) == 0)
12494     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12495              TREE_INT_CST_LOW (node));
12496   else if (TREE_INT_CST_HIGH (node) == -1
12497            && TREE_INT_CST_LOW (node) != 0)
12498     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12499              -TREE_INT_CST_LOW (node));
12500   else
12501     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12502              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12503
12504   return buffer;
12505 }
12506
12507 \f
12508 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12509    context.  */
12510
12511 /* 15.25 Assignment operators. */
12512
12513 static tree
12514 patch_assignment (tree node, tree wfl_op1)
12515 {
12516   tree rhs = TREE_OPERAND (node, 1);
12517   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12518   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12519   int error_found = 0;
12520   int lvalue_from_array = 0;
12521   int is_return = 0;
12522
12523   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12524
12525   /* Lhs can be a named variable */
12526   if (JDECL_P (lvalue))
12527     {
12528       lhs_type = TREE_TYPE (lvalue);
12529     }
12530   /* Or Lhs can be an array access. */
12531   else if (TREE_CODE (lvalue) == ARRAY_REF)
12532     {
12533       lhs_type = TREE_TYPE (lvalue);
12534       lvalue_from_array = 1;
12535     }
12536   /* Or a field access */
12537   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12538     lhs_type = TREE_TYPE (lvalue);
12539   /* Or a function return slot */
12540   else if (TREE_CODE (lvalue) == RESULT_DECL)
12541     {
12542       /* If the return type is an integral type, then we create the
12543          RESULT_DECL with a promoted type, but we need to do these
12544          checks against the unpromoted type to ensure type safety.  So
12545          here we look at the real type, not the type of the decl we
12546          are modifying.  */
12547       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12548       is_return = 1;
12549     }
12550   /* Otherwise, we might want to try to write into an optimized static
12551      final, this is an of a different nature, reported further on. */
12552   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12553            && resolve_expression_name (wfl_op1, &llvalue))
12554     {
12555       lhs_type = TREE_TYPE (lvalue);
12556     }
12557   else
12558     {
12559       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12560       error_found = 1;
12561     }
12562
12563   rhs_type = TREE_TYPE (rhs);
12564
12565   /* 5.1 Try the assignment conversion for builtin type. */
12566   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12567
12568   /* 5.2 If it failed, try a reference conversion */
12569   if (!new_rhs)
12570     new_rhs = try_reference_assignconv (lhs_type, rhs);
12571
12572   /* 15.25.2 If we have a compound assignment, convert RHS into the
12573      type of the LHS */
12574   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12575     new_rhs = convert (lhs_type, rhs);
12576
12577   /* Explicit cast required. This is an error */
12578   if (!new_rhs)
12579     {
12580       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12581       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12582       tree wfl;
12583       char operation [32];      /* Max size known */
12584
12585       /* If the assignment is part of a declaration, we use the WFL of
12586          the declared variable to point out the error and call it a
12587          declaration problem. If the assignment is a genuine =
12588          operator, we call is a operator `=' problem, otherwise we
12589          call it an assignment problem. In both of these last cases,
12590          we use the WFL of the operator to indicate the error. */
12591
12592       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12593         {
12594           wfl = wfl_op1;
12595           strcpy (operation, "declaration");
12596         }
12597       else
12598         {
12599           wfl = wfl_operator;
12600           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12601             strcpy (operation, "assignment");
12602           else if (is_return)
12603             strcpy (operation, "`return'");
12604           else
12605             strcpy (operation, "`='");
12606         }
12607
12608       if (!valid_cast_to_p (rhs_type, lhs_type))
12609         parse_error_context
12610           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12611            operation, t1, t2);
12612       else
12613         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12614                              operation, t1, t2);
12615       free (t1); free (t2);
12616       error_found = 1;
12617     }
12618
12619   if (error_found)
12620     return error_mark_node;
12621
12622   /* If we're processing a `return' statement, promote the actual type
12623      to the promoted type.  */
12624   if (is_return)
12625     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12626
12627   /* 10.10: Array Store Exception runtime check */
12628   if (!flag_emit_class_files
12629       && !flag_emit_xref
12630       && lvalue_from_array
12631       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12632     {
12633       tree array, store_check, base, index_expr;
12634
12635       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12636       new_rhs = save_expr (new_rhs);
12637
12638       /* Get the INDIRECT_REF. */
12639       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12640       /* Get the array pointer expr. */
12641       array = TREE_OPERAND (array, 0);
12642       store_check = build_java_arraystore_check (array, new_rhs);
12643
12644       index_expr = TREE_OPERAND (lvalue, 1);
12645
12646       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12647         {
12648           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12649              happen before the store check, so prepare to insert the store
12650              check within the second operand of the existing COMPOUND_EXPR. */
12651           base = index_expr;
12652         }
12653       else
12654         base = lvalue;
12655
12656       index_expr = TREE_OPERAND (base, 1);
12657       TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
12658                                        store_check, index_expr);
12659     }
12660
12661   /* Final locals can be used as case values in switch
12662      statement. Prepare them for this eventuality. */
12663   if (TREE_CODE (lvalue) == VAR_DECL
12664       && DECL_FINAL (lvalue)
12665       && TREE_CONSTANT (new_rhs)
12666       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12667       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12668       )
12669     {
12670       TREE_CONSTANT (lvalue) = 1;
12671       TREE_INVARIANT (lvalue) = 1;
12672       DECL_INITIAL (lvalue) = new_rhs;
12673     }
12674
12675   /* Copy the rhs if it's a reference.  */
12676   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12677     {
12678       switch (TREE_CODE (new_rhs))
12679         {
12680         case ARRAY_REF:
12681         case INDIRECT_REF:
12682         case COMPONENT_REF:
12683           /* Transform a = foo.bar
12684              into a = ({int tmp; tmp = foo.bar;}).
12685              We need to ensure that if a read from memory fails
12686              because of a NullPointerException, a destination variable
12687              will remain unchanged.  An explicit temporary does what
12688              we need.
12689
12690              If flag_check_references is set, this is unnecessary
12691              because we'll check each reference before doing any
12692              reads.  If optimize is not set the result will never be
12693              written to a stack slot that contains the LHS.  */
12694           {
12695             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12696                                    TREE_TYPE (new_rhs));
12697             tree block = make_node (BLOCK);
12698             tree assignment
12699               = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12700             DECL_CONTEXT (tmp) = current_function_decl;
12701             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12702             BLOCK_VARS (block) = tmp;
12703             BLOCK_EXPR_BODY (block) = assignment;
12704             TREE_SIDE_EFFECTS (block) = 1;
12705             new_rhs = block;
12706           }
12707           break;
12708         default:
12709           break;
12710         }
12711     }
12712
12713   TREE_OPERAND (node, 0) = lvalue;
12714   TREE_OPERAND (node, 1) = new_rhs;
12715   TREE_TYPE (node) = lhs_type;
12716   return node;
12717 }
12718
12719 /* Check that type SOURCE can be cast into type DEST. If the cast
12720    can't occur at all, return NULL; otherwise, return a possibly
12721    modified rhs.  */
12722
12723 static tree
12724 try_reference_assignconv (tree lhs_type, tree rhs)
12725 {
12726   tree new_rhs = NULL_TREE;
12727   tree rhs_type = TREE_TYPE (rhs);
12728
12729   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12730     {
12731       /* `null' may be assigned to any reference type */
12732       if (rhs == null_pointer_node)
12733         new_rhs = null_pointer_node;
12734       /* Try the reference assignment conversion */
12735       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12736         new_rhs = rhs;
12737       /* This is a magic assignment that we process differently */
12738       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12739         new_rhs = rhs;
12740     }
12741   return new_rhs;
12742 }
12743
12744 /* Check that RHS can be converted into LHS_TYPE by the assignment
12745    conversion (5.2), for the cases of RHS being a builtin type. Return
12746    NULL_TREE if the conversion fails or if because RHS isn't of a
12747    builtin type. Return a converted RHS if the conversion is possible.  */
12748
12749 static tree
12750 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12751 {
12752   tree new_rhs = NULL_TREE;
12753   tree rhs_type = TREE_TYPE (rhs);
12754
12755   /* Handle boolean specially.  */
12756   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12757       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12758     {
12759       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12760           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12761         new_rhs = rhs;
12762     }
12763
12764   /* 5.1.1 Try Identity Conversion,
12765      5.1.2 Try Widening Primitive Conversion */
12766   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12767     new_rhs = convert (lhs_type, rhs);
12768
12769   /* Try a narrowing primitive conversion (5.1.3):
12770        - expression is a constant expression of type byte, short, char,
12771          or int, AND
12772        - variable is byte, short or char AND
12773        - The value of the expression is representable in the type of the
12774          variable */
12775   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12776             || rhs_type == char_type_node || rhs_type == int_type_node)
12777             && TREE_CONSTANT (rhs)
12778            && (lhs_type == byte_type_node || lhs_type == char_type_node
12779                || lhs_type == short_type_node))
12780     {
12781       if (int_fits_type_p (rhs, lhs_type))
12782         new_rhs = convert (lhs_type, rhs);
12783       else if (wfl_op1)         /* Might be called with a NULL */
12784         parse_warning_context
12785           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12786            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12787       /* Reported a warning that will turn into an error further
12788          down, so we don't return */
12789     }
12790
12791   return new_rhs;
12792 }
12793
12794 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12795    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12796    0 is the conversion test fails.  This implements parts the method
12797    invocation conversion (5.3).  */
12798
12799 static int
12800 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12801 {
12802   /* 5.1.1: This is the identity conversion part. */
12803   if (lhs_type == rhs_type)
12804     return 1;
12805
12806   /* Reject non primitive types and boolean conversions.  */
12807   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12808     return 0;
12809
12810   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12811      than a char can't be converted into a char. Short can't too, but
12812      the < test below takes care of that */
12813   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12814     return 0;
12815
12816   /* Accept all promoted type here. Note, we can't use <= in the test
12817      below, because we still need to bounce out assignments of short
12818      to char and the likes */
12819   if (lhs_type == int_type_node
12820       && (rhs_type == promoted_byte_type_node
12821           || rhs_type == promoted_short_type_node
12822           || rhs_type == promoted_char_type_node
12823           || rhs_type == promoted_boolean_type_node))
12824     return 1;
12825
12826   /* From here, an integral is widened if its precision is smaller
12827      than the precision of the LHS or if the LHS is a floating point
12828      type, or the RHS is a float and the RHS a double. */
12829   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12830        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12831       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12832       || (rhs_type == float_type_node && lhs_type == double_type_node))
12833     return 1;
12834
12835   return 0;
12836 }
12837
12838 /* Check that something of SOURCE type can be assigned or cast to
12839    something of DEST type at runtime. Return 1 if the operation is
12840    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12841    were SOURCE is cast into DEST, which borrows a lot of the
12842    assignment check. */
12843
12844 static int
12845 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12846 {
12847   /* SOURCE or DEST might be null if not from a declared entity. */
12848   if (!source || !dest)
12849     return 0;
12850   if (JNULLP_TYPE_P (source))
12851     return 1;
12852   if (TREE_CODE (source) == POINTER_TYPE)
12853     source = TREE_TYPE (source);
12854   if (TREE_CODE (dest) == POINTER_TYPE)
12855     dest = TREE_TYPE (dest);
12856
12857   /* If source and dest are being compiled from bytecode, they may need to
12858      be loaded. */
12859   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12860     {
12861       load_class (source, 1);
12862       safe_layout_class (source);
12863     }
12864   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12865     {
12866       load_class (dest, 1);
12867       safe_layout_class (dest);
12868     }
12869
12870   /* Case where SOURCE is a class type */
12871   if (TYPE_CLASS_P (source))
12872     {
12873       if (TYPE_CLASS_P (dest))
12874         return  (source == dest
12875                  || inherits_from_p (source, dest)
12876                  || (cast && inherits_from_p (dest, source)));
12877       if (TYPE_INTERFACE_P (dest))
12878         {
12879           /* If doing a cast and SOURCE is final, the operation is
12880              always correct a compile time (because even if SOURCE
12881              does not implement DEST, a subclass of SOURCE might). */
12882           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12883             return 1;
12884           /* Otherwise, SOURCE must implement DEST */
12885           return interface_of_p (dest, source);
12886         }
12887       /* DEST is an array, cast permitted if SOURCE is of Object type */
12888       return (cast && source == object_type_node ? 1 : 0);
12889     }
12890   if (TYPE_INTERFACE_P (source))
12891     {
12892       if (TYPE_CLASS_P (dest))
12893         {
12894           /* If not casting, DEST must be the Object type */
12895           if (!cast)
12896             return dest == object_type_node;
12897           /* We're doing a cast. The cast is always valid is class
12898              DEST is not final, otherwise, DEST must implement SOURCE */
12899           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12900             return 1;
12901           else
12902             return interface_of_p (source, dest);
12903         }
12904       if (TYPE_INTERFACE_P (dest))
12905         {
12906           /* If doing a cast, then if SOURCE and DEST contain method
12907              with the same signature but different return type, then
12908              this is a (compile time) error */
12909           if (cast)
12910             {
12911               tree method_source, method_dest;
12912               tree source_type;
12913               tree source_sig;
12914               tree source_name;
12915               for (method_source = TYPE_METHODS (source); method_source;
12916                    method_source = TREE_CHAIN (method_source))
12917                 {
12918                   source_sig =
12919                     build_java_argument_signature (TREE_TYPE (method_source));
12920                   source_type = TREE_TYPE (TREE_TYPE (method_source));
12921                   source_name = DECL_NAME (method_source);
12922                   for (method_dest = TYPE_METHODS (dest);
12923                        method_dest; method_dest = TREE_CHAIN (method_dest))
12924                     if (source_sig ==
12925                         build_java_argument_signature (TREE_TYPE (method_dest))
12926                         && source_name == DECL_NAME (method_dest)
12927                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12928                       return 0;
12929                 }
12930               return 1;
12931             }
12932           else
12933             return source == dest || interface_of_p (dest, source);
12934         }
12935       else
12936         {
12937           /* Array */
12938           return (cast
12939                   && (DECL_NAME (TYPE_NAME (source))
12940                       == java_lang_cloneable_identifier_node
12941                       || (DECL_NAME (TYPE_NAME (source))
12942                           == java_io_serializable_identifier_node)));
12943         }
12944     }
12945   if (TYPE_ARRAY_P (source))
12946     {
12947       if (TYPE_CLASS_P (dest))
12948         return dest == object_type_node;
12949       /* Can't cast an array to an interface unless the interface is
12950          java.lang.Cloneable or java.io.Serializable.  */
12951       if (TYPE_INTERFACE_P (dest))
12952         return (DECL_NAME (TYPE_NAME (dest))
12953                 == java_lang_cloneable_identifier_node
12954                 || (DECL_NAME (TYPE_NAME (dest))
12955                     == java_io_serializable_identifier_node));
12956       else                      /* Arrays */
12957         {
12958           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12959           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12960
12961           /* In case of severe errors, they turn out null */
12962           if (!dest_element_type || !source_element_type)
12963             return 0;
12964           if (source_element_type == dest_element_type)
12965             return 1;
12966           return valid_ref_assignconv_cast_p (source_element_type,
12967                                               dest_element_type, cast);
12968         }
12969       return 0;
12970     }
12971   return 0;
12972 }
12973
12974 static int
12975 valid_cast_to_p (tree source, tree dest)
12976 {
12977   if (TREE_CODE (source) == POINTER_TYPE)
12978     source = TREE_TYPE (source);
12979   if (TREE_CODE (dest) == POINTER_TYPE)
12980     dest = TREE_TYPE (dest);
12981
12982   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
12983     return valid_ref_assignconv_cast_p (source, dest, 1);
12984
12985   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
12986     return 1;
12987
12988   else if (TREE_CODE (source) == BOOLEAN_TYPE
12989            && TREE_CODE (dest) == BOOLEAN_TYPE)
12990     return 1;
12991
12992   return 0;
12993 }
12994
12995 static tree
12996 do_unary_numeric_promotion (tree arg)
12997 {
12998   tree type = TREE_TYPE (arg);
12999   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13000       || TREE_CODE (type) == CHAR_TYPE)
13001     arg = convert (int_type_node, arg);
13002   return arg;
13003 }
13004
13005 /* Return a nonzero value if SOURCE can be converted into DEST using
13006    the method invocation conversion rule (5.3).  */
13007 static int
13008 valid_method_invocation_conversion_p (tree dest, tree source)
13009 {
13010   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13011            && valid_builtin_assignconv_identity_widening_p (dest, source))
13012           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13013               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13014               && valid_ref_assignconv_cast_p (source, dest, 0)));
13015 }
13016
13017 /* Build an incomplete binop expression. */
13018
13019 static tree
13020 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13021 {
13022   tree binop = build2 (op, NULL_TREE, op1, op2);
13023   TREE_SIDE_EFFECTS (binop) = 1;
13024   /* Store the location of the operator, for better error report. The
13025      string of the operator will be rebuild based on the OP value. */
13026   EXPR_WFL_LINECOL (binop) = op_location;
13027   return binop;
13028 }
13029
13030 /* Build the string of the operator retained by NODE. If NODE is part
13031    of a compound expression, add an '=' at the end of the string. This
13032    function is called when an error needs to be reported on an
13033    operator. The string is returned as a pointer to a static character
13034    buffer. */
13035
13036 static char *
13037 operator_string (tree node)
13038 {
13039 #define BUILD_OPERATOR_STRING(S)                                        \
13040   {                                                                     \
13041     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13042     return buffer;                                                      \
13043   }
13044
13045   static char buffer [10];
13046   switch (TREE_CODE (node))
13047     {
13048     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13049     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13050     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13051     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13052     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13053     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13054     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13055     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13056     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13057     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13058     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13059     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13060     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13061     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13062     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13063     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13064     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13065     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13066     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13067     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13068     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13069     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13070     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13071     case PREINCREMENT_EXPR:     /* Fall through */
13072     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13073     case PREDECREMENT_EXPR:     /* Fall through */
13074     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13075     default:
13076       internal_error ("unregistered operator %s",
13077                       tree_code_name [TREE_CODE (node)]);
13078     }
13079   return NULL;
13080 #undef BUILD_OPERATOR_STRING
13081 }
13082
13083 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13084
13085 static int
13086 java_decl_equiv (tree var_acc1, tree var_acc2)
13087 {
13088   if (JDECL_P (var_acc1))
13089     return (var_acc1 == var_acc2);
13090
13091   return (TREE_CODE (var_acc1) == COMPONENT_REF
13092           && TREE_CODE (var_acc2) == COMPONENT_REF
13093           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13094              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13095           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13096 }
13097
13098 /* Return a nonzero value if CODE is one of the operators that can be
13099    used in conjunction with the `=' operator in a compound assignment.  */
13100
13101 static int
13102 binop_compound_p (enum tree_code code)
13103 {
13104   int i;
13105   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13106     if (binop_lookup [i] == code)
13107       break;
13108
13109   return i < BINOP_COMPOUND_CANDIDATES;
13110 }
13111
13112 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13113
13114 static tree
13115 java_refold (tree t)
13116 {
13117   tree c, b, ns, decl;
13118
13119   if (TREE_CODE (t) != MODIFY_EXPR)
13120     return t;
13121
13122   c = TREE_OPERAND (t, 1);
13123   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13124          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13125          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13126     return t;
13127
13128   /* Now the left branch of the binary operator. */
13129   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13130   if (! (b && TREE_CODE (b) == NOP_EXPR
13131          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13132     return t;
13133
13134   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13135   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13136          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13137     return t;
13138
13139   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13140   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13141       /* It's got to be the an equivalent decl */
13142       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13143     {
13144       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13145       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13146       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13147       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13148       /* Change the right part of the BINOP_EXPR */
13149       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13150     }
13151
13152   return t;
13153 }
13154
13155 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13156    errors but we modify NODE so that it contains the type computed
13157    according to the expression, when it's fixed. Otherwise, we write
13158    error_mark_node as the type. It allows us to further the analysis
13159    of remaining nodes and detects more errors in certain cases.  */
13160
13161 static tree
13162 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13163 {
13164   tree op1 = TREE_OPERAND (node, 0);
13165   tree op2 = TREE_OPERAND (node, 1);
13166   tree op1_type = TREE_TYPE (op1);
13167   tree op2_type = TREE_TYPE (op2);
13168   tree prom_type = NULL_TREE, cn;
13169   enum tree_code code = TREE_CODE (node);
13170
13171   /* If 1, tell the routine that we have to return error_mark_node
13172      after checking for the initialization of the RHS */
13173   int error_found = 0;
13174
13175   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13176
13177   /* If either op<n>_type are NULL, this might be early signs of an
13178      error situation, unless it's too early to tell (in case we're
13179      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13180      correctly so the error can be later on reported accurately. */
13181   if (! (code == PLUS_EXPR || code == NE_EXPR
13182          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13183     {
13184       tree n;
13185       if (! op1_type)
13186         {
13187           n = java_complete_tree (op1);
13188           op1_type = TREE_TYPE (n);
13189         }
13190       if (! op2_type)
13191         {
13192           n = java_complete_tree (op2);
13193           op2_type = TREE_TYPE (n);
13194         }
13195     }
13196
13197   switch (code)
13198     {
13199     /* 15.16 Multiplicative operators */
13200     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13201     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13202     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13203     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13204       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13205         {
13206           if (!JNUMERIC_TYPE_P (op1_type))
13207             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13208           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13209             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13210           TREE_TYPE (node) = error_mark_node;
13211           error_found = 1;
13212           break;
13213         }
13214       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13215
13216       /* Detect integral division by zero */
13217       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13218           && TREE_CODE (prom_type) == INTEGER_TYPE
13219           && (op2 == integer_zero_node || op2 == long_zero_node ||
13220               (TREE_CODE (op2) == INTEGER_CST &&
13221                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13222         {
13223           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13224           TREE_CONSTANT (node) = 0;
13225           TREE_INVARIANT (node) = 0;
13226         }
13227
13228       /* Change the division operator if necessary */
13229       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13230         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13231
13232       /* Before divisions as is disappear, try to simplify and bail if
13233          applicable, otherwise we won't perform even simple
13234          simplifications like (1-1)/3. We can't do that with floating
13235          point number, folds can't handle them at this stage. */
13236       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13237           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13238         {
13239           TREE_TYPE (node) = prom_type;
13240           node = fold (node);
13241           if (TREE_CODE (node) != code)
13242             return node;
13243         }
13244
13245       if (TREE_CODE (prom_type) == INTEGER_TYPE
13246           && flag_use_divide_subroutine
13247           && ! flag_emit_class_files
13248           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13249         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13250
13251       /* This one is more complicated. FLOATs are processed by a
13252          function call to soft_fmod. Duplicate the value of the
13253          COMPOUND_ASSIGN_P flag. */
13254       if (code == TRUNC_MOD_EXPR)
13255         {
13256           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13257           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13258           TREE_SIDE_EFFECTS (mod)
13259             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13260           return mod;
13261         }
13262       break;
13263
13264     /* 15.17 Additive Operators */
13265     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13266
13267       /* Operation is valid if either one argument is a string
13268          constant, a String object or a StringBuffer crafted for the
13269          purpose of the a previous usage of the String concatenation
13270          operator */
13271
13272       if (TREE_CODE (op1) == STRING_CST
13273           || TREE_CODE (op2) == STRING_CST
13274           || JSTRING_TYPE_P (op1_type)
13275           || JSTRING_TYPE_P (op2_type)
13276           || IS_CRAFTED_STRING_BUFFER_P (op1)
13277           || IS_CRAFTED_STRING_BUFFER_P (op2))
13278         return build_string_concatenation (op1, op2);
13279
13280     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13281                                    Numeric Types */
13282       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13283         {
13284           if (!JNUMERIC_TYPE_P (op1_type))
13285             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13286           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13287             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13288           TREE_TYPE (node) = error_mark_node;
13289           error_found = 1;
13290           break;
13291         }
13292       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13293       break;
13294
13295     /* 15.18 Shift Operators */
13296     case LSHIFT_EXPR:
13297     case RSHIFT_EXPR:
13298     case URSHIFT_EXPR:
13299       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13300         {
13301           if (!JINTEGRAL_TYPE_P (op1_type))
13302             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13303           else
13304             {
13305               if (JNUMERIC_TYPE_P (op2_type))
13306                 parse_error_context (wfl_operator,
13307                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13308                                      operator_string (node),
13309                                      lang_printable_name (op2_type, 0));
13310               else
13311                 parse_error_context (wfl_operator,
13312                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13313                                      operator_string (node),
13314                                      lang_printable_name (op2_type, 0));
13315             }
13316           TREE_TYPE (node) = error_mark_node;
13317           error_found = 1;
13318           break;
13319         }
13320
13321       /* Unary numeric promotion (5.6.1) is performed on each operand
13322          separately */
13323       op1 = do_unary_numeric_promotion (op1);
13324       op2 = do_unary_numeric_promotion (op2);
13325
13326       /* If the right hand side is of type `long', first cast it to
13327          `int'.  */
13328       if (TREE_TYPE (op2) == long_type_node)
13329         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13330
13331       /* The type of the shift expression is the type of the promoted
13332          type of the left-hand operand */
13333       prom_type = TREE_TYPE (op1);
13334
13335       /* Shift int only up to 0x1f and long up to 0x3f */
13336       if (prom_type == int_type_node)
13337         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13338                             build_int_cst (NULL_TREE, 0x1f)));
13339       else
13340         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13341                             build_int_cst (NULL_TREE, 0x3f)));
13342
13343       /* The >>> operator is a >> operating on unsigned quantities */
13344       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13345         {
13346           tree to_return;
13347           tree utype = java_unsigned_type (prom_type);
13348           op1 = convert (utype, op1);
13349           TREE_SET_CODE (node, RSHIFT_EXPR);
13350           TREE_OPERAND (node, 0) = op1;
13351           TREE_OPERAND (node, 1) = op2;
13352           TREE_TYPE (node) = utype;
13353           to_return = convert (prom_type, node);
13354           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13355           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13356           TREE_SIDE_EFFECTS (to_return)
13357             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13358           return to_return;
13359         }
13360       break;
13361
13362       /* 15.19.1 Type Comparison Operator instanceof */
13363     case INSTANCEOF_EXPR:
13364
13365       TREE_TYPE (node) = boolean_type_node;
13366
13367       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13368       if ((cn = patch_string (op1)))
13369         {
13370           op1 = cn;
13371           op1_type = TREE_TYPE (op1);
13372         }
13373       if (op1_type == NULL_TREE)
13374         abort ();
13375
13376       if (!(op2_type = resolve_type_during_patch (op2)))
13377         return error_mark_node;
13378
13379       /* The first operand must be a reference type or the null type */
13380       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13381         error_found = 1;        /* Error reported further below */
13382
13383       /* The second operand must be a reference type */
13384       if (!JREFERENCE_TYPE_P (op2_type))
13385         {
13386           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13387           parse_error_context
13388             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13389              lang_printable_name (op2_type, 0));
13390           error_found = 1;
13391         }
13392
13393       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13394         {
13395           /* If the first operand is null, the result is always false */
13396           if (op1 == null_pointer_node)
13397             return boolean_false_node;
13398           else if (flag_emit_class_files)
13399             {
13400               TREE_OPERAND (node, 1) = op2_type;
13401               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13402               return node;
13403             }
13404           /* Otherwise we have to invoke instance of to figure it out */
13405           else
13406             return build_instanceof (op1, op2_type);
13407         }
13408       /* There is no way the expression operand can be an instance of
13409          the type operand. This is a compile time error. */
13410       else
13411         {
13412           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13413           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13414           parse_error_context
13415             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13416              t1, lang_printable_name (op2_type, 0));
13417           free (t1);
13418           error_found = 1;
13419         }
13420
13421       break;
13422
13423       /* 15.21 Bitwise and Logical Operators */
13424     case BIT_AND_EXPR:
13425     case BIT_XOR_EXPR:
13426     case BIT_IOR_EXPR:
13427       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13428         /* Binary numeric promotion is performed on both operand and the
13429            expression retain that type */
13430         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13431
13432       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13433                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13434         /* The type of the bitwise operator expression is BOOLEAN */
13435         prom_type = boolean_type_node;
13436       else
13437         {
13438           if (!JINTEGRAL_TYPE_P (op1_type))
13439             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13440           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13441             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13442           TREE_TYPE (node) = error_mark_node;
13443           error_found = 1;
13444           /* Insert a break here if adding thing before the switch's
13445              break for this case */
13446         }
13447       break;
13448
13449       /* 15.22 Conditional-And Operator */
13450     case TRUTH_ANDIF_EXPR:
13451       /* 15.23 Conditional-Or Operator */
13452     case TRUTH_ORIF_EXPR:
13453       /* Operands must be of BOOLEAN type */
13454       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13455           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13456         {
13457           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13458             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13459           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13460             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13461           TREE_TYPE (node) = boolean_type_node;
13462           error_found = 1;
13463           break;
13464         }
13465       else if (integer_zerop (op1))
13466         {
13467           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13468         }
13469       else if (integer_onep (op1))
13470         {
13471           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13472         }
13473       /* The type of the conditional operators is BOOLEAN */
13474       prom_type = boolean_type_node;
13475       break;
13476
13477       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13478     case LT_EXPR:
13479     case GT_EXPR:
13480     case LE_EXPR:
13481     case GE_EXPR:
13482       /* The type of each of the operands must be a primitive numeric
13483          type */
13484       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13485         {
13486           if (!JNUMERIC_TYPE_P (op1_type))
13487             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13488           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13489             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13490           TREE_TYPE (node) = boolean_type_node;
13491           error_found = 1;
13492           break;
13493         }
13494       /* Binary numeric promotion is performed on the operands */
13495       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13496       /* The type of the relation expression is always BOOLEAN */
13497       prom_type = boolean_type_node;
13498       break;
13499
13500       /* 15.20 Equality Operator */
13501     case EQ_EXPR:
13502     case NE_EXPR:
13503       /* It's time for us to patch the strings. */
13504       if ((cn = patch_string (op1)))
13505        {
13506          op1 = cn;
13507          op1_type = TREE_TYPE (op1);
13508        }
13509       if ((cn = patch_string (op2)))
13510        {
13511          op2 = cn;
13512          op2_type = TREE_TYPE (op2);
13513        }
13514
13515       /* 15.20.1 Numerical Equality Operators == and != */
13516       /* Binary numeric promotion is performed on the operands */
13517       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13518         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13519
13520       /* 15.20.2 Boolean Equality Operators == and != */
13521       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13522           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13523         ;                       /* Nothing to do here */
13524
13525       /* 15.20.3 Reference Equality Operators == and != */
13526       /* Types have to be either references or the null type. If
13527          they're references, it must be possible to convert either
13528          type to the other by casting conversion. */
13529       else if (op1 == null_pointer_node || op2 == null_pointer_node
13530                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13531                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13532                        || valid_ref_assignconv_cast_p (op2_type,
13533                                                        op1_type, 1))))
13534         ;                       /* Nothing to do here */
13535
13536       /* Else we have an error figure what can't be converted into
13537          what and report the error */
13538       else
13539         {
13540           char *t1;
13541           t1 = xstrdup (lang_printable_name (op1_type, 0));
13542           parse_error_context
13543             (wfl_operator,
13544              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13545              operator_string (node), t1,
13546              lang_printable_name (op2_type, 0));
13547           free (t1);
13548           TREE_TYPE (node) = boolean_type_node;
13549           error_found = 1;
13550           break;
13551         }
13552       prom_type = boolean_type_node;
13553       break;
13554     default:
13555       abort ();
13556     }
13557
13558   if (error_found)
13559     return error_mark_node;
13560
13561   TREE_OPERAND (node, 0) = op1;
13562   TREE_OPERAND (node, 1) = op2;
13563   TREE_TYPE (node) = prom_type;
13564   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13565
13566   if (flag_emit_xref)
13567     return node;
13568
13569   /* fold does not respect side-effect order as required for Java but not C.
13570    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13571    * bytecode.
13572    */
13573   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13574       : ! TREE_SIDE_EFFECTS (node))
13575     node = fold (node);
13576   return node;
13577 }
13578
13579 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13580    zero value, the value of CSTE comes after the valude of STRING */
13581
13582 static tree
13583 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13584 {
13585   const char *old = TREE_STRING_POINTER (cste);
13586   int old_len = TREE_STRING_LENGTH (cste);
13587   int len = old_len + string_len;
13588   char *new = alloca (len+1);
13589
13590   if (after)
13591     {
13592       memcpy (new, string, string_len);
13593       memcpy (&new [string_len], old, old_len);
13594     }
13595   else
13596     {
13597       memcpy (new, old, old_len);
13598       memcpy (&new [old_len], string, string_len);
13599     }
13600   new [len] = '\0';
13601   return build_string (len, new);
13602 }
13603
13604 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13605    new STRING_CST on success, NULL_TREE on failure.  */
13606
13607 static tree
13608 merge_string_cste (tree op1, tree op2, int after)
13609 {
13610   /* Handle two string constants right away.  */
13611   if (TREE_CODE (op2) == STRING_CST)
13612     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13613                                  TREE_STRING_LENGTH (op2), after);
13614
13615   /* Reasonable integer constant can be treated right away.  */
13616   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13617     {
13618       static const char *const boolean_true = "true";
13619       static const char *const boolean_false = "false";
13620       static const char *const null_pointer = "null";
13621       char ch[4];
13622       const char *string;
13623
13624       if (op2 == boolean_true_node)
13625         string = boolean_true;
13626       else if (op2 == boolean_false_node)
13627         string = boolean_false;
13628       else if (op2 == null_pointer_node
13629                || (integer_zerop (op2)
13630                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13631         /* FIXME: null is not a compile-time constant, so it is only safe to
13632            merge if the overall expression is non-constant. However, this
13633            code always merges without checking the overall expression.  */
13634         string = null_pointer;
13635       else if (TREE_TYPE (op2) == char_type_node)
13636         {
13637           /* Convert the character into UTF-8.  */
13638           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13639           unsigned char *p = (unsigned char *) ch;
13640           if (0x01 <= c && c <= 0x7f)
13641             *p++ = (unsigned char) c;
13642           else if (c < 0x7ff)
13643             {
13644               *p++ = (unsigned char) (c >> 6 | 0xc0);
13645               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13646             }
13647           else
13648             {
13649               *p++ = (unsigned char) (c >> 12 | 0xe0);
13650               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13651               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13652             }
13653           *p = '\0';
13654
13655           string = ch;
13656         }
13657       else
13658         string = string_convert_int_cst (op2);
13659
13660       return do_merge_string_cste (op1, string, strlen (string), after);
13661     }
13662   return NULL_TREE;
13663 }
13664
13665 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13666    has to be a STRING_CST and the other part must be a STRING_CST or a
13667    INTEGRAL constant. Return a new STRING_CST if the operation
13668    succeed, NULL_TREE otherwise.
13669
13670    If the case we want to optimize for space, we might want to return
13671    NULL_TREE for each invocation of this routine. FIXME */
13672
13673 static tree
13674 string_constant_concatenation (tree op1, tree op2)
13675 {
13676   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13677     {
13678       tree string, rest;
13679       int invert;
13680
13681       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13682       rest   = (string == op1 ? op2 : op1);
13683       invert = (string == op1 ? 0 : 1 );
13684
13685       /* Walk REST, only if it looks reasonable */
13686       if (TREE_CODE (rest) != STRING_CST
13687           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13688           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13689           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13690         {
13691           rest = java_complete_tree (rest);
13692           if (rest == error_mark_node)
13693             return error_mark_node;
13694           rest = fold (rest);
13695         }
13696       return merge_string_cste (string, rest, invert);
13697     }
13698   return NULL_TREE;
13699 }
13700
13701 /* Implement the `+' operator. Does static optimization if possible,
13702    otherwise create (if necessary) and append elements to a
13703    StringBuffer. The StringBuffer will be carried around until it is
13704    used for a function call or an assignment. Then toString() will be
13705    called on it to turn it into a String object. */
13706
13707 static tree
13708 build_string_concatenation (tree op1, tree op2)
13709 {
13710   tree result;
13711   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13712
13713   if (flag_emit_xref)
13714     return build2 (PLUS_EXPR, string_type_node, op1, op2);
13715
13716   /* Try to do some static optimization */
13717   if ((result = string_constant_concatenation (op1, op2)))
13718     return result;
13719
13720   /* Discard empty strings on either side of the expression */
13721   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13722     {
13723       op1 = op2;
13724       op2 = NULL_TREE;
13725     }
13726   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13727     op2 = NULL_TREE;
13728
13729   /* If operands are string constant, turn then into object references */
13730   if (TREE_CODE (op1) == STRING_CST)
13731     op1 = patch_string_cst (op1);
13732   if (op2 && TREE_CODE (op2) == STRING_CST)
13733     op2 = patch_string_cst (op2);
13734
13735   /* If either one of the constant is null and the other non null
13736      operand is a String constant, return it. */
13737   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13738     return op1;
13739
13740   /* If OP1 isn't already a StringBuffer, create and
13741      initialize a new one */
13742   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13743     {
13744       /* Two solutions here:
13745          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13746          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13747       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13748         op1 = BUILD_STRING_BUFFER (op1);
13749       else
13750         {
13751           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13752           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13753         }
13754     }
13755
13756   if (op2)
13757     {
13758       /* OP1 is no longer the last node holding a crafted StringBuffer */
13759       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13760       /* Create a node for `{new...,xxx}.append (op2)' */
13761       if (op2)
13762         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13763     }
13764
13765   /* Mark the last node holding a crafted StringBuffer */
13766   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13767
13768   TREE_SIDE_EFFECTS (op1) = side_effects;
13769   return op1;
13770 }
13771
13772 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13773    StringBuffer. If no string were found to be patched, return
13774    NULL. */
13775
13776 static tree
13777 patch_string (tree node)
13778 {
13779   if (node == error_mark_node)
13780     return error_mark_node;
13781   if (TREE_CODE (node) == STRING_CST)
13782     return patch_string_cst (node);
13783   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13784     {
13785       int saved = ctxp->explicit_constructor_p;
13786       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13787       tree ret;
13788       /* Temporary disable forbid the use of `this'. */
13789       ctxp->explicit_constructor_p = 0;
13790       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13791       /* String concatenation arguments must be evaluated in order too. */
13792       ret = force_evaluation_order (ret);
13793       /* Restore it at its previous value */
13794       ctxp->explicit_constructor_p = saved;
13795       return ret;
13796     }
13797   return NULL_TREE;
13798 }
13799
13800 /* Build the internal representation of a string constant.  */
13801
13802 static tree
13803 patch_string_cst (tree node)
13804 {
13805   int location;
13806   if (! flag_emit_class_files)
13807     {
13808       node = get_identifier (TREE_STRING_POINTER (node));
13809       location = alloc_name_constant (CONSTANT_String, node);
13810       node = build_ref_from_constant_pool (location);
13811     }
13812   TREE_CONSTANT (node) = 1;
13813   TREE_INVARIANT (node) = 1;
13814
13815   /* ??? Guessing that the class file code can't handle casts.  */
13816   if (! flag_emit_class_files)
13817     node = convert (string_ptr_type_node, node);
13818   else
13819     TREE_TYPE (node) = string_ptr_type_node;
13820
13821   return node;
13822 }
13823
13824 /* Build an incomplete unary operator expression. */
13825
13826 static tree
13827 build_unaryop (int op_token, int op_location, tree op1)
13828 {
13829   enum tree_code op;
13830   tree unaryop;
13831   switch (op_token)
13832     {
13833     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13834     case MINUS_TK: op = NEGATE_EXPR; break;
13835     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13836     case NOT_TK: op = BIT_NOT_EXPR; break;
13837     default: abort ();
13838     }
13839
13840   unaryop = build1 (op, NULL_TREE, op1);
13841   TREE_SIDE_EFFECTS (unaryop) = 1;
13842   /* Store the location of the operator, for better error report. The
13843      string of the operator will be rebuild based on the OP value. */
13844   EXPR_WFL_LINECOL (unaryop) = op_location;
13845   return unaryop;
13846 }
13847
13848 /* Special case for the ++/-- operators, since they require an extra
13849    argument to build, which is set to NULL and patched
13850    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13851
13852 static tree
13853 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13854 {
13855   static const enum tree_code lookup [2][2] =
13856     {
13857       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13858       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13859     };
13860   tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
13861                       NULL_TREE, op1, NULL_TREE);
13862   TREE_SIDE_EFFECTS (node) = 1;
13863   /* Store the location of the operator, for better error report. The
13864      string of the operator will be rebuild based on the OP value. */
13865   EXPR_WFL_LINECOL (node) = op_location;
13866   return node;
13867 }
13868
13869 /* Build an incomplete cast operator, based on the use of the
13870    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13871    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13872    though its type is already set.  */
13873
13874 static tree
13875 build_cast (int location, tree type, tree exp)
13876 {
13877   tree node = build1 (CONVERT_EXPR, type, exp);
13878   EXPR_WFL_LINECOL (node) = location;
13879   return node;
13880 }
13881
13882 /* Build an incomplete class reference operator.  */
13883 static tree
13884 build_incomplete_class_ref (int location, tree class_name)
13885 {
13886   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13887   tree class_decl = GET_CPC ();
13888   tree this_class = TREE_TYPE (class_decl);
13889
13890   /* Generate the synthetic static method `class$'.  (Previously we
13891      deferred this, causing different method tables to be emitted
13892      for native code and bytecode.)  */
13893   if (!TYPE_DOT_CLASS (this_class)
13894       && !JPRIMITIVE_TYPE_P (class_name)
13895       && !(TREE_CODE (class_name) == VOID_TYPE))
13896     {
13897       tree cpc_list = GET_CPC_LIST();
13898       tree cpc = cpc_list;
13899       tree target_class;
13900
13901       /* For inner classes, add a 'class$' method to their outermost
13902          context, creating it if necessary.  */
13903
13904       while (GET_NEXT_ENCLOSING_CPC(cpc))
13905         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
13906       class_decl = TREE_VALUE (cpc);
13907
13908       target_class = TREE_TYPE (class_decl);
13909
13910       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
13911         {
13912           /* For interfaces, adding a static 'class$' method directly
13913              is illegal.  So create an inner class to contain the new
13914              method.  Empirically this matches the behavior of javac.  */
13915           tree t, inner;
13916           /* We want the generated inner class inside the outermost class. */
13917           GET_CPC_LIST() = cpc;
13918           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13919           inner = create_anonymous_class (t);
13920           target_class = TREE_TYPE (inner);
13921           end_class_declaration (1);
13922           GET_CPC_LIST() = cpc_list;
13923         }
13924
13925       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
13926         build_dot_class_method (target_class);
13927
13928       if (this_class != target_class)
13929         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
13930     }
13931
13932   EXPR_WFL_LINECOL (node) = location;
13933   return node;
13934 }
13935
13936 /* Complete an incomplete class reference operator.  */
13937 static tree
13938 patch_incomplete_class_ref (tree node)
13939 {
13940   tree type = TREE_OPERAND (node, 0);
13941   tree ref_type;
13942
13943   if (!(ref_type = resolve_type_during_patch (type)))
13944     return error_mark_node;
13945
13946   /* If we're not emitting class files and we know ref_type is a
13947      compiled class, build a direct reference.  */
13948   if ((! flag_emit_class_files && is_compiled_class (ref_type))
13949       || JPRIMITIVE_TYPE_P (ref_type)
13950       || TREE_CODE (ref_type) == VOID_TYPE)
13951     {
13952       tree dot = build_class_ref (ref_type);
13953       /* A class referenced by `foo.class' is initialized.  */
13954       if (!flag_emit_class_files)
13955        dot = build_class_init (ref_type, dot);
13956       return java_complete_tree (dot);
13957     }
13958
13959   /* If we're emitting class files and we have to deal with non
13960      primitive types, we invoke the synthetic static method `class$'.  */
13961   ref_type = build_dot_class_method_invocation (current_class, ref_type);
13962   return java_complete_tree (ref_type);
13963 }
13964
13965 /* 15.14 Unary operators. We return error_mark_node in case of error,
13966    but preserve the type of NODE if the type is fixed.  */
13967
13968 static tree
13969 patch_unaryop (tree node, tree wfl_op)
13970 {
13971   tree op = TREE_OPERAND (node, 0);
13972   tree op_type = TREE_TYPE (op);
13973   tree prom_type = NULL_TREE, value, decl;
13974   int outer_field_flag = 0;
13975   int code = TREE_CODE (node);
13976   int error_found = 0;
13977
13978   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13979
13980   switch (code)
13981     {
13982       /* 15.13.2 Postfix Increment Operator ++ */
13983     case POSTINCREMENT_EXPR:
13984       /* 15.13.3 Postfix Increment Operator -- */
13985     case POSTDECREMENT_EXPR:
13986       /* 15.14.1 Prefix Increment Operator ++ */
13987     case PREINCREMENT_EXPR:
13988       /* 15.14.2 Prefix Decrement Operator -- */
13989     case PREDECREMENT_EXPR:
13990       op = decl = strip_out_static_field_access_decl (op);
13991       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
13992       /* We might be trying to change an outer field accessed using
13993          access method. */
13994       if (outer_field_flag)
13995         {
13996           /* Retrieve the decl of the field we're trying to access. We
13997              do that by first retrieving the function we would call to
13998              access the field. It has been already verified that this
13999              field isn't final */
14000           if (flag_emit_class_files)
14001             decl = TREE_OPERAND (op, 0);
14002           else
14003             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14004           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14005         }
14006       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14007       else if (!JDECL_P (decl)
14008           && TREE_CODE (decl) != COMPONENT_REF
14009           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14010           && TREE_CODE (decl) != INDIRECT_REF
14011           && !(TREE_CODE (decl) == COMPOUND_EXPR
14012                && TREE_OPERAND (decl, 1)
14013                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14014         {
14015           TREE_TYPE (node) = error_mark_node;
14016           error_found = 1;
14017         }
14018
14019       /* From now on, we know that op if a variable and that it has a
14020          valid wfl. We use wfl_op to locate errors related to the
14021          ++/-- operand. */
14022       if (!JNUMERIC_TYPE_P (op_type))
14023         {
14024           parse_error_context
14025             (wfl_op, "Invalid argument type `%s' to `%s'",
14026              lang_printable_name (op_type, 0), operator_string (node));
14027           TREE_TYPE (node) = error_mark_node;
14028           error_found = 1;
14029         }
14030       else
14031         {
14032           /* Before the addition, binary numeric promotion is performed on
14033              both operands, if really necessary */
14034           if (JINTEGRAL_TYPE_P (op_type))
14035             {
14036               value = build_int_cst (op_type, 1);
14037               TREE_TYPE (node) = op_type;
14038             }
14039           else
14040             {
14041               value = build_int_cst (NULL_TREE, 1);
14042               TREE_TYPE (node) =
14043                 binary_numeric_promotion (op_type,
14044                                           TREE_TYPE (value), &op, &value);
14045             }
14046
14047           /* We remember we might be accessing an outer field */
14048           if (outer_field_flag)
14049             {
14050               /* We re-generate an access to the field */
14051               value = build2 (PLUS_EXPR, TREE_TYPE (op),
14052                               build_outer_field_access (wfl_op, decl), value);
14053
14054               /* And we patch the original access$() into a write
14055                  with plus_op as a rhs */
14056               return outer_field_access_fix (node, op, value);
14057             }
14058
14059           /* And write back into the node. */
14060           TREE_OPERAND (node, 0) = op;
14061           TREE_OPERAND (node, 1) = value;
14062           /* Convert the overall back into its original type, if
14063              necessary, and return */
14064           if (JINTEGRAL_TYPE_P (op_type))
14065             return fold (node);
14066           else
14067             return fold (convert (op_type, node));
14068         }
14069       break;
14070
14071       /* 15.14.3 Unary Plus Operator + */
14072     case UNARY_PLUS_EXPR:
14073       /* 15.14.4 Unary Minus Operator - */
14074     case NEGATE_EXPR:
14075       if (!JNUMERIC_TYPE_P (op_type))
14076         {
14077           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14078           TREE_TYPE (node) = error_mark_node;
14079           error_found = 1;
14080         }
14081       /* Unary numeric promotion is performed on operand */
14082       else
14083         {
14084           op = do_unary_numeric_promotion (op);
14085           prom_type = TREE_TYPE (op);
14086           if (code == UNARY_PLUS_EXPR)
14087             return fold (op);
14088         }
14089       break;
14090
14091       /* 15.14.5 Bitwise Complement Operator ~ */
14092     case BIT_NOT_EXPR:
14093       if (!JINTEGRAL_TYPE_P (op_type))
14094         {
14095           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14096           TREE_TYPE (node) = error_mark_node;
14097           error_found = 1;
14098         }
14099       else
14100         {
14101           op = do_unary_numeric_promotion (op);
14102           prom_type = TREE_TYPE (op);
14103         }
14104       break;
14105
14106       /* 15.14.6 Logical Complement Operator ! */
14107     case TRUTH_NOT_EXPR:
14108       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14109         {
14110           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14111           /* But the type is known. We will report an error if further
14112              attempt of a assignment is made with this rhs */
14113           TREE_TYPE (node) = boolean_type_node;
14114           error_found = 1;
14115         }
14116       else
14117         prom_type = boolean_type_node;
14118       break;
14119
14120       /* 15.15 Cast Expression */
14121     case CONVERT_EXPR:
14122       value = patch_cast (node, wfl_operator);
14123       if (value == error_mark_node)
14124         {
14125           /* If this cast is part of an assignment, we tell the code
14126              that deals with it not to complain about a mismatch,
14127              because things have been cast, anyways */
14128           TREE_TYPE (node) = error_mark_node;
14129           error_found = 1;
14130         }
14131       else
14132         {
14133           value = fold (value);
14134           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14135           return value;
14136         }
14137       break;
14138     }
14139
14140   if (error_found)
14141     return error_mark_node;
14142
14143   /* There are cases where node has been replaced by something else
14144      and we don't end up returning here: UNARY_PLUS_EXPR,
14145      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14146   TREE_OPERAND (node, 0) = fold (op);
14147   TREE_TYPE (node) = prom_type;
14148   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14149   return fold (node);
14150 }
14151
14152 /* Generic type resolution that sometimes takes place during node
14153    patching. Returned the resolved type or generate an error
14154    message. Return the resolved type or NULL_TREE.  */
14155
14156 static tree
14157 resolve_type_during_patch (tree type)
14158 {
14159   if (unresolved_type_p (type, NULL))
14160     {
14161       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14162       if (!type_decl)
14163         {
14164           parse_error_context (type,
14165                                "Class `%s' not found in type declaration",
14166                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14167           return NULL_TREE;
14168         }
14169
14170       check_deprecation (type, type_decl);
14171
14172       return TREE_TYPE (type_decl);
14173     }
14174   return type;
14175 }
14176
14177 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14178    found. Otherwise NODE or something meant to replace it is returned.  */
14179
14180 static tree
14181 patch_cast (tree node, tree wfl_op)
14182 {
14183   tree op = TREE_OPERAND (node, 0);
14184   tree cast_type = TREE_TYPE (node);
14185   tree patched, op_type;
14186   char *t1;
14187
14188   /* Some string patching might be necessary at this stage */
14189   if ((patched = patch_string (op)))
14190     TREE_OPERAND (node, 0) = op = patched;
14191   op_type = TREE_TYPE (op);
14192
14193   /* First resolve OP_TYPE if unresolved */
14194   if (!(cast_type = resolve_type_during_patch (cast_type)))
14195     return error_mark_node;
14196
14197   /* Check on cast that are proven correct at compile time */
14198   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14199     {
14200       /* Same type */
14201       if (cast_type == op_type)
14202         return node;
14203
14204       /* A narrowing conversion from a floating-point number to an
14205          integral type requires special handling (5.1.3).  */
14206       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14207         if (cast_type != long_type_node)
14208           op = convert (integer_type_node, op);
14209
14210       /* Try widening/narrowing conversion.  Potentially, things need
14211          to be worked out in gcc so we implement the extreme cases
14212          correctly.  fold_convert() needs to be fixed.  */
14213       return convert (cast_type, op);
14214     }
14215
14216   /* It's also valid to cast a boolean into a boolean */
14217   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14218     return node;
14219
14220   /* null can be casted to references */
14221   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14222     return build_null_of_type (cast_type);
14223
14224   /* The remaining legal casts involve conversion between reference
14225      types. Check for their compile time correctness. */
14226   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14227       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14228     {
14229       TREE_TYPE (node) = promote_type (cast_type);
14230       /* Now, the case can be determined correct at compile time if
14231          OP_TYPE can be converted into CAST_TYPE by assignment
14232          conversion (5.2) */
14233
14234       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14235         {
14236           TREE_SET_CODE (node, NOP_EXPR);
14237           return node;
14238         }
14239
14240       if (flag_emit_class_files)
14241         {
14242           TREE_SET_CODE (node, CONVERT_EXPR);
14243           return node;
14244         }
14245
14246       /* The cast requires a run-time check */
14247       return build3 (CALL_EXPR, promote_type (cast_type),
14248                      build_address_of (soft_checkcast_node),
14249                      tree_cons (NULL_TREE, build_class_ref (cast_type),
14250                                 build_tree_list (NULL_TREE, op)),
14251                      NULL_TREE);
14252     }
14253
14254   /* Any other casts are proven incorrect at compile time */
14255   t1 = xstrdup (lang_printable_name (op_type, 0));
14256   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14257                        t1, lang_printable_name (cast_type, 0));
14258   free (t1);
14259   return error_mark_node;
14260 }
14261
14262 /* Build a null constant and give it the type TYPE.  */
14263
14264 static tree
14265 build_null_of_type (tree type)
14266 {
14267   tree node = build_int_cst (promote_type (type), 0);
14268   return node;
14269 }
14270
14271 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14272    a list of indices. */
14273 static tree
14274 build_array_ref (int location, tree array, tree index)
14275 {
14276   tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14277                       NULL_TREE, NULL_TREE);
14278   EXPR_WFL_LINECOL (node) = location;
14279   return node;
14280 }
14281
14282 /* 15.12 Array Access Expression */
14283
14284 static tree
14285 patch_array_ref (tree node)
14286 {
14287   tree array = TREE_OPERAND (node, 0);
14288   tree array_type  = TREE_TYPE (array);
14289   tree index = TREE_OPERAND (node, 1);
14290   tree index_type = TREE_TYPE (index);
14291   int error_found = 0;
14292
14293   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14294
14295   if (TREE_CODE (array_type) == POINTER_TYPE)
14296     array_type = TREE_TYPE (array_type);
14297
14298   /* The array reference must be an array */
14299   if (!TYPE_ARRAY_P (array_type))
14300     {
14301       parse_error_context
14302         (wfl_operator,
14303          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14304          lang_printable_name (array_type, 0));
14305       TREE_TYPE (node) = error_mark_node;
14306       error_found = 1;
14307     }
14308
14309   /* The array index undergoes unary numeric promotion. The promoted
14310      type must be int */
14311   index = do_unary_numeric_promotion (index);
14312   if (TREE_TYPE (index) != int_type_node)
14313     {
14314       if (valid_cast_to_p (index_type, int_type_node))
14315         parse_error_context (wfl_operator,
14316    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14317                              lang_printable_name (index_type, 0));
14318       else
14319         parse_error_context (wfl_operator,
14320           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14321                              lang_printable_name (index_type, 0));
14322       TREE_TYPE (node) = error_mark_node;
14323       error_found = 1;
14324     }
14325
14326   if (error_found)
14327     return error_mark_node;
14328
14329   array_type = TYPE_ARRAY_ELEMENT (array_type);
14330
14331   if (flag_emit_class_files || flag_emit_xref)
14332     {
14333       TREE_OPERAND (node, 0) = array;
14334       TREE_OPERAND (node, 1) = index;
14335     }
14336   else
14337     node = build_java_arrayaccess (array, array_type, index);
14338   TREE_TYPE (node) = array_type;
14339   return node;
14340 }
14341
14342 /* 15.9 Array Creation Expressions */
14343
14344 static tree
14345 build_newarray_node (tree type, tree dims, int extra_dims)
14346 {
14347   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14348                       nreverse (dims),
14349                       build_int_cst (NULL_TREE, extra_dims));
14350   return node;
14351 }
14352
14353 static tree
14354 patch_newarray (tree node)
14355 {
14356   tree type = TREE_OPERAND (node, 0);
14357   tree dims = TREE_OPERAND (node, 1);
14358   tree cdim, array_type;
14359   int error_found = 0;
14360   int ndims = 0;
14361   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14362
14363   /* Dimension types are verified. It's better for the types to be
14364      verified in order. */
14365   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14366     {
14367       int dim_error = 0;
14368       tree dim = TREE_VALUE (cdim);
14369
14370       /* Dim might have been saved during its evaluation */
14371       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14372
14373       /* The type of each specified dimension must be an integral type. */
14374       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14375         dim_error = 1;
14376
14377       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14378          promoted type must be int. */
14379       else
14380         {
14381           dim = do_unary_numeric_promotion (dim);
14382           if (TREE_TYPE (dim) != int_type_node)
14383             dim_error = 1;
14384         }
14385
14386       /* Report errors on types here */
14387       if (dim_error)
14388         {
14389           parse_error_context
14390             (TREE_PURPOSE (cdim),
14391              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14392              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14393               "Explicit cast needed to" : "Can't"),
14394              lang_printable_name (TREE_TYPE (dim), 0));
14395           error_found = 1;
14396         }
14397
14398       TREE_PURPOSE (cdim) = NULL_TREE;
14399     }
14400
14401   /* Resolve array base type if unresolved */
14402   if (!(type = resolve_type_during_patch (type)))
14403     error_found = 1;
14404
14405   if (error_found)
14406     {
14407       /* We don't want further evaluation of this bogus array creation
14408          operation */
14409       TREE_TYPE (node) = error_mark_node;
14410       return error_mark_node;
14411     }
14412
14413   /* Set array_type to the actual (promoted) array type of the result. */
14414   if (TREE_CODE (type) == RECORD_TYPE)
14415     type = build_pointer_type (type);
14416   while (--xdims >= 0)
14417     {
14418       type = promote_type (build_java_array_type (type, -1));
14419     }
14420   dims = nreverse (dims);
14421   array_type = type;
14422   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14423     {
14424       type = array_type;
14425       array_type
14426         = build_java_array_type (type,
14427                                  TREE_CODE (cdim) == INTEGER_CST
14428                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14429                                  : -1);
14430       array_type = promote_type (array_type);
14431     }
14432   dims = nreverse (dims);
14433
14434   /* The node is transformed into a function call. Things are done
14435      differently according to the number of dimensions. If the number
14436      of dimension is equal to 1, then the nature of the base type
14437      (primitive or not) matters. */
14438   if (ndims == 1)
14439     return build_new_array (type, TREE_VALUE (dims));
14440
14441   /* Can't reuse what's already written in expr.c because it uses the
14442      JVM stack representation. Provide a build_multianewarray. FIXME */
14443   return build3 (CALL_EXPR, array_type,
14444                  build_address_of (soft_multianewarray_node),
14445                  tree_cons (NULL_TREE,
14446                             build_class_ref (TREE_TYPE (array_type)),
14447                             tree_cons (NULL_TREE,
14448                                        build_int_cst (NULL_TREE, ndims),
14449                                        dims)),
14450                  NULL_TREE);
14451 }
14452
14453 /* 10.6 Array initializer.  */
14454
14455 /* Build a wfl for array element that don't have one, so we can
14456    pin-point errors.  */
14457
14458 static tree
14459 maybe_build_array_element_wfl (tree node)
14460 {
14461   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14462     return build_expr_wfl (NULL_TREE, ctxp->filename,
14463                            ctxp->elc.line, ctxp->elc.prev_col);
14464   else
14465     return NULL_TREE;
14466 }
14467
14468 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14469    identification of initialized arrays easier to detect during walk
14470    and expansion.  */
14471
14472 static tree
14473 build_new_array_init (int location, tree values)
14474 {
14475   tree constructor = build_constructor (NULL_TREE, values);
14476   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14477   EXPR_WFL_LINECOL (to_return) = location;
14478   return to_return;
14479 }
14480
14481 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14482    occurred.  Otherwise return NODE after having set its type
14483    appropriately.  */
14484
14485 static tree
14486 patch_new_array_init (tree type, tree node)
14487 {
14488   int error_seen = 0;
14489   tree current, element_type;
14490   HOST_WIDE_INT length;
14491   int all_constant = 1;
14492   tree init = TREE_OPERAND (node, 0);
14493
14494   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14495     {
14496       parse_error_context (node,
14497                            "Invalid array initializer for non-array type `%s'",
14498                            lang_printable_name (type, 1));
14499       return error_mark_node;
14500     }
14501   type = TREE_TYPE (type);
14502   element_type = TYPE_ARRAY_ELEMENT (type);
14503
14504   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14505
14506   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14507        current;  length++, current = TREE_CHAIN (current))
14508     {
14509       tree elt = TREE_VALUE (current);
14510       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14511         {
14512           error_seen |= array_constructor_check_entry (element_type, current);
14513           elt = TREE_VALUE (current);
14514           /* When compiling to native code, STRING_CST is converted to
14515              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14516           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14517             all_constant = 0;
14518         }
14519       else
14520         {
14521           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14522           TREE_PURPOSE (current) = NULL_TREE;
14523           all_constant = 0;
14524         }
14525       if (elt && TREE_CODE (elt) == TREE_LIST
14526           && TREE_VALUE (elt) == error_mark_node)
14527         error_seen = 1;
14528     }
14529
14530   if (error_seen)
14531     return error_mark_node;
14532
14533   /* Create a new type. We can't reuse the one we have here by
14534      patching its dimension because it originally is of dimension -1
14535      hence reused by gcc. This would prevent triangular arrays. */
14536   type = build_java_array_type (element_type, length);
14537   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14538   TREE_TYPE (node) = promote_type (type);
14539   TREE_CONSTANT (init) = all_constant;
14540   TREE_INVARIANT (init) = all_constant;
14541   TREE_CONSTANT (node) = all_constant;
14542   TREE_INVARIANT (node) = all_constant;
14543   return node;
14544 }
14545
14546 /* Verify that one entry of the initializer element list can be
14547    assigned to the array base type. Report 1 if an error occurred, 0
14548    otherwise.  */
14549
14550 static int
14551 array_constructor_check_entry (tree type, tree entry)
14552 {
14553   char *array_type_string = NULL;       /* For error reports */
14554   tree value, type_value, new_value, wfl_value, patched;
14555   int error_seen = 0;
14556
14557   new_value = NULL_TREE;
14558   wfl_value = TREE_VALUE (entry);
14559
14560   value = java_complete_tree (TREE_VALUE (entry));
14561   /* patch_string return error_mark_node if arg is error_mark_node */
14562   if ((patched = patch_string (value)))
14563     value = patched;
14564   if (value == error_mark_node)
14565     return 1;
14566
14567   type_value = TREE_TYPE (value);
14568
14569   /* At anytime, try_builtin_assignconv can report a warning on
14570      constant overflow during narrowing. */
14571   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14572   new_value = try_builtin_assignconv (wfl_operator, type, value);
14573   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14574     type_value = promote_type (type);
14575
14576   /* Check and report errors */
14577   if (!new_value)
14578     {
14579       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14580                    "Can't" : "Explicit cast needed to");
14581       if (!array_type_string)
14582         array_type_string = xstrdup (lang_printable_name (type, 1));
14583       parse_error_context
14584         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14585          msg, lang_printable_name (type_value, 1), array_type_string);
14586       error_seen = 1;
14587     }
14588
14589   if (new_value)
14590     TREE_VALUE (entry) = new_value;
14591
14592   if (array_type_string)
14593     free (array_type_string);
14594
14595   TREE_PURPOSE (entry) = NULL_TREE;
14596   return error_seen;
14597 }
14598
14599 static tree
14600 build_this (int location)
14601 {
14602   tree node = build_wfl_node (this_identifier_node);
14603   TREE_SET_CODE (node, THIS_EXPR);
14604   EXPR_WFL_LINECOL (node) = location;
14605   return node;
14606 }
14607
14608 /* 14.15 The return statement. It builds a modify expression that
14609    assigns the returned value to the RESULT_DECL that hold the value
14610    to be returned. */
14611
14612 static tree
14613 build_return (int location, tree op)
14614 {
14615   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14616   EXPR_WFL_LINECOL (node) = location;
14617   node = build_debugable_stmt (location, node);
14618   return node;
14619 }
14620
14621 static tree
14622 patch_return (tree node)
14623 {
14624   tree return_exp = TREE_OPERAND (node, 0);
14625   tree meth = current_function_decl;
14626   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14627   int error_found = 0;
14628
14629   TREE_TYPE (node) = error_mark_node;
14630   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14631
14632   /* It's invalid to have a return value within a function that is
14633      declared with the keyword void or that is a constructor */
14634   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14635     error_found = 1;
14636
14637   /* It's invalid to use a return statement in a static block */
14638   if (DECL_CLINIT_P (current_function_decl))
14639     error_found = 1;
14640
14641   /* It's invalid to have a no return value within a function that
14642      isn't declared with the keyword `void' */
14643   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14644     error_found = 2;
14645
14646   if (DECL_INSTINIT_P (current_function_decl))
14647     error_found = 1;
14648
14649   if (error_found)
14650     {
14651       if (DECL_INSTINIT_P (current_function_decl))
14652         parse_error_context (wfl_operator,
14653                              "`return' inside instance initializer");
14654
14655       else if (DECL_CLINIT_P (current_function_decl))
14656         parse_error_context (wfl_operator,
14657                              "`return' inside static initializer");
14658
14659       else if (!DECL_CONSTRUCTOR_P (meth))
14660         {
14661           char *t = xstrdup (lang_printable_name (mtype, 0));
14662           parse_error_context (wfl_operator,
14663                                "`return' with%s value from `%s %s'",
14664                                (error_found == 1 ? "" : "out"),
14665                                t, lang_printable_name (meth, 2));
14666           free (t);
14667         }
14668       else
14669         parse_error_context (wfl_operator,
14670                              "`return' with value from constructor `%s'",
14671                              lang_printable_name (meth, 2));
14672       return error_mark_node;
14673     }
14674
14675   /* If we have a return_exp, build a modify expression and expand
14676      it. Note: at that point, the assignment is declared valid, but we
14677      may want to carry some more hacks */
14678   if (return_exp)
14679     {
14680       tree exp = java_complete_tree (return_exp);
14681       tree modify, patched;
14682
14683       if ((patched = patch_string (exp)))
14684         exp = patched;
14685
14686       modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14687       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14688       modify = java_complete_tree (modify);
14689
14690       if (modify != error_mark_node)
14691         {
14692           TREE_SIDE_EFFECTS (modify) = 1;
14693           TREE_OPERAND (node, 0) = modify;
14694         }
14695       else
14696         return error_mark_node;
14697     }
14698   TREE_TYPE (node) = void_type_node;
14699   TREE_SIDE_EFFECTS (node) = 1;
14700   return node;
14701 }
14702
14703 /* 14.8 The if Statement */
14704
14705 static tree
14706 build_if_else_statement (int location, tree expression, tree if_body,
14707                          tree else_body)
14708 {
14709   tree node;
14710   if (!else_body)
14711     else_body = build_java_empty_stmt ();
14712   node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14713   EXPR_WFL_LINECOL (node) = location;
14714   node = build_debugable_stmt (location, node);
14715   return node;
14716 }
14717
14718 static tree
14719 patch_if_else_statement (tree node)
14720 {
14721   tree expression = TREE_OPERAND (node, 0);
14722   int can_complete_normally
14723     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14724        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14725
14726   TREE_TYPE (node) = error_mark_node;
14727   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14728
14729   /* The type of expression must be boolean */
14730   if (TREE_TYPE (expression) != boolean_type_node
14731       && TREE_TYPE (expression) != promoted_boolean_type_node)
14732     {
14733       parse_error_context
14734         (wfl_operator,
14735          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14736          lang_printable_name (TREE_TYPE (expression), 0));
14737       return error_mark_node;
14738     }
14739
14740   TREE_TYPE (node) = void_type_node;
14741   TREE_SIDE_EFFECTS (node) = 1;
14742   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14743   return node;
14744 }
14745
14746 /* 14.6 Labeled Statements */
14747
14748 /* Action taken when a labeled statement is parsed. a new
14749    LABELED_BLOCK_EXPR is created. No statement is attached to the
14750    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14751
14752 static tree
14753 build_labeled_block (int location, tree label)
14754 {
14755   tree label_name ;
14756   tree label_decl, node;
14757   if (label == NULL_TREE || label == continue_identifier_node)
14758     label_name = label;
14759   else
14760     {
14761       label_name = merge_qualified_name (label_id, label);
14762       /* Issue an error if we try to reuse a label that was previously
14763          declared */
14764       if (IDENTIFIER_LOCAL_VALUE (label_name))
14765         {
14766           EXPR_WFL_LINECOL (wfl_operator) = location;
14767           parse_error_context (wfl_operator,
14768             "Declaration of `%s' shadows a previous label declaration",
14769                                IDENTIFIER_POINTER (label));
14770           EXPR_WFL_LINECOL (wfl_operator) =
14771             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14772           parse_error_context (wfl_operator,
14773             "This is the location of the previous declaration of label `%s'",
14774                                IDENTIFIER_POINTER (label));
14775           java_error_count--;
14776         }
14777     }
14778
14779   label_decl = create_label_decl (label_name);
14780   node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14781   EXPR_WFL_LINECOL (node) = location;
14782   TREE_SIDE_EFFECTS (node) = 1;
14783   return node;
14784 }
14785
14786 /* A labeled statement LBE is attached a statement.  */
14787
14788 static tree
14789 finish_labeled_statement (tree lbe, /* Labeled block expr */
14790                           tree statement)
14791 {
14792   /* In anyways, tie the loop to its statement */
14793   LABELED_BLOCK_BODY (lbe) = statement;
14794   pop_labeled_block ();
14795   POP_LABELED_BLOCK ();
14796   return lbe;
14797 }
14798
14799 /* 14.10, 14.11, 14.12 Loop Statements */
14800
14801 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14802    list. */
14803
14804 static tree
14805 build_new_loop (tree loop_body)
14806 {
14807   tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
14808   TREE_SIDE_EFFECTS (loop) = 1;
14809   PUSH_LOOP (loop);
14810   return loop;
14811 }
14812
14813 /* Create a loop body according to the following structure:
14814      COMPOUND_EXPR
14815        COMPOUND_EXPR            (loop main body)
14816          EXIT_EXPR              (this order is for while/for loops.
14817          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14818            LABEL_DECL           (a continue occurring here branches at the
14819            BODY                  end of this labeled block)
14820        INCREMENT                (if any)
14821
14822   REVERSED, if nonzero, tells that the loop condition expr comes
14823   after the body, like in the do-while loop.
14824
14825   To obtain a loop, the loop body structure described above is
14826   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14827
14828    LABELED_BLOCK_EXPR
14829      LABEL_DECL                   (use this label to exit the loop)
14830      LOOP_EXPR
14831        <structure described above> */
14832
14833 static tree
14834 build_loop_body (int location, tree condition, int reversed)
14835 {
14836   tree first, second, body;
14837
14838   condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14839   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14840   condition = build_debugable_stmt (location, condition);
14841   TREE_SIDE_EFFECTS (condition) = 1;
14842
14843   body = build_labeled_block (0, continue_identifier_node);
14844   first = (reversed ? body : condition);
14845   second = (reversed ? condition : body);
14846   return build2 (COMPOUND_EXPR, NULL_TREE,
14847                  build2 (COMPOUND_EXPR, NULL_TREE, first, second),
14848                  build_java_empty_stmt ());
14849 }
14850
14851 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14852    their order) on the current loop. Unlink the current loop from the
14853    loop list.  */
14854
14855 static tree
14856 finish_loop_body (int location, tree condition, tree body, int reversed)
14857 {
14858   tree to_return = ctxp->current_loop;
14859   tree loop_body = LOOP_EXPR_BODY (to_return);
14860   if (condition)
14861     {
14862       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14863       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14864          The real EXIT_EXPR is one operand further. */
14865       EXPR_WFL_LINECOL (cnode) = location;
14866       /* This one is for accurate error reports */
14867       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14868       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14869     }
14870   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14871   POP_LOOP ();
14872   return to_return;
14873 }
14874
14875 /* Tailored version of finish_loop_body for FOR loops, when FOR
14876    loops feature the condition part */
14877
14878 static tree
14879 finish_for_loop (int location, tree condition, tree update, tree body)
14880 {
14881   /* Put the condition and the loop body in place */
14882   tree loop = finish_loop_body (location, condition, body, 0);
14883   /* LOOP is the current loop which has been now popped of the loop
14884      stack.  Mark the update block as reachable and install it.  We do
14885      this because the (current interpretation of the) JLS requires
14886      that the update expression be considered reachable even if the
14887      for loop's body doesn't complete normally.  */
14888   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
14889     {
14890       tree up2 = update;
14891       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14892         up2 = EXPR_WFL_NODE (up2);
14893       /* It is possible for the update expression to be an
14894          EXPR_WFL_NODE wrapping nothing.  */
14895       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
14896         {
14897           /* Try to detect constraint violations.  These would be
14898              programming errors somewhere.  */
14899           if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
14900             abort ();
14901           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14902         }
14903     }
14904   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14905   return loop;
14906 }
14907
14908 /* Try to find the loop a block might be related to. This comprises
14909    the case where the LOOP_EXPR is found as the second operand of a
14910    COMPOUND_EXPR, because the loop happens to have an initialization
14911    part, then expressed as the first operand of the COMPOUND_EXPR. If
14912    the search finds something, 1 is returned. Otherwise, 0 is
14913    returned. The search is assumed to start from a
14914    LABELED_BLOCK_EXPR's block.  */
14915
14916 static tree
14917 search_loop (tree statement)
14918 {
14919   if (TREE_CODE (statement) == LOOP_EXPR)
14920     return statement;
14921
14922   if (TREE_CODE (statement) == BLOCK)
14923     statement = BLOCK_SUBBLOCKS (statement);
14924   else
14925     return NULL_TREE;
14926
14927   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14928     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14929       statement = TREE_OPERAND (statement, 1);
14930
14931   return (TREE_CODE (statement) == LOOP_EXPR
14932           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14933 }
14934
14935 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14936    returned otherwise.  */
14937
14938 static int
14939 labeled_block_contains_loop_p (tree block, tree loop)
14940 {
14941   if (!block)
14942     return 0;
14943
14944   if (LABELED_BLOCK_BODY (block) == loop)
14945     return 1;
14946
14947   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
14948     return 1;
14949
14950   return 0;
14951 }
14952
14953 /* If the loop isn't surrounded by a labeled statement, create one and
14954    insert LOOP as its body.  */
14955
14956 static tree
14957 patch_loop_statement (tree loop)
14958 {
14959   tree loop_label;
14960
14961   TREE_TYPE (loop) = void_type_node;
14962   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14963     return loop;
14964
14965   loop_label = build_labeled_block (0, NULL_TREE);
14966   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14967      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
14968   LABELED_BLOCK_BODY (loop_label) = loop;
14969   PUSH_LABELED_BLOCK (loop_label);
14970   return loop_label;
14971 }
14972
14973 /* 14.13, 14.14: break and continue Statements */
14974
14975 /* Build a break or a continue statement. a null NAME indicates an
14976    unlabeled break/continue statement.  */
14977
14978 static tree
14979 build_bc_statement (int location, int is_break, tree name)
14980 {
14981   tree break_continue, label_block_expr = NULL_TREE;
14982
14983   if (name)
14984     {
14985       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
14986             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
14987         /* Null means that we don't have a target for this named
14988            break/continue. In this case, we make the target to be the
14989            label name, so that the error can be reported accurately in
14990            patch_bc_statement. */
14991         label_block_expr = EXPR_WFL_NODE (name);
14992     }
14993   /* Unlabeled break/continue will be handled during the
14994      break/continue patch operation */
14995   break_continue = build2 (EXIT_BLOCK_EXPR, NULL_TREE,
14996                            label_block_expr, NULL_TREE);
14997
14998   IS_BREAK_STMT_P (break_continue) = is_break;
14999   TREE_SIDE_EFFECTS (break_continue) = 1;
15000   EXPR_WFL_LINECOL (break_continue) = location;
15001   break_continue = build_debugable_stmt (location, break_continue);
15002   return break_continue;
15003 }
15004
15005 /* Verification of a break/continue statement. */
15006
15007 static tree
15008 patch_bc_statement (tree node)
15009 {
15010   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15011   tree labeled_block = ctxp->current_labeled_block;
15012   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15013
15014   /* Having an identifier here means that the target is unknown. */
15015   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15016     {
15017       parse_error_context (wfl_operator, "No label definition found for `%s'",
15018                            IDENTIFIER_POINTER (bc_label));
15019       return error_mark_node;
15020     }
15021   if (! IS_BREAK_STMT_P (node))
15022     {
15023       /* It's a continue statement. */
15024       for (;; labeled_block = TREE_CHAIN (labeled_block))
15025         {
15026           if (labeled_block == NULL_TREE)
15027             {
15028               if (bc_label == NULL_TREE)
15029                 parse_error_context (wfl_operator,
15030                                      "`continue' must be in loop");
15031               else
15032                 parse_error_context
15033                   (wfl_operator, "continue label `%s' does not name a loop",
15034                    IDENTIFIER_POINTER (bc_label));
15035               return error_mark_node;
15036             }
15037           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15038                == continue_identifier_node)
15039               && (bc_label == NULL_TREE
15040                   || TREE_CHAIN (labeled_block) == bc_label))
15041             {
15042               bc_label = labeled_block;
15043               break;
15044             }
15045         }
15046     }
15047   else if (!bc_label)
15048     {
15049       for (;; labeled_block = TREE_CHAIN (labeled_block))
15050         {
15051           if (labeled_block == NULL_TREE)
15052             {
15053               parse_error_context (wfl_operator,
15054                                      "`break' must be in loop or switch");
15055               return error_mark_node;
15056             }
15057           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15058           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15059               || search_loop (target_stmt))
15060             {
15061               bc_label = labeled_block;
15062               break;
15063             }
15064         }
15065     }
15066
15067   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15068   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15069
15070   /* Our break/continue don't return values. */
15071   TREE_TYPE (node) = void_type_node;
15072   /* Encapsulate the break within a compound statement so that it's
15073      expanded all the times by expand_expr (and not clobbered
15074      sometimes, like after a if statement) */
15075   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15076   TREE_SIDE_EFFECTS (node) = 1;
15077   return node;
15078 }
15079
15080 /* Process the exit expression belonging to a loop. Its type must be
15081    boolean.  */
15082
15083 static tree
15084 patch_exit_expr (tree node)
15085 {
15086   tree expression = TREE_OPERAND (node, 0);
15087   TREE_TYPE (node) = error_mark_node;
15088   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15089
15090   /* The type of expression must be boolean */
15091   if (TREE_TYPE (expression) != boolean_type_node)
15092     {
15093       parse_error_context
15094         (wfl_operator,
15095     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15096          lang_printable_name (TREE_TYPE (expression), 0));
15097       return error_mark_node;
15098     }
15099   /* Now we know things are allright, invert the condition, fold and
15100      return */
15101   TREE_OPERAND (node, 0) =
15102     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15103
15104   if (! integer_zerop (TREE_OPERAND (node, 0))
15105       && ctxp->current_loop != NULL_TREE
15106       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15107     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15108   if (! integer_onep (TREE_OPERAND (node, 0)))
15109     CAN_COMPLETE_NORMALLY (node) = 1;
15110
15111
15112   TREE_TYPE (node) = void_type_node;
15113   return node;
15114 }
15115
15116 /* 14.9 Switch statement */
15117
15118 static tree
15119 patch_switch_statement (tree node)
15120 {
15121   tree se = TREE_OPERAND (node, 0), se_type;
15122   tree save, iter;
15123
15124   /* Complete the switch expression */
15125   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15126   se_type = TREE_TYPE (se);
15127   /* The type of the switch expression must be char, byte, short or
15128      int */
15129   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15130     {
15131       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15132       parse_error_context (wfl_operator,
15133           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15134                            lang_printable_name (se_type, 0));
15135       /* This is what java_complete_tree will check */
15136       TREE_OPERAND (node, 0) = error_mark_node;
15137       return error_mark_node;
15138     }
15139
15140   /* Save and restore the outer case label list.  */
15141   save = case_label_list;
15142   case_label_list = NULL_TREE;
15143
15144   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15145
15146   /* See if we've found a duplicate label.  We can't leave this until
15147      code generation, because in `--syntax-only' and `-C' modes we
15148      don't do ordinary code generation.  */
15149   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15150     {
15151       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15152       tree subiter;
15153       for (subiter = TREE_CHAIN (iter);
15154            subiter != NULL_TREE;
15155            subiter = TREE_CHAIN (subiter))
15156         {
15157           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15158           if (val == subval)
15159             {
15160               EXPR_WFL_LINECOL (wfl_operator)
15161                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15162               /* The case_label_list is in reverse order, so print the
15163                  outer label first.  */
15164               parse_error_context (wfl_operator, "duplicate case label: `"
15165                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15166               EXPR_WFL_LINECOL (wfl_operator)
15167                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15168               parse_error_context (wfl_operator, "original label is here");
15169
15170               break;
15171             }
15172         }
15173     }
15174
15175   case_label_list = save;
15176
15177   /* Ready to return */
15178   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15179     {
15180       TREE_TYPE (node) = error_mark_node;
15181       return error_mark_node;
15182     }
15183   TREE_TYPE (node) = void_type_node;
15184   TREE_SIDE_EFFECTS (node) = 1;
15185   CAN_COMPLETE_NORMALLY (node)
15186     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15187       || ! SWITCH_HAS_DEFAULT (node);
15188   return node;
15189 }
15190
15191 /* Assertions.  */
15192
15193 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15194    might be NULL_TREE.  */
15195 static tree
15196 build_assertion (int location, tree condition, tree value)
15197 {
15198   tree node;
15199   tree klass = GET_CPC ();
15200
15201   if (! enable_assertions (klass))
15202     {
15203       condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15204                           boolean_false_node, condition);
15205       if (value == NULL_TREE)
15206         value = build_java_empty_stmt ();
15207       return build_if_else_statement (location, condition,
15208                                       value, NULL_TREE);
15209     }
15210
15211   if (! CLASS_USES_ASSERTIONS (klass))
15212     {
15213       tree field, classdollar, id, call;
15214       tree class_type = TREE_TYPE (klass);
15215
15216       field = add_field (class_type,
15217                          get_identifier ("$assertionsDisabled"),
15218                          boolean_type_node,
15219                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15220       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15221       FIELD_SYNTHETIC (field) = 1;
15222
15223       classdollar = build_incomplete_class_ref (location, class_type);
15224
15225       /* Call CLASS.desiredAssertionStatus().  */
15226       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15227       call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15228       call = make_qualified_primary (classdollar, call, location);
15229       TREE_SIDE_EFFECTS (call) = 1;
15230
15231       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15232          seem odd, but we do it to generate code identical to that of
15233          the JDK.  */
15234       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15235       TREE_SIDE_EFFECTS (call) = 1;
15236       DECL_INITIAL (field) = call;
15237
15238       /* Record the initializer in the initializer statement list.  */
15239       call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15240       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15241       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15242       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15243
15244       CLASS_USES_ASSERTIONS (klass) = 1;
15245     }
15246
15247   if (value != NULL_TREE)
15248     value = tree_cons (NULL_TREE, value, NULL_TREE);
15249
15250   node = build_wfl_node (get_identifier ("java"));
15251   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15252                               location);
15253   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15254                               location);
15255
15256   node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15257   TREE_SIDE_EFFECTS (node) = 1;
15258   /* It is too early to use BUILD_THROW.  */
15259   node = build1 (THROW_EXPR, NULL_TREE, node);
15260   TREE_SIDE_EFFECTS (node) = 1;
15261
15262   /* We invert the condition; if we just put NODE as the `else' part
15263      then we generate weird-looking bytecode.  */
15264   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15265   /* Check $assertionsDisabled.  */
15266   condition
15267     = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15268               build1 (TRUTH_NOT_EXPR, NULL_TREE,
15269                       build_wfl_node (get_identifier ("$assertionsDisabled"))),
15270               condition);
15271   node = build_if_else_statement (location, condition, node, NULL_TREE);
15272   return node;
15273 }
15274
15275 /* 14.18 The try/catch statements */
15276
15277 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15278    catches TYPE and executes CATCH_STMTS.  */
15279
15280 static tree
15281 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15282                             tree catch_stmts)
15283 {
15284   tree try_block, catch_clause_param, catch_block, catch;
15285
15286   /* First build a try block */
15287   try_block = build_expr_block (try_stmts, NULL_TREE);
15288
15289   /* Build a catch block: we need a catch clause parameter */
15290   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15291     {
15292       tree catch_type = obtain_incomplete_type (type_or_name);
15293       jdep *dep;
15294       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15295       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15296                                 catch_clause_param, catch_type);
15297       dep = CLASSD_LAST (ctxp->classd_list);
15298       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15299     }
15300   else
15301     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15302                                      build_pointer_type (type_or_name));
15303
15304   /* And a block */
15305   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15306
15307   /* Initialize the variable and store in the block */
15308   catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15309                   build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15310   add_stmt_to_block (catch_block, NULL_TREE, catch);
15311
15312   /* Add the catch statements */
15313   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15314
15315   /* Now we can build a JAVA_CATCH_EXPR */
15316   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15317
15318   return build_try_statement (location, try_block, catch_block);
15319 }
15320
15321 static tree
15322 build_try_statement (int location, tree try_block, tree catches)
15323 {
15324   tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15325   EXPR_WFL_LINECOL (node) = location;
15326   return node;
15327 }
15328
15329 static tree
15330 build_try_finally_statement (int location, tree try_block, tree finally)
15331 {
15332   tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15333   EXPR_WFL_LINECOL (node) = location;
15334   return node;
15335 }
15336
15337 static tree
15338 patch_try_statement (tree node)
15339 {
15340   int error_found = 0;
15341   tree try = TREE_OPERAND (node, 0);
15342   /* Exception handlers are considered in left to right order */
15343   tree catch = nreverse (TREE_OPERAND (node, 1));
15344   tree current, caught_type_list = NULL_TREE;
15345
15346   /* Check catch clauses, if any. Every time we find an error, we try
15347      to process the next catch clause. We process the catch clause before
15348      the try block so that when processing the try block we can check thrown
15349      exceptions againts the caught type list. */
15350   for (current = catch; current; current = TREE_CHAIN (current))
15351     {
15352       tree carg_decl, carg_type;
15353       tree sub_current, catch_block, catch_clause;
15354       int unreachable;
15355
15356       /* At this point, the structure of the catch clause is
15357            JAVA_CATCH_EXPR              (catch node)
15358              BLOCK              (with the decl of the parameter)
15359                COMPOUND_EXPR
15360                  MODIFY_EXPR   (assignment of the catch parameter)
15361                  BLOCK          (catch clause block)
15362        */
15363       catch_clause = TREE_OPERAND (current, 0);
15364       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15365       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15366
15367       /* Catch clauses can't have more than one parameter declared,
15368          but it's already enforced by the grammar. Make sure that the
15369          only parameter of the clause statement in of class Throwable
15370          or a subclass of Throwable, but that was done earlier. The
15371          catch clause parameter type has also been resolved. */
15372
15373       /* Just make sure that the catch clause parameter type inherits
15374          from java.lang.Throwable */
15375       if (!inherits_from_p (carg_type, throwable_type_node))
15376         {
15377           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15378           parse_error_context (wfl_operator,
15379                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15380                                lang_printable_name (carg_type, 0));
15381           error_found = 1;
15382           continue;
15383         }
15384
15385       /* Partial check for unreachable catch statement: The catch
15386          clause is reachable iff is no earlier catch block A in
15387          the try statement such that the type of the catch
15388          clause's parameter is the same as or a subclass of the
15389          type of A's parameter */
15390       unreachable = 0;
15391       for (sub_current = catch;
15392            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15393         {
15394           tree sub_catch_clause, decl;
15395           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15396           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15397
15398           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15399             {
15400               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15401               parse_error_context
15402                 (wfl_operator,
15403                  "`catch' not reached because of the catch clause at line %d",
15404                  EXPR_WFL_LINENO (sub_current));
15405               unreachable = error_found = 1;
15406               break;
15407             }
15408         }
15409       /* Complete the catch clause block */
15410       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15411       if (catch_block == error_mark_node)
15412         {
15413           error_found = 1;
15414           continue;
15415         }
15416       if (CAN_COMPLETE_NORMALLY (catch_block))
15417         CAN_COMPLETE_NORMALLY (node) = 1;
15418       TREE_OPERAND (current, 0) = catch_block;
15419
15420       if (unreachable)
15421         continue;
15422
15423       /* Things to do here: the exception must be thrown */
15424
15425       /* Link this type to the caught type list */
15426       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15427     }
15428
15429   PUSH_EXCEPTIONS (caught_type_list);
15430   if ((try = java_complete_tree (try)) == error_mark_node)
15431     error_found = 1;
15432   if (CAN_COMPLETE_NORMALLY (try))
15433     CAN_COMPLETE_NORMALLY (node) = 1;
15434   POP_EXCEPTIONS ();
15435
15436   /* Verification ends here */
15437   if (error_found)
15438     return error_mark_node;
15439
15440   TREE_OPERAND (node, 0) = try;
15441   TREE_OPERAND (node, 1) = catch;
15442   TREE_TYPE (node) = void_type_node;
15443   return node;
15444 }
15445
15446 /* 14.17 The synchronized Statement */
15447
15448 static tree
15449 patch_synchronized_statement (tree node, tree wfl_op1)
15450 {
15451   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15452   tree block = TREE_OPERAND (node, 1);
15453
15454   tree tmp, enter, exit, expr_decl, assignment;
15455
15456   if (expr == error_mark_node)
15457     {
15458       block = java_complete_tree (block);
15459       return expr;
15460     }
15461
15462   /* We might be trying to synchronize on a STRING_CST */
15463   if ((tmp = patch_string (expr)))
15464     expr = tmp;
15465
15466   /* The TYPE of expr must be a reference type */
15467   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15468     {
15469       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15470       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15471                            lang_printable_name (TREE_TYPE (expr), 0));
15472       return error_mark_node;
15473     }
15474
15475   if (flag_emit_xref)
15476     {
15477       TREE_OPERAND (node, 0) = expr;
15478       TREE_OPERAND (node, 1) = java_complete_tree (block);
15479       CAN_COMPLETE_NORMALLY (node) = 1;
15480       return node;
15481     }
15482
15483   /* Generate a try-finally for the synchronized statement, except
15484      that the handler that catches all throw exception calls
15485      _Jv_MonitorExit and then rethrow the exception.
15486      The synchronized statement is then implemented as:
15487      TRY
15488        {
15489          _Jv_MonitorEnter (expression)
15490          synchronized_block
15491          _Jv_MonitorExit (expression)
15492        }
15493      CATCH_ALL
15494        {
15495          e = _Jv_exception_info ();
15496          _Jv_MonitorExit (expression)
15497          Throw (e);
15498        } */
15499
15500   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15501   BUILD_MONITOR_ENTER (enter, expr_decl);
15502   BUILD_MONITOR_EXIT (exit, expr_decl);
15503   CAN_COMPLETE_NORMALLY (enter) = 1;
15504   CAN_COMPLETE_NORMALLY (exit) = 1;
15505   assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15506   TREE_SIDE_EFFECTS (assignment) = 1;
15507   node = build2 (COMPOUND_EXPR, NULL_TREE,
15508                  build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15509                  build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15510   node = build_expr_block (node, expr_decl);
15511
15512   return java_complete_tree (node);
15513 }
15514
15515 /* 14.16 The throw Statement */
15516
15517 static tree
15518 patch_throw_statement (tree node, tree wfl_op1)
15519 {
15520   tree expr = TREE_OPERAND (node, 0);
15521   tree type = TREE_TYPE (expr);
15522   int unchecked_ok = 0, tryblock_throws_ok = 0;
15523
15524   /* Thrown expression must be assignable to java.lang.Throwable */
15525   if (!try_reference_assignconv (throwable_type_node, expr))
15526     {
15527       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15528       parse_error_context (wfl_operator,
15529     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15530                            lang_printable_name (type, 0));
15531       /* If the thrown expression was a reference, we further the
15532          compile-time check. */
15533       if (!JREFERENCE_TYPE_P (type))
15534         return error_mark_node;
15535     }
15536
15537   /* At least one of the following must be true */
15538
15539   /* The type of the throw expression is a not checked exception,
15540      i.e. is a unchecked expression. */
15541   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15542
15543   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15544   /* An instance can't throw a checked exception unless that exception
15545      is explicitly declared in the `throws' clause of each
15546      constructor. This doesn't apply to anonymous classes, since they
15547      don't have declared constructors. */
15548   if (!unchecked_ok
15549       && DECL_INSTINIT_P (current_function_decl)
15550       && !ANONYMOUS_CLASS_P (current_class))
15551     {
15552       tree current;
15553       for (current = TYPE_METHODS (current_class); current;
15554            current = TREE_CHAIN (current))
15555         if (DECL_CONSTRUCTOR_P (current)
15556             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15557           {
15558             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)",
15559                                  lang_printable_name (TREE_TYPE (expr), 0));
15560             return error_mark_node;
15561           }
15562     }
15563
15564   /* Throw is contained in a try statement and at least one catch
15565      clause can receive the thrown expression or the current method is
15566      declared to throw such an exception. Or, the throw statement is
15567      contained in a method or constructor declaration and the type of
15568      the Expression is assignable to at least one type listed in the
15569      throws clause the declaration. */
15570   if (!unchecked_ok)
15571     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15572   if (!(unchecked_ok || tryblock_throws_ok))
15573     {
15574       /* If there is a surrounding try block that has no matching
15575          clatch clause, report it first. A surrounding try block exits
15576          only if there is something after the list of checked
15577          exception thrown by the current function (if any). */
15578       if (IN_TRY_BLOCK_P ())
15579         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15580                              lang_printable_name (type, 0));
15581       /* If we have no surrounding try statement and the method doesn't have
15582          any throws, report it now. FIXME */
15583
15584       /* We report that the exception can't be throw from a try block
15585          in all circumstances but when the `throw' is inside a static
15586          block. */
15587       else if (!EXCEPTIONS_P (currently_caught_type_list)
15588                && !tryblock_throws_ok)
15589         {
15590           if (DECL_CLINIT_P (current_function_decl))
15591             parse_error_context (wfl_operator,
15592                    "Checked exception `%s' can't be thrown in initializer",
15593                                  lang_printable_name (type, 0));
15594           else
15595             parse_error_context (wfl_operator,
15596                    "Checked exception `%s' isn't thrown from a `try' block",
15597                                  lang_printable_name (type, 0));
15598         }
15599       /* Otherwise, the current method doesn't have the appropriate
15600          throws declaration */
15601       else
15602         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15603                              lang_printable_name (type, 0));
15604       return error_mark_node;
15605     }
15606
15607   if (! flag_emit_class_files && ! flag_emit_xref)
15608     BUILD_THROW (node, expr);
15609
15610   /* If doing xrefs, keep the location where the `throw' was seen. */
15611   if (flag_emit_xref)
15612     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15613   return node;
15614 }
15615
15616 /* Check that exception said to be thrown by method DECL can be
15617    effectively caught from where DECL is invoked.  THIS_EXPR is the
15618    expression that computes `this' for the method call.  */
15619 static void
15620 check_thrown_exceptions (int location, tree decl, tree this_expr)
15621 {
15622   tree throws;
15623   int is_array_call = 0;
15624
15625   /* Skip check within generated methods, such as access$<n>.  */
15626   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15627     return;
15628
15629   if (this_expr != NULL_TREE
15630       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15631       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15632     is_array_call = 1;
15633
15634   /* For all the unchecked exceptions thrown by DECL.  */
15635   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15636        throws = TREE_CHAIN (throws))
15637     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15638       {
15639         /* Suppress errors about cloning arrays.  */
15640         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15641           continue;
15642
15643         EXPR_WFL_LINECOL (wfl_operator) = location;
15644         if (DECL_FINIT_P (current_function_decl))
15645           parse_error_context
15646             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15647              lang_printable_name (TREE_VALUE (throws), 0));
15648         else
15649           {
15650             parse_error_context
15651               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15652                lang_printable_name (TREE_VALUE (throws), 0),
15653                (DECL_INIT_P (current_function_decl) ?
15654                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15655                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15656           }
15657       }
15658 }
15659
15660 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15661    try-catch blocks, OR is listed in the `throws' clause of the
15662    current method.  */
15663
15664 static int
15665 check_thrown_exceptions_do (tree exception)
15666 {
15667   tree list = currently_caught_type_list;
15668   resolve_and_layout (exception, NULL_TREE);
15669   /* First, all the nested try-catch-finally at that stage. The
15670      last element contains `throws' clause exceptions, if any. */
15671   if (IS_UNCHECKED_EXCEPTION_P (exception))
15672     return 1;
15673   while (list)
15674     {
15675       tree caught;
15676       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15677         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15678           return 1;
15679       list = TREE_CHAIN (list);
15680     }
15681   return 0;
15682 }
15683
15684 static void
15685 purge_unchecked_exceptions (tree mdecl)
15686 {
15687   tree throws = DECL_FUNCTION_THROWS (mdecl);
15688   tree new = NULL_TREE;
15689
15690   while (throws)
15691     {
15692       tree next = TREE_CHAIN (throws);
15693       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15694         {
15695           TREE_CHAIN (throws) = new;
15696           new = throws;
15697         }
15698       throws = next;
15699     }
15700   /* List is inverted here, but it doesn't matter */
15701   DECL_FUNCTION_THROWS (mdecl) = new;
15702 }
15703
15704 /* This function goes over all of CLASS_TYPE ctors and checks whether
15705    each of them features at least one unchecked exception in its
15706    `throws' clause. If it's the case, it returns `true', `false'
15707    otherwise.  */
15708
15709 static bool
15710 ctors_unchecked_throws_clause_p (tree class_type)
15711 {
15712   tree current;
15713
15714   for (current = TYPE_METHODS (class_type); current;
15715        current = TREE_CHAIN (current))
15716     {
15717       bool ctu = false; /* Ctor Throws Unchecked */
15718       if (DECL_CONSTRUCTOR_P (current))
15719         {
15720           tree throws;
15721           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15722                throws = TREE_CHAIN (throws))
15723             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15724               ctu = true;
15725         }
15726       /* We return false as we found one ctor that is unfit. */
15727       if (!ctu && DECL_CONSTRUCTOR_P (current))
15728         return false;
15729     }
15730   /* All ctors feature at least one unchecked exception in their
15731      `throws' clause. */
15732   return true;
15733 }
15734
15735 /* 15.24 Conditional Operator ?: */
15736
15737 static tree
15738 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15739 {
15740   tree cond = TREE_OPERAND (node, 0);
15741   tree op1 = TREE_OPERAND (node, 1);
15742   tree op2 = TREE_OPERAND (node, 2);
15743   tree resulting_type = NULL_TREE;
15744   tree t1, t2, patched;
15745   int error_found = 0;
15746
15747   /* Operands of ?: might be StringBuffers crafted as a result of a
15748      string concatenation. Obtain a descent operand here.  */
15749   if ((patched = patch_string (op1)))
15750     TREE_OPERAND (node, 1) = op1 = patched;
15751   if ((patched = patch_string (op2)))
15752     TREE_OPERAND (node, 2) = op2 = patched;
15753
15754   t1 = TREE_TYPE (op1);
15755   t2 = TREE_TYPE (op2);
15756
15757   /* The first expression must be a boolean */
15758   if (TREE_TYPE (cond) != boolean_type_node)
15759     {
15760       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15761       parse_error_context (wfl_operator,
15762                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15763                            lang_printable_name (TREE_TYPE (cond), 0));
15764       error_found = 1;
15765     }
15766
15767   /* Second and third can be numeric, boolean (i.e. primitive),
15768      references or null. Anything else results in an error */
15769   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15770         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15771             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15772         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15773     error_found = 1;
15774
15775   /* Determine the type of the conditional expression. Same types are
15776      easy to deal with */
15777   else if (t1 == t2)
15778     resulting_type = t1;
15779
15780   /* There are different rules for numeric types */
15781   else if (JNUMERIC_TYPE_P (t1))
15782     {
15783       /* if byte/short found, the resulting type is short */
15784       if ((t1 == byte_type_node && t2 == short_type_node)
15785           || (t1 == short_type_node && t2 == byte_type_node))
15786         resulting_type = short_type_node;
15787
15788       /* If t1 is a constant int and t2 is of type byte, short or char
15789          and t1's value fits in t2, then the resulting type is t2 */
15790       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15791           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15792         resulting_type = t2;
15793
15794       /* If t2 is a constant int and t1 is of type byte, short or char
15795          and t2's value fits in t1, then the resulting type is t1 */
15796       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15797           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15798         resulting_type = t1;
15799
15800       /* Otherwise, binary numeric promotion is applied and the
15801          resulting type is the promoted type of operand 1 and 2 */
15802       else
15803         resulting_type = binary_numeric_promotion (t1, t2,
15804                                                    &TREE_OPERAND (node, 1),
15805                                                    &TREE_OPERAND (node, 2));
15806     }
15807
15808   /* Cases of a reference and a null type */
15809   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15810     resulting_type = t1;
15811
15812   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15813     resulting_type = t2;
15814
15815   /* Last case: different reference types. If a type can be converted
15816      into the other one by assignment conversion, the latter
15817      determines the type of the expression */
15818   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15819     resulting_type = promote_type (t1);
15820
15821   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15822     resulting_type = promote_type (t2);
15823
15824   /* If we don't have any resulting type, we're in trouble */
15825   if (!resulting_type)
15826     {
15827       char *t = xstrdup (lang_printable_name (t1, 0));
15828       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15829       parse_error_context (wfl_operator,
15830                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15831                            t, lang_printable_name (t2, 0));
15832       free (t);
15833       error_found = 1;
15834     }
15835
15836   if (error_found)
15837     {
15838       TREE_TYPE (node) = error_mark_node;
15839       return error_mark_node;
15840     }
15841
15842   TREE_TYPE (node) = resulting_type;
15843   TREE_SET_CODE (node, COND_EXPR);
15844   CAN_COMPLETE_NORMALLY (node) = 1;
15845   return node;
15846 }
15847
15848 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15849
15850 static tree
15851 maybe_build_class_init_for_field (tree decl, tree expr)
15852 {
15853   tree clas = DECL_CONTEXT (decl);
15854   if (flag_emit_class_files || flag_emit_xref)
15855     return expr;
15856
15857   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15858       && FIELD_FINAL (decl))
15859     {
15860       tree init = DECL_INITIAL (decl);
15861       if (init != NULL_TREE)
15862         init = fold_constant_for_init (init, decl);
15863       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15864         return expr;
15865     }
15866
15867   return build_class_init (clas, expr);
15868 }
15869
15870 /* Try to constant fold NODE.
15871    If NODE is not a constant expression, return NULL_EXPR.
15872    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15873
15874 static tree
15875 fold_constant_for_init (tree node, tree context)
15876 {
15877   tree op0, op1, val;
15878   enum tree_code code = TREE_CODE (node);
15879
15880   switch (code)
15881     {
15882     case INTEGER_CST:
15883       if (node == null_pointer_node)
15884         return NULL_TREE;
15885     case STRING_CST:
15886     case REAL_CST:
15887       return node;
15888
15889     case PLUS_EXPR:
15890     case MINUS_EXPR:
15891     case MULT_EXPR:
15892     case TRUNC_MOD_EXPR:
15893     case RDIV_EXPR:
15894     case LSHIFT_EXPR:
15895     case RSHIFT_EXPR:
15896     case URSHIFT_EXPR:
15897     case BIT_AND_EXPR:
15898     case BIT_XOR_EXPR:
15899     case BIT_IOR_EXPR:
15900     case TRUTH_ANDIF_EXPR:
15901     case TRUTH_ORIF_EXPR:
15902     case EQ_EXPR:
15903     case NE_EXPR:
15904     case GT_EXPR:
15905     case GE_EXPR:
15906     case LT_EXPR:
15907     case LE_EXPR:
15908       op0 = TREE_OPERAND (node, 0);
15909       op1 = TREE_OPERAND (node, 1);
15910       val = fold_constant_for_init (op0, context);
15911       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15912         return NULL_TREE;
15913       TREE_OPERAND (node, 0) = val;
15914       val = fold_constant_for_init (op1, context);
15915       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15916         return NULL_TREE;
15917       TREE_OPERAND (node, 1) = val;
15918       return patch_binop (node, op0, op1);
15919
15920     case UNARY_PLUS_EXPR:
15921     case NEGATE_EXPR:
15922     case TRUTH_NOT_EXPR:
15923     case BIT_NOT_EXPR:
15924     case CONVERT_EXPR:
15925       op0 = TREE_OPERAND (node, 0);
15926       val = fold_constant_for_init (op0, context);
15927       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15928         return NULL_TREE;
15929       TREE_OPERAND (node, 0) = val;
15930       val = patch_unaryop (node, op0);
15931       if (! TREE_CONSTANT (val))
15932         return NULL_TREE;
15933       return val;
15934
15935       break;
15936
15937     case COND_EXPR:
15938       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
15939       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15940         return NULL_TREE;
15941       TREE_OPERAND (node, 0) = val;
15942       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
15943       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15944         return NULL_TREE;
15945       TREE_OPERAND (node, 1) = val;
15946       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
15947       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15948         return NULL_TREE;
15949       TREE_OPERAND (node, 2) = val;
15950       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
15951         : TREE_OPERAND (node, 2);
15952
15953     case VAR_DECL:
15954     case FIELD_DECL:
15955       if (! FIELD_FINAL (node)
15956           || DECL_INITIAL (node) == NULL_TREE)
15957         return NULL_TREE;
15958       val = DECL_INITIAL (node);
15959       /* Guard against infinite recursion. */
15960       DECL_INITIAL (node) = NULL_TREE;
15961       val = fold_constant_for_init (val, node);
15962       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
15963         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
15964       DECL_INITIAL (node) = val;
15965       return val;
15966
15967     case EXPR_WITH_FILE_LOCATION:
15968       /* Compare java_complete_tree and resolve_expression_name. */
15969       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
15970           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15971         {
15972           tree name = EXPR_WFL_NODE (node);
15973           tree decl;
15974           if (PRIMARY_P (node))
15975             return NULL_TREE;
15976           else if (! QUALIFIED_P (name))
15977             {
15978               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
15979               if (decl == NULL_TREE
15980                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
15981                 return NULL_TREE;
15982               return fold_constant_for_init (decl, decl);
15983             }
15984           else
15985             {
15986               tree r = NULL_TREE;
15987               /* Install the proper context for the field resolution.  */
15988               tree saved_current_class = current_class;
15989               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
15990               current_class = DECL_CONTEXT (context);
15991               qualify_ambiguous_name (node);
15992               r = resolve_field_access (node, &decl, NULL);
15993               /* Restore prior context.  */
15994               current_class = saved_current_class;
15995               if (r != error_mark_node && decl != NULL_TREE)
15996                 return fold_constant_for_init (decl, decl);
15997               return NULL_TREE;
15998             }
15999         }
16000       else
16001         {
16002           op0 = TREE_OPERAND (node, 0);
16003           val = fold_constant_for_init (op0, context);
16004           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16005             return NULL_TREE;
16006           TREE_OPERAND (node, 0) = val;
16007           return val;
16008         }
16009
16010 #ifdef USE_COMPONENT_REF
16011     case IDENTIFIER:
16012     case COMPONENT_REF:
16013       ?;
16014 #endif
16015
16016     default:
16017       return NULL_TREE;
16018     }
16019 }
16020
16021 #ifdef USE_COMPONENT_REF
16022 /* Context is 'T' for TypeName, 'P' for PackageName,
16023    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16024
16025 tree
16026 resolve_simple_name (tree name, int context)
16027 {
16028 }
16029
16030 tree
16031 resolve_qualified_name (tree name, int context)
16032 {
16033 }
16034 #endif
16035
16036 void
16037 init_src_parse (void)
16038 {
16039   /* Sanity check; we've been bit by this before.  */
16040   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16041     abort ();
16042 }
16043
16044 \f
16045
16046 /* This section deals with the functions that are called when tables
16047    recording class initialization information are traversed.  */
16048
16049 /* Attach to PTR (a block) the declaration found in ENTRY. */
16050
16051 static int
16052 attach_init_test_initialization_flags (void **entry, void *ptr)
16053 {
16054   tree block = (tree)ptr;
16055   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16056
16057   if (block != error_mark_node)
16058     {
16059       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16060       BLOCK_EXPR_DECLS (block) = ite->value;
16061     }
16062   return true;
16063 }
16064
16065 /* This function is called for each class that is known definitely
16066    initialized when a given static method was called. This function
16067    augments a compound expression (INFO) storing all assignment to
16068    initialized static class flags if a flag already existed, otherwise
16069    a new one is created.  */
16070
16071 static int
16072 emit_test_initialization (void **entry_p, void *info)
16073 {
16074   tree l = (tree) info;
16075   tree decl, init;
16076   tree key = (tree) *entry_p;
16077   tree *ite;
16078   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16079
16080   /* If we haven't found a flag and we're dealing with self registered
16081      with current_function_decl, then don't do anything. Self is
16082      always added as definitely initialized but this information is
16083      valid only if used outside the current function. */
16084   if (current_function_decl == TREE_PURPOSE (l)
16085       && java_treetreehash_find (cf_ht, key) == NULL)
16086     return true;
16087
16088   ite = java_treetreehash_new (cf_ht, key);
16089
16090   /* If we don't have a variable, create one and install it. */
16091   if (*ite == NULL)
16092     {
16093       tree block;
16094
16095       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16096       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16097       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16098       DECL_CONTEXT (decl) = current_function_decl;
16099       DECL_INITIAL (decl) = boolean_true_node;
16100       /* Don't emit any symbolic debugging info for this decl.  */
16101       DECL_IGNORED_P (decl) = 1;
16102
16103       /* The trick is to find the right context for it. */
16104       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16105       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16106       BLOCK_EXPR_DECLS (block) = decl;
16107       *ite = decl;
16108     }
16109   else
16110     decl = *ite;
16111
16112   /* Now simply augment the compound that holds all the assignments
16113      pertaining to this method invocation. */
16114   init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16115   TREE_SIDE_EFFECTS (init) = 1;
16116   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16117   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16118
16119   return true;
16120 }
16121
16122 #include "gt-java-parse.h"
16123 #include "gtype-java.h"