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               /* We must set CAN_COMPLETE_NORMALLY for the first call
9611                  since it is done nowhere else.  */
9612               CAN_COMPLETE_NORMALLY (decl) = 1;
9613               decl = build2 (COMPOUND_EXPR, TREE_TYPE (*where_found),
9614                              decl, *where_found);
9615               TREE_SIDE_EFFECTS (decl) = 1;
9616             }
9617           else
9618             {
9619               previous_call_static = is_static;
9620               decl = *where_found;
9621             }
9622           from_type = 0;
9623           continue;
9624
9625         case NEW_ARRAY_EXPR:
9626         case NEW_ANONYMOUS_ARRAY_EXPR:
9627           *where_found = decl = java_complete_tree (qual_wfl);
9628           if (decl == error_mark_node)
9629             return 1;
9630           *type_found = type = QUAL_DECL_TYPE (decl);
9631           continue;
9632
9633         case CONVERT_EXPR:
9634           *where_found = decl = java_complete_tree (qual_wfl);
9635           if (decl == error_mark_node)
9636             return 1;
9637           *type_found = type = QUAL_DECL_TYPE (decl);
9638           from_cast = 1;
9639           continue;
9640
9641         case CONDITIONAL_EXPR:
9642         case STRING_CST:
9643         case MODIFY_EXPR:
9644           *where_found = decl = java_complete_tree (qual_wfl);
9645           if (decl == error_mark_node)
9646             return 1;
9647           *type_found = type = QUAL_DECL_TYPE (decl);
9648           continue;
9649
9650         case ARRAY_REF:
9651           /* If the access to the function call is a non static field,
9652              build the code to access it. */
9653           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9654             {
9655               decl = maybe_access_field (decl, *where_found, type);
9656               if (decl == error_mark_node)
9657                 return 1;
9658             }
9659           /* And code for the array reference expression */
9660           decl = java_complete_tree (qual_wfl);
9661           if (decl == error_mark_node)
9662             return 1;
9663           type = QUAL_DECL_TYPE (decl);
9664           continue;
9665
9666         case PLUS_EXPR:
9667           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9668             return 1;
9669           if ((type = patch_string (decl)))
9670             decl = type;
9671           *where_found = QUAL_RESOLUTION (q) = decl;
9672           *type_found = type = TREE_TYPE (decl);
9673           break;
9674
9675         case CLASS_LITERAL:
9676           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9677             return 1;
9678           *where_found = QUAL_RESOLUTION (q) = decl;
9679           *type_found = type = TREE_TYPE (decl);
9680           break;
9681
9682         default:
9683           /* Fix for -Wall Just go to the next statement. Don't
9684              continue */
9685           break;
9686         }
9687
9688       /* If we fall here, we weren't processing a (static) function call. */
9689       previous_call_static = 0;
9690
9691       /* It can be the keyword THIS */
9692       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9693           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9694         {
9695           if (!current_this)
9696             {
9697               parse_error_context
9698                 (wfl, "Keyword `this' used outside allowed context");
9699               return 1;
9700             }
9701           if (ctxp->explicit_constructor_p
9702               && type == current_class)
9703             {
9704               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9705               return 1;
9706             }
9707           /* We have to generate code for intermediate access */
9708           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9709             {
9710               *where_found = decl = current_this;
9711               *type_found = type = QUAL_DECL_TYPE (decl);
9712             }
9713           /* We're trying to access the this from somewhere else. Make sure
9714              it's allowed before doing so. */
9715           else
9716             {
9717               if (!enclosing_context_p (type, current_class))
9718                 {
9719                   char *p  = xstrdup (lang_printable_name (type, 0));
9720                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9721                                        p, p,
9722                                        lang_printable_name (current_class, 0));
9723                   free (p);
9724                   return 1;
9725                 }
9726               from_qualified_this = 1;
9727               /* If there's nothing else after that, we need to
9728                  produce something now, otherwise, the section of the
9729                  code that needs to produce <T>.this will generate
9730                  what is necessary. */
9731               if (!TREE_CHAIN (q))
9732                 {
9733                   decl = build_access_to_thisn (current_class, type, 0);
9734                   *where_found = decl = java_complete_tree (decl);
9735                   *type_found = type = TREE_TYPE (decl);
9736                 }
9737             }
9738
9739           from_type = 0;
9740           continue;
9741         }
9742
9743       /* 15.10.2 Accessing Superclass Members using SUPER */
9744       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9745           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9746         {
9747           tree node;
9748           /* Check on the restricted use of SUPER */
9749           if (METHOD_STATIC (current_function_decl)
9750               || current_class == object_type_node)
9751             {
9752               parse_error_context
9753                 (wfl, "Keyword `super' used outside allowed context");
9754               return 1;
9755             }
9756           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9757           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9758                              CLASSTYPE_SUPER (current_class),
9759                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9760           *where_found = decl = java_complete_tree (node);
9761           if (decl == error_mark_node)
9762             return 1;
9763           *type_found = type = QUAL_DECL_TYPE (decl);
9764           from_super = from_type = 1;
9765           continue;
9766         }
9767
9768       /* 15.13.1: Can't search for field name in packages, so we
9769          assume a variable/class name was meant. */
9770       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9771         {
9772           tree name;
9773           if ((decl = resolve_package (wfl, &q, &name)))
9774             {
9775               tree list;
9776               *where_found = decl;
9777
9778               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9779
9780               /* We want to be absolutely sure that the class is laid
9781                  out. We're going to search something inside it. */
9782               *type_found = type = TREE_TYPE (decl);
9783               layout_class (type);
9784               from_type = 1;
9785
9786               /* Fix them all the way down, if any are left. */
9787               if (q)
9788                 {
9789                   list = TREE_CHAIN (q);
9790                   while (list)
9791                     {
9792                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9793                       list = TREE_CHAIN (list);
9794                     }
9795                 }
9796             }
9797           else
9798             {
9799               if (from_super || from_cast)
9800                 parse_error_context
9801                   ((from_cast ? qual_wfl : wfl),
9802                    "No variable `%s' defined in class `%s'",
9803                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9804                    lang_printable_name (type, 0));
9805               else
9806                 parse_error_context
9807                   (qual_wfl, "Undefined variable or class name: `%s'",
9808                    IDENTIFIER_POINTER (name));
9809               return 1;
9810             }
9811         }
9812
9813       /* We have a type name. It's been already resolved when the
9814          expression was qualified. */
9815       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9816         {
9817           decl = QUAL_RESOLUTION (q);
9818
9819           /* Sneak preview. If next we see a `new', we're facing a
9820              qualification which resulted in a type being selected
9821              instead of a field.  Report the error.  */
9822           if(TREE_CHAIN (q)
9823              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9824             {
9825               parse_error_context (qual_wfl, "Undefined variable `%s'",
9826                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9827               return 1;
9828             }
9829
9830           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9831
9832           check_deprecation (qual_wfl, decl);
9833
9834           type = TREE_TYPE (decl);
9835           from_type = 1;
9836         }
9837       /* We resolve an expression name */
9838       else
9839         {
9840           tree field_decl = NULL_TREE;
9841
9842           /* If there exists an early resolution, use it. That occurs
9843              only once and we know that there are more things to
9844              come. Don't do that when processing something after SUPER
9845              (we need more thing to be put in place below */
9846           if (!from_super && QUAL_RESOLUTION (q))
9847             {
9848               decl = QUAL_RESOLUTION (q);
9849               if (!type)
9850                 {
9851                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9852                     {
9853                       if (current_this)
9854                         *where_found = current_this;
9855                       else
9856                         {
9857                           static_ref_err (qual_wfl, DECL_NAME (decl),
9858                                           current_class);
9859                           return 1;
9860                         }
9861                       if (outer_field_access_p (current_class, decl))
9862                         decl = build_outer_field_access (qual_wfl, decl);
9863                     }
9864                   else
9865                     {
9866                       *where_found = TREE_TYPE (decl);
9867                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9868                         *where_found = TREE_TYPE (*where_found);
9869                     }
9870                 }
9871             }
9872
9873           /* Report and error if we're using a numerical literal as a
9874              qualifier. It can only be an INTEGER_CST. */
9875           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9876             {
9877               parse_error_context
9878                 (wfl, "Can't use type `%s' as a qualifier",
9879                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9880               return 1;
9881             }
9882
9883           /* We have to search for a field, knowing the type of its
9884              container. The flag FROM_TYPE indicates that we resolved
9885              the last member of the expression as a type name, which
9886              means that for the resolution of this field, we'll look
9887              for other errors than if it was resolved as a member of
9888              an other field. */
9889           else
9890             {
9891               int is_static;
9892               tree field_decl_type; /* For layout */
9893
9894               if (!from_type && !JREFERENCE_TYPE_P (type))
9895                 {
9896                   parse_error_context
9897                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9898                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9899                      lang_printable_name (type, 0),
9900                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9901                   return 1;
9902                 }
9903
9904               field_decl = lookup_field_wrapper (type,
9905                                                  EXPR_WFL_NODE (qual_wfl));
9906
9907               /* Maybe what we're trying to access to is an inner
9908                  class, only if decl is a TYPE_DECL. */
9909               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9910                 {
9911                   tree ptr, inner_decl;
9912
9913                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9914                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9915                   if (inner_decl)
9916                     {
9917                       check_inner_class_access (inner_decl, decl, qual_wfl);
9918                       type = TREE_TYPE (inner_decl);
9919                       decl = inner_decl;
9920                       from_type = 1;
9921                       continue;
9922                     }
9923                 }
9924
9925               if (field_decl == NULL_TREE)
9926                 {
9927                   parse_error_context
9928                     (qual_wfl, "No variable `%s' defined in type `%s'",
9929                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9930                      GET_TYPE_NAME (type));
9931                   return 1;
9932                 }
9933               if (field_decl == error_mark_node)
9934                 return 1;
9935
9936               /* Layout the type of field_decl, since we may need
9937                  it. Don't do primitive types or loaded classes. The
9938                  situation of non primitive arrays may not handled
9939                  properly here. FIXME */
9940               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9941                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9942               else
9943                 field_decl_type = TREE_TYPE (field_decl);
9944               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9945                   && !CLASS_LOADED_P (field_decl_type)
9946                   && !TYPE_ARRAY_P (field_decl_type))
9947                 resolve_and_layout (field_decl_type, NULL_TREE);
9948
9949               /* Check on accessibility here */
9950               if (not_accessible_p (current_class, field_decl,
9951                                     *type_found, from_super))
9952                 return not_accessible_field_error (qual_wfl,field_decl);
9953               check_deprecation (qual_wfl, field_decl);
9954
9955               /* There are things to check when fields are accessed
9956                  from type. There are no restrictions on a static
9957                  declaration of the field when it is accessed from an
9958                  interface */
9959               is_static = FIELD_STATIC (field_decl);
9960               if (!from_super && from_type
9961                   && !TYPE_INTERFACE_P (type)
9962                   && !is_static
9963                   && (current_function_decl
9964                       && METHOD_STATIC (current_function_decl)))
9965                 {
9966                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9967                   return 1;
9968                 }
9969               from_cast = from_super = 0;
9970
9971               /* It's an access from a type but it isn't static, we
9972                  make it relative to `this'. */
9973               if (!is_static && from_type)
9974                 decl = current_this;
9975
9976               /* If we need to generate something to get a proper
9977                  handle on what this field is accessed from, do it
9978                  now. */
9979               if (!is_static)
9980                 {
9981                   decl = maybe_access_field (decl, *where_found, *type_found);
9982                   if (decl == error_mark_node)
9983                     return 1;
9984                 }
9985
9986               /* We want to keep the location were found it, and the type
9987                  we found. */
9988               *where_found = decl;
9989               *type_found = type;
9990
9991               /* Generate the correct expression for field access from
9992                  qualified this */
9993               if (from_qualified_this)
9994                 {
9995                   field_decl = build_outer_field_access (qual_wfl, field_decl);
9996                   from_qualified_this = 0;
9997                 }
9998
9999               /* This is the decl found and eventually the next one to
10000                  search from */
10001               decl = field_decl;
10002             }
10003           from_type = 0;
10004           type = QUAL_DECL_TYPE (decl);
10005
10006           /* Sneak preview. If decl is qualified by a `new', report
10007              the error here to be accurate on the peculiar construct */
10008           if (TREE_CHAIN (q)
10009               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10010               && !JREFERENCE_TYPE_P (type))
10011             {
10012               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10013                                    lang_printable_name (type, 0));
10014               return 1;
10015             }
10016         }
10017       /* `q' might have changed due to a after package resolution
10018          re-qualification */
10019       if (!q)
10020         break;
10021     }
10022   *found_decl = decl;
10023   return 0;
10024 }
10025
10026 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10027    can't be accessed from REFERENCE (a record type). If MEMBER
10028    features a protected access, we then use WHERE which, if non null,
10029    holds the type of MEMBER's access that is checked against
10030    6.6.2.1. This function should be used when decl is a field or a
10031    method.  */
10032
10033 static int
10034 not_accessible_p (tree reference, tree member, tree where, int from_super)
10035 {
10036   int access_flag = get_access_flags_from_decl (member);
10037   bool is_static = false;
10038
10039   if (TREE_CODE (member) == FIELD_DECL ||
10040       TREE_CODE (member) == VAR_DECL)
10041     is_static = FIELD_STATIC (member);
10042   else
10043     is_static = METHOD_STATIC (member);
10044
10045   /* Access always granted for members declared public */
10046   if (access_flag & ACC_PUBLIC)
10047     return 0;
10048
10049   /* Check access on protected members */
10050   if (access_flag & ACC_PROTECTED)
10051     {
10052       /* Access granted if it occurs from within the package
10053          containing the class in which the protected member is
10054          declared */
10055       if (class_in_current_package (DECL_CONTEXT (member)))
10056         return 0;
10057
10058       /* If accessed with the form `super.member', then access is granted */
10059       if (from_super)
10060         return 0;
10061
10062       /* If WHERE is active, access was made through a qualifier. For
10063          non-static members, access is granted if the type of the qualifier
10064          is or is a sublass of the type the access is made from (6.6.2.1.)  */
10065       if (where && !is_static)
10066         {
10067           while (reference)
10068             {
10069               if (inherits_from_p (where, reference))
10070                 return 0;
10071               if (INNER_CLASS_TYPE_P (reference))
10072                 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10073               else
10074                 break;
10075             }
10076           return 1;
10077         }
10078
10079       /* Otherwise, access is granted if occurring from within the class
10080          where member is declared, or a subclass of it.  */
10081       while (reference)
10082         {
10083           if (inherits_from_p (reference, DECL_CONTEXT (member)))
10084             return 0;
10085           if (INNER_CLASS_TYPE_P (reference))
10086             reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10087           else
10088             break;
10089         }
10090       return 1;
10091     }
10092
10093   /* Check access on private members. Access is granted only if it
10094      occurs from within the class in which it is declared -- that does
10095      it for innerclasses too. */
10096   if (access_flag & ACC_PRIVATE)
10097     {
10098       if (reference == DECL_CONTEXT (member) ||
10099           common_enclosing_context_p (DECL_CONTEXT (member), reference))
10100         return 0;
10101       return 1;
10102     }
10103
10104   /* Default access is permitted only when occurring from within the
10105      package in which the context (MEMBER) is declared.  */
10106   return !class_in_current_package (DECL_CONTEXT (member));
10107 }
10108
10109 /* Test deprecated decl access.  */
10110 static void
10111 check_deprecation (tree wfl, tree decl)
10112 {
10113   const char *file;
10114   tree elt;
10115
10116   if (! warn_deprecated)
10117     return;
10118
10119   /* We want to look at the element type of arrays here, so we strip
10120      all surrounding array types.  */
10121   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10122     {
10123       elt = TREE_TYPE (decl);
10124       while (TYPE_ARRAY_P (elt))
10125         elt = TYPE_ARRAY_ELEMENT (elt);
10126       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10127          to the record.  */
10128       decl = TYPE_NAME (TREE_TYPE (elt));
10129     }
10130   file = DECL_SOURCE_FILE (decl);
10131
10132   /* Complain if the field is deprecated and the file it was defined
10133      in isn't compiled at the same time the file which contains its
10134      use is */
10135   if (DECL_DEPRECATED (decl)
10136       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10137     {
10138       const char *the;
10139       switch (TREE_CODE (decl))
10140         {
10141         case FUNCTION_DECL:
10142           the = "method";
10143           break;
10144         case FIELD_DECL:
10145         case VAR_DECL:
10146           the = "field";
10147           break;
10148         case TYPE_DECL:
10149           parse_warning_context (wfl, "The class `%s' has been deprecated",
10150                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10151           return;
10152         default:
10153           abort ();
10154         }
10155       /* Don't issue a message if the context as been deprecated as a
10156          whole. */
10157       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10158         parse_warning_context
10159           (wfl, "The %s `%s' in class `%s' has been deprecated",
10160            the, lang_printable_name (decl, 0),
10161            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10162     }
10163 }
10164
10165 /* Returns 1 if class was declared in the current package, 0 otherwise */
10166
10167 static GTY(()) tree cicp_cache;
10168 static int
10169 class_in_current_package (tree class)
10170 {
10171   int qualified_flag;
10172   tree left;
10173
10174   if (cicp_cache == class)
10175     return 1;
10176
10177   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10178
10179   /* If the current package is empty and the name of CLASS is
10180      qualified, class isn't in the current package.  If there is a
10181      current package and the name of the CLASS is not qualified, class
10182      isn't in the current package */
10183   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10184     return 0;
10185
10186   /* If there is not package and the name of CLASS isn't qualified,
10187      they belong to the same unnamed package */
10188   if (!ctxp->package && !qualified_flag)
10189     return 1;
10190
10191   /* Compare the left part of the name of CLASS with the package name */
10192   split_qualified_name (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10193   if (ctxp->package == left)
10194     {
10195       cicp_cache = class;
10196       return 1;
10197     }
10198   return 0;
10199 }
10200
10201 /* This function may generate code to access DECL from WHERE. This is
10202    done only if certain conditions meet.  */
10203
10204 static tree
10205 maybe_access_field (tree decl, tree where, tree type)
10206 {
10207   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10208       && !FIELD_STATIC (decl))
10209     decl = build_field_ref (where ? where : current_this,
10210                             (type ? type : DECL_CONTEXT (decl)),
10211                             DECL_NAME (decl));
10212   return decl;
10213 }
10214
10215 /* Build a method invocation, by patching PATCH. If non NULL
10216    and according to the situation, PRIMARY and WHERE may be
10217    used. IS_STATIC is set to 1 if the invoked function is static. */
10218
10219 static tree
10220 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10221                          int *is_static, tree *ret_decl)
10222 {
10223   tree wfl = TREE_OPERAND (patch, 0);
10224   tree args = TREE_OPERAND (patch, 1);
10225   tree name = EXPR_WFL_NODE (wfl);
10226   tree list;
10227   int is_static_flag = 0;
10228   int is_super_init = 0;
10229   tree this_arg = NULL_TREE;
10230   int is_array_clone_call = 0;
10231
10232   /* Should be overridden if everything goes well. Otherwise, if
10233      something fails, it should keep this value. It stop the
10234      evaluation of a bogus assignment. See java_complete_tree,
10235      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10236      evaluating an assignment */
10237   TREE_TYPE (patch) = error_mark_node;
10238
10239   /* Since lookup functions are messing with line numbers, save the
10240      context now.  */
10241   java_parser_context_save_global ();
10242
10243   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10244
10245   /* Resolution of qualified name, excluding constructors */
10246   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10247     {
10248       tree identifier, identifier_wfl, type, resolved;
10249       /* Extract the last IDENTIFIER of the qualified
10250          expression. This is a wfl and we will use it's location
10251          data during error report. */
10252       identifier_wfl = cut_identifier_in_qualified (wfl);
10253       identifier = EXPR_WFL_NODE (identifier_wfl);
10254
10255       /* Given the context, IDENTIFIER is syntactically qualified
10256          as a MethodName. We need to qualify what's before */
10257       qualify_ambiguous_name (wfl);
10258       resolved = resolve_field_access (wfl, NULL, NULL);
10259
10260       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10261          && FIELD_FINAL (resolved)
10262          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10263          && !flag_emit_class_files && !flag_emit_xref)
10264        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10265
10266       if (resolved == error_mark_node)
10267         PATCH_METHOD_RETURN_ERROR ();
10268
10269       type = GET_SKIP_TYPE (resolved);
10270       resolve_and_layout (type, NULL_TREE);
10271
10272       if (JPRIMITIVE_TYPE_P (type))
10273         {
10274           parse_error_context
10275             (identifier_wfl,
10276              "Can't invoke a method on primitive type `%s'",
10277              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10278           PATCH_METHOD_RETURN_ERROR ();
10279         }
10280
10281       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10282       args = nreverse (args);
10283
10284       /* We're resolving a call from a type */
10285       if (TREE_CODE (resolved) == TYPE_DECL)
10286         {
10287           if (CLASS_INTERFACE (resolved))
10288             {
10289               parse_error_context
10290                 (identifier_wfl,
10291                 "Can't make static reference to method `%s' in interface `%s'",
10292                  IDENTIFIER_POINTER (identifier),
10293                  IDENTIFIER_POINTER (name));
10294               PATCH_METHOD_RETURN_ERROR ();
10295             }
10296           if (list && !METHOD_STATIC (list))
10297             {
10298               char *fct_name = xstrdup (lang_printable_name (list, 2));
10299               parse_error_context
10300                 (identifier_wfl,
10301                  "Can't make static reference to method `%s %s' in class `%s'",
10302                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10303                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10304               free (fct_name);
10305               PATCH_METHOD_RETURN_ERROR ();
10306             }
10307         }
10308       else
10309         this_arg = primary = resolved;
10310
10311       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10312         is_array_clone_call = 1;
10313
10314       /* IDENTIFIER_WFL will be used to report any problem further */
10315       wfl = identifier_wfl;
10316     }
10317   /* Resolution of simple names, names generated after a primary: or
10318      constructors */
10319   else
10320     {
10321       tree class_to_search = NULL_TREE;
10322       int lc;                   /* Looking for Constructor */
10323
10324       /* We search constructor in their target class */
10325       if (CALL_CONSTRUCTOR_P (patch))
10326         {
10327           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10328             class_to_search = EXPR_WFL_NODE (wfl);
10329           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10330                    this_identifier_node)
10331             class_to_search = NULL_TREE;
10332           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10333                    super_identifier_node)
10334             {
10335               is_super_init = 1;
10336               if (CLASSTYPE_SUPER (current_class))
10337                 class_to_search =
10338                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10339               else
10340                 {
10341                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10342                   PATCH_METHOD_RETURN_ERROR ();
10343                 }
10344             }
10345
10346           /* Class to search is NULL if we're searching the current one */
10347           if (class_to_search)
10348             {
10349               class_to_search = resolve_and_layout (class_to_search, wfl);
10350
10351               if (!class_to_search)
10352                 {
10353                   parse_error_context
10354                     (wfl, "Class `%s' not found in type declaration",
10355                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10356                   PATCH_METHOD_RETURN_ERROR ();
10357                 }
10358
10359               /* Can't instantiate an abstract class, but we can
10360                  invoke it's constructor. It's use within the `new'
10361                  context is denied here. */
10362               if (CLASS_ABSTRACT (class_to_search)
10363                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10364                 {
10365                   parse_error_context
10366                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10367                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10368                   PATCH_METHOD_RETURN_ERROR ();
10369                 }
10370
10371               class_to_search = TREE_TYPE (class_to_search);
10372             }
10373           else
10374             class_to_search = current_class;
10375           lc = 1;
10376         }
10377       /* This is a regular search in the local class, unless an
10378          alternate class is specified. */
10379       else
10380         {
10381           if (where != NULL_TREE)
10382             class_to_search = where;
10383           else if (QUALIFIED_P (name))
10384             class_to_search = current_class;
10385           else
10386             {
10387               class_to_search = current_class;
10388
10389               for (;;)
10390                 {
10391                   if (has_method (class_to_search, name))
10392                     break;
10393                   if (! INNER_CLASS_TYPE_P (class_to_search))
10394                     {
10395                       parse_error_context (wfl,
10396                                            "No method named `%s' in scope",
10397                                            IDENTIFIER_POINTER (name));
10398                       PATCH_METHOD_RETURN_ERROR ();
10399                     }
10400                   class_to_search
10401                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10402                 }
10403             }
10404           lc = 0;
10405         }
10406
10407       /* NAME is a simple identifier or comes from a primary. Search
10408          in the class whose declaration contain the method being
10409          invoked. */
10410       resolve_and_layout (class_to_search, NULL_TREE);
10411
10412       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10413       /* Don't continue if no method were found, as the next statement
10414          can't be executed then. */
10415       if (!list)
10416         PATCH_METHOD_RETURN_ERROR ();
10417
10418       if (TYPE_ARRAY_P (class_to_search)
10419           && DECL_NAME (list) == get_identifier ("clone"))
10420         is_array_clone_call = 1;
10421
10422       /* Check for static reference if non static methods */
10423       if (check_for_static_method_reference (wfl, patch, list,
10424                                              class_to_search, primary))
10425         PATCH_METHOD_RETURN_ERROR ();
10426
10427       /* Check for inner classes creation from illegal contexts */
10428       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10429                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10430           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10431           && !DECL_INIT_P (current_function_decl))
10432         {
10433           parse_error_context
10434             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10435              lang_printable_name (class_to_search, 0),
10436              (!current_this ? "" :
10437               "; an explicit one must be provided when creating this inner class"));
10438           PATCH_METHOD_RETURN_ERROR ();
10439         }
10440
10441       /* Non static methods are called with the current object extra
10442          argument. If patch a `new TYPE()', the argument is the value
10443          returned by the object allocator. If method is resolved as a
10444          primary, use the primary otherwise use the current THIS. */
10445       args = nreverse (args);
10446       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10447         {
10448           this_arg = primary ? primary : current_this;
10449
10450           /* If we're using an access method, things are different.
10451              There are two family of cases:
10452
10453              1) We're not generating bytecodes:
10454
10455              - LIST is non static. It's invocation is transformed from
10456                x(a1,...,an) into this$<n>.x(a1,....an).
10457              - LIST is static. It's invocation is transformed from
10458                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10459
10460              2) We're generating bytecodes:
10461
10462              - LIST is non static. It's invocation is transformed from
10463                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10464              - LIST is static. It's invocation is transformed from
10465                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10466
10467              Of course, this$<n> can be arbitrarily complex, ranging from
10468              this$0 (the immediate outer context) to
10469              access$0(access$0(...(this$0))).
10470
10471              maybe_use_access_method returns a nonzero value if the
10472              this_arg has to be moved into the (then generated) stub
10473              argument list. In the meantime, the selected function
10474              might have be replaced by a generated stub. */
10475           if (!primary &&
10476               maybe_use_access_method (is_super_init, &list, &this_arg))
10477             {
10478               args = tree_cons (NULL_TREE, this_arg, args);
10479               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10480             }
10481         }
10482     }
10483
10484   /* Merge point of all resolution schemes. If we have nothing, this
10485      is an error, already signaled */
10486   if (!list)
10487     PATCH_METHOD_RETURN_ERROR ();
10488
10489   /* Check accessibility, position the is_static flag, build and
10490      return the call */
10491   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10492                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10493                          NULL_TREE), from_super)
10494       /* Calls to clone() on array types are permitted as a special-case. */
10495       && !is_array_clone_call)
10496     {
10497       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10498       const char *const access =
10499         accessibility_string (get_access_flags_from_decl (list));
10500       const char *const klass =
10501         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10502       const char *const refklass =
10503         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10504       const char *const what = (DECL_CONSTRUCTOR_P (list)
10505                                 ? "constructor" : "method");
10506       parse_error_context (wfl,
10507                            "Can't access %s %s `%s.%s' from `%s'",
10508                            access, what, klass, fct_name, refklass);
10509       PATCH_METHOD_RETURN_ERROR ();
10510     }
10511
10512   /* Deprecation check: check whether the method being invoked or the
10513      instance-being-created's type are deprecated.  */
10514   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10515     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10516   check_deprecation (wfl, list);
10517
10518   /* If invoking a innerclass constructor, there are hidden parameters
10519      to pass */
10520   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10521       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10522     {
10523       /* And make sure we add the accessed local variables to be saved
10524          in field aliases. */
10525       args = build_alias_initializer_parameter_list
10526         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10527
10528       /* Secretly pass the current_this/primary as a second argument */
10529       if (primary || current_this)
10530         {
10531           tree extra_arg;
10532           tree this_type = (current_this ?
10533                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10534           /* Method's (list) enclosing context */
10535           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10536           /* If we have a primary, use it. */
10537           if (primary)
10538             extra_arg = primary;
10539           /* The current `this' is an inner class but isn't a direct
10540              enclosing context for the inner class we're trying to
10541              create. Build an access to the proper enclosing context
10542              and use it. */
10543           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10544                    && this_type != TREE_TYPE (mec))
10545             {
10546
10547               extra_arg = build_access_to_thisn (current_class,
10548                                                  TREE_TYPE (mec), 0);
10549               extra_arg = java_complete_tree (extra_arg);
10550             }
10551           /* Otherwise, just use the current `this' as an enclosing
10552              context. */
10553           else
10554             extra_arg = current_this;
10555           args = tree_cons (NULL_TREE, extra_arg, args);
10556         }
10557       else
10558         args = tree_cons (NULL_TREE, integer_zero_node, args);
10559     }
10560
10561   /* This handles the situation where a constructor invocation needs
10562      to have an enclosing context passed as a second parameter (the
10563      constructor is one of an inner class). */
10564   if ((is_super_init ||
10565        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10566       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10567     {
10568       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10569       tree extra_arg =
10570         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10571       extra_arg = java_complete_tree (extra_arg);
10572       args = tree_cons (NULL_TREE, extra_arg, args);
10573     }
10574
10575   is_static_flag = METHOD_STATIC (list);
10576   if (! is_static_flag && this_arg != NULL_TREE)
10577     args = tree_cons (NULL_TREE, this_arg, args);
10578
10579   /* In the context of an explicit constructor invocation, we can't
10580      invoke any method relying on `this'. Exceptions are: we're
10581      invoking a static function, primary exists and is not the current
10582      this, we're creating a new object. */
10583   if (ctxp->explicit_constructor_p
10584       && !is_static_flag
10585       && (!primary || primary == current_this)
10586       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10587     {
10588       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10589       PATCH_METHOD_RETURN_ERROR ();
10590     }
10591   java_parser_context_restore_global ();
10592   if (is_static)
10593     *is_static = is_static_flag;
10594   /* Sometimes, we want the decl of the selected method. Such as for
10595      EH checking */
10596   if (ret_decl)
10597     *ret_decl = list;
10598   patch = patch_invoke (patch, list, args);
10599
10600   /* Now is a good time to insert the call to finit$ */
10601   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10602     {
10603       tree finit_parms, finit_call;
10604
10605       /* Prepare to pass hidden parameters to finit$, if any. */
10606       finit_parms = build_alias_initializer_parameter_list
10607         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10608
10609       finit_call =
10610         build_method_invocation (build_wfl_node (finit_identifier_node),
10611                                  finit_parms);
10612
10613       /* Generate the code used to initialize fields declared with an
10614          initialization statement and build a compound statement along
10615          with the super constructor invocation. */
10616       CAN_COMPLETE_NORMALLY (patch) = 1;
10617       patch = build2 (COMPOUND_EXPR, void_type_node, patch,
10618                       java_complete_tree (finit_call));
10619     }
10620   return patch;
10621 }
10622
10623 /* Check that we're not trying to do a static reference to a method in
10624    non static method. Return 1 if it's the case, 0 otherwise. */
10625
10626 static int
10627 check_for_static_method_reference (tree wfl, tree node, tree method,
10628                                    tree where, tree primary)
10629 {
10630   if (METHOD_STATIC (current_function_decl)
10631       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10632     {
10633       char *fct_name = xstrdup (lang_printable_name (method, 0));
10634       parse_error_context
10635         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10636          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10637          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10638       free (fct_name);
10639       return 1;
10640     }
10641   return 0;
10642 }
10643
10644 /* Fix the invocation of *MDECL if necessary in the case of a
10645    invocation from an inner class. *THIS_ARG might be modified
10646    appropriately and an alternative access to *MDECL might be
10647    returned.  */
10648
10649 static int
10650 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10651 {
10652   tree ctx;
10653   tree md = *mdecl, ta = *this_arg;
10654   int to_return = 0;
10655   int non_static_context = !METHOD_STATIC (md);
10656
10657   if (is_super_init
10658       || DECL_CONTEXT (md) == current_class
10659       || !PURE_INNER_CLASS_TYPE_P (current_class)
10660       || DECL_FINIT_P (md)
10661       || DECL_INSTINIT_P (md))
10662     return 0;
10663
10664   /* If we're calling a method found in an enclosing class, generate
10665      what it takes to retrieve the right this. Don't do that if we're
10666      invoking a static method. Note that if MD's type is unrelated to
10667      CURRENT_CLASS, then the current this can be used. */
10668
10669   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10670     {
10671       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10672       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10673         {
10674           ta = build_current_thisn (current_class);
10675           ta = build_wfl_node (ta);
10676         }
10677       else
10678         {
10679           tree type = ctx;
10680           while (type)
10681             {
10682               maybe_build_thisn_access_method (type);
10683               if (inherits_from_p (type, DECL_CONTEXT (md)))
10684                 {
10685                   ta = build_access_to_thisn (ctx, type, 0);
10686                   break;
10687                 }
10688               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10689                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10690             }
10691         }
10692       ta = java_complete_tree (ta);
10693     }
10694
10695   /* We might have to use an access method to get to MD. We can
10696      break the method access rule as far as we're not generating
10697      bytecode */
10698   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10699     {
10700       md = build_outer_method_access_method (md);
10701       to_return = 1;
10702     }
10703
10704   *mdecl = md;
10705   *this_arg = ta;
10706
10707   /* Returning a nonzero value indicates we were doing a non static
10708      method invocation that is now a static invocation. It will have
10709      callee displace `this' to insert it in the regular argument
10710      list. */
10711   return (non_static_context && to_return);
10712 }
10713
10714 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10715    mode.  */
10716
10717 static tree
10718 patch_invoke (tree patch, tree method, tree args)
10719 {
10720   tree dtable, func;
10721   tree original_call, t, ta;
10722   tree check = NULL_TREE;
10723
10724   /* Last step for args: convert build-in types. If we're dealing with
10725      a new TYPE() type call, the first argument to the constructor
10726      isn't found in the incoming argument list, but delivered by
10727      `new' */
10728   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10729   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10730     t = TREE_CHAIN (t);
10731   for (ta = args; t != end_params_node && ta;
10732        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10733     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10734         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10735       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10736
10737   /* Resolve unresolved returned type issues */
10738   t = TREE_TYPE (TREE_TYPE (method));
10739   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10740     resolve_and_layout (TREE_TYPE (t), NULL);
10741
10742   if (flag_emit_class_files || flag_emit_xref)
10743     func = method;
10744   else
10745     {
10746       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10747         {
10748         case INVOKE_VIRTUAL:
10749           dtable = invoke_build_dtable (0, args);
10750           func = build_invokevirtual (dtable, method);
10751           break;
10752
10753         case INVOKE_NONVIRTUAL:
10754           /* If the object for the method call is null, we throw an
10755              exception.  We don't do this if the object is the current
10756              method's `this'.  In other cases we just rely on an
10757              optimization pass to eliminate redundant checks.  */
10758           if (TREE_VALUE (args) != current_this)
10759             {
10760               /* We use a save_expr here to make sure we only evaluate
10761                  the new `self' expression once.  */
10762               tree save_arg = save_expr (TREE_VALUE (args));
10763               TREE_VALUE (args) = save_arg;
10764               check = java_check_reference (save_arg, 1);
10765             }
10766           /* Fall through.  */
10767
10768         case INVOKE_SUPER:
10769         case INVOKE_STATIC:
10770           {
10771             tree signature = build_java_signature (TREE_TYPE (method));
10772             func = build_known_method_ref (method, TREE_TYPE (method),
10773                                            DECL_CONTEXT (method),
10774                                            signature, args);
10775           }
10776           break;
10777
10778         case INVOKE_INTERFACE:
10779           dtable = invoke_build_dtable (1, args);
10780           func = build_invokeinterface (dtable, method);
10781           break;
10782
10783         default:
10784           abort ();
10785         }
10786
10787       /* Ensure self_type is initialized, (invokestatic). FIXME */
10788       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10789     }
10790
10791   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10792   TREE_OPERAND (patch, 0) = func;
10793   TREE_OPERAND (patch, 1) = args;
10794   patch = check_for_builtin (method, patch);
10795   original_call = patch;
10796
10797   /* We're processing a `new TYPE ()' form. New is called and its
10798      returned value is the first argument to the constructor. We build
10799      a COMPOUND_EXPR and use saved expression so that the overall NEW
10800      expression value is a pointer to a newly created and initialized
10801      class. */
10802   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10803     {
10804       tree class = DECL_CONTEXT (method);
10805       tree c1, saved_new, size, new;
10806       tree alloc_node;
10807
10808       if (flag_emit_class_files || flag_emit_xref)
10809         {
10810           TREE_TYPE (patch) = build_pointer_type (class);
10811           return patch;
10812         }
10813       if (!TYPE_SIZE (class))
10814         safe_layout_class (class);
10815       size = size_in_bytes (class);
10816       alloc_node =
10817         (class_has_finalize_method (class) ? alloc_object_node
10818                                            : alloc_no_finalizer_node);
10819       new = build3 (CALL_EXPR, promote_type (class),
10820                     build_address_of (alloc_node),
10821                     build_tree_list (NULL_TREE, build_class_ref (class)),
10822                     NULL_TREE);
10823       saved_new = save_expr (new);
10824       c1 = build_tree_list (NULL_TREE, saved_new);
10825       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10826       TREE_OPERAND (original_call, 1) = c1;
10827       TREE_SET_CODE (original_call, CALL_EXPR);
10828       patch = build2 (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10829     }
10830
10831   /* If CHECK is set, then we are building a check to see if the object
10832      is NULL.  */
10833   if (check != NULL_TREE)
10834     {
10835       /* We have to call force_evaluation_order now because creating a
10836          COMPOUND_EXPR wraps the arg list in a way that makes it
10837          unrecognizable by force_evaluation_order later.  Yuk.  */
10838       patch = build2 (COMPOUND_EXPR, TREE_TYPE (patch), check,
10839                       force_evaluation_order (patch));
10840       TREE_SIDE_EFFECTS (patch) = 1;
10841     }
10842
10843   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10844      put it as the first expression of a COMPOUND_EXPR. The second
10845      expression being an empty statement to be later patched if
10846      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10847      the VALUE is the compound) in a hashtable and return a
10848      COMPOUND_EXPR built so that the result of the evaluation of the
10849      original PATCH node is returned. */
10850   if (STATIC_CLASS_INIT_OPT_P ()
10851       && current_function_decl && METHOD_STATIC (method))
10852     {
10853       tree list;
10854       tree fndecl = current_function_decl;
10855       /* We have to call force_evaluation_order now because creating a
10856          COMPOUND_EXPR wraps the arg list in a way that makes it
10857          unrecognizable by force_evaluation_order later.  Yuk.  */
10858       tree save = force_evaluation_order (patch);
10859       tree type = TREE_TYPE (patch);
10860
10861       patch = build2 (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
10862       list = tree_cons (method, patch,
10863                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10864
10865       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10866
10867       patch = build2 (COMPOUND_EXPR, type, patch, save);
10868     }
10869
10870   return patch;
10871 }
10872
10873 static int
10874 invocation_mode (tree method, int super)
10875 {
10876   int access = get_access_flags_from_decl (method);
10877
10878   if (super)
10879     return INVOKE_SUPER;
10880
10881   if (access & ACC_STATIC)
10882     return INVOKE_STATIC;
10883
10884   /* We have to look for a constructor before we handle nonvirtual
10885      calls; otherwise the constructor will look nonvirtual.  */
10886   if (DECL_CONSTRUCTOR_P (method))
10887     return INVOKE_STATIC;
10888
10889   if (access & ACC_FINAL || access & ACC_PRIVATE)
10890     return INVOKE_NONVIRTUAL;
10891
10892   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10893     return INVOKE_NONVIRTUAL;
10894
10895   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10896     return INVOKE_INTERFACE;
10897
10898   return INVOKE_VIRTUAL;
10899 }
10900
10901 /* Retrieve a refined list of matching methods. It covers the step
10902    15.11.2 (Compile-Time Step 2) */
10903
10904 static tree
10905 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10906 {
10907   tree atl = end_params_node;           /* Arg Type List */
10908   tree method, signature, list, node;
10909   const char *candidates;               /* Used for error report */
10910   char *dup;
10911
10912   /* Fix the arguments */
10913   for (node = arg_list; node; node = TREE_CHAIN (node))
10914     {
10915       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10916       /* Non primitive type may have to be resolved */
10917       if (!JPRIMITIVE_TYPE_P (current_arg))
10918         resolve_and_layout (current_arg, NULL_TREE);
10919       /* And promoted */
10920       if (TREE_CODE (current_arg) == RECORD_TYPE)
10921         current_arg = promote_type (current_arg);
10922       atl = tree_cons (NULL_TREE, current_arg, atl);
10923     }
10924
10925   /* Presto. If we're dealing with an anonymous class and a
10926      constructor call, generate the right constructor now, since we
10927      know the arguments' types. */
10928
10929   if (lc && ANONYMOUS_CLASS_P (class))
10930     {
10931       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10932       /* The anonymous class may have already been laid out, so make sure
10933          the new constructor is laid out here.  */
10934       layout_class_method (class, CLASSTYPE_SUPER (class), mdecl, NULL_TREE);
10935     }
10936
10937   /* Find all candidates and then refine the list, searching for the
10938      most specific method. */
10939   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10940   list = find_most_specific_methods_list (list);
10941   if (list && !TREE_CHAIN (list))
10942     return TREE_VALUE (list);
10943
10944   /* Issue an error. List candidates if any. Candidates are listed
10945      only if accessible (non accessible methods may end-up here for
10946      the sake of a better error report). */
10947   candidates = NULL;
10948   if (list)
10949     {
10950       tree current;
10951       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10952       for (current = list; current; current = TREE_CHAIN (current))
10953         {
10954           tree cm = TREE_VALUE (current);
10955           char string [4096];
10956           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10957             continue;
10958           sprintf
10959             (string, "  `%s' in `%s'%s",
10960              get_printable_method_name (cm),
10961              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10962              (TREE_CHAIN (current) ? "\n" : ""));
10963           obstack_grow (&temporary_obstack, string, strlen (string));
10964         }
10965       obstack_1grow (&temporary_obstack, '\0');
10966       candidates = obstack_finish (&temporary_obstack);
10967     }
10968   /* Issue the error message */
10969   method = make_node (FUNCTION_TYPE);
10970   TYPE_ARG_TYPES (method) = atl;
10971   signature = build_java_argument_signature (method);
10972   dup = xstrdup (lang_printable_name (class, 0));
10973   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10974                        (lc ? "constructor" : "method"),
10975                        (lc ? dup : IDENTIFIER_POINTER (name)),
10976                        IDENTIFIER_POINTER (signature), dup,
10977                        (candidates ? candidates : ""));
10978   free (dup);
10979   return NULL_TREE;
10980 }
10981
10982 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10983    when we're looking for a constructor. */
10984
10985 static tree
10986 find_applicable_accessible_methods_list (int lc, tree class, tree name,
10987                                          tree arglist)
10988 {
10989   static htab_t searched_classes;
10990   static int search_not_done = 0;
10991   tree list = NULL_TREE, all_list = NULL_TREE;
10992   tree base_binfo;
10993   int i;
10994
10995   /* Check the hash table to determine if this class has been searched
10996      already. */
10997   if (searched_classes)
10998     {
10999       if (htab_find (searched_classes, class) != NULL)
11000         return NULL;
11001     }
11002   else
11003     {
11004       searched_classes = htab_create (10, htab_hash_pointer,
11005                                       htab_eq_pointer, NULL);
11006     }
11007
11008   search_not_done++;
11009   *htab_find_slot (searched_classes, class, INSERT) = class;
11010
11011   if (!CLASS_LOADED_P (class))
11012     {
11013       load_class (class, 1);
11014       safe_layout_class (class);
11015     }
11016
11017   /* Search interfaces */
11018   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11019       && CLASS_INTERFACE (TYPE_NAME (class)))
11020     {
11021       search_applicable_methods_list (lc, TYPE_METHODS (class),
11022                                       name, arglist, &list, &all_list);
11023       for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11024         {
11025           tree t = BINFO_TYPE (base_binfo);
11026           tree rlist;
11027
11028           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11029                                                            arglist);
11030           list = chainon (rlist, list);
11031         }
11032     }
11033   /* Search classes */
11034   else
11035     {
11036       search_applicable_methods_list (lc, TYPE_METHODS (class),
11037                                       name, arglist, &list, &all_list);
11038
11039       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11040          that we only search in class. Note that we should have found
11041          something at this point. */
11042       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11043         {
11044           lc = 1;
11045           if (!list)
11046             abort ();
11047         }
11048
11049       /* We must search all interfaces of this class */
11050       if (!lc)
11051         {
11052           for (i = 1;
11053                BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11054             {
11055               tree t = BINFO_TYPE (base_binfo);
11056               if (t != object_type_node)
11057                 {
11058                   tree rlist
11059                     = find_applicable_accessible_methods_list (lc, t,
11060                                                                name, arglist);
11061                   list = chainon (rlist, list);
11062                 }
11063             }
11064         }
11065
11066       /* Search superclass */
11067       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11068         {
11069           tree rlist;
11070           class = CLASSTYPE_SUPER (class);
11071           rlist = find_applicable_accessible_methods_list (lc, class,
11072                                                            name, arglist);
11073           list = chainon (rlist, list);
11074         }
11075     }
11076
11077   search_not_done--;
11078
11079   /* We're done. Reset the searched classes list and finally search
11080      java.lang.Object if it wasn't searched already. */
11081   if (!search_not_done)
11082     {
11083       if (!lc
11084           && TYPE_METHODS (object_type_node)
11085           && htab_find (searched_classes, object_type_node) == NULL)
11086         {
11087           search_applicable_methods_list (lc,
11088                                           TYPE_METHODS (object_type_node),
11089                                           name, arglist, &list, &all_list);
11090         }
11091       htab_delete (searched_classes);
11092       searched_classes = NULL;
11093     }
11094
11095   /* Either return the list obtained or all selected (but
11096      inaccessible) methods for better error report. */
11097   return (!list ? all_list : list);
11098 }
11099
11100 /* Effectively search for the appropriate method in method */
11101
11102 static void
11103 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11104                                 tree *list, tree *all_list)
11105 {
11106   for (; method; method = TREE_CHAIN (method))
11107     {
11108       /* When dealing with constructor, stop here, otherwise search
11109          other classes */
11110       if (lc && !DECL_CONSTRUCTOR_P (method))
11111         continue;
11112       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11113                        || (DECL_NAME (method) != name)))
11114         continue;
11115
11116       if (argument_types_convertible (method, arglist))
11117         {
11118           /* Retain accessible methods only */
11119           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11120                                  method, NULL_TREE, 0))
11121             *list = tree_cons (NULL_TREE, method, *list);
11122           else
11123             /* Also retain all selected method here */
11124             *all_list = tree_cons (NULL_TREE, method, *list);
11125         }
11126     }
11127 }
11128
11129 /* 15.11.2.2 Choose the Most Specific Method */
11130
11131 static tree
11132 find_most_specific_methods_list (tree list)
11133 {
11134   int max = 0;
11135   int abstract, candidates;
11136   tree current, new_list = NULL_TREE;
11137   for (current = list; current; current = TREE_CHAIN (current))
11138     {
11139       tree method;
11140       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11141
11142       for (method = list; method; method = TREE_CHAIN (method))
11143         {
11144           tree method_v, current_v;
11145           /* Don't test a method against itself */
11146           if (method == current)
11147             continue;
11148
11149           method_v = TREE_VALUE (method);
11150           current_v = TREE_VALUE (current);
11151
11152           /* Compare arguments and location where methods where declared */
11153           if (argument_types_convertible (method_v, current_v))
11154             {
11155               if (valid_method_invocation_conversion_p
11156                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11157                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11158                       && enclosing_context_p (DECL_CONTEXT (method_v),
11159                                               DECL_CONTEXT (current_v))))
11160                 {
11161                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11162                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11163                   max = (v > max ? v : max);
11164                 }
11165             }
11166         }
11167     }
11168
11169   /* Review the list and select the maximally specific methods */
11170   for (current = list, abstract = -1, candidates = -1;
11171        current; current = TREE_CHAIN (current))
11172     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11173       {
11174         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11175         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11176         candidates++;
11177       }
11178
11179   /* If we have several and they're all abstract, just pick the
11180      closest one. */
11181   if (candidates > 0 && candidates == abstract)
11182     {
11183       /* FIXME: merge the throws clauses.  There is no convenient way
11184          to do this in gcj right now, since ideally we'd like to
11185          introduce a new METHOD_DECL here, but that is really not
11186          possible.  */
11187       new_list = nreverse (new_list);
11188       TREE_CHAIN (new_list) = NULL_TREE;
11189       return new_list;
11190     }
11191
11192   /* We have several (we couldn't find a most specific), all but one
11193      are abstract, we pick the only non abstract one. */
11194   if (candidates > 0 && (candidates == abstract+1))
11195     {
11196       for (current = new_list; current; current = TREE_CHAIN (current))
11197         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11198           {
11199             TREE_CHAIN (current) = NULL_TREE;
11200             new_list = current;
11201           }
11202     }
11203
11204   /* If we can't find one, lower expectations and try to gather multiple
11205      maximally specific methods */
11206   while (!new_list && max)
11207     {
11208       while (--max > 0)
11209         {
11210           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11211             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11212         }
11213     }
11214
11215   return new_list;
11216 }
11217
11218 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11219    converted by method invocation conversion (5.3) to the type of the
11220    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11221    to change less often than M1. */
11222
11223 static GTY(()) tree m2_arg_value;
11224 static GTY(()) tree m2_arg_cache;
11225
11226 static int
11227 argument_types_convertible (tree m1, tree m2_or_arglist)
11228 {
11229   tree m1_arg, m2_arg;
11230
11231   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11232
11233   if (m2_arg_value == m2_or_arglist)
11234     m2_arg = m2_arg_cache;
11235   else
11236     {
11237       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11238          argument types */
11239       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11240         {
11241           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11242           if (!METHOD_STATIC (m2_or_arglist))
11243             m2_arg = TREE_CHAIN (m2_arg);
11244         }
11245       else
11246         m2_arg = m2_or_arglist;
11247
11248       m2_arg_value = m2_or_arglist;
11249       m2_arg_cache = m2_arg;
11250     }
11251
11252   while (m1_arg != end_params_node && m2_arg != end_params_node)
11253     {
11254       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11255       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11256                                                  TREE_VALUE (m2_arg)))
11257         break;
11258       m1_arg = TREE_CHAIN (m1_arg);
11259       m2_arg = TREE_CHAIN (m2_arg);
11260     }
11261   return m1_arg == end_params_node && m2_arg == end_params_node;
11262 }
11263
11264 /* Qualification routines */
11265
11266 /* Given a name x.y.z, look up x locally.  If it's found, save the
11267    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11268    so that we later try and load the appropriate classes.  */
11269 static void
11270 qualify_ambiguous_name (tree id)
11271 {
11272   tree name, decl;
11273
11274   /* We inspect the first item of the qualification list.  As a sanity
11275      check, make sure that it is an identfier node.  */
11276   tree qual = EXPR_WFL_QUALIFICATION (id);
11277   tree qual_wfl = QUAL_WFL (qual);
11278
11279   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11280     return;
11281
11282   name = EXPR_WFL_NODE (qual_wfl);
11283
11284   /* If we don't have an identifier, or we have a 'this' or 'super',
11285      then field access processing is all we need : there is nothing
11286      for us to do.  */
11287   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11288       name == this_identifier_node ||
11289       name == super_identifier_node)
11290     return;
11291
11292   /* If name appears within the scope of a local variable declaration
11293      or parameter declaration, or is a field within an enclosing
11294      class, then it is an expression name.  Save the decl and let
11295      resolve_field_access do it's work.  */
11296   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11297       (decl = lookup_field_wrapper (current_class, name)))
11298     {
11299       QUAL_RESOLUTION (qual) = decl;
11300       return;
11301     }
11302
11303   /* If name is a known class name (either declared or imported), mark
11304      us as a type name.  */
11305   if ((decl = resolve_and_layout (name, NULL_TREE)))
11306     {
11307       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11308       QUAL_RESOLUTION (qual) = decl;
11309     }
11310
11311   /* Check here that NAME isn't declared by more than one
11312      type-import-on-demand declaration of the compilation unit
11313      containing NAME. FIXME */
11314
11315   /* We couldn't find a declaration for the name.  Assume for now that
11316      we have a qualified class name that needs to be loaded from an
11317      external class file.  */
11318   else
11319     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11320
11321   /* Propagate the qualification across other components of the
11322      qualified name */
11323   for (qual = TREE_CHAIN (qual); qual;
11324        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11325     {
11326       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11327         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11328     }
11329
11330   /* Store the global qualification for the ambiguous part of ID back
11331      into ID fields */
11332   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11333     RESOLVE_TYPE_NAME_P (id) = 1;
11334   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11335     RESOLVE_PACKAGE_NAME_P (id) = 1;
11336 }
11337
11338 /* Patch tree nodes in a function body. When a BLOCK is found, push
11339    local variable decls if present.
11340    Same as java_complete_lhs, but does resolve static finals to values. */
11341
11342 static tree
11343 java_complete_tree (tree node)
11344 {
11345   node = java_complete_lhs (node);
11346   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11347       && DECL_INITIAL (node) != NULL_TREE
11348       && !flag_emit_xref)
11349     {
11350       tree value = fold_constant_for_init (node, node);
11351       if (value != NULL_TREE)
11352         return value;
11353     }
11354   return node;
11355 }
11356
11357 static tree
11358 java_stabilize_reference (tree node)
11359 {
11360   if (TREE_CODE (node) == COMPOUND_EXPR)
11361     {
11362       tree op0 = TREE_OPERAND (node, 0);
11363       tree op1 = TREE_OPERAND (node, 1);
11364       TREE_OPERAND (node, 0) = save_expr (op0);
11365       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11366       return node;
11367     }
11368   return stabilize_reference (node);
11369 }
11370
11371 /* Patch tree nodes in a function body. When a BLOCK is found, push
11372    local variable decls if present.
11373    Same as java_complete_tree, but does not resolve static finals to values. */
11374
11375 static tree
11376 java_complete_lhs (tree node)
11377 {
11378   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11379   int flag;
11380
11381   /* CONVERT_EXPR always has its type set, even though it needs to be
11382      worked out. */
11383   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11384     return node;
11385
11386   /* The switch block implements cases processing container nodes
11387      first.  Contained nodes are always written back. Leaves come
11388      next and return a value. */
11389   switch (TREE_CODE (node))
11390     {
11391     case BLOCK:
11392
11393       /* 1- Block section.
11394          Set the local values on decl names so we can identify them
11395          faster when they're referenced. At that stage, identifiers
11396          are legal so we don't check for declaration errors. */
11397       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11398         {
11399           DECL_CONTEXT (cn) = current_function_decl;
11400           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11401         }
11402       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11403           CAN_COMPLETE_NORMALLY (node) = 1;
11404       else
11405         {
11406           tree stmt = BLOCK_EXPR_BODY (node);
11407           tree *ptr;
11408           int error_seen = 0;
11409           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11410             {
11411               /* Re-order from (((A; B); C); ...; Z) to
11412                  (A; (B; (C ; (...; Z)))).
11413                  This makes it easier to scan the statements left-to-right
11414                  without using recursion (which might overflow the stack
11415                  if the block has many statements. */
11416               for (;;)
11417                 {
11418                   tree left = TREE_OPERAND (stmt, 0);
11419                   if (TREE_CODE (left) != COMPOUND_EXPR)
11420                     break;
11421                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11422                   TREE_OPERAND (left, 1) = stmt;
11423                   stmt = left;
11424                 }
11425               BLOCK_EXPR_BODY (node) = stmt;
11426             }
11427
11428           /* Now do the actual complete, without deep recursion for
11429              long blocks. */
11430           ptr = &BLOCK_EXPR_BODY (node);
11431           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11432                  && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11433             {
11434               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11435               tree *next = &TREE_OPERAND (*ptr, 1);
11436               TREE_OPERAND (*ptr, 0) = cur;
11437               if (IS_EMPTY_STMT (cur))
11438                 {
11439                   /* Optimization;  makes it easier to detect empty bodies.
11440                      Most useful for <clinit> with all-constant initializer. */
11441                   *ptr = *next;
11442                   continue;
11443                 }
11444               if (TREE_CODE (cur) == ERROR_MARK)
11445                 error_seen++;
11446               else if (! CAN_COMPLETE_NORMALLY (cur))
11447                 {
11448                   wfl_op2 = *next;
11449                   for (;;)
11450                     {
11451                       if (TREE_CODE (wfl_op2) == BLOCK)
11452                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11453                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11454                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11455                       else
11456                         break;
11457                     }
11458                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11459                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11460                     unreachable_stmt_error (*ptr);
11461                 }
11462               if (TREE_TYPE (*ptr) == NULL_TREE)
11463                 TREE_TYPE (*ptr) = void_type_node;
11464               ptr = next;
11465             }
11466           *ptr = java_complete_tree (*ptr);
11467
11468           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11469             return error_mark_node;
11470           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11471         }
11472       /* Turn local bindings to null */
11473       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11474         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11475
11476       TREE_TYPE (node) = void_type_node;
11477       break;
11478
11479       /* 2- They are expressions but ultimately deal with statements */
11480
11481     case THROW_EXPR:
11482       wfl_op1 = TREE_OPERAND (node, 0);
11483       COMPLETE_CHECK_OP_0 (node);
11484       /* 14.19 A throw statement cannot complete normally. */
11485       CAN_COMPLETE_NORMALLY (node) = 0;
11486       return patch_throw_statement (node, wfl_op1);
11487
11488     case SYNCHRONIZED_EXPR:
11489       wfl_op1 = TREE_OPERAND (node, 0);
11490       return patch_synchronized_statement (node, wfl_op1);
11491
11492     case TRY_EXPR:
11493       return patch_try_statement (node);
11494
11495     case TRY_FINALLY_EXPR:
11496       COMPLETE_CHECK_OP_0 (node);
11497       COMPLETE_CHECK_OP_1 (node);
11498       if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11499         /* Reduce try/finally nodes with an empty try block.  */
11500         return TREE_OPERAND (node, 1);
11501       if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11502         /* Likewise for an empty finally block.  */
11503         return TREE_OPERAND (node, 0);
11504       CAN_COMPLETE_NORMALLY (node)
11505         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11506            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11507       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11508       return node;
11509
11510     case LABELED_BLOCK_EXPR:
11511       PUSH_LABELED_BLOCK (node);
11512       if (LABELED_BLOCK_BODY (node))
11513         COMPLETE_CHECK_OP_1 (node);
11514       TREE_TYPE (node) = void_type_node;
11515       POP_LABELED_BLOCK ();
11516
11517       if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11518         {
11519           LABELED_BLOCK_BODY (node) = NULL_TREE;
11520           CAN_COMPLETE_NORMALLY (node) = 1;
11521         }
11522       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11523         CAN_COMPLETE_NORMALLY (node) = 1;
11524       return node;
11525
11526     case EXIT_BLOCK_EXPR:
11527       /* We don't complete operand 1, because it's the return value of
11528          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11529       return patch_bc_statement (node);
11530
11531     case CASE_EXPR:
11532       cn = java_complete_tree (TREE_OPERAND (node, 0));
11533       if (cn == error_mark_node)
11534         return cn;
11535
11536       /* First, the case expression must be constant. Values of final
11537          fields are accepted. */
11538       cn = fold (cn);
11539       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11540           && JDECL_P (TREE_OPERAND (cn, 1))
11541           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11542           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11543         {
11544           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11545                                        TREE_OPERAND (cn, 1));
11546         }
11547       /* Accept final locals too. */
11548       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11549                && DECL_INITIAL (cn))
11550         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11551
11552       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11553         {
11554           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11555           parse_error_context (node, "Constant expression required");
11556           return error_mark_node;
11557         }
11558
11559       nn = ctxp->current_loop;
11560
11561       /* It must be assignable to the type of the switch expression. */
11562       if (!try_builtin_assignconv (NULL_TREE,
11563                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11564         {
11565           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11566           parse_error_context
11567             (wfl_operator,
11568              "Incompatible type for case. Can't convert `%s' to `int'",
11569              lang_printable_name (TREE_TYPE (cn), 0));
11570           return error_mark_node;
11571         }
11572
11573       cn = fold (convert (int_type_node, cn));
11574       TREE_CONSTANT_OVERFLOW (cn) = 0;
11575       CAN_COMPLETE_NORMALLY (cn) = 1;
11576
11577       /* Save the label on a list so that we can later check for
11578          duplicates.  */
11579       case_label_list = tree_cons (node, cn, case_label_list);
11580
11581       /* Multiple instance of a case label bearing the same value is
11582          checked later. The case expression is all right so far. */
11583       if (TREE_CODE (cn) == VAR_DECL)
11584         cn = DECL_INITIAL (cn);
11585       TREE_OPERAND (node, 0) = cn;
11586       TREE_TYPE (node) = void_type_node;
11587       CAN_COMPLETE_NORMALLY (node) = 1;
11588       TREE_SIDE_EFFECTS (node) = 1;
11589       break;
11590
11591     case DEFAULT_EXPR:
11592       nn = ctxp->current_loop;
11593       /* Only one default label is allowed per switch statement */
11594       if (SWITCH_HAS_DEFAULT (nn))
11595         {
11596           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11597           parse_error_context (wfl_operator,
11598                                "Duplicate case label: `default'");
11599           return error_mark_node;
11600         }
11601       else
11602         SWITCH_HAS_DEFAULT (nn) = 1;
11603       TREE_TYPE (node) = void_type_node;
11604       TREE_SIDE_EFFECTS (node) = 1;
11605       CAN_COMPLETE_NORMALLY (node) = 1;
11606       break;
11607
11608     case SWITCH_EXPR:
11609     case LOOP_EXPR:
11610       PUSH_LOOP (node);
11611       /* Check whether the loop was enclosed in a labeled
11612          statement. If not, create one, insert the loop in it and
11613          return the node */
11614       nn = patch_loop_statement (node);
11615
11616       /* Anyways, walk the body of the loop */
11617       if (TREE_CODE (node) == LOOP_EXPR)
11618         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11619       /* Switch statement: walk the switch expression and the cases */
11620       else
11621         node = patch_switch_statement (node);
11622
11623       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11624         nn = error_mark_node;
11625       else
11626         {
11627           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11628           /* If we returned something different, that's because we
11629              inserted a label. Pop the label too. */
11630           if (nn != node)
11631             {
11632               if (CAN_COMPLETE_NORMALLY (node))
11633                 CAN_COMPLETE_NORMALLY (nn) = 1;
11634               POP_LABELED_BLOCK ();
11635             }
11636         }
11637       POP_LOOP ();
11638       return nn;
11639
11640     case EXIT_EXPR:
11641       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11642       return patch_exit_expr (node);
11643
11644     case COND_EXPR:
11645       /* Condition */
11646       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11647       if (TREE_OPERAND (node, 0) == error_mark_node)
11648         return error_mark_node;
11649       /* then-else branches */
11650       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11651       if (TREE_OPERAND (node, 1) == error_mark_node)
11652         return error_mark_node;
11653       {
11654         /* This is a special case due to build_assertion().  When
11655            assertions are disabled we build a COND_EXPR in which
11656            Operand 1 is the body of the assertion.  If that happens to
11657            be a string concatenation we'll need to patch it here.  */
11658         tree patched = patch_string (TREE_OPERAND (node, 1));
11659         if (patched)
11660           TREE_OPERAND (node, 1) = patched;
11661       }
11662      TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11663       if (TREE_OPERAND (node, 2) == error_mark_node)
11664         return error_mark_node;
11665       return patch_if_else_statement (node);
11666       break;
11667
11668     case CONDITIONAL_EXPR:
11669       /* Condition */
11670       wfl_op1 = TREE_OPERAND (node, 0);
11671       COMPLETE_CHECK_OP_0 (node);
11672       wfl_op2 = TREE_OPERAND (node, 1);
11673       COMPLETE_CHECK_OP_1 (node);
11674       wfl_op3 = TREE_OPERAND (node, 2);
11675       COMPLETE_CHECK_OP_2 (node);
11676       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11677
11678       /* 3- Expression section */
11679     case COMPOUND_EXPR:
11680       wfl_op2 = TREE_OPERAND (node, 1);
11681       TREE_OPERAND (node, 0) = nn =
11682         java_complete_tree (TREE_OPERAND (node, 0));
11683       if (IS_EMPTY_STMT (wfl_op2))
11684         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11685       else
11686         {
11687           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11688             {
11689               /* An unreachable condition in a do-while statement
11690                  is *not* (technically) an unreachable statement. */
11691               nn = wfl_op2;
11692               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11693                 nn = EXPR_WFL_NODE (nn);
11694               /* NN can be NULL_TREE exactly when UPDATE is, in
11695                  finish_for_loop.  */
11696               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11697                 {
11698                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11699                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11700                     {
11701                       /* Perhaps this warning should have an
11702                          associated flag.  The code being compiled is
11703                          pedantically correct, but useless.  */
11704                       parse_warning_context (wfl_operator,
11705                                              "Unreachable statement");
11706                     }
11707                   else
11708                     parse_error_context (wfl_operator,
11709                                          "Unreachable statement");
11710                 }
11711             }
11712           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11713           if (TREE_OPERAND (node, 1) == error_mark_node)
11714             return error_mark_node;
11715           /* Even though we might allow the case where the first
11716              operand doesn't return normally, we still should compute
11717              CAN_COMPLETE_NORMALLY correctly.  */
11718           CAN_COMPLETE_NORMALLY (node)
11719             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11720                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11721         }
11722       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11723       break;
11724
11725     case RETURN_EXPR:
11726       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11727       return patch_return (node);
11728
11729     case EXPR_WITH_FILE_LOCATION:
11730       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11731           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11732         {
11733           tree wfl = node;
11734           node = resolve_expression_name (node, NULL);
11735           if (node == error_mark_node)
11736             return node;
11737           /* Keep line number information somewhere were it doesn't
11738              disrupt the completion process. */
11739           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11740             {
11741               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11742               TREE_OPERAND (node, 1) = wfl;
11743             }
11744           CAN_COMPLETE_NORMALLY (node) = 1;
11745         }
11746       else
11747         {
11748           tree body;
11749           int save_lineno = input_line;
11750           input_line = EXPR_WFL_LINENO (node);
11751           body = java_complete_tree (EXPR_WFL_NODE (node));
11752           input_line = save_lineno;
11753           EXPR_WFL_NODE (node) = body;
11754           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11755           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11756           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11757             {
11758               /* Makes it easier to constant fold, detect empty bodies. */
11759               return body;
11760             }
11761           if (body == error_mark_node)
11762             {
11763               /* Its important for the evaluation of assignment that
11764                  this mark on the TREE_TYPE is propagated. */
11765               TREE_TYPE (node) = error_mark_node;
11766               return error_mark_node;
11767             }
11768           else
11769             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11770
11771         }
11772       break;
11773
11774     case NEW_ARRAY_EXPR:
11775       /* Patch all the dimensions */
11776       flag = 0;
11777       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11778         {
11779           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11780           tree dim = convert (int_type_node,
11781                               java_complete_tree (TREE_VALUE (cn)));
11782           if (dim == error_mark_node)
11783             {
11784               flag = 1;
11785               continue;
11786             }
11787           else
11788             {
11789               TREE_VALUE (cn) = dim;
11790               /* Setup the location of the current dimension, for
11791                  later error report. */
11792               TREE_PURPOSE (cn) =
11793                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11794               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11795             }
11796         }
11797       /* They complete the array creation expression, if no errors
11798          were found. */
11799       CAN_COMPLETE_NORMALLY (node) = 1;
11800       return (flag ? error_mark_node
11801               : force_evaluation_order (patch_newarray (node)));
11802
11803     case NEW_ANONYMOUS_ARRAY_EXPR:
11804       /* Create the array type if necessary. */
11805       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11806         {
11807           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11808           if (!(type = resolve_type_during_patch (type)))
11809             return error_mark_node;
11810           type = build_array_from_name (type, NULL_TREE,
11811                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11812           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11813         }
11814       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11815                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11816       if (node == error_mark_node)
11817         return error_mark_node;
11818       CAN_COMPLETE_NORMALLY (node) = 1;
11819       return node;
11820
11821     case NEW_CLASS_EXPR:
11822     case CALL_EXPR:
11823       /* Complete function's argument(s) first */
11824       if (complete_function_arguments (node))
11825         return error_mark_node;
11826       else
11827         {
11828           tree decl, wfl = TREE_OPERAND (node, 0);
11829           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11830           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11831                            super_identifier_node);
11832           tree arguments;
11833           int location = EXPR_WFL_LINECOL (node);
11834
11835           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11836                                           from_super, 0, &decl);
11837           if (node == error_mark_node)
11838             return error_mark_node;
11839
11840           if (TREE_CODE (node) == CALL_EXPR
11841               && TREE_OPERAND (node, 1) != NULL_TREE)
11842             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11843           else
11844             arguments = NULL_TREE;
11845           check_thrown_exceptions (location, decl, arguments);
11846           /* If we call this(...), register signature and positions */
11847           if (in_this)
11848             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11849               tree_cons (wfl, decl,
11850                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11851           CAN_COMPLETE_NORMALLY (node) = 1;
11852           return force_evaluation_order (node);
11853         }
11854
11855     case MODIFY_EXPR:
11856       /* Save potential wfls */
11857       wfl_op1 = TREE_OPERAND (node, 0);
11858       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11859
11860       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11861           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11862           && DECL_INITIAL (nn) != NULL_TREE)
11863         {
11864           tree value;
11865
11866           value = fold_constant_for_init (nn, nn);
11867
11868           /* When we have a primitype type, or a string and we're not
11869              emitting a class file, we actually don't want to generate
11870              anything for the assignment. */
11871           if (value != NULL_TREE &&
11872               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11873                (TREE_TYPE (value) == string_ptr_type_node &&
11874                 ! flag_emit_class_files)))
11875             {
11876               /* Prepare node for patch_assignment */
11877               TREE_OPERAND (node, 1) = value;
11878               /* Call patch assignment to verify the assignment */
11879               if (patch_assignment (node, wfl_op1) == error_mark_node)
11880                 return error_mark_node;
11881               /* Set DECL_INITIAL properly (a conversion might have
11882                  been decided by patch_assignment) and return the
11883                  empty statement. */
11884               else
11885                 {
11886                   tree patched = patch_string (TREE_OPERAND (node, 1));
11887                   if (patched)
11888                     DECL_INITIAL (nn) = patched;
11889                   else
11890                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11891                   DECL_FIELD_FINAL_IUD (nn) = 1;
11892                   return build_java_empty_stmt ();
11893                 }
11894             }
11895           if (! flag_emit_class_files)
11896             DECL_INITIAL (nn) = NULL_TREE;
11897         }
11898       wfl_op2 = TREE_OPERAND (node, 1);
11899
11900       if (TREE_OPERAND (node, 0) == error_mark_node)
11901         return error_mark_node;
11902
11903       flag = COMPOUND_ASSIGN_P (wfl_op2);
11904       if (flag)
11905         {
11906           /* This might break when accessing outer field from inner
11907              class. TESTME, FIXME */
11908           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11909
11910           /* Hand stabilize the lhs on both places */
11911           TREE_OPERAND (node, 0) = lvalue;
11912           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11913             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11914
11915           /* 15.25.2.a: Left hand is not an array access. FIXME */
11916           /* Now complete the RHS. We write it back later on. */
11917           nn = java_complete_tree (TREE_OPERAND (node, 1));
11918
11919           if ((cn = patch_string (nn)))
11920             nn = cn;
11921
11922           /* The last part of the rewrite for E1 op= E2 is to have
11923              E1 = (T)(E1 op E2), with T being the type of E1. */
11924           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11925                                                TREE_TYPE (lvalue), nn));
11926
11927           /* If the assignment is compound and has reference type,
11928              then ensure the LHS has type String and nothing else.  */
11929           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
11930               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
11931             parse_error_context (wfl_op2,
11932                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
11933                                  lang_printable_name (TREE_TYPE (lvalue), 0));
11934
11935           /* 15.25.2.b: Left hand is an array access. FIXME */
11936         }
11937
11938       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11939          function to complete this RHS. Note that a NEW_ARRAY_INIT
11940          might have been already fully expanded if created as a result
11941          of processing an anonymous array initializer. We avoid doing
11942          the operation twice by testing whether the node already bears
11943          a type. */
11944       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
11945         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
11946                                    TREE_OPERAND (node, 1));
11947       /* Otherwise we simply complete the RHS */
11948       else
11949         nn = java_complete_tree (TREE_OPERAND (node, 1));
11950
11951       if (nn == error_mark_node)
11952         return error_mark_node;
11953
11954       /* Write back the RHS as we evaluated it. */
11955       TREE_OPERAND (node, 1) = nn;
11956
11957       /* In case we're handling = with a String as a RHS, we need to
11958          produce a String out of the RHS (it might still be a
11959          STRING_CST or a StringBuffer at this stage */
11960       if ((nn = patch_string (TREE_OPERAND (node, 1))))
11961         TREE_OPERAND (node, 1) = nn;
11962
11963       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11964                                         TREE_OPERAND (node, 1))))
11965         {
11966           /* We return error_mark_node if outer_field_access_fix
11967              detects we write into a final. */
11968           if (nn == error_mark_node)
11969             return error_mark_node;
11970           node = nn;
11971         }
11972       else
11973         {
11974           node = patch_assignment (node, wfl_op1);
11975           if (node == error_mark_node)
11976             return error_mark_node;
11977           /* Reorganize the tree if necessary. */
11978           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11979                        || JSTRING_P (TREE_TYPE (node))))
11980             node = java_refold (node);
11981         }
11982
11983       /* Seek to set DECL_INITIAL to a proper value, since it might have
11984          undergone a conversion in patch_assignment. We do that only when
11985          it's necessary to have DECL_INITIAL properly set. */
11986       nn = TREE_OPERAND (node, 0);
11987       if (TREE_CODE (nn) == VAR_DECL
11988           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
11989           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
11990           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
11991               || TREE_TYPE (nn) == string_ptr_type_node))
11992         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11993
11994       CAN_COMPLETE_NORMALLY (node) = 1;
11995       return node;
11996
11997     case MULT_EXPR:
11998     case PLUS_EXPR:
11999     case MINUS_EXPR:
12000     case LSHIFT_EXPR:
12001     case RSHIFT_EXPR:
12002     case URSHIFT_EXPR:
12003     case BIT_AND_EXPR:
12004     case BIT_XOR_EXPR:
12005     case BIT_IOR_EXPR:
12006     case TRUNC_MOD_EXPR:
12007     case TRUNC_DIV_EXPR:
12008     case RDIV_EXPR:
12009     case TRUTH_ANDIF_EXPR:
12010     case TRUTH_ORIF_EXPR:
12011     case EQ_EXPR:
12012     case NE_EXPR:
12013     case GT_EXPR:
12014     case GE_EXPR:
12015     case LT_EXPR:
12016     case LE_EXPR:
12017       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12018          knows how to handle those cases. */
12019       wfl_op1 = TREE_OPERAND (node, 0);
12020       wfl_op2 = TREE_OPERAND (node, 1);
12021
12022       CAN_COMPLETE_NORMALLY (node) = 1;
12023       /* Don't complete string nodes if dealing with the PLUS operand. */
12024       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12025         {
12026           nn = java_complete_tree (wfl_op1);
12027           if (nn == error_mark_node)
12028             return error_mark_node;
12029
12030           TREE_OPERAND (node, 0) = nn;
12031         }
12032       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12033         {
12034           nn = java_complete_tree (wfl_op2);
12035           if (nn == error_mark_node)
12036             return error_mark_node;
12037
12038           TREE_OPERAND (node, 1) = nn;
12039         }
12040       return patch_binop (node, wfl_op1, wfl_op2);
12041
12042     case INSTANCEOF_EXPR:
12043       wfl_op1 = TREE_OPERAND (node, 0);
12044       COMPLETE_CHECK_OP_0 (node);
12045       if (flag_emit_xref)
12046         {
12047           TREE_TYPE (node) = boolean_type_node;
12048           return node;
12049         }
12050       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12051
12052     case UNARY_PLUS_EXPR:
12053     case NEGATE_EXPR:
12054     case TRUTH_NOT_EXPR:
12055     case BIT_NOT_EXPR:
12056     case PREDECREMENT_EXPR:
12057     case PREINCREMENT_EXPR:
12058     case POSTDECREMENT_EXPR:
12059     case POSTINCREMENT_EXPR:
12060     case CONVERT_EXPR:
12061       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12062          how to handle those cases. */
12063       wfl_op1 = TREE_OPERAND (node, 0);
12064       CAN_COMPLETE_NORMALLY (node) = 1;
12065       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12066       if (TREE_OPERAND (node, 0) == error_mark_node)
12067         return error_mark_node;
12068       node = patch_unaryop (node, wfl_op1);
12069       CAN_COMPLETE_NORMALLY (node) = 1;
12070       break;
12071
12072     case ARRAY_REF:
12073       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12074          how to handle those cases. */
12075       wfl_op1 = TREE_OPERAND (node, 0);
12076       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12077       if (TREE_OPERAND (node, 0) == error_mark_node)
12078         return error_mark_node;
12079       if (!flag_emit_class_files && !flag_emit_xref)
12080         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12081       /* The same applies to wfl_op2 */
12082       wfl_op2 = TREE_OPERAND (node, 1);
12083       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12084       if (TREE_OPERAND (node, 1) == error_mark_node)
12085         return error_mark_node;
12086       if (!flag_emit_class_files && !flag_emit_xref)
12087         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12088       return patch_array_ref (node);
12089
12090     case RECORD_TYPE:
12091       return node;;
12092
12093     case COMPONENT_REF:
12094       /* The first step in the re-write of qualified name handling.  FIXME.
12095          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12096       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12097       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12098         {
12099           tree name = TREE_OPERAND (node, 1);
12100           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12101           if (field == NULL_TREE)
12102             {
12103               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12104               return error_mark_node;
12105             }
12106           if (! FIELD_STATIC (field))
12107             {
12108               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12109               return error_mark_node;
12110             }
12111           return field;
12112         }
12113       else
12114         abort ();
12115       break;
12116
12117     case THIS_EXPR:
12118       /* Can't use THIS in a static environment */
12119       if (!current_this)
12120         {
12121           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12122           parse_error_context (wfl_operator,
12123                                "Keyword `this' used outside allowed context");
12124           TREE_TYPE (node) = error_mark_node;
12125           return error_mark_node;
12126         }
12127       if (ctxp->explicit_constructor_p)
12128         {
12129           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12130           parse_error_context
12131             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12132           TREE_TYPE (node) = error_mark_node;
12133           return error_mark_node;
12134         }
12135       return current_this;
12136
12137     case CLASS_LITERAL:
12138       CAN_COMPLETE_NORMALLY (node) = 1;
12139       node = patch_incomplete_class_ref (node);
12140       if (node == error_mark_node)
12141         return error_mark_node;
12142       break;
12143
12144     default:
12145       CAN_COMPLETE_NORMALLY (node) = 1;
12146       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12147          and it's time to turn it into the appropriate String object */
12148       if ((nn = patch_string (node)))
12149         node = nn;
12150       else
12151         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12152     }
12153   return node;
12154 }
12155
12156 /* Complete function call's argument. Return a nonzero value is an
12157    error was found.  */
12158
12159 static int
12160 complete_function_arguments (tree node)
12161 {
12162   int flag = 0;
12163   tree cn;
12164
12165   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12166   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12167     {
12168       tree wfl = TREE_VALUE (cn), parm, temp;
12169       parm = java_complete_tree (wfl);
12170
12171       if (parm == error_mark_node)
12172         {
12173           flag = 1;
12174           continue;
12175         }
12176       /* If we have a string literal that we haven't transformed yet or a
12177          crafted string buffer, as a result of the use of the String
12178          `+' operator. Build `parm.toString()' and expand it. */
12179       if ((temp = patch_string (parm)))
12180         parm = temp;
12181
12182       TREE_VALUE (cn) = parm;
12183     }
12184   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12185   return flag;
12186 }
12187
12188 /* Sometimes (for loops and variable initialized during their
12189    declaration), we want to wrap a statement around a WFL and turn it
12190    debugable.  */
12191
12192 static tree
12193 build_debugable_stmt (int location, tree stmt)
12194 {
12195   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12196     {
12197       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12198       EXPR_WFL_LINECOL (stmt) = location;
12199     }
12200   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12201   return stmt;
12202 }
12203
12204 static tree
12205 build_expr_block (tree body, tree decls)
12206 {
12207   tree node = make_node (BLOCK);
12208   BLOCK_EXPR_DECLS (node) = decls;
12209   BLOCK_EXPR_BODY (node) = body;
12210   if (body)
12211     TREE_TYPE (node) = TREE_TYPE (body);
12212   TREE_SIDE_EFFECTS (node) = 1;
12213   return node;
12214 }
12215
12216 /* Create a new function block and link it appropriately to current
12217    function block chain */
12218
12219 static tree
12220 enter_block (void)
12221 {
12222   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12223
12224   /* Link block B supercontext to the previous block. The current
12225      function DECL is used as supercontext when enter_a_block is called
12226      for the first time for a given function. The current function body
12227      (DECL_FUNCTION_BODY) is set to be block B.  */
12228
12229   tree fndecl = current_function_decl;
12230
12231   if (!fndecl) {
12232     BLOCK_SUPERCONTEXT (b) = current_static_block;
12233     current_static_block = b;
12234   }
12235
12236   else if (!DECL_FUNCTION_BODY (fndecl))
12237     {
12238       BLOCK_SUPERCONTEXT (b) = fndecl;
12239       DECL_FUNCTION_BODY (fndecl) = b;
12240     }
12241   else
12242     {
12243       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12244       DECL_FUNCTION_BODY (fndecl) = b;
12245     }
12246   return b;
12247 }
12248
12249 /* Exit a block by changing the current function body
12250    (DECL_FUNCTION_BODY) to the current block super context, only if
12251    the block being exited isn't the method's top level one.  */
12252
12253 static tree
12254 exit_block (void)
12255 {
12256   tree b;
12257   if (current_function_decl)
12258     {
12259       b = DECL_FUNCTION_BODY (current_function_decl);
12260       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12261         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12262     }
12263   else
12264     {
12265       b = current_static_block;
12266
12267       if (BLOCK_SUPERCONTEXT (b))
12268         current_static_block = BLOCK_SUPERCONTEXT (b);
12269     }
12270   return b;
12271 }
12272
12273 /* Lookup for NAME in the nested function's blocks, all the way up to
12274    the current toplevel one. It complies with Java's local variable
12275    scoping rules.  */
12276
12277 static tree
12278 lookup_name_in_blocks (tree name)
12279 {
12280   tree b = GET_CURRENT_BLOCK (current_function_decl);
12281
12282   while (b != current_function_decl)
12283     {
12284       tree current;
12285
12286       /* Paranoid sanity check. To be removed */
12287       if (TREE_CODE (b) != BLOCK)
12288         abort ();
12289
12290       for (current = BLOCK_EXPR_DECLS (b); current;
12291            current = TREE_CHAIN (current))
12292         if (DECL_NAME (current) == name)
12293           return current;
12294       b = BLOCK_SUPERCONTEXT (b);
12295     }
12296   return NULL_TREE;
12297 }
12298
12299 static void
12300 maybe_absorb_scoping_blocks (void)
12301 {
12302   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12303     {
12304       tree b = exit_block ();
12305       java_method_add_stmt (current_function_decl, b);
12306       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12307     }
12308 }
12309
12310 \f
12311 /* This section of the source is reserved to build_* functions that
12312    are building incomplete tree nodes and the patch_* functions that
12313    are completing them.  */
12314
12315 /* Wrap a non WFL node around a WFL.  */
12316
12317 static tree
12318 build_wfl_wrap (tree node, int location)
12319 {
12320   tree wfl, node_to_insert = node;
12321
12322   /* We want to process THIS . xxx symbolically, to keep it consistent
12323      with the way we're processing SUPER. A THIS from a primary as a
12324      different form than a SUPER. Turn THIS into something symbolic */
12325   if (TREE_CODE (node) == THIS_EXPR)
12326     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12327   else
12328     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12329
12330   EXPR_WFL_LINECOL (wfl) = location;
12331   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12332   return wfl;
12333 }
12334
12335 /* Build a super() constructor invocation. Returns an empty statement if
12336    we're currently dealing with the class java.lang.Object. */
12337
12338 static tree
12339 build_super_invocation (tree mdecl)
12340 {
12341   if (DECL_CONTEXT (mdecl) == object_type_node)
12342     return build_java_empty_stmt ();
12343   else
12344     {
12345       tree super_wfl = build_wfl_node (super_identifier_node);
12346       tree a = NULL_TREE, t;
12347
12348       /* This is called after parsing is done, so the parser context
12349          won't be accurate. Set location info from current_class decl. */
12350       tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12351       EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12352
12353       /* If we're dealing with an anonymous class, pass the arguments
12354          of the crafted constructor along. */
12355       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12356         {
12357           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12358           for (; t != end_params_node; t = TREE_CHAIN (t))
12359             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12360         }
12361       return build_method_invocation (super_wfl, a);
12362     }
12363 }
12364
12365 /* Build a SUPER/THIS qualified method invocation.  */
12366
12367 static tree
12368 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12369                                        int lloc, int rloc)
12370 {
12371   tree invok;
12372   tree wfl =
12373     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12374   EXPR_WFL_LINECOL (wfl) = lloc;
12375   invok = build_method_invocation (name, args);
12376   return make_qualified_primary (wfl, invok, rloc);
12377 }
12378
12379 /* Build an incomplete CALL_EXPR node. */
12380
12381 static tree
12382 build_method_invocation (tree name, tree args)
12383 {
12384   tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12385   TREE_SIDE_EFFECTS (call) = 1;
12386   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12387   return call;
12388 }
12389
12390 /* Build an incomplete new xxx(...) node. */
12391
12392 static tree
12393 build_new_invocation (tree name, tree args)
12394 {
12395   tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12396   TREE_SIDE_EFFECTS (call) = 1;
12397   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12398   return call;
12399 }
12400
12401 /* Build an incomplete assignment expression. */
12402
12403 static tree
12404 build_assignment (int op, int op_location, tree lhs, tree rhs)
12405 {
12406   tree assignment;
12407   /* Build the corresponding binop if we deal with a Compound
12408      Assignment operator. Mark the binop sub-tree as part of a
12409      Compound Assignment expression */
12410   if (op != ASSIGN_TK)
12411     {
12412       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12413       COMPOUND_ASSIGN_P (rhs) = 1;
12414     }
12415   assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12416   TREE_SIDE_EFFECTS (assignment) = 1;
12417   EXPR_WFL_LINECOL (assignment) = op_location;
12418   return assignment;
12419 }
12420
12421 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12422    the buffer.  This is used only for string conversion.  */
12423 static char *
12424 string_convert_int_cst (tree node)
12425 {
12426   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12427   static char buffer[21];
12428
12429   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12430   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12431   char *p = buffer + sizeof (buffer);
12432   int neg = 0;
12433
12434   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12435                                   << (HOST_BITS_PER_WIDE_INT - 1));
12436
12437   *--p = '\0';
12438
12439   /* If negative, note the fact and negate the value.  */
12440   if ((hi & hibit))
12441     {
12442       lo = ~lo;
12443       hi = ~hi;
12444       if (++lo == 0)
12445         ++hi;
12446       neg = 1;
12447     }
12448
12449   /* Divide by 10 until there are no bits left.  */
12450   do
12451     {
12452       unsigned HOST_WIDE_INT acc = 0;
12453       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12454       unsigned int i;
12455
12456       /* Use long division to compute the result and the remainder.  */
12457       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12458         {
12459           /* Shift a bit into accumulator.  */
12460           acc <<= 1;
12461           if ((hi & hibit))
12462             acc |= 1;
12463
12464           /* Shift the value.  */
12465           hi <<= 1;
12466           if ((lo & hibit))
12467             hi |= 1;
12468           lo <<= 1;
12469
12470           /* Shift the correct bit into the result.  */
12471           outhi <<= 1;
12472           if ((outlo & hibit))
12473             outhi |= 1;
12474           outlo <<= 1;
12475           if (acc >= 10)
12476             {
12477               acc -= 10;
12478               outlo |= 1;
12479             }
12480         }
12481
12482       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12483       *--p = '\060' + acc;
12484
12485       hi = outhi;
12486       lo = outlo;
12487     }
12488   while (hi || lo);
12489
12490   if (neg)
12491     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12492
12493   return p;
12494 }
12495
12496 /* Print an INTEGER_CST node in a static buffer, and return the
12497    buffer.  This is used only for error handling.  */
12498 char *
12499 print_int_node (tree node)
12500 {
12501   static char buffer [80];
12502   if (TREE_CONSTANT_OVERFLOW (node))
12503     sprintf (buffer, "<overflow>");
12504
12505   if (TREE_INT_CST_HIGH (node) == 0)
12506     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12507              TREE_INT_CST_LOW (node));
12508   else if (TREE_INT_CST_HIGH (node) == -1
12509            && TREE_INT_CST_LOW (node) != 0)
12510     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12511              -TREE_INT_CST_LOW (node));
12512   else
12513     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12514              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12515
12516   return buffer;
12517 }
12518
12519 \f
12520 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12521    context.  */
12522
12523 /* 15.25 Assignment operators. */
12524
12525 static tree
12526 patch_assignment (tree node, tree wfl_op1)
12527 {
12528   tree rhs = TREE_OPERAND (node, 1);
12529   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12530   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12531   int error_found = 0;
12532   int lvalue_from_array = 0;
12533   int is_return = 0;
12534
12535   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12536
12537   /* Lhs can be a named variable */
12538   if (JDECL_P (lvalue))
12539     {
12540       lhs_type = TREE_TYPE (lvalue);
12541     }
12542   /* Or Lhs can be an array access. */
12543   else if (TREE_CODE (lvalue) == ARRAY_REF)
12544     {
12545       lhs_type = TREE_TYPE (lvalue);
12546       lvalue_from_array = 1;
12547     }
12548   /* Or a field access */
12549   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12550     lhs_type = TREE_TYPE (lvalue);
12551   /* Or a function return slot */
12552   else if (TREE_CODE (lvalue) == RESULT_DECL)
12553     {
12554       /* If the return type is an integral type, then we create the
12555          RESULT_DECL with a promoted type, but we need to do these
12556          checks against the unpromoted type to ensure type safety.  So
12557          here we look at the real type, not the type of the decl we
12558          are modifying.  */
12559       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12560       is_return = 1;
12561     }
12562   /* Otherwise, we might want to try to write into an optimized static
12563      final, this is an of a different nature, reported further on. */
12564   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12565            && resolve_expression_name (wfl_op1, &llvalue))
12566     {
12567       lhs_type = TREE_TYPE (lvalue);
12568     }
12569   else
12570     {
12571       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12572       error_found = 1;
12573     }
12574
12575   rhs_type = TREE_TYPE (rhs);
12576
12577   /* 5.1 Try the assignment conversion for builtin type. */
12578   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12579
12580   /* 5.2 If it failed, try a reference conversion */
12581   if (!new_rhs)
12582     new_rhs = try_reference_assignconv (lhs_type, rhs);
12583
12584   /* 15.25.2 If we have a compound assignment, convert RHS into the
12585      type of the LHS */
12586   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12587     new_rhs = convert (lhs_type, rhs);
12588
12589   /* Explicit cast required. This is an error */
12590   if (!new_rhs)
12591     {
12592       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12593       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12594       tree wfl;
12595       char operation [32];      /* Max size known */
12596
12597       /* If the assignment is part of a declaration, we use the WFL of
12598          the declared variable to point out the error and call it a
12599          declaration problem. If the assignment is a genuine =
12600          operator, we call is a operator `=' problem, otherwise we
12601          call it an assignment problem. In both of these last cases,
12602          we use the WFL of the operator to indicate the error. */
12603
12604       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12605         {
12606           wfl = wfl_op1;
12607           strcpy (operation, "declaration");
12608         }
12609       else
12610         {
12611           wfl = wfl_operator;
12612           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12613             strcpy (operation, "assignment");
12614           else if (is_return)
12615             strcpy (operation, "`return'");
12616           else
12617             strcpy (operation, "`='");
12618         }
12619
12620       if (!valid_cast_to_p (rhs_type, lhs_type))
12621         parse_error_context
12622           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12623            operation, t1, t2);
12624       else
12625         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12626                              operation, t1, t2);
12627       free (t1); free (t2);
12628       error_found = 1;
12629     }
12630
12631   if (error_found)
12632     return error_mark_node;
12633
12634   /* If we're processing a `return' statement, promote the actual type
12635      to the promoted type.  */
12636   if (is_return)
12637     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12638
12639   /* 10.10: Array Store Exception runtime check */
12640   if (!flag_emit_class_files
12641       && !flag_emit_xref
12642       && lvalue_from_array
12643       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12644     {
12645       tree array, store_check, base, index_expr;
12646
12647       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12648       new_rhs = save_expr (new_rhs);
12649
12650       /* Get the INDIRECT_REF. */
12651       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12652       /* Get the array pointer expr. */
12653       array = TREE_OPERAND (array, 0);
12654       store_check = build_java_arraystore_check (array, new_rhs);
12655
12656       index_expr = TREE_OPERAND (lvalue, 1);
12657
12658       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12659         {
12660           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12661              happen before the store check, so prepare to insert the store
12662              check within the second operand of the existing COMPOUND_EXPR. */
12663           base = index_expr;
12664         }
12665       else
12666         base = lvalue;
12667
12668       index_expr = TREE_OPERAND (base, 1);
12669       TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
12670                                        store_check, index_expr);
12671     }
12672
12673   /* Final locals can be used as case values in switch
12674      statement. Prepare them for this eventuality. */
12675   if (TREE_CODE (lvalue) == VAR_DECL
12676       && DECL_FINAL (lvalue)
12677       && TREE_CONSTANT (new_rhs)
12678       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12679       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12680       )
12681     {
12682       TREE_CONSTANT (lvalue) = 1;
12683       TREE_INVARIANT (lvalue) = 1;
12684       DECL_INITIAL (lvalue) = new_rhs;
12685     }
12686
12687   /* Copy the rhs if it's a reference.  */
12688   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12689     {
12690       switch (TREE_CODE (new_rhs))
12691         {
12692         case ARRAY_REF:
12693         case INDIRECT_REF:
12694         case COMPONENT_REF:
12695           /* Transform a = foo.bar
12696              into a = ({int tmp; tmp = foo.bar;}).
12697              We need to ensure that if a read from memory fails
12698              because of a NullPointerException, a destination variable
12699              will remain unchanged.  An explicit temporary does what
12700              we need.
12701
12702              If flag_check_references is set, this is unnecessary
12703              because we'll check each reference before doing any
12704              reads.  If optimize is not set the result will never be
12705              written to a stack slot that contains the LHS.  */
12706           {
12707             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12708                                    TREE_TYPE (new_rhs));
12709             tree block = make_node (BLOCK);
12710             tree assignment
12711               = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12712             DECL_CONTEXT (tmp) = current_function_decl;
12713             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12714             BLOCK_VARS (block) = tmp;
12715             BLOCK_EXPR_BODY (block) = assignment;
12716             TREE_SIDE_EFFECTS (block) = 1;
12717             new_rhs = block;
12718           }
12719           break;
12720         default:
12721           break;
12722         }
12723     }
12724
12725   TREE_OPERAND (node, 0) = lvalue;
12726   TREE_OPERAND (node, 1) = new_rhs;
12727   TREE_TYPE (node) = lhs_type;
12728   return node;
12729 }
12730
12731 /* Check that type SOURCE can be cast into type DEST. If the cast
12732    can't occur at all, return NULL; otherwise, return a possibly
12733    modified rhs.  */
12734
12735 static tree
12736 try_reference_assignconv (tree lhs_type, tree rhs)
12737 {
12738   tree new_rhs = NULL_TREE;
12739   tree rhs_type = TREE_TYPE (rhs);
12740
12741   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12742     {
12743       /* `null' may be assigned to any reference type */
12744       if (rhs == null_pointer_node)
12745         new_rhs = null_pointer_node;
12746       /* Try the reference assignment conversion */
12747       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12748         new_rhs = rhs;
12749       /* This is a magic assignment that we process differently */
12750       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12751         new_rhs = rhs;
12752     }
12753   return new_rhs;
12754 }
12755
12756 /* Check that RHS can be converted into LHS_TYPE by the assignment
12757    conversion (5.2), for the cases of RHS being a builtin type. Return
12758    NULL_TREE if the conversion fails or if because RHS isn't of a
12759    builtin type. Return a converted RHS if the conversion is possible.  */
12760
12761 static tree
12762 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12763 {
12764   tree new_rhs = NULL_TREE;
12765   tree rhs_type = TREE_TYPE (rhs);
12766
12767   /* Handle boolean specially.  */
12768   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12769       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12770     {
12771       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12772           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12773         new_rhs = rhs;
12774     }
12775
12776   /* 5.1.1 Try Identity Conversion,
12777      5.1.2 Try Widening Primitive Conversion */
12778   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12779     new_rhs = convert (lhs_type, rhs);
12780
12781   /* Try a narrowing primitive conversion (5.1.3):
12782        - expression is a constant expression of type byte, short, char,
12783          or int, AND
12784        - variable is byte, short or char AND
12785        - The value of the expression is representable in the type of the
12786          variable */
12787   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12788             || rhs_type == char_type_node || rhs_type == int_type_node)
12789             && TREE_CONSTANT (rhs)
12790            && (lhs_type == byte_type_node || lhs_type == char_type_node
12791                || lhs_type == short_type_node))
12792     {
12793       if (int_fits_type_p (rhs, lhs_type))
12794         new_rhs = convert (lhs_type, rhs);
12795       else if (wfl_op1)         /* Might be called with a NULL */
12796         parse_warning_context
12797           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12798            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12799       /* Reported a warning that will turn into an error further
12800          down, so we don't return */
12801     }
12802
12803   return new_rhs;
12804 }
12805
12806 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12807    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12808    0 is the conversion test fails.  This implements parts the method
12809    invocation conversion (5.3).  */
12810
12811 static int
12812 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12813 {
12814   /* 5.1.1: This is the identity conversion part. */
12815   if (lhs_type == rhs_type)
12816     return 1;
12817
12818   /* Reject non primitive types and boolean conversions.  */
12819   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12820     return 0;
12821
12822   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12823      than a char can't be converted into a char. Short can't too, but
12824      the < test below takes care of that */
12825   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12826     return 0;
12827
12828   /* Accept all promoted type here. Note, we can't use <= in the test
12829      below, because we still need to bounce out assignments of short
12830      to char and the likes */
12831   if (lhs_type == int_type_node
12832       && (rhs_type == promoted_byte_type_node
12833           || rhs_type == promoted_short_type_node
12834           || rhs_type == promoted_char_type_node
12835           || rhs_type == promoted_boolean_type_node))
12836     return 1;
12837
12838   /* From here, an integral is widened if its precision is smaller
12839      than the precision of the LHS or if the LHS is a floating point
12840      type, or the RHS is a float and the RHS a double. */
12841   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12842        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12843       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12844       || (rhs_type == float_type_node && lhs_type == double_type_node))
12845     return 1;
12846
12847   return 0;
12848 }
12849
12850 /* Check that something of SOURCE type can be assigned or cast to
12851    something of DEST type at runtime. Return 1 if the operation is
12852    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12853    were SOURCE is cast into DEST, which borrows a lot of the
12854    assignment check. */
12855
12856 static int
12857 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12858 {
12859   /* SOURCE or DEST might be null if not from a declared entity. */
12860   if (!source || !dest)
12861     return 0;
12862   if (JNULLP_TYPE_P (source))
12863     return 1;
12864   if (TREE_CODE (source) == POINTER_TYPE)
12865     source = TREE_TYPE (source);
12866   if (TREE_CODE (dest) == POINTER_TYPE)
12867     dest = TREE_TYPE (dest);
12868
12869   /* If source and dest are being compiled from bytecode, they may need to
12870      be loaded. */
12871   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12872     {
12873       load_class (source, 1);
12874       safe_layout_class (source);
12875     }
12876   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12877     {
12878       load_class (dest, 1);
12879       safe_layout_class (dest);
12880     }
12881
12882   /* Case where SOURCE is a class type */
12883   if (TYPE_CLASS_P (source))
12884     {
12885       if (TYPE_CLASS_P (dest))
12886         return  (source == dest
12887                  || inherits_from_p (source, dest)
12888                  || (cast && inherits_from_p (dest, source)));
12889       if (TYPE_INTERFACE_P (dest))
12890         {
12891           /* If doing a cast and SOURCE is final, the operation is
12892              always correct a compile time (because even if SOURCE
12893              does not implement DEST, a subclass of SOURCE might). */
12894           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12895             return 1;
12896           /* Otherwise, SOURCE must implement DEST */
12897           return interface_of_p (dest, source);
12898         }
12899       /* DEST is an array, cast permitted if SOURCE is of Object type */
12900       return (cast && source == object_type_node ? 1 : 0);
12901     }
12902   if (TYPE_INTERFACE_P (source))
12903     {
12904       if (TYPE_CLASS_P (dest))
12905         {
12906           /* If not casting, DEST must be the Object type */
12907           if (!cast)
12908             return dest == object_type_node;
12909           /* We're doing a cast. The cast is always valid is class
12910              DEST is not final, otherwise, DEST must implement SOURCE */
12911           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12912             return 1;
12913           else
12914             return interface_of_p (source, dest);
12915         }
12916       if (TYPE_INTERFACE_P (dest))
12917         {
12918           /* If doing a cast, then if SOURCE and DEST contain method
12919              with the same signature but different return type, then
12920              this is a (compile time) error */
12921           if (cast)
12922             {
12923               tree method_source, method_dest;
12924               tree source_type;
12925               tree source_sig;
12926               tree source_name;
12927               for (method_source = TYPE_METHODS (source); method_source;
12928                    method_source = TREE_CHAIN (method_source))
12929                 {
12930                   source_sig =
12931                     build_java_argument_signature (TREE_TYPE (method_source));
12932                   source_type = TREE_TYPE (TREE_TYPE (method_source));
12933                   source_name = DECL_NAME (method_source);
12934                   for (method_dest = TYPE_METHODS (dest);
12935                        method_dest; method_dest = TREE_CHAIN (method_dest))
12936                     if (source_sig ==
12937                         build_java_argument_signature (TREE_TYPE (method_dest))
12938                         && source_name == DECL_NAME (method_dest)
12939                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12940                       return 0;
12941                 }
12942               return 1;
12943             }
12944           else
12945             return source == dest || interface_of_p (dest, source);
12946         }
12947       else
12948         {
12949           /* Array */
12950           return (cast
12951                   && (DECL_NAME (TYPE_NAME (source))
12952                       == java_lang_cloneable_identifier_node
12953                       || (DECL_NAME (TYPE_NAME (source))
12954                           == java_io_serializable_identifier_node)));
12955         }
12956     }
12957   if (TYPE_ARRAY_P (source))
12958     {
12959       if (TYPE_CLASS_P (dest))
12960         return dest == object_type_node;
12961       /* Can't cast an array to an interface unless the interface is
12962          java.lang.Cloneable or java.io.Serializable.  */
12963       if (TYPE_INTERFACE_P (dest))
12964         return (DECL_NAME (TYPE_NAME (dest))
12965                 == java_lang_cloneable_identifier_node
12966                 || (DECL_NAME (TYPE_NAME (dest))
12967                     == java_io_serializable_identifier_node));
12968       else                      /* Arrays */
12969         {
12970           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12971           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12972
12973           /* In case of severe errors, they turn out null */
12974           if (!dest_element_type || !source_element_type)
12975             return 0;
12976           if (source_element_type == dest_element_type)
12977             return 1;
12978           return valid_ref_assignconv_cast_p (source_element_type,
12979                                               dest_element_type, cast);
12980         }
12981       return 0;
12982     }
12983   return 0;
12984 }
12985
12986 static int
12987 valid_cast_to_p (tree source, tree dest)
12988 {
12989   if (TREE_CODE (source) == POINTER_TYPE)
12990     source = TREE_TYPE (source);
12991   if (TREE_CODE (dest) == POINTER_TYPE)
12992     dest = TREE_TYPE (dest);
12993
12994   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
12995     return valid_ref_assignconv_cast_p (source, dest, 1);
12996
12997   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
12998     return 1;
12999
13000   else if (TREE_CODE (source) == BOOLEAN_TYPE
13001            && TREE_CODE (dest) == BOOLEAN_TYPE)
13002     return 1;
13003
13004   return 0;
13005 }
13006
13007 static tree
13008 do_unary_numeric_promotion (tree arg)
13009 {
13010   tree type = TREE_TYPE (arg);
13011   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13012       || TREE_CODE (type) == CHAR_TYPE)
13013     arg = convert (int_type_node, arg);
13014   return arg;
13015 }
13016
13017 /* Return a nonzero value if SOURCE can be converted into DEST using
13018    the method invocation conversion rule (5.3).  */
13019 static int
13020 valid_method_invocation_conversion_p (tree dest, tree source)
13021 {
13022   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13023            && valid_builtin_assignconv_identity_widening_p (dest, source))
13024           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13025               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13026               && valid_ref_assignconv_cast_p (source, dest, 0)));
13027 }
13028
13029 /* Build an incomplete binop expression. */
13030
13031 static tree
13032 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13033 {
13034   tree binop = build2 (op, NULL_TREE, op1, op2);
13035   TREE_SIDE_EFFECTS (binop) = 1;
13036   /* Store the location of the operator, for better error report. The
13037      string of the operator will be rebuild based on the OP value. */
13038   EXPR_WFL_LINECOL (binop) = op_location;
13039   return binop;
13040 }
13041
13042 /* Build the string of the operator retained by NODE. If NODE is part
13043    of a compound expression, add an '=' at the end of the string. This
13044    function is called when an error needs to be reported on an
13045    operator. The string is returned as a pointer to a static character
13046    buffer. */
13047
13048 static char *
13049 operator_string (tree node)
13050 {
13051 #define BUILD_OPERATOR_STRING(S)                                        \
13052   {                                                                     \
13053     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13054     return buffer;                                                      \
13055   }
13056
13057   static char buffer [10];
13058   switch (TREE_CODE (node))
13059     {
13060     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13061     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13062     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13063     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13064     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13065     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13066     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13067     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13068     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13069     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13070     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13071     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13072     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13073     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13074     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13075     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13076     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13077     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13078     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13079     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13080     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13081     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13082     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13083     case PREINCREMENT_EXPR:     /* Fall through */
13084     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13085     case PREDECREMENT_EXPR:     /* Fall through */
13086     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13087     default:
13088       internal_error ("unregistered operator %s",
13089                       tree_code_name [TREE_CODE (node)]);
13090     }
13091   return NULL;
13092 #undef BUILD_OPERATOR_STRING
13093 }
13094
13095 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13096
13097 static int
13098 java_decl_equiv (tree var_acc1, tree var_acc2)
13099 {
13100   if (JDECL_P (var_acc1))
13101     return (var_acc1 == var_acc2);
13102
13103   return (TREE_CODE (var_acc1) == COMPONENT_REF
13104           && TREE_CODE (var_acc2) == COMPONENT_REF
13105           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13106              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13107           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13108 }
13109
13110 /* Return a nonzero value if CODE is one of the operators that can be
13111    used in conjunction with the `=' operator in a compound assignment.  */
13112
13113 static int
13114 binop_compound_p (enum tree_code code)
13115 {
13116   int i;
13117   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13118     if (binop_lookup [i] == code)
13119       break;
13120
13121   return i < BINOP_COMPOUND_CANDIDATES;
13122 }
13123
13124 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13125
13126 static tree
13127 java_refold (tree t)
13128 {
13129   tree c, b, ns, decl;
13130
13131   if (TREE_CODE (t) != MODIFY_EXPR)
13132     return t;
13133
13134   c = TREE_OPERAND (t, 1);
13135   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13136          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13137          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13138     return t;
13139
13140   /* Now the left branch of the binary operator. */
13141   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13142   if (! (b && TREE_CODE (b) == NOP_EXPR
13143          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13144     return t;
13145
13146   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13147   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13148          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13149     return t;
13150
13151   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13152   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13153       /* It's got to be the an equivalent decl */
13154       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13155     {
13156       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13157       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13158       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13159       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13160       /* Change the right part of the BINOP_EXPR */
13161       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13162     }
13163
13164   return t;
13165 }
13166
13167 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13168    errors but we modify NODE so that it contains the type computed
13169    according to the expression, when it's fixed. Otherwise, we write
13170    error_mark_node as the type. It allows us to further the analysis
13171    of remaining nodes and detects more errors in certain cases.  */
13172
13173 static tree
13174 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13175 {
13176   tree op1 = TREE_OPERAND (node, 0);
13177   tree op2 = TREE_OPERAND (node, 1);
13178   tree op1_type = TREE_TYPE (op1);
13179   tree op2_type = TREE_TYPE (op2);
13180   tree prom_type = NULL_TREE, cn;
13181   enum tree_code code = TREE_CODE (node);
13182
13183   /* If 1, tell the routine that we have to return error_mark_node
13184      after checking for the initialization of the RHS */
13185   int error_found = 0;
13186
13187   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13188
13189   /* If either op<n>_type are NULL, this might be early signs of an
13190      error situation, unless it's too early to tell (in case we're
13191      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13192      correctly so the error can be later on reported accurately. */
13193   if (! (code == PLUS_EXPR || code == NE_EXPR
13194          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13195     {
13196       tree n;
13197       if (! op1_type)
13198         {
13199           n = java_complete_tree (op1);
13200           op1_type = TREE_TYPE (n);
13201         }
13202       if (! op2_type)
13203         {
13204           n = java_complete_tree (op2);
13205           op2_type = TREE_TYPE (n);
13206         }
13207     }
13208
13209   switch (code)
13210     {
13211     /* 15.16 Multiplicative operators */
13212     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13213     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13214     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13215     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13216       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13217         {
13218           if (!JNUMERIC_TYPE_P (op1_type))
13219             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13220           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13221             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13222           TREE_TYPE (node) = error_mark_node;
13223           error_found = 1;
13224           break;
13225         }
13226       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13227
13228       /* Detect integral division by zero */
13229       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13230           && TREE_CODE (prom_type) == INTEGER_TYPE
13231           && (op2 == integer_zero_node || op2 == long_zero_node ||
13232               (TREE_CODE (op2) == INTEGER_CST &&
13233                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13234         {
13235           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13236           TREE_CONSTANT (node) = 0;
13237           TREE_INVARIANT (node) = 0;
13238         }
13239
13240       /* Change the division operator if necessary */
13241       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13242         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13243
13244       /* Before divisions as is disappear, try to simplify and bail if
13245          applicable, otherwise we won't perform even simple
13246          simplifications like (1-1)/3. We can't do that with floating
13247          point number, folds can't handle them at this stage. */
13248       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13249           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13250         {
13251           TREE_TYPE (node) = prom_type;
13252           node = fold (node);
13253           if (TREE_CODE (node) != code)
13254             return node;
13255         }
13256
13257       if (TREE_CODE (prom_type) == INTEGER_TYPE
13258           && flag_use_divide_subroutine
13259           && ! flag_emit_class_files
13260           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13261         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13262
13263       /* This one is more complicated. FLOATs are processed by a
13264          function call to soft_fmod. Duplicate the value of the
13265          COMPOUND_ASSIGN_P flag. */
13266       if (code == TRUNC_MOD_EXPR)
13267         {
13268           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13269           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13270           TREE_SIDE_EFFECTS (mod)
13271             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13272           return mod;
13273         }
13274       break;
13275
13276     /* 15.17 Additive Operators */
13277     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13278
13279       /* Operation is valid if either one argument is a string
13280          constant, a String object or a StringBuffer crafted for the
13281          purpose of the a previous usage of the String concatenation
13282          operator */
13283
13284       if (TREE_CODE (op1) == STRING_CST
13285           || TREE_CODE (op2) == STRING_CST
13286           || JSTRING_TYPE_P (op1_type)
13287           || JSTRING_TYPE_P (op2_type)
13288           || IS_CRAFTED_STRING_BUFFER_P (op1)
13289           || IS_CRAFTED_STRING_BUFFER_P (op2))
13290         return build_string_concatenation (op1, op2);
13291
13292     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13293                                    Numeric Types */
13294       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13295         {
13296           if (!JNUMERIC_TYPE_P (op1_type))
13297             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13298           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13299             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13300           TREE_TYPE (node) = error_mark_node;
13301           error_found = 1;
13302           break;
13303         }
13304       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13305       break;
13306
13307     /* 15.18 Shift Operators */
13308     case LSHIFT_EXPR:
13309     case RSHIFT_EXPR:
13310     case URSHIFT_EXPR:
13311       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13312         {
13313           if (!JINTEGRAL_TYPE_P (op1_type))
13314             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13315           else
13316             {
13317               if (JNUMERIC_TYPE_P (op2_type))
13318                 parse_error_context (wfl_operator,
13319                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13320                                      operator_string (node),
13321                                      lang_printable_name (op2_type, 0));
13322               else
13323                 parse_error_context (wfl_operator,
13324                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13325                                      operator_string (node),
13326                                      lang_printable_name (op2_type, 0));
13327             }
13328           TREE_TYPE (node) = error_mark_node;
13329           error_found = 1;
13330           break;
13331         }
13332
13333       /* Unary numeric promotion (5.6.1) is performed on each operand
13334          separately */
13335       op1 = do_unary_numeric_promotion (op1);
13336       op2 = do_unary_numeric_promotion (op2);
13337
13338       /* If the right hand side is of type `long', first cast it to
13339          `int'.  */
13340       if (TREE_TYPE (op2) == long_type_node)
13341         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13342
13343       /* The type of the shift expression is the type of the promoted
13344          type of the left-hand operand */
13345       prom_type = TREE_TYPE (op1);
13346
13347       /* Shift int only up to 0x1f and long up to 0x3f */
13348       if (prom_type == int_type_node)
13349         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13350                             build_int_cst (NULL_TREE, 0x1f)));
13351       else
13352         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13353                             build_int_cst (NULL_TREE, 0x3f)));
13354
13355       /* The >>> operator is a >> operating on unsigned quantities */
13356       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13357         {
13358           tree to_return;
13359           tree utype = java_unsigned_type (prom_type);
13360           op1 = convert (utype, op1);
13361           TREE_SET_CODE (node, RSHIFT_EXPR);
13362           TREE_OPERAND (node, 0) = op1;
13363           TREE_OPERAND (node, 1) = op2;
13364           TREE_TYPE (node) = utype;
13365           to_return = convert (prom_type, node);
13366           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13367           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13368           TREE_SIDE_EFFECTS (to_return)
13369             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13370           return to_return;
13371         }
13372       break;
13373
13374       /* 15.19.1 Type Comparison Operator instanceof */
13375     case INSTANCEOF_EXPR:
13376
13377       TREE_TYPE (node) = boolean_type_node;
13378
13379       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13380       if ((cn = patch_string (op1)))
13381         {
13382           op1 = cn;
13383           op1_type = TREE_TYPE (op1);
13384         }
13385       if (op1_type == NULL_TREE)
13386         abort ();
13387
13388       if (!(op2_type = resolve_type_during_patch (op2)))
13389         return error_mark_node;
13390
13391       /* The first operand must be a reference type or the null type */
13392       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13393         error_found = 1;        /* Error reported further below */
13394
13395       /* The second operand must be a reference type */
13396       if (!JREFERENCE_TYPE_P (op2_type))
13397         {
13398           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13399           parse_error_context
13400             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13401              lang_printable_name (op2_type, 0));
13402           error_found = 1;
13403         }
13404
13405       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13406         {
13407           /* If the first operand is null, the result is always false */
13408           if (op1 == null_pointer_node)
13409             return boolean_false_node;
13410           else if (flag_emit_class_files)
13411             {
13412               TREE_OPERAND (node, 1) = op2_type;
13413               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13414               return node;
13415             }
13416           /* Otherwise we have to invoke instance of to figure it out */
13417           else
13418             return build_instanceof (op1, op2_type);
13419         }
13420       /* There is no way the expression operand can be an instance of
13421          the type operand. This is a compile time error. */
13422       else
13423         {
13424           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13425           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13426           parse_error_context
13427             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13428              t1, lang_printable_name (op2_type, 0));
13429           free (t1);
13430           error_found = 1;
13431         }
13432
13433       break;
13434
13435       /* 15.21 Bitwise and Logical Operators */
13436     case BIT_AND_EXPR:
13437     case BIT_XOR_EXPR:
13438     case BIT_IOR_EXPR:
13439       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13440         /* Binary numeric promotion is performed on both operand and the
13441            expression retain that type */
13442         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13443
13444       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13445                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13446         /* The type of the bitwise operator expression is BOOLEAN */
13447         prom_type = boolean_type_node;
13448       else
13449         {
13450           if (!JINTEGRAL_TYPE_P (op1_type))
13451             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13452           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13453             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13454           TREE_TYPE (node) = error_mark_node;
13455           error_found = 1;
13456           /* Insert a break here if adding thing before the switch's
13457              break for this case */
13458         }
13459       break;
13460
13461       /* 15.22 Conditional-And Operator */
13462     case TRUTH_ANDIF_EXPR:
13463       /* 15.23 Conditional-Or Operator */
13464     case TRUTH_ORIF_EXPR:
13465       /* Operands must be of BOOLEAN type */
13466       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13467           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13468         {
13469           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13470             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13471           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13472             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13473           TREE_TYPE (node) = boolean_type_node;
13474           error_found = 1;
13475           break;
13476         }
13477       else if (integer_zerop (op1))
13478         {
13479           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13480         }
13481       else if (integer_onep (op1))
13482         {
13483           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13484         }
13485       /* The type of the conditional operators is BOOLEAN */
13486       prom_type = boolean_type_node;
13487       break;
13488
13489       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13490     case LT_EXPR:
13491     case GT_EXPR:
13492     case LE_EXPR:
13493     case GE_EXPR:
13494       /* The type of each of the operands must be a primitive numeric
13495          type */
13496       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13497         {
13498           if (!JNUMERIC_TYPE_P (op1_type))
13499             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13500           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13501             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13502           TREE_TYPE (node) = boolean_type_node;
13503           error_found = 1;
13504           break;
13505         }
13506       /* Binary numeric promotion is performed on the operands */
13507       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13508       /* The type of the relation expression is always BOOLEAN */
13509       prom_type = boolean_type_node;
13510       break;
13511
13512       /* 15.20 Equality Operator */
13513     case EQ_EXPR:
13514     case NE_EXPR:
13515       /* It's time for us to patch the strings. */
13516       if ((cn = patch_string (op1)))
13517        {
13518          op1 = cn;
13519          op1_type = TREE_TYPE (op1);
13520        }
13521       if ((cn = patch_string (op2)))
13522        {
13523          op2 = cn;
13524          op2_type = TREE_TYPE (op2);
13525        }
13526
13527       /* 15.20.1 Numerical Equality Operators == and != */
13528       /* Binary numeric promotion is performed on the operands */
13529       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13530         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13531
13532       /* 15.20.2 Boolean Equality Operators == and != */
13533       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13534           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13535         ;                       /* Nothing to do here */
13536
13537       /* 15.20.3 Reference Equality Operators == and != */
13538       /* Types have to be either references or the null type. If
13539          they're references, it must be possible to convert either
13540          type to the other by casting conversion. */
13541       else if (op1 == null_pointer_node || op2 == null_pointer_node
13542                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13543                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13544                        || valid_ref_assignconv_cast_p (op2_type,
13545                                                        op1_type, 1))))
13546         ;                       /* Nothing to do here */
13547
13548       /* Else we have an error figure what can't be converted into
13549          what and report the error */
13550       else
13551         {
13552           char *t1;
13553           t1 = xstrdup (lang_printable_name (op1_type, 0));
13554           parse_error_context
13555             (wfl_operator,
13556              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13557              operator_string (node), t1,
13558              lang_printable_name (op2_type, 0));
13559           free (t1);
13560           TREE_TYPE (node) = boolean_type_node;
13561           error_found = 1;
13562           break;
13563         }
13564       prom_type = boolean_type_node;
13565       break;
13566     default:
13567       abort ();
13568     }
13569
13570   if (error_found)
13571     return error_mark_node;
13572
13573   TREE_OPERAND (node, 0) = op1;
13574   TREE_OPERAND (node, 1) = op2;
13575   TREE_TYPE (node) = prom_type;
13576   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13577
13578   if (flag_emit_xref)
13579     return node;
13580
13581   /* fold does not respect side-effect order as required for Java but not C.
13582    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13583    * bytecode.
13584    */
13585   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13586       : ! TREE_SIDE_EFFECTS (node))
13587     node = fold (node);
13588   return node;
13589 }
13590
13591 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13592    zero value, the value of CSTE comes after the valude of STRING */
13593
13594 static tree
13595 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13596 {
13597   const char *old = TREE_STRING_POINTER (cste);
13598   int old_len = TREE_STRING_LENGTH (cste);
13599   int len = old_len + string_len;
13600   char *new = alloca (len+1);
13601
13602   if (after)
13603     {
13604       memcpy (new, string, string_len);
13605       memcpy (&new [string_len], old, old_len);
13606     }
13607   else
13608     {
13609       memcpy (new, old, old_len);
13610       memcpy (&new [old_len], string, string_len);
13611     }
13612   new [len] = '\0';
13613   return build_string (len, new);
13614 }
13615
13616 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13617    new STRING_CST on success, NULL_TREE on failure.  */
13618
13619 static tree
13620 merge_string_cste (tree op1, tree op2, int after)
13621 {
13622   /* Handle two string constants right away.  */
13623   if (TREE_CODE (op2) == STRING_CST)
13624     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13625                                  TREE_STRING_LENGTH (op2), after);
13626
13627   /* Reasonable integer constant can be treated right away.  */
13628   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13629     {
13630       static const char *const boolean_true = "true";
13631       static const char *const boolean_false = "false";
13632       static const char *const null_pointer = "null";
13633       char ch[4];
13634       const char *string;
13635
13636       if (op2 == boolean_true_node)
13637         string = boolean_true;
13638       else if (op2 == boolean_false_node)
13639         string = boolean_false;
13640       else if (op2 == null_pointer_node
13641                || (integer_zerop (op2)
13642                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13643         /* FIXME: null is not a compile-time constant, so it is only safe to
13644            merge if the overall expression is non-constant. However, this
13645            code always merges without checking the overall expression.  */
13646         string = null_pointer;
13647       else if (TREE_TYPE (op2) == char_type_node)
13648         {
13649           /* Convert the character into UTF-8.  */
13650           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13651           unsigned char *p = (unsigned char *) ch;
13652           if (0x01 <= c && c <= 0x7f)
13653             *p++ = (unsigned char) c;
13654           else if (c < 0x7ff)
13655             {
13656               *p++ = (unsigned char) (c >> 6 | 0xc0);
13657               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13658             }
13659           else
13660             {
13661               *p++ = (unsigned char) (c >> 12 | 0xe0);
13662               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13663               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13664             }
13665           *p = '\0';
13666
13667           string = ch;
13668         }
13669       else
13670         string = string_convert_int_cst (op2);
13671
13672       return do_merge_string_cste (op1, string, strlen (string), after);
13673     }
13674   return NULL_TREE;
13675 }
13676
13677 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13678    has to be a STRING_CST and the other part must be a STRING_CST or a
13679    INTEGRAL constant. Return a new STRING_CST if the operation
13680    succeed, NULL_TREE otherwise.
13681
13682    If the case we want to optimize for space, we might want to return
13683    NULL_TREE for each invocation of this routine. FIXME */
13684
13685 static tree
13686 string_constant_concatenation (tree op1, tree op2)
13687 {
13688   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13689     {
13690       tree string, rest;
13691       int invert;
13692
13693       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13694       rest   = (string == op1 ? op2 : op1);
13695       invert = (string == op1 ? 0 : 1 );
13696
13697       /* Walk REST, only if it looks reasonable */
13698       if (TREE_CODE (rest) != STRING_CST
13699           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13700           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13701           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13702         {
13703           rest = java_complete_tree (rest);
13704           if (rest == error_mark_node)
13705             return error_mark_node;
13706           rest = fold (rest);
13707         }
13708       return merge_string_cste (string, rest, invert);
13709     }
13710   return NULL_TREE;
13711 }
13712
13713 /* Implement the `+' operator. Does static optimization if possible,
13714    otherwise create (if necessary) and append elements to a
13715    StringBuffer. The StringBuffer will be carried around until it is
13716    used for a function call or an assignment. Then toString() will be
13717    called on it to turn it into a String object. */
13718
13719 static tree
13720 build_string_concatenation (tree op1, tree op2)
13721 {
13722   tree result;
13723   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13724
13725   if (flag_emit_xref)
13726     return build2 (PLUS_EXPR, string_type_node, op1, op2);
13727
13728   /* Try to do some static optimization */
13729   if ((result = string_constant_concatenation (op1, op2)))
13730     return result;
13731
13732   /* Discard empty strings on either side of the expression */
13733   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13734     {
13735       op1 = op2;
13736       op2 = NULL_TREE;
13737     }
13738   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13739     op2 = NULL_TREE;
13740
13741   /* If operands are string constant, turn then into object references */
13742   if (TREE_CODE (op1) == STRING_CST)
13743     op1 = patch_string_cst (op1);
13744   if (op2 && TREE_CODE (op2) == STRING_CST)
13745     op2 = patch_string_cst (op2);
13746
13747   /* If either one of the constant is null and the other non null
13748      operand is a String constant, return it. */
13749   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13750     return op1;
13751
13752   /* If OP1 isn't already a StringBuffer, create and
13753      initialize a new one */
13754   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13755     {
13756       /* Two solutions here:
13757          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13758          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13759       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13760         op1 = BUILD_STRING_BUFFER (op1);
13761       else
13762         {
13763           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13764           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13765         }
13766     }
13767
13768   if (op2)
13769     {
13770       /* OP1 is no longer the last node holding a crafted StringBuffer */
13771       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13772       /* Create a node for `{new...,xxx}.append (op2)' */
13773       if (op2)
13774         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13775     }
13776
13777   /* Mark the last node holding a crafted StringBuffer */
13778   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13779
13780   TREE_SIDE_EFFECTS (op1) = side_effects;
13781   return op1;
13782 }
13783
13784 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13785    StringBuffer. If no string were found to be patched, return
13786    NULL. */
13787
13788 static tree
13789 patch_string (tree node)
13790 {
13791   if (node == error_mark_node)
13792     return error_mark_node;
13793   if (TREE_CODE (node) == STRING_CST)
13794     return patch_string_cst (node);
13795   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13796     {
13797       int saved = ctxp->explicit_constructor_p;
13798       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13799       tree ret;
13800       /* Temporary disable forbid the use of `this'. */
13801       ctxp->explicit_constructor_p = 0;
13802       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13803       /* String concatenation arguments must be evaluated in order too. */
13804       ret = force_evaluation_order (ret);
13805       /* Restore it at its previous value */
13806       ctxp->explicit_constructor_p = saved;
13807       return ret;
13808     }
13809   return NULL_TREE;
13810 }
13811
13812 /* Build the internal representation of a string constant.  */
13813
13814 static tree
13815 patch_string_cst (tree node)
13816 {
13817   int location;
13818   if (! flag_emit_class_files)
13819     {
13820       node = get_identifier (TREE_STRING_POINTER (node));
13821       location = alloc_name_constant (CONSTANT_String, node);
13822       node = build_ref_from_constant_pool (location);
13823     }
13824   TREE_CONSTANT (node) = 1;
13825   TREE_INVARIANT (node) = 1;
13826
13827   /* ??? Guessing that the class file code can't handle casts.  */
13828   if (! flag_emit_class_files)
13829     node = convert (string_ptr_type_node, node);
13830   else
13831     TREE_TYPE (node) = string_ptr_type_node;
13832
13833   return node;
13834 }
13835
13836 /* Build an incomplete unary operator expression. */
13837
13838 static tree
13839 build_unaryop (int op_token, int op_location, tree op1)
13840 {
13841   enum tree_code op;
13842   tree unaryop;
13843   switch (op_token)
13844     {
13845     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13846     case MINUS_TK: op = NEGATE_EXPR; break;
13847     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13848     case NOT_TK: op = BIT_NOT_EXPR; break;
13849     default: abort ();
13850     }
13851
13852   unaryop = build1 (op, NULL_TREE, op1);
13853   TREE_SIDE_EFFECTS (unaryop) = 1;
13854   /* Store the location of the operator, for better error report. The
13855      string of the operator will be rebuild based on the OP value. */
13856   EXPR_WFL_LINECOL (unaryop) = op_location;
13857   return unaryop;
13858 }
13859
13860 /* Special case for the ++/-- operators, since they require an extra
13861    argument to build, which is set to NULL and patched
13862    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13863
13864 static tree
13865 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13866 {
13867   static const enum tree_code lookup [2][2] =
13868     {
13869       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13870       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13871     };
13872   tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
13873                       NULL_TREE, op1, NULL_TREE);
13874   TREE_SIDE_EFFECTS (node) = 1;
13875   /* Store the location of the operator, for better error report. The
13876      string of the operator will be rebuild based on the OP value. */
13877   EXPR_WFL_LINECOL (node) = op_location;
13878   return node;
13879 }
13880
13881 /* Build an incomplete cast operator, based on the use of the
13882    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13883    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13884    though its type is already set.  */
13885
13886 static tree
13887 build_cast (int location, tree type, tree exp)
13888 {
13889   tree node = build1 (CONVERT_EXPR, type, exp);
13890   EXPR_WFL_LINECOL (node) = location;
13891   return node;
13892 }
13893
13894 /* Build an incomplete class reference operator.  */
13895 static tree
13896 build_incomplete_class_ref (int location, tree class_name)
13897 {
13898   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13899   tree class_decl = GET_CPC ();
13900   tree this_class = TREE_TYPE (class_decl);
13901
13902   /* Generate the synthetic static method `class$'.  (Previously we
13903      deferred this, causing different method tables to be emitted
13904      for native code and bytecode.)  */
13905   if (!TYPE_DOT_CLASS (this_class)
13906       && !JPRIMITIVE_TYPE_P (class_name)
13907       && !(TREE_CODE (class_name) == VOID_TYPE))
13908     {
13909       tree cpc_list = GET_CPC_LIST();
13910       tree cpc = cpc_list;
13911       tree target_class;
13912
13913       /* For inner classes, add a 'class$' method to their outermost
13914          context, creating it if necessary.  */
13915
13916       while (GET_NEXT_ENCLOSING_CPC(cpc))
13917         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
13918       class_decl = TREE_VALUE (cpc);
13919
13920       target_class = TREE_TYPE (class_decl);
13921
13922       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
13923         {
13924           /* For interfaces, adding a static 'class$' method directly
13925              is illegal.  So create an inner class to contain the new
13926              method.  Empirically this matches the behavior of javac.  */
13927           tree t, inner;
13928           /* We want the generated inner class inside the outermost class. */
13929           GET_CPC_LIST() = cpc;
13930           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13931           inner = create_anonymous_class (t);
13932           target_class = TREE_TYPE (inner);
13933           end_class_declaration (1);
13934           GET_CPC_LIST() = cpc_list;
13935         }
13936
13937       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
13938         build_dot_class_method (target_class);
13939
13940       if (this_class != target_class)
13941         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
13942     }
13943
13944   EXPR_WFL_LINECOL (node) = location;
13945   return node;
13946 }
13947
13948 /* Complete an incomplete class reference operator.  */
13949 static tree
13950 patch_incomplete_class_ref (tree node)
13951 {
13952   tree type = TREE_OPERAND (node, 0);
13953   tree ref_type;
13954
13955   if (!(ref_type = resolve_type_during_patch (type)))
13956     return error_mark_node;
13957
13958   /* If we're not emitting class files and we know ref_type is a
13959      compiled class, build a direct reference.  */
13960   if ((! flag_emit_class_files && is_compiled_class (ref_type))
13961       || JPRIMITIVE_TYPE_P (ref_type)
13962       || TREE_CODE (ref_type) == VOID_TYPE)
13963     {
13964       tree dot = build_class_ref (ref_type);
13965       /* A class referenced by `foo.class' is initialized.  */
13966       if (!flag_emit_class_files)
13967        dot = build_class_init (ref_type, dot);
13968       return java_complete_tree (dot);
13969     }
13970
13971   /* If we're emitting class files and we have to deal with non
13972      primitive types, we invoke the synthetic static method `class$'.  */
13973   ref_type = build_dot_class_method_invocation (current_class, ref_type);
13974   return java_complete_tree (ref_type);
13975 }
13976
13977 /* 15.14 Unary operators. We return error_mark_node in case of error,
13978    but preserve the type of NODE if the type is fixed.  */
13979
13980 static tree
13981 patch_unaryop (tree node, tree wfl_op)
13982 {
13983   tree op = TREE_OPERAND (node, 0);
13984   tree op_type = TREE_TYPE (op);
13985   tree prom_type = NULL_TREE, value, decl;
13986   int outer_field_flag = 0;
13987   int code = TREE_CODE (node);
13988   int error_found = 0;
13989
13990   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13991
13992   switch (code)
13993     {
13994       /* 15.13.2 Postfix Increment Operator ++ */
13995     case POSTINCREMENT_EXPR:
13996       /* 15.13.3 Postfix Increment Operator -- */
13997     case POSTDECREMENT_EXPR:
13998       /* 15.14.1 Prefix Increment Operator ++ */
13999     case PREINCREMENT_EXPR:
14000       /* 15.14.2 Prefix Decrement Operator -- */
14001     case PREDECREMENT_EXPR:
14002       op = decl = strip_out_static_field_access_decl (op);
14003       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14004       /* We might be trying to change an outer field accessed using
14005          access method. */
14006       if (outer_field_flag)
14007         {
14008           /* Retrieve the decl of the field we're trying to access. We
14009              do that by first retrieving the function we would call to
14010              access the field. It has been already verified that this
14011              field isn't final */
14012           if (flag_emit_class_files)
14013             decl = TREE_OPERAND (op, 0);
14014           else
14015             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14016           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14017         }
14018       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14019       else if (!JDECL_P (decl)
14020           && TREE_CODE (decl) != COMPONENT_REF
14021           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14022           && TREE_CODE (decl) != INDIRECT_REF
14023           && !(TREE_CODE (decl) == COMPOUND_EXPR
14024                && TREE_OPERAND (decl, 1)
14025                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14026         {
14027           TREE_TYPE (node) = error_mark_node;
14028           error_found = 1;
14029         }
14030
14031       /* From now on, we know that op if a variable and that it has a
14032          valid wfl. We use wfl_op to locate errors related to the
14033          ++/-- operand. */
14034       if (!JNUMERIC_TYPE_P (op_type))
14035         {
14036           parse_error_context
14037             (wfl_op, "Invalid argument type `%s' to `%s'",
14038              lang_printable_name (op_type, 0), operator_string (node));
14039           TREE_TYPE (node) = error_mark_node;
14040           error_found = 1;
14041         }
14042       else
14043         {
14044           /* Before the addition, binary numeric promotion is performed on
14045              both operands, if really necessary */
14046           if (JINTEGRAL_TYPE_P (op_type))
14047             {
14048               value = build_int_cst (op_type, 1);
14049               TREE_TYPE (node) = op_type;
14050             }
14051           else
14052             {
14053               value = build_int_cst (NULL_TREE, 1);
14054               TREE_TYPE (node) =
14055                 binary_numeric_promotion (op_type,
14056                                           TREE_TYPE (value), &op, &value);
14057             }
14058
14059           /* We remember we might be accessing an outer field */
14060           if (outer_field_flag)
14061             {
14062               /* We re-generate an access to the field */
14063               value = build2 (PLUS_EXPR, TREE_TYPE (op),
14064                               build_outer_field_access (wfl_op, decl), value);
14065
14066               /* And we patch the original access$() into a write
14067                  with plus_op as a rhs */
14068               return outer_field_access_fix (node, op, value);
14069             }
14070
14071           /* And write back into the node. */
14072           TREE_OPERAND (node, 0) = op;
14073           TREE_OPERAND (node, 1) = value;
14074           /* Convert the overall back into its original type, if
14075              necessary, and return */
14076           if (JINTEGRAL_TYPE_P (op_type))
14077             return fold (node);
14078           else
14079             return fold (convert (op_type, node));
14080         }
14081       break;
14082
14083       /* 15.14.3 Unary Plus Operator + */
14084     case UNARY_PLUS_EXPR:
14085       /* 15.14.4 Unary Minus Operator - */
14086     case NEGATE_EXPR:
14087       if (!JNUMERIC_TYPE_P (op_type))
14088         {
14089           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14090           TREE_TYPE (node) = error_mark_node;
14091           error_found = 1;
14092         }
14093       /* Unary numeric promotion is performed on operand */
14094       else
14095         {
14096           op = do_unary_numeric_promotion (op);
14097           prom_type = TREE_TYPE (op);
14098           if (code == UNARY_PLUS_EXPR)
14099             return fold (op);
14100         }
14101       break;
14102
14103       /* 15.14.5 Bitwise Complement Operator ~ */
14104     case BIT_NOT_EXPR:
14105       if (!JINTEGRAL_TYPE_P (op_type))
14106         {
14107           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14108           TREE_TYPE (node) = error_mark_node;
14109           error_found = 1;
14110         }
14111       else
14112         {
14113           op = do_unary_numeric_promotion (op);
14114           prom_type = TREE_TYPE (op);
14115         }
14116       break;
14117
14118       /* 15.14.6 Logical Complement Operator ! */
14119     case TRUTH_NOT_EXPR:
14120       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14121         {
14122           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14123           /* But the type is known. We will report an error if further
14124              attempt of a assignment is made with this rhs */
14125           TREE_TYPE (node) = boolean_type_node;
14126           error_found = 1;
14127         }
14128       else
14129         prom_type = boolean_type_node;
14130       break;
14131
14132       /* 15.15 Cast Expression */
14133     case CONVERT_EXPR:
14134       value = patch_cast (node, wfl_operator);
14135       if (value == error_mark_node)
14136         {
14137           /* If this cast is part of an assignment, we tell the code
14138              that deals with it not to complain about a mismatch,
14139              because things have been cast, anyways */
14140           TREE_TYPE (node) = error_mark_node;
14141           error_found = 1;
14142         }
14143       else
14144         {
14145           value = fold (value);
14146           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14147           return value;
14148         }
14149       break;
14150     }
14151
14152   if (error_found)
14153     return error_mark_node;
14154
14155   /* There are cases where node has been replaced by something else
14156      and we don't end up returning here: UNARY_PLUS_EXPR,
14157      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14158   TREE_OPERAND (node, 0) = fold (op);
14159   TREE_TYPE (node) = prom_type;
14160   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14161   return fold (node);
14162 }
14163
14164 /* Generic type resolution that sometimes takes place during node
14165    patching. Returned the resolved type or generate an error
14166    message. Return the resolved type or NULL_TREE.  */
14167
14168 static tree
14169 resolve_type_during_patch (tree type)
14170 {
14171   if (unresolved_type_p (type, NULL))
14172     {
14173       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14174       if (!type_decl)
14175         {
14176           parse_error_context (type,
14177                                "Class `%s' not found in type declaration",
14178                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14179           return NULL_TREE;
14180         }
14181
14182       check_deprecation (type, type_decl);
14183
14184       return TREE_TYPE (type_decl);
14185     }
14186   return type;
14187 }
14188
14189 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14190    found. Otherwise NODE or something meant to replace it is returned.  */
14191
14192 static tree
14193 patch_cast (tree node, tree wfl_op)
14194 {
14195   tree op = TREE_OPERAND (node, 0);
14196   tree cast_type = TREE_TYPE (node);
14197   tree patched, op_type;
14198   char *t1;
14199
14200   /* Some string patching might be necessary at this stage */
14201   if ((patched = patch_string (op)))
14202     TREE_OPERAND (node, 0) = op = patched;
14203   op_type = TREE_TYPE (op);
14204
14205   /* First resolve OP_TYPE if unresolved */
14206   if (!(cast_type = resolve_type_during_patch (cast_type)))
14207     return error_mark_node;
14208
14209   /* Check on cast that are proven correct at compile time */
14210   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14211     {
14212       /* Same type */
14213       if (cast_type == op_type)
14214         return node;
14215
14216       /* A narrowing conversion from a floating-point number to an
14217          integral type requires special handling (5.1.3).  */
14218       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14219         if (cast_type != long_type_node)
14220           op = convert (integer_type_node, op);
14221
14222       /* Try widening/narrowing conversion.  Potentially, things need
14223          to be worked out in gcc so we implement the extreme cases
14224          correctly.  fold_convert() needs to be fixed.  */
14225       return convert (cast_type, op);
14226     }
14227
14228   /* It's also valid to cast a boolean into a boolean */
14229   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14230     return node;
14231
14232   /* null can be casted to references */
14233   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14234     return build_null_of_type (cast_type);
14235
14236   /* The remaining legal casts involve conversion between reference
14237      types. Check for their compile time correctness. */
14238   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14239       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14240     {
14241       TREE_TYPE (node) = promote_type (cast_type);
14242       /* Now, the case can be determined correct at compile time if
14243          OP_TYPE can be converted into CAST_TYPE by assignment
14244          conversion (5.2) */
14245
14246       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14247         {
14248           TREE_SET_CODE (node, NOP_EXPR);
14249           return node;
14250         }
14251
14252       if (flag_emit_class_files)
14253         {
14254           TREE_SET_CODE (node, CONVERT_EXPR);
14255           return node;
14256         }
14257
14258       /* The cast requires a run-time check */
14259       return build3 (CALL_EXPR, promote_type (cast_type),
14260                      build_address_of (soft_checkcast_node),
14261                      tree_cons (NULL_TREE, build_class_ref (cast_type),
14262                                 build_tree_list (NULL_TREE, op)),
14263                      NULL_TREE);
14264     }
14265
14266   /* Any other casts are proven incorrect at compile time */
14267   t1 = xstrdup (lang_printable_name (op_type, 0));
14268   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14269                        t1, lang_printable_name (cast_type, 0));
14270   free (t1);
14271   return error_mark_node;
14272 }
14273
14274 /* Build a null constant and give it the type TYPE.  */
14275
14276 static tree
14277 build_null_of_type (tree type)
14278 {
14279   tree node = build_int_cst (promote_type (type), 0);
14280   return node;
14281 }
14282
14283 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14284    a list of indices. */
14285 static tree
14286 build_array_ref (int location, tree array, tree index)
14287 {
14288   tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14289                       NULL_TREE, NULL_TREE);
14290   EXPR_WFL_LINECOL (node) = location;
14291   return node;
14292 }
14293
14294 /* 15.12 Array Access Expression */
14295
14296 static tree
14297 patch_array_ref (tree node)
14298 {
14299   tree array = TREE_OPERAND (node, 0);
14300   tree array_type  = TREE_TYPE (array);
14301   tree index = TREE_OPERAND (node, 1);
14302   tree index_type = TREE_TYPE (index);
14303   int error_found = 0;
14304
14305   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14306
14307   if (TREE_CODE (array_type) == POINTER_TYPE)
14308     array_type = TREE_TYPE (array_type);
14309
14310   /* The array reference must be an array */
14311   if (!TYPE_ARRAY_P (array_type))
14312     {
14313       parse_error_context
14314         (wfl_operator,
14315          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14316          lang_printable_name (array_type, 0));
14317       TREE_TYPE (node) = error_mark_node;
14318       error_found = 1;
14319     }
14320
14321   /* The array index undergoes unary numeric promotion. The promoted
14322      type must be int */
14323   index = do_unary_numeric_promotion (index);
14324   if (TREE_TYPE (index) != int_type_node)
14325     {
14326       if (valid_cast_to_p (index_type, int_type_node))
14327         parse_error_context (wfl_operator,
14328    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14329                              lang_printable_name (index_type, 0));
14330       else
14331         parse_error_context (wfl_operator,
14332           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14333                              lang_printable_name (index_type, 0));
14334       TREE_TYPE (node) = error_mark_node;
14335       error_found = 1;
14336     }
14337
14338   if (error_found)
14339     return error_mark_node;
14340
14341   array_type = TYPE_ARRAY_ELEMENT (array_type);
14342
14343   if (flag_emit_class_files || flag_emit_xref)
14344     {
14345       TREE_OPERAND (node, 0) = array;
14346       TREE_OPERAND (node, 1) = index;
14347     }
14348   else
14349     node = build_java_arrayaccess (array, array_type, index);
14350   TREE_TYPE (node) = array_type;
14351   return node;
14352 }
14353
14354 /* 15.9 Array Creation Expressions */
14355
14356 static tree
14357 build_newarray_node (tree type, tree dims, int extra_dims)
14358 {
14359   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14360                       nreverse (dims),
14361                       build_int_cst (NULL_TREE, extra_dims));
14362   return node;
14363 }
14364
14365 static tree
14366 patch_newarray (tree node)
14367 {
14368   tree type = TREE_OPERAND (node, 0);
14369   tree dims = TREE_OPERAND (node, 1);
14370   tree cdim, array_type;
14371   int error_found = 0;
14372   int ndims = 0;
14373   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14374
14375   /* Dimension types are verified. It's better for the types to be
14376      verified in order. */
14377   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14378     {
14379       int dim_error = 0;
14380       tree dim = TREE_VALUE (cdim);
14381
14382       /* Dim might have been saved during its evaluation */
14383       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14384
14385       /* The type of each specified dimension must be an integral type. */
14386       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14387         dim_error = 1;
14388
14389       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14390          promoted type must be int. */
14391       else
14392         {
14393           dim = do_unary_numeric_promotion (dim);
14394           if (TREE_TYPE (dim) != int_type_node)
14395             dim_error = 1;
14396         }
14397
14398       /* Report errors on types here */
14399       if (dim_error)
14400         {
14401           parse_error_context
14402             (TREE_PURPOSE (cdim),
14403              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14404              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14405               "Explicit cast needed to" : "Can't"),
14406              lang_printable_name (TREE_TYPE (dim), 0));
14407           error_found = 1;
14408         }
14409
14410       TREE_PURPOSE (cdim) = NULL_TREE;
14411     }
14412
14413   /* Resolve array base type if unresolved */
14414   if (!(type = resolve_type_during_patch (type)))
14415     error_found = 1;
14416
14417   if (error_found)
14418     {
14419       /* We don't want further evaluation of this bogus array creation
14420          operation */
14421       TREE_TYPE (node) = error_mark_node;
14422       return error_mark_node;
14423     }
14424
14425   /* Set array_type to the actual (promoted) array type of the result. */
14426   if (TREE_CODE (type) == RECORD_TYPE)
14427     type = build_pointer_type (type);
14428   while (--xdims >= 0)
14429     {
14430       type = promote_type (build_java_array_type (type, -1));
14431     }
14432   dims = nreverse (dims);
14433   array_type = type;
14434   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14435     {
14436       type = array_type;
14437       array_type
14438         = build_java_array_type (type,
14439                                  TREE_CODE (cdim) == INTEGER_CST
14440                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14441                                  : -1);
14442       array_type = promote_type (array_type);
14443     }
14444   dims = nreverse (dims);
14445
14446   /* The node is transformed into a function call. Things are done
14447      differently according to the number of dimensions. If the number
14448      of dimension is equal to 1, then the nature of the base type
14449      (primitive or not) matters. */
14450   if (ndims == 1)
14451     return build_new_array (type, TREE_VALUE (dims));
14452
14453   /* Can't reuse what's already written in expr.c because it uses the
14454      JVM stack representation. Provide a build_multianewarray. FIXME */
14455   return build3 (CALL_EXPR, array_type,
14456                  build_address_of (soft_multianewarray_node),
14457                  tree_cons (NULL_TREE,
14458                             build_class_ref (TREE_TYPE (array_type)),
14459                             tree_cons (NULL_TREE,
14460                                        build_int_cst (NULL_TREE, ndims),
14461                                        dims)),
14462                  NULL_TREE);
14463 }
14464
14465 /* 10.6 Array initializer.  */
14466
14467 /* Build a wfl for array element that don't have one, so we can
14468    pin-point errors.  */
14469
14470 static tree
14471 maybe_build_array_element_wfl (tree node)
14472 {
14473   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14474     return build_expr_wfl (NULL_TREE, ctxp->filename,
14475                            ctxp->elc.line, ctxp->elc.prev_col);
14476   else
14477     return NULL_TREE;
14478 }
14479
14480 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14481    identification of initialized arrays easier to detect during walk
14482    and expansion.  */
14483
14484 static tree
14485 build_new_array_init (int location, tree values)
14486 {
14487   tree constructor = build_constructor (NULL_TREE, values);
14488   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14489   EXPR_WFL_LINECOL (to_return) = location;
14490   return to_return;
14491 }
14492
14493 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14494    occurred.  Otherwise return NODE after having set its type
14495    appropriately.  */
14496
14497 static tree
14498 patch_new_array_init (tree type, tree node)
14499 {
14500   int error_seen = 0;
14501   tree current, element_type;
14502   HOST_WIDE_INT length;
14503   int all_constant = 1;
14504   tree init = TREE_OPERAND (node, 0);
14505
14506   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14507     {
14508       parse_error_context (node,
14509                            "Invalid array initializer for non-array type `%s'",
14510                            lang_printable_name (type, 1));
14511       return error_mark_node;
14512     }
14513   type = TREE_TYPE (type);
14514   element_type = TYPE_ARRAY_ELEMENT (type);
14515
14516   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14517
14518   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14519        current;  length++, current = TREE_CHAIN (current))
14520     {
14521       tree elt = TREE_VALUE (current);
14522       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14523         {
14524           error_seen |= array_constructor_check_entry (element_type, current);
14525           elt = TREE_VALUE (current);
14526           /* When compiling to native code, STRING_CST is converted to
14527              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14528           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14529             all_constant = 0;
14530         }
14531       else
14532         {
14533           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14534           TREE_PURPOSE (current) = NULL_TREE;
14535           all_constant = 0;
14536         }
14537       if (elt && TREE_CODE (elt) == TREE_LIST
14538           && TREE_VALUE (elt) == error_mark_node)
14539         error_seen = 1;
14540     }
14541
14542   if (error_seen)
14543     return error_mark_node;
14544
14545   /* Create a new type. We can't reuse the one we have here by
14546      patching its dimension because it originally is of dimension -1
14547      hence reused by gcc. This would prevent triangular arrays. */
14548   type = build_java_array_type (element_type, length);
14549   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14550   TREE_TYPE (node) = promote_type (type);
14551   TREE_CONSTANT (init) = all_constant;
14552   TREE_INVARIANT (init) = all_constant;
14553   TREE_CONSTANT (node) = all_constant;
14554   TREE_INVARIANT (node) = all_constant;
14555   return node;
14556 }
14557
14558 /* Verify that one entry of the initializer element list can be
14559    assigned to the array base type. Report 1 if an error occurred, 0
14560    otherwise.  */
14561
14562 static int
14563 array_constructor_check_entry (tree type, tree entry)
14564 {
14565   char *array_type_string = NULL;       /* For error reports */
14566   tree value, type_value, new_value, wfl_value, patched;
14567   int error_seen = 0;
14568
14569   new_value = NULL_TREE;
14570   wfl_value = TREE_VALUE (entry);
14571
14572   value = java_complete_tree (TREE_VALUE (entry));
14573   /* patch_string return error_mark_node if arg is error_mark_node */
14574   if ((patched = patch_string (value)))
14575     value = patched;
14576   if (value == error_mark_node)
14577     return 1;
14578
14579   type_value = TREE_TYPE (value);
14580
14581   /* At anytime, try_builtin_assignconv can report a warning on
14582      constant overflow during narrowing. */
14583   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14584   new_value = try_builtin_assignconv (wfl_operator, type, value);
14585   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14586     type_value = promote_type (type);
14587
14588   /* Check and report errors */
14589   if (!new_value)
14590     {
14591       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14592                    "Can't" : "Explicit cast needed to");
14593       if (!array_type_string)
14594         array_type_string = xstrdup (lang_printable_name (type, 1));
14595       parse_error_context
14596         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14597          msg, lang_printable_name (type_value, 1), array_type_string);
14598       error_seen = 1;
14599     }
14600
14601   if (new_value)
14602     TREE_VALUE (entry) = new_value;
14603
14604   if (array_type_string)
14605     free (array_type_string);
14606
14607   TREE_PURPOSE (entry) = NULL_TREE;
14608   return error_seen;
14609 }
14610
14611 static tree
14612 build_this (int location)
14613 {
14614   tree node = build_wfl_node (this_identifier_node);
14615   TREE_SET_CODE (node, THIS_EXPR);
14616   EXPR_WFL_LINECOL (node) = location;
14617   return node;
14618 }
14619
14620 /* 14.15 The return statement. It builds a modify expression that
14621    assigns the returned value to the RESULT_DECL that hold the value
14622    to be returned. */
14623
14624 static tree
14625 build_return (int location, tree op)
14626 {
14627   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14628   EXPR_WFL_LINECOL (node) = location;
14629   node = build_debugable_stmt (location, node);
14630   return node;
14631 }
14632
14633 static tree
14634 patch_return (tree node)
14635 {
14636   tree return_exp = TREE_OPERAND (node, 0);
14637   tree meth = current_function_decl;
14638   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14639   int error_found = 0;
14640
14641   TREE_TYPE (node) = error_mark_node;
14642   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14643
14644   /* It's invalid to have a return value within a function that is
14645      declared with the keyword void or that is a constructor */
14646   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14647     error_found = 1;
14648
14649   /* It's invalid to use a return statement in a static block */
14650   if (DECL_CLINIT_P (current_function_decl))
14651     error_found = 1;
14652
14653   /* It's invalid to have a no return value within a function that
14654      isn't declared with the keyword `void' */
14655   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14656     error_found = 2;
14657
14658   if (DECL_INSTINIT_P (current_function_decl))
14659     error_found = 1;
14660
14661   if (error_found)
14662     {
14663       if (DECL_INSTINIT_P (current_function_decl))
14664         parse_error_context (wfl_operator,
14665                              "`return' inside instance initializer");
14666
14667       else if (DECL_CLINIT_P (current_function_decl))
14668         parse_error_context (wfl_operator,
14669                              "`return' inside static initializer");
14670
14671       else if (!DECL_CONSTRUCTOR_P (meth))
14672         {
14673           char *t = xstrdup (lang_printable_name (mtype, 0));
14674           parse_error_context (wfl_operator,
14675                                "`return' with%s value from `%s %s'",
14676                                (error_found == 1 ? "" : "out"),
14677                                t, lang_printable_name (meth, 2));
14678           free (t);
14679         }
14680       else
14681         parse_error_context (wfl_operator,
14682                              "`return' with value from constructor `%s'",
14683                              lang_printable_name (meth, 2));
14684       return error_mark_node;
14685     }
14686
14687   /* If we have a return_exp, build a modify expression and expand
14688      it. Note: at that point, the assignment is declared valid, but we
14689      may want to carry some more hacks */
14690   if (return_exp)
14691     {
14692       tree exp = java_complete_tree (return_exp);
14693       tree modify, patched;
14694
14695       if ((patched = patch_string (exp)))
14696         exp = patched;
14697
14698       modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14699       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14700       modify = java_complete_tree (modify);
14701
14702       if (modify != error_mark_node)
14703         {
14704           TREE_SIDE_EFFECTS (modify) = 1;
14705           TREE_OPERAND (node, 0) = modify;
14706         }
14707       else
14708         return error_mark_node;
14709     }
14710   TREE_TYPE (node) = void_type_node;
14711   TREE_SIDE_EFFECTS (node) = 1;
14712   return node;
14713 }
14714
14715 /* 14.8 The if Statement */
14716
14717 static tree
14718 build_if_else_statement (int location, tree expression, tree if_body,
14719                          tree else_body)
14720 {
14721   tree node;
14722   if (!else_body)
14723     else_body = build_java_empty_stmt ();
14724   node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14725   EXPR_WFL_LINECOL (node) = location;
14726   node = build_debugable_stmt (location, node);
14727   return node;
14728 }
14729
14730 static tree
14731 patch_if_else_statement (tree node)
14732 {
14733   tree expression = TREE_OPERAND (node, 0);
14734   int can_complete_normally
14735     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14736        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14737
14738   TREE_TYPE (node) = error_mark_node;
14739   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14740
14741   /* The type of expression must be boolean */
14742   if (TREE_TYPE (expression) != boolean_type_node
14743       && TREE_TYPE (expression) != promoted_boolean_type_node)
14744     {
14745       parse_error_context
14746         (wfl_operator,
14747          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14748          lang_printable_name (TREE_TYPE (expression), 0));
14749       return error_mark_node;
14750     }
14751
14752   TREE_TYPE (node) = void_type_node;
14753   TREE_SIDE_EFFECTS (node) = 1;
14754   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14755   return node;
14756 }
14757
14758 /* 14.6 Labeled Statements */
14759
14760 /* Action taken when a labeled statement is parsed. a new
14761    LABELED_BLOCK_EXPR is created. No statement is attached to the
14762    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14763
14764 static tree
14765 build_labeled_block (int location, tree label)
14766 {
14767   tree label_name ;
14768   tree label_decl, node;
14769   if (label == NULL_TREE || label == continue_identifier_node)
14770     label_name = label;
14771   else
14772     {
14773       label_name = merge_qualified_name (label_id, label);
14774       /* Issue an error if we try to reuse a label that was previously
14775          declared */
14776       if (IDENTIFIER_LOCAL_VALUE (label_name))
14777         {
14778           EXPR_WFL_LINECOL (wfl_operator) = location;
14779           parse_error_context (wfl_operator,
14780             "Declaration of `%s' shadows a previous label declaration",
14781                                IDENTIFIER_POINTER (label));
14782           EXPR_WFL_LINECOL (wfl_operator) =
14783             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14784           parse_error_context (wfl_operator,
14785             "This is the location of the previous declaration of label `%s'",
14786                                IDENTIFIER_POINTER (label));
14787           java_error_count--;
14788         }
14789     }
14790
14791   label_decl = create_label_decl (label_name);
14792   node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14793   EXPR_WFL_LINECOL (node) = location;
14794   TREE_SIDE_EFFECTS (node) = 1;
14795   return node;
14796 }
14797
14798 /* A labeled statement LBE is attached a statement.  */
14799
14800 static tree
14801 finish_labeled_statement (tree lbe, /* Labeled block expr */
14802                           tree statement)
14803 {
14804   /* In anyways, tie the loop to its statement */
14805   LABELED_BLOCK_BODY (lbe) = statement;
14806   pop_labeled_block ();
14807   POP_LABELED_BLOCK ();
14808   return lbe;
14809 }
14810
14811 /* 14.10, 14.11, 14.12 Loop Statements */
14812
14813 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14814    list. */
14815
14816 static tree
14817 build_new_loop (tree loop_body)
14818 {
14819   tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
14820   TREE_SIDE_EFFECTS (loop) = 1;
14821   PUSH_LOOP (loop);
14822   return loop;
14823 }
14824
14825 /* Create a loop body according to the following structure:
14826      COMPOUND_EXPR
14827        COMPOUND_EXPR            (loop main body)
14828          EXIT_EXPR              (this order is for while/for loops.
14829          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14830            LABEL_DECL           (a continue occurring here branches at the
14831            BODY                  end of this labeled block)
14832        INCREMENT                (if any)
14833
14834   REVERSED, if nonzero, tells that the loop condition expr comes
14835   after the body, like in the do-while loop.
14836
14837   To obtain a loop, the loop body structure described above is
14838   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14839
14840    LABELED_BLOCK_EXPR
14841      LABEL_DECL                   (use this label to exit the loop)
14842      LOOP_EXPR
14843        <structure described above> */
14844
14845 static tree
14846 build_loop_body (int location, tree condition, int reversed)
14847 {
14848   tree first, second, body;
14849
14850   condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14851   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14852   condition = build_debugable_stmt (location, condition);
14853   TREE_SIDE_EFFECTS (condition) = 1;
14854
14855   body = build_labeled_block (0, continue_identifier_node);
14856   first = (reversed ? body : condition);
14857   second = (reversed ? condition : body);
14858   return build2 (COMPOUND_EXPR, NULL_TREE,
14859                  build2 (COMPOUND_EXPR, NULL_TREE, first, second),
14860                  build_java_empty_stmt ());
14861 }
14862
14863 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14864    their order) on the current loop. Unlink the current loop from the
14865    loop list.  */
14866
14867 static tree
14868 finish_loop_body (int location, tree condition, tree body, int reversed)
14869 {
14870   tree to_return = ctxp->current_loop;
14871   tree loop_body = LOOP_EXPR_BODY (to_return);
14872   if (condition)
14873     {
14874       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14875       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14876          The real EXIT_EXPR is one operand further. */
14877       EXPR_WFL_LINECOL (cnode) = location;
14878       /* This one is for accurate error reports */
14879       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14880       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14881     }
14882   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14883   POP_LOOP ();
14884   return to_return;
14885 }
14886
14887 /* Tailored version of finish_loop_body for FOR loops, when FOR
14888    loops feature the condition part */
14889
14890 static tree
14891 finish_for_loop (int location, tree condition, tree update, tree body)
14892 {
14893   /* Put the condition and the loop body in place */
14894   tree loop = finish_loop_body (location, condition, body, 0);
14895   /* LOOP is the current loop which has been now popped of the loop
14896      stack.  Mark the update block as reachable and install it.  We do
14897      this because the (current interpretation of the) JLS requires
14898      that the update expression be considered reachable even if the
14899      for loop's body doesn't complete normally.  */
14900   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
14901     {
14902       tree up2 = update;
14903       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14904         up2 = EXPR_WFL_NODE (up2);
14905       /* It is possible for the update expression to be an
14906          EXPR_WFL_NODE wrapping nothing.  */
14907       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
14908         {
14909           /* Try to detect constraint violations.  These would be
14910              programming errors somewhere.  */
14911           if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
14912             abort ();
14913           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14914         }
14915     }
14916   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14917   return loop;
14918 }
14919
14920 /* Try to find the loop a block might be related to. This comprises
14921    the case where the LOOP_EXPR is found as the second operand of a
14922    COMPOUND_EXPR, because the loop happens to have an initialization
14923    part, then expressed as the first operand of the COMPOUND_EXPR. If
14924    the search finds something, 1 is returned. Otherwise, 0 is
14925    returned. The search is assumed to start from a
14926    LABELED_BLOCK_EXPR's block.  */
14927
14928 static tree
14929 search_loop (tree statement)
14930 {
14931   if (TREE_CODE (statement) == LOOP_EXPR)
14932     return statement;
14933
14934   if (TREE_CODE (statement) == BLOCK)
14935     statement = BLOCK_SUBBLOCKS (statement);
14936   else
14937     return NULL_TREE;
14938
14939   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14940     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14941       statement = TREE_OPERAND (statement, 1);
14942
14943   return (TREE_CODE (statement) == LOOP_EXPR
14944           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14945 }
14946
14947 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14948    returned otherwise.  */
14949
14950 static int
14951 labeled_block_contains_loop_p (tree block, tree loop)
14952 {
14953   if (!block)
14954     return 0;
14955
14956   if (LABELED_BLOCK_BODY (block) == loop)
14957     return 1;
14958
14959   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
14960     return 1;
14961
14962   return 0;
14963 }
14964
14965 /* If the loop isn't surrounded by a labeled statement, create one and
14966    insert LOOP as its body.  */
14967
14968 static tree
14969 patch_loop_statement (tree loop)
14970 {
14971   tree loop_label;
14972
14973   TREE_TYPE (loop) = void_type_node;
14974   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14975     return loop;
14976
14977   loop_label = build_labeled_block (0, NULL_TREE);
14978   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14979      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
14980   LABELED_BLOCK_BODY (loop_label) = loop;
14981   PUSH_LABELED_BLOCK (loop_label);
14982   return loop_label;
14983 }
14984
14985 /* 14.13, 14.14: break and continue Statements */
14986
14987 /* Build a break or a continue statement. a null NAME indicates an
14988    unlabeled break/continue statement.  */
14989
14990 static tree
14991 build_bc_statement (int location, int is_break, tree name)
14992 {
14993   tree break_continue, label_block_expr = NULL_TREE;
14994
14995   if (name)
14996     {
14997       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
14998             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
14999         /* Null means that we don't have a target for this named
15000            break/continue. In this case, we make the target to be the
15001            label name, so that the error can be reported accurately in
15002            patch_bc_statement. */
15003         label_block_expr = EXPR_WFL_NODE (name);
15004     }
15005   /* Unlabeled break/continue will be handled during the
15006      break/continue patch operation */
15007   break_continue = build2 (EXIT_BLOCK_EXPR, NULL_TREE,
15008                            label_block_expr, NULL_TREE);
15009
15010   IS_BREAK_STMT_P (break_continue) = is_break;
15011   TREE_SIDE_EFFECTS (break_continue) = 1;
15012   EXPR_WFL_LINECOL (break_continue) = location;
15013   break_continue = build_debugable_stmt (location, break_continue);
15014   return break_continue;
15015 }
15016
15017 /* Verification of a break/continue statement. */
15018
15019 static tree
15020 patch_bc_statement (tree node)
15021 {
15022   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15023   tree labeled_block = ctxp->current_labeled_block;
15024   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15025
15026   /* Having an identifier here means that the target is unknown. */
15027   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15028     {
15029       parse_error_context (wfl_operator, "No label definition found for `%s'",
15030                            IDENTIFIER_POINTER (bc_label));
15031       return error_mark_node;
15032     }
15033   if (! IS_BREAK_STMT_P (node))
15034     {
15035       /* It's a continue statement. */
15036       for (;; labeled_block = TREE_CHAIN (labeled_block))
15037         {
15038           if (labeled_block == NULL_TREE)
15039             {
15040               if (bc_label == NULL_TREE)
15041                 parse_error_context (wfl_operator,
15042                                      "`continue' must be in loop");
15043               else
15044                 parse_error_context
15045                   (wfl_operator, "continue label `%s' does not name a loop",
15046                    IDENTIFIER_POINTER (bc_label));
15047               return error_mark_node;
15048             }
15049           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15050                == continue_identifier_node)
15051               && (bc_label == NULL_TREE
15052                   || TREE_CHAIN (labeled_block) == bc_label))
15053             {
15054               bc_label = labeled_block;
15055               break;
15056             }
15057         }
15058     }
15059   else if (!bc_label)
15060     {
15061       for (;; labeled_block = TREE_CHAIN (labeled_block))
15062         {
15063           if (labeled_block == NULL_TREE)
15064             {
15065               parse_error_context (wfl_operator,
15066                                      "`break' must be in loop or switch");
15067               return error_mark_node;
15068             }
15069           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15070           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15071               || search_loop (target_stmt))
15072             {
15073               bc_label = labeled_block;
15074               break;
15075             }
15076         }
15077     }
15078
15079   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15080   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15081
15082   /* Our break/continue don't return values. */
15083   TREE_TYPE (node) = void_type_node;
15084   /* Encapsulate the break within a compound statement so that it's
15085      expanded all the times by expand_expr (and not clobbered
15086      sometimes, like after a if statement) */
15087   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15088   TREE_SIDE_EFFECTS (node) = 1;
15089   return node;
15090 }
15091
15092 /* Process the exit expression belonging to a loop. Its type must be
15093    boolean.  */
15094
15095 static tree
15096 patch_exit_expr (tree node)
15097 {
15098   tree expression = TREE_OPERAND (node, 0);
15099   TREE_TYPE (node) = error_mark_node;
15100   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15101
15102   /* The type of expression must be boolean */
15103   if (TREE_TYPE (expression) != boolean_type_node)
15104     {
15105       parse_error_context
15106         (wfl_operator,
15107     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15108          lang_printable_name (TREE_TYPE (expression), 0));
15109       return error_mark_node;
15110     }
15111   /* Now we know things are allright, invert the condition, fold and
15112      return */
15113   TREE_OPERAND (node, 0) =
15114     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15115
15116   if (! integer_zerop (TREE_OPERAND (node, 0))
15117       && ctxp->current_loop != NULL_TREE
15118       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15119     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15120   if (! integer_onep (TREE_OPERAND (node, 0)))
15121     CAN_COMPLETE_NORMALLY (node) = 1;
15122
15123
15124   TREE_TYPE (node) = void_type_node;
15125   return node;
15126 }
15127
15128 /* 14.9 Switch statement */
15129
15130 static tree
15131 patch_switch_statement (tree node)
15132 {
15133   tree se = TREE_OPERAND (node, 0), se_type;
15134   tree save, iter;
15135
15136   /* Complete the switch expression */
15137   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15138   se_type = TREE_TYPE (se);
15139   /* The type of the switch expression must be char, byte, short or
15140      int */
15141   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15142     {
15143       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15144       parse_error_context (wfl_operator,
15145           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15146                            lang_printable_name (se_type, 0));
15147       /* This is what java_complete_tree will check */
15148       TREE_OPERAND (node, 0) = error_mark_node;
15149       return error_mark_node;
15150     }
15151
15152   /* Save and restore the outer case label list.  */
15153   save = case_label_list;
15154   case_label_list = NULL_TREE;
15155
15156   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15157
15158   /* See if we've found a duplicate label.  We can't leave this until
15159      code generation, because in `--syntax-only' and `-C' modes we
15160      don't do ordinary code generation.  */
15161   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15162     {
15163       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15164       tree subiter;
15165       for (subiter = TREE_CHAIN (iter);
15166            subiter != NULL_TREE;
15167            subiter = TREE_CHAIN (subiter))
15168         {
15169           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15170           if (val == subval)
15171             {
15172               EXPR_WFL_LINECOL (wfl_operator)
15173                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15174               /* The case_label_list is in reverse order, so print the
15175                  outer label first.  */
15176               parse_error_context (wfl_operator, "duplicate case label: `"
15177                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15178               EXPR_WFL_LINECOL (wfl_operator)
15179                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15180               parse_error_context (wfl_operator, "original label is here");
15181
15182               break;
15183             }
15184         }
15185     }
15186
15187   case_label_list = save;
15188
15189   /* Ready to return */
15190   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15191     {
15192       TREE_TYPE (node) = error_mark_node;
15193       return error_mark_node;
15194     }
15195   TREE_TYPE (node) = void_type_node;
15196   TREE_SIDE_EFFECTS (node) = 1;
15197   CAN_COMPLETE_NORMALLY (node)
15198     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15199       || ! SWITCH_HAS_DEFAULT (node);
15200   return node;
15201 }
15202
15203 /* Assertions.  */
15204
15205 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15206    might be NULL_TREE.  */
15207 static tree
15208 build_assertion (int location, tree condition, tree value)
15209 {
15210   tree node;
15211   tree klass = GET_CPC ();
15212
15213   if (! enable_assertions (klass))
15214     {
15215       condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15216                           boolean_false_node, condition);
15217       if (value == NULL_TREE)
15218         value = build_java_empty_stmt ();
15219       return build_if_else_statement (location, condition,
15220                                       value, NULL_TREE);
15221     }
15222
15223   if (! CLASS_USES_ASSERTIONS (klass))
15224     {
15225       tree field, classdollar, id, call;
15226       tree class_type = TREE_TYPE (klass);
15227
15228       field = add_field (class_type,
15229                          get_identifier ("$assertionsDisabled"),
15230                          boolean_type_node,
15231                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15232       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15233       FIELD_SYNTHETIC (field) = 1;
15234
15235       classdollar = build_incomplete_class_ref (location, class_type);
15236
15237       /* Call CLASS.desiredAssertionStatus().  */
15238       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15239       call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15240       call = make_qualified_primary (classdollar, call, location);
15241       TREE_SIDE_EFFECTS (call) = 1;
15242
15243       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15244          seem odd, but we do it to generate code identical to that of
15245          the JDK.  */
15246       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15247       TREE_SIDE_EFFECTS (call) = 1;
15248       DECL_INITIAL (field) = call;
15249
15250       /* Record the initializer in the initializer statement list.  */
15251       call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15252       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15253       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15254       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15255
15256       CLASS_USES_ASSERTIONS (klass) = 1;
15257     }
15258
15259   if (value != NULL_TREE)
15260     value = tree_cons (NULL_TREE, value, NULL_TREE);
15261
15262   node = build_wfl_node (get_identifier ("java"));
15263   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15264                               location);
15265   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15266                               location);
15267
15268   node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15269   TREE_SIDE_EFFECTS (node) = 1;
15270   /* It is too early to use BUILD_THROW.  */
15271   node = build1 (THROW_EXPR, NULL_TREE, node);
15272   TREE_SIDE_EFFECTS (node) = 1;
15273
15274   /* We invert the condition; if we just put NODE as the `else' part
15275      then we generate weird-looking bytecode.  */
15276   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15277   /* Check $assertionsDisabled.  */
15278   condition
15279     = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15280               build1 (TRUTH_NOT_EXPR, NULL_TREE,
15281                       build_wfl_node (get_identifier ("$assertionsDisabled"))),
15282               condition);
15283   node = build_if_else_statement (location, condition, node, NULL_TREE);
15284   return node;
15285 }
15286
15287 /* 14.18 The try/catch statements */
15288
15289 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15290    catches TYPE and executes CATCH_STMTS.  */
15291
15292 static tree
15293 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15294                             tree catch_stmts)
15295 {
15296   tree try_block, catch_clause_param, catch_block, catch;
15297
15298   /* First build a try block */
15299   try_block = build_expr_block (try_stmts, NULL_TREE);
15300
15301   /* Build a catch block: we need a catch clause parameter */
15302   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15303     {
15304       tree catch_type = obtain_incomplete_type (type_or_name);
15305       jdep *dep;
15306       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15307       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15308                                 catch_clause_param, catch_type);
15309       dep = CLASSD_LAST (ctxp->classd_list);
15310       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15311     }
15312   else
15313     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15314                                      build_pointer_type (type_or_name));
15315
15316   /* And a block */
15317   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15318
15319   /* Initialize the variable and store in the block */
15320   catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15321                   build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15322   add_stmt_to_block (catch_block, NULL_TREE, catch);
15323
15324   /* Add the catch statements */
15325   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15326
15327   /* Now we can build a JAVA_CATCH_EXPR */
15328   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15329
15330   return build_try_statement (location, try_block, catch_block);
15331 }
15332
15333 static tree
15334 build_try_statement (int location, tree try_block, tree catches)
15335 {
15336   tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15337   EXPR_WFL_LINECOL (node) = location;
15338   return node;
15339 }
15340
15341 static tree
15342 build_try_finally_statement (int location, tree try_block, tree finally)
15343 {
15344   tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15345   EXPR_WFL_LINECOL (node) = location;
15346   return node;
15347 }
15348
15349 static tree
15350 patch_try_statement (tree node)
15351 {
15352   int error_found = 0;
15353   tree try = TREE_OPERAND (node, 0);
15354   /* Exception handlers are considered in left to right order */
15355   tree catch = nreverse (TREE_OPERAND (node, 1));
15356   tree current, caught_type_list = NULL_TREE;
15357
15358   /* Check catch clauses, if any. Every time we find an error, we try
15359      to process the next catch clause. We process the catch clause before
15360      the try block so that when processing the try block we can check thrown
15361      exceptions againts the caught type list. */
15362   for (current = catch; current; current = TREE_CHAIN (current))
15363     {
15364       tree carg_decl, carg_type;
15365       tree sub_current, catch_block, catch_clause;
15366       int unreachable;
15367
15368       /* At this point, the structure of the catch clause is
15369            JAVA_CATCH_EXPR              (catch node)
15370              BLOCK              (with the decl of the parameter)
15371                COMPOUND_EXPR
15372                  MODIFY_EXPR   (assignment of the catch parameter)
15373                  BLOCK          (catch clause block)
15374        */
15375       catch_clause = TREE_OPERAND (current, 0);
15376       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15377       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15378
15379       /* Catch clauses can't have more than one parameter declared,
15380          but it's already enforced by the grammar. Make sure that the
15381          only parameter of the clause statement in of class Throwable
15382          or a subclass of Throwable, but that was done earlier. The
15383          catch clause parameter type has also been resolved. */
15384
15385       /* Just make sure that the catch clause parameter type inherits
15386          from java.lang.Throwable */
15387       if (!inherits_from_p (carg_type, throwable_type_node))
15388         {
15389           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15390           parse_error_context (wfl_operator,
15391                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15392                                lang_printable_name (carg_type, 0));
15393           error_found = 1;
15394           continue;
15395         }
15396
15397       /* Partial check for unreachable catch statement: The catch
15398          clause is reachable iff is no earlier catch block A in
15399          the try statement such that the type of the catch
15400          clause's parameter is the same as or a subclass of the
15401          type of A's parameter */
15402       unreachable = 0;
15403       for (sub_current = catch;
15404            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15405         {
15406           tree sub_catch_clause, decl;
15407           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15408           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15409
15410           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15411             {
15412               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15413               parse_error_context
15414                 (wfl_operator,
15415                  "`catch' not reached because of the catch clause at line %d",
15416                  EXPR_WFL_LINENO (sub_current));
15417               unreachable = error_found = 1;
15418               break;
15419             }
15420         }
15421       /* Complete the catch clause block */
15422       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15423       if (catch_block == error_mark_node)
15424         {
15425           error_found = 1;
15426           continue;
15427         }
15428       if (CAN_COMPLETE_NORMALLY (catch_block))
15429         CAN_COMPLETE_NORMALLY (node) = 1;
15430       TREE_OPERAND (current, 0) = catch_block;
15431
15432       if (unreachable)
15433         continue;
15434
15435       /* Things to do here: the exception must be thrown */
15436
15437       /* Link this type to the caught type list */
15438       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15439     }
15440
15441   PUSH_EXCEPTIONS (caught_type_list);
15442   if ((try = java_complete_tree (try)) == error_mark_node)
15443     error_found = 1;
15444   if (CAN_COMPLETE_NORMALLY (try))
15445     CAN_COMPLETE_NORMALLY (node) = 1;
15446   POP_EXCEPTIONS ();
15447
15448   /* Verification ends here */
15449   if (error_found)
15450     return error_mark_node;
15451
15452   TREE_OPERAND (node, 0) = try;
15453   TREE_OPERAND (node, 1) = catch;
15454   TREE_TYPE (node) = void_type_node;
15455   return node;
15456 }
15457
15458 /* 14.17 The synchronized Statement */
15459
15460 static tree
15461 patch_synchronized_statement (tree node, tree wfl_op1)
15462 {
15463   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15464   tree block = TREE_OPERAND (node, 1);
15465
15466   tree tmp, enter, exit, expr_decl, assignment;
15467
15468   if (expr == error_mark_node)
15469     {
15470       block = java_complete_tree (block);
15471       return expr;
15472     }
15473
15474   /* We might be trying to synchronize on a STRING_CST */
15475   if ((tmp = patch_string (expr)))
15476     expr = tmp;
15477
15478   /* The TYPE of expr must be a reference type */
15479   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15480     {
15481       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15482       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15483                            lang_printable_name (TREE_TYPE (expr), 0));
15484       return error_mark_node;
15485     }
15486
15487   if (flag_emit_xref)
15488     {
15489       TREE_OPERAND (node, 0) = expr;
15490       TREE_OPERAND (node, 1) = java_complete_tree (block);
15491       CAN_COMPLETE_NORMALLY (node) = 1;
15492       return node;
15493     }
15494
15495   /* Generate a try-finally for the synchronized statement, except
15496      that the handler that catches all throw exception calls
15497      _Jv_MonitorExit and then rethrow the exception.
15498      The synchronized statement is then implemented as:
15499      TRY
15500        {
15501          _Jv_MonitorEnter (expression)
15502          synchronized_block
15503          _Jv_MonitorExit (expression)
15504        }
15505      CATCH_ALL
15506        {
15507          e = _Jv_exception_info ();
15508          _Jv_MonitorExit (expression)
15509          Throw (e);
15510        } */
15511
15512   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15513   BUILD_MONITOR_ENTER (enter, expr_decl);
15514   BUILD_MONITOR_EXIT (exit, expr_decl);
15515   CAN_COMPLETE_NORMALLY (enter) = 1;
15516   CAN_COMPLETE_NORMALLY (exit) = 1;
15517   assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15518   TREE_SIDE_EFFECTS (assignment) = 1;
15519   node = build2 (COMPOUND_EXPR, NULL_TREE,
15520                  build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15521                  build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15522   node = build_expr_block (node, expr_decl);
15523
15524   return java_complete_tree (node);
15525 }
15526
15527 /* 14.16 The throw Statement */
15528
15529 static tree
15530 patch_throw_statement (tree node, tree wfl_op1)
15531 {
15532   tree expr = TREE_OPERAND (node, 0);
15533   tree type = TREE_TYPE (expr);
15534   int unchecked_ok = 0, tryblock_throws_ok = 0;
15535
15536   /* Thrown expression must be assignable to java.lang.Throwable */
15537   if (!try_reference_assignconv (throwable_type_node, expr))
15538     {
15539       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15540       parse_error_context (wfl_operator,
15541     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15542                            lang_printable_name (type, 0));
15543       /* If the thrown expression was a reference, we further the
15544          compile-time check. */
15545       if (!JREFERENCE_TYPE_P (type))
15546         return error_mark_node;
15547     }
15548
15549   /* At least one of the following must be true */
15550
15551   /* The type of the throw expression is a not checked exception,
15552      i.e. is a unchecked expression. */
15553   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15554
15555   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15556   /* An instance can't throw a checked exception unless that exception
15557      is explicitly declared in the `throws' clause of each
15558      constructor. This doesn't apply to anonymous classes, since they
15559      don't have declared constructors. */
15560   if (!unchecked_ok
15561       && DECL_INSTINIT_P (current_function_decl)
15562       && !ANONYMOUS_CLASS_P (current_class))
15563     {
15564       tree current;
15565       for (current = TYPE_METHODS (current_class); current;
15566            current = TREE_CHAIN (current))
15567         if (DECL_CONSTRUCTOR_P (current)
15568             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15569           {
15570             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)",
15571                                  lang_printable_name (TREE_TYPE (expr), 0));
15572             return error_mark_node;
15573           }
15574     }
15575
15576   /* Throw is contained in a try statement and at least one catch
15577      clause can receive the thrown expression or the current method is
15578      declared to throw such an exception. Or, the throw statement is
15579      contained in a method or constructor declaration and the type of
15580      the Expression is assignable to at least one type listed in the
15581      throws clause the declaration. */
15582   if (!unchecked_ok)
15583     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15584   if (!(unchecked_ok || tryblock_throws_ok))
15585     {
15586       /* If there is a surrounding try block that has no matching
15587          clatch clause, report it first. A surrounding try block exits
15588          only if there is something after the list of checked
15589          exception thrown by the current function (if any). */
15590       if (IN_TRY_BLOCK_P ())
15591         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15592                              lang_printable_name (type, 0));
15593       /* If we have no surrounding try statement and the method doesn't have
15594          any throws, report it now. FIXME */
15595
15596       /* We report that the exception can't be throw from a try block
15597          in all circumstances but when the `throw' is inside a static
15598          block. */
15599       else if (!EXCEPTIONS_P (currently_caught_type_list)
15600                && !tryblock_throws_ok)
15601         {
15602           if (DECL_CLINIT_P (current_function_decl))
15603             parse_error_context (wfl_operator,
15604                    "Checked exception `%s' can't be thrown in initializer",
15605                                  lang_printable_name (type, 0));
15606           else
15607             parse_error_context (wfl_operator,
15608                    "Checked exception `%s' isn't thrown from a `try' block",
15609                                  lang_printable_name (type, 0));
15610         }
15611       /* Otherwise, the current method doesn't have the appropriate
15612          throws declaration */
15613       else
15614         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15615                              lang_printable_name (type, 0));
15616       return error_mark_node;
15617     }
15618
15619   if (! flag_emit_class_files && ! flag_emit_xref)
15620     BUILD_THROW (node, expr);
15621
15622   /* If doing xrefs, keep the location where the `throw' was seen. */
15623   if (flag_emit_xref)
15624     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15625   return node;
15626 }
15627
15628 /* Check that exception said to be thrown by method DECL can be
15629    effectively caught from where DECL is invoked.  THIS_EXPR is the
15630    expression that computes `this' for the method call.  */
15631 static void
15632 check_thrown_exceptions (int location, tree decl, tree this_expr)
15633 {
15634   tree throws;
15635   int is_array_call = 0;
15636
15637   /* Skip check within generated methods, such as access$<n>.  */
15638   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15639     return;
15640
15641   if (this_expr != NULL_TREE
15642       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15643       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15644     is_array_call = 1;
15645
15646   /* For all the unchecked exceptions thrown by DECL.  */
15647   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15648        throws = TREE_CHAIN (throws))
15649     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15650       {
15651         /* Suppress errors about cloning arrays.  */
15652         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15653           continue;
15654
15655         EXPR_WFL_LINECOL (wfl_operator) = location;
15656         if (DECL_FINIT_P (current_function_decl))
15657           parse_error_context
15658             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15659              lang_printable_name (TREE_VALUE (throws), 0));
15660         else
15661           {
15662             parse_error_context
15663               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15664                lang_printable_name (TREE_VALUE (throws), 0),
15665                (DECL_INIT_P (current_function_decl) ?
15666                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15667                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15668           }
15669       }
15670 }
15671
15672 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15673    try-catch blocks, OR is listed in the `throws' clause of the
15674    current method.  */
15675
15676 static int
15677 check_thrown_exceptions_do (tree exception)
15678 {
15679   tree list = currently_caught_type_list;
15680   resolve_and_layout (exception, NULL_TREE);
15681   /* First, all the nested try-catch-finally at that stage. The
15682      last element contains `throws' clause exceptions, if any. */
15683   if (IS_UNCHECKED_EXCEPTION_P (exception))
15684     return 1;
15685   while (list)
15686     {
15687       tree caught;
15688       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15689         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15690           return 1;
15691       list = TREE_CHAIN (list);
15692     }
15693   return 0;
15694 }
15695
15696 static void
15697 purge_unchecked_exceptions (tree mdecl)
15698 {
15699   tree throws = DECL_FUNCTION_THROWS (mdecl);
15700   tree new = NULL_TREE;
15701
15702   while (throws)
15703     {
15704       tree next = TREE_CHAIN (throws);
15705       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15706         {
15707           TREE_CHAIN (throws) = new;
15708           new = throws;
15709         }
15710       throws = next;
15711     }
15712   /* List is inverted here, but it doesn't matter */
15713   DECL_FUNCTION_THROWS (mdecl) = new;
15714 }
15715
15716 /* This function goes over all of CLASS_TYPE ctors and checks whether
15717    each of them features at least one unchecked exception in its
15718    `throws' clause. If it's the case, it returns `true', `false'
15719    otherwise.  */
15720
15721 static bool
15722 ctors_unchecked_throws_clause_p (tree class_type)
15723 {
15724   tree current;
15725
15726   for (current = TYPE_METHODS (class_type); current;
15727        current = TREE_CHAIN (current))
15728     {
15729       bool ctu = false; /* Ctor Throws Unchecked */
15730       if (DECL_CONSTRUCTOR_P (current))
15731         {
15732           tree throws;
15733           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15734                throws = TREE_CHAIN (throws))
15735             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15736               ctu = true;
15737         }
15738       /* We return false as we found one ctor that is unfit. */
15739       if (!ctu && DECL_CONSTRUCTOR_P (current))
15740         return false;
15741     }
15742   /* All ctors feature at least one unchecked exception in their
15743      `throws' clause. */
15744   return true;
15745 }
15746
15747 /* 15.24 Conditional Operator ?: */
15748
15749 static tree
15750 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15751 {
15752   tree cond = TREE_OPERAND (node, 0);
15753   tree op1 = TREE_OPERAND (node, 1);
15754   tree op2 = TREE_OPERAND (node, 2);
15755   tree resulting_type = NULL_TREE;
15756   tree t1, t2, patched;
15757   int error_found = 0;
15758
15759   /* Operands of ?: might be StringBuffers crafted as a result of a
15760      string concatenation. Obtain a descent operand here.  */
15761   if ((patched = patch_string (op1)))
15762     TREE_OPERAND (node, 1) = op1 = patched;
15763   if ((patched = patch_string (op2)))
15764     TREE_OPERAND (node, 2) = op2 = patched;
15765
15766   t1 = TREE_TYPE (op1);
15767   t2 = TREE_TYPE (op2);
15768
15769   /* The first expression must be a boolean */
15770   if (TREE_TYPE (cond) != boolean_type_node)
15771     {
15772       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15773       parse_error_context (wfl_operator,
15774                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15775                            lang_printable_name (TREE_TYPE (cond), 0));
15776       error_found = 1;
15777     }
15778
15779   /* Second and third can be numeric, boolean (i.e. primitive),
15780      references or null. Anything else results in an error */
15781   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15782         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15783             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15784         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15785     error_found = 1;
15786
15787   /* Determine the type of the conditional expression. Same types are
15788      easy to deal with */
15789   else if (t1 == t2)
15790     resulting_type = t1;
15791
15792   /* There are different rules for numeric types */
15793   else if (JNUMERIC_TYPE_P (t1))
15794     {
15795       /* if byte/short found, the resulting type is short */
15796       if ((t1 == byte_type_node && t2 == short_type_node)
15797           || (t1 == short_type_node && t2 == byte_type_node))
15798         resulting_type = short_type_node;
15799
15800       /* If t1 is a constant int and t2 is of type byte, short or char
15801          and t1's value fits in t2, then the resulting type is t2 */
15802       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15803           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15804         resulting_type = t2;
15805
15806       /* If t2 is a constant int and t1 is of type byte, short or char
15807          and t2's value fits in t1, then the resulting type is t1 */
15808       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15809           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15810         resulting_type = t1;
15811
15812       /* Otherwise, binary numeric promotion is applied and the
15813          resulting type is the promoted type of operand 1 and 2 */
15814       else
15815         resulting_type = binary_numeric_promotion (t1, t2,
15816                                                    &TREE_OPERAND (node, 1),
15817                                                    &TREE_OPERAND (node, 2));
15818     }
15819
15820   /* Cases of a reference and a null type */
15821   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15822     resulting_type = t1;
15823
15824   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15825     resulting_type = t2;
15826
15827   /* Last case: different reference types. If a type can be converted
15828      into the other one by assignment conversion, the latter
15829      determines the type of the expression */
15830   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15831     resulting_type = promote_type (t1);
15832
15833   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15834     resulting_type = promote_type (t2);
15835
15836   /* If we don't have any resulting type, we're in trouble */
15837   if (!resulting_type)
15838     {
15839       char *t = xstrdup (lang_printable_name (t1, 0));
15840       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15841       parse_error_context (wfl_operator,
15842                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15843                            t, lang_printable_name (t2, 0));
15844       free (t);
15845       error_found = 1;
15846     }
15847
15848   if (error_found)
15849     {
15850       TREE_TYPE (node) = error_mark_node;
15851       return error_mark_node;
15852     }
15853
15854   TREE_TYPE (node) = resulting_type;
15855   TREE_SET_CODE (node, COND_EXPR);
15856   CAN_COMPLETE_NORMALLY (node) = 1;
15857   return node;
15858 }
15859
15860 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15861
15862 static tree
15863 maybe_build_class_init_for_field (tree decl, tree expr)
15864 {
15865   tree clas = DECL_CONTEXT (decl);
15866   if (flag_emit_class_files || flag_emit_xref)
15867     return expr;
15868
15869   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15870       && FIELD_FINAL (decl))
15871     {
15872       tree init = DECL_INITIAL (decl);
15873       if (init != NULL_TREE)
15874         init = fold_constant_for_init (init, decl);
15875       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15876         return expr;
15877     }
15878
15879   return build_class_init (clas, expr);
15880 }
15881
15882 /* Try to constant fold NODE.
15883    If NODE is not a constant expression, return NULL_EXPR.
15884    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15885
15886 static tree
15887 fold_constant_for_init (tree node, tree context)
15888 {
15889   tree op0, op1, val;
15890   enum tree_code code = TREE_CODE (node);
15891
15892   switch (code)
15893     {
15894     case INTEGER_CST:
15895       if (node == null_pointer_node)
15896         return NULL_TREE;
15897     case STRING_CST:
15898     case REAL_CST:
15899       return node;
15900
15901     case PLUS_EXPR:
15902     case MINUS_EXPR:
15903     case MULT_EXPR:
15904     case TRUNC_MOD_EXPR:
15905     case RDIV_EXPR:
15906     case LSHIFT_EXPR:
15907     case RSHIFT_EXPR:
15908     case URSHIFT_EXPR:
15909     case BIT_AND_EXPR:
15910     case BIT_XOR_EXPR:
15911     case BIT_IOR_EXPR:
15912     case TRUTH_ANDIF_EXPR:
15913     case TRUTH_ORIF_EXPR:
15914     case EQ_EXPR:
15915     case NE_EXPR:
15916     case GT_EXPR:
15917     case GE_EXPR:
15918     case LT_EXPR:
15919     case LE_EXPR:
15920       op0 = TREE_OPERAND (node, 0);
15921       op1 = TREE_OPERAND (node, 1);
15922       val = fold_constant_for_init (op0, context);
15923       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15924         return NULL_TREE;
15925       TREE_OPERAND (node, 0) = val;
15926       val = fold_constant_for_init (op1, context);
15927       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15928         return NULL_TREE;
15929       TREE_OPERAND (node, 1) = val;
15930       return patch_binop (node, op0, op1);
15931
15932     case UNARY_PLUS_EXPR:
15933     case NEGATE_EXPR:
15934     case TRUTH_NOT_EXPR:
15935     case BIT_NOT_EXPR:
15936     case CONVERT_EXPR:
15937       op0 = TREE_OPERAND (node, 0);
15938       val = fold_constant_for_init (op0, context);
15939       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15940         return NULL_TREE;
15941       TREE_OPERAND (node, 0) = val;
15942       val = patch_unaryop (node, op0);
15943       if (! TREE_CONSTANT (val))
15944         return NULL_TREE;
15945       return val;
15946
15947       break;
15948
15949     case COND_EXPR:
15950       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
15951       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15952         return NULL_TREE;
15953       TREE_OPERAND (node, 0) = val;
15954       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
15955       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15956         return NULL_TREE;
15957       TREE_OPERAND (node, 1) = val;
15958       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
15959       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15960         return NULL_TREE;
15961       TREE_OPERAND (node, 2) = val;
15962       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
15963         : TREE_OPERAND (node, 2);
15964
15965     case VAR_DECL:
15966     case FIELD_DECL:
15967       if (! FIELD_FINAL (node)
15968           || DECL_INITIAL (node) == NULL_TREE)
15969         return NULL_TREE;
15970       val = DECL_INITIAL (node);
15971       /* Guard against infinite recursion. */
15972       DECL_INITIAL (node) = NULL_TREE;
15973       val = fold_constant_for_init (val, node);
15974       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
15975         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
15976       DECL_INITIAL (node) = val;
15977       return val;
15978
15979     case EXPR_WITH_FILE_LOCATION:
15980       /* Compare java_complete_tree and resolve_expression_name. */
15981       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
15982           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15983         {
15984           tree name = EXPR_WFL_NODE (node);
15985           tree decl;
15986           if (PRIMARY_P (node))
15987             return NULL_TREE;
15988           else if (! QUALIFIED_P (name))
15989             {
15990               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
15991               if (decl == NULL_TREE
15992                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
15993                 return NULL_TREE;
15994               return fold_constant_for_init (decl, decl);
15995             }
15996           else
15997             {
15998               tree r = NULL_TREE;
15999               /* Install the proper context for the field resolution.  */
16000               tree saved_current_class = current_class;
16001               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16002               current_class = DECL_CONTEXT (context);
16003               qualify_ambiguous_name (node);
16004               r = resolve_field_access (node, &decl, NULL);
16005               /* Restore prior context.  */
16006               current_class = saved_current_class;
16007               if (r != error_mark_node && decl != NULL_TREE)
16008                 return fold_constant_for_init (decl, decl);
16009               return NULL_TREE;
16010             }
16011         }
16012       else
16013         {
16014           op0 = TREE_OPERAND (node, 0);
16015           val = fold_constant_for_init (op0, context);
16016           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16017             return NULL_TREE;
16018           TREE_OPERAND (node, 0) = val;
16019           return val;
16020         }
16021
16022 #ifdef USE_COMPONENT_REF
16023     case IDENTIFIER:
16024     case COMPONENT_REF:
16025       ?;
16026 #endif
16027
16028     default:
16029       return NULL_TREE;
16030     }
16031 }
16032
16033 #ifdef USE_COMPONENT_REF
16034 /* Context is 'T' for TypeName, 'P' for PackageName,
16035    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16036
16037 tree
16038 resolve_simple_name (tree name, int context)
16039 {
16040 }
16041
16042 tree
16043 resolve_qualified_name (tree name, int context)
16044 {
16045 }
16046 #endif
16047
16048 void
16049 init_src_parse (void)
16050 {
16051   /* Sanity check; we've been bit by this before.  */
16052   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16053     abort ();
16054 }
16055
16056 \f
16057
16058 /* This section deals with the functions that are called when tables
16059    recording class initialization information are traversed.  */
16060
16061 /* Attach to PTR (a block) the declaration found in ENTRY. */
16062
16063 static int
16064 attach_init_test_initialization_flags (void **entry, void *ptr)
16065 {
16066   tree block = (tree)ptr;
16067   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16068
16069   if (block != error_mark_node)
16070     {
16071       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16072       BLOCK_EXPR_DECLS (block) = ite->value;
16073     }
16074   return true;
16075 }
16076
16077 /* This function is called for each class that is known definitely
16078    initialized when a given static method was called. This function
16079    augments a compound expression (INFO) storing all assignment to
16080    initialized static class flags if a flag already existed, otherwise
16081    a new one is created.  */
16082
16083 static int
16084 emit_test_initialization (void **entry_p, void *info)
16085 {
16086   tree l = (tree) info;
16087   tree decl, init;
16088   tree key = (tree) *entry_p;
16089   tree *ite;
16090   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16091
16092   /* If we haven't found a flag and we're dealing with self registered
16093      with current_function_decl, then don't do anything. Self is
16094      always added as definitely initialized but this information is
16095      valid only if used outside the current function. */
16096   if (current_function_decl == TREE_PURPOSE (l)
16097       && java_treetreehash_find (cf_ht, key) == NULL)
16098     return true;
16099
16100   ite = java_treetreehash_new (cf_ht, key);
16101
16102   /* If we don't have a variable, create one and install it. */
16103   if (*ite == NULL)
16104     {
16105       tree block;
16106
16107       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16108       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16109       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16110       DECL_CONTEXT (decl) = current_function_decl;
16111       DECL_INITIAL (decl) = boolean_true_node;
16112       /* Don't emit any symbolic debugging info for this decl.  */
16113       DECL_IGNORED_P (decl) = 1;
16114
16115       /* The trick is to find the right context for it. */
16116       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16117       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16118       BLOCK_EXPR_DECLS (block) = decl;
16119       *ite = decl;
16120     }
16121   else
16122     decl = *ite;
16123
16124   /* Now simply augment the compound that holds all the assignments
16125      pertaining to this method invocation. */
16126   init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16127   TREE_SIDE_EFFECTS (init) = 1;
16128   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16129   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16130
16131   return true;
16132 }
16133
16134 #include "gt-java-parse.h"
16135 #include "gtype-java.h"