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            referring 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                 {$$ = NULL_TREE; yyerror ("'(' expected"); DRECOVER(new_1);}
2020 |       NEW_TK class_type error
2021                 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2022 |       NEW_TK class_type OP_TK error
2023                 {$$ = NULL_TREE; yyerror ("')' or term expected"); RECOVER;}
2024 |       NEW_TK class_type OP_TK argument_list error
2025                 {$$ = NULL_TREE; yyerror ("')' expected"); RECOVER;}
2026 |       something_dot_new error
2027                 {
2028                   $$ = NULL_TREE;
2029                   YYERROR_NOW;
2030                   yyerror ("Identifier expected");
2031                   RECOVER;
2032                 }
2033 |       something_dot_new identifier error
2034                 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2035 ;
2036
2037 /* Created after JDK1.1 rules originally added to
2038    class_instance_creation_expression, but modified to use
2039    'class_type' instead of 'TypeName' (type_name) which is mentioned
2040    in the documentation but doesn't exist. */
2041
2042 anonymous_class_creation:
2043         NEW_TK class_type OP_TK argument_list CP_TK
2044                 { create_anonymous_class ($2); }
2045         class_body
2046                 {
2047                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2048                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2049
2050                   end_class_declaration (1);
2051
2052                   /* Now we can craft the new expression */
2053                   $$ = build_new_invocation (id, $4);
2054
2055                   /* Note that we can't possibly be here if
2056                      `class_type' is an interface (in which case the
2057                      anonymous class extends Object and implements
2058                      `class_type', hence its constructor can't have
2059                      arguments.) */
2060
2061                   /* Otherwise, the innerclass must feature a
2062                      constructor matching `argument_list'. Anonymous
2063                      classes are a bit special: it's impossible to
2064                      define constructor for them, hence constructors
2065                      must be generated following the hints provided by
2066                      the `new' expression. Whether a super constructor
2067                      of that nature exists or not is to be verified
2068                      later on in verify_constructor_super.
2069
2070                      It's during the expansion of a `new' statement
2071                      referring to an anonymous class that a ctor will
2072                      be generated for the anonymous class, with the
2073                      right arguments. */
2074
2075                 }
2076 |       NEW_TK class_type OP_TK CP_TK
2077                 { create_anonymous_class ($2); }
2078         class_body
2079                 {
2080                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2081                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2082
2083                   end_class_declaration (1);
2084
2085                   /* Now we can craft the new expression. The
2086                      statement doesn't need to be remember so that a
2087                      constructor can be generated, since its signature
2088                      is already known. */
2089                   $$ = build_new_invocation (id, NULL_TREE);
2090                 }
2091 ;
2092
2093 something_dot_new:              /* Added, not part of the specs. */
2094         name DOT_TK NEW_TK
2095                 { $$ = $1; }
2096 |       primary DOT_TK NEW_TK
2097                 { $$ = $1; }
2098 ;
2099
2100 argument_list:
2101         expression
2102                 {
2103                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2104                   ctxp->formal_parameter_number = 1;
2105                 }
2106 |       argument_list C_TK expression
2107                 {
2108                   ctxp->formal_parameter_number += 1;
2109                   $$ = tree_cons (NULL_TREE, $3, $1);
2110                 }
2111 |       argument_list C_TK error
2112                 {yyerror ("Missing term"); RECOVER;}
2113 ;
2114
2115 array_creation_uninitialized:
2116         NEW_TK primitive_type dim_exprs
2117                 { $$ = build_newarray_node ($2, $3, 0); }
2118 |       NEW_TK class_or_interface_type dim_exprs
2119                 { $$ = build_newarray_node ($2, $3, 0); }
2120 |       NEW_TK primitive_type dim_exprs dims
2121                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2122 |       NEW_TK class_or_interface_type dim_exprs dims
2123                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2124 |       NEW_TK error CSB_TK
2125                 {yyerror ("'[' expected"); DRECOVER ("]");}
2126 |       NEW_TK error OSB_TK
2127                 {yyerror ("']' expected"); RECOVER;}
2128 ;
2129
2130 array_creation_initialized:
2131         /* Added, JDK1.1 anonymous array. Initial documentation rule
2132            modified */
2133         NEW_TK class_or_interface_type dims array_initializer
2134                 {
2135                   char *sig;
2136                   int osb = pop_current_osb (ctxp);
2137                   while (osb--)
2138                     obstack_grow (&temporary_obstack, "[]", 2);
2139                   obstack_1grow (&temporary_obstack, '\0');
2140                   sig = obstack_finish (&temporary_obstack);
2141                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2142                                $2, get_identifier (sig), $4);
2143                 }
2144 |       NEW_TK primitive_type dims array_initializer
2145                 {
2146                   int osb = pop_current_osb (ctxp);
2147                   tree type = $2;
2148                   while (osb--)
2149                     type = build_java_array_type (type, -1);
2150                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2151                                build_pointer_type (type), NULL_TREE, $4);
2152                 }
2153 |       NEW_TK error CSB_TK
2154                 {yyerror ("'[' expected"); DRECOVER ("]");}
2155 |       NEW_TK error OSB_TK
2156                 {yyerror ("']' expected"); RECOVER;}
2157 ;
2158
2159 dim_exprs:
2160         dim_expr
2161                 { $$ = build_tree_list (NULL_TREE, $1); }
2162 |       dim_exprs dim_expr
2163                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2164 ;
2165
2166 dim_expr:
2167         OSB_TK expression CSB_TK
2168                 {
2169                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2170                     {
2171                       $2 = build_wfl_node ($2);
2172                       TREE_TYPE ($2) = NULL_TREE;
2173                     }
2174                   EXPR_WFL_LINECOL ($2) = $1.location;
2175                   $$ = $2;
2176                 }
2177 |       OSB_TK expression error
2178                 {yyerror ("']' expected"); RECOVER;}
2179 |       OSB_TK error
2180                 {
2181                   yyerror ("Missing term");
2182                   yyerror ("']' expected");
2183                   RECOVER;
2184                 }
2185 ;
2186
2187 dims:
2188         OSB_TK CSB_TK
2189                 {
2190                   int allocate = 0;
2191                   /* If not initialized, allocate memory for the osb
2192                      numbers stack */
2193                   if (!ctxp->osb_limit)
2194                     {
2195                       allocate = ctxp->osb_limit = 32;
2196                       ctxp->osb_depth = -1;
2197                     }
2198                   /* If capacity overflown, reallocate a bigger chunk */
2199                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2200                     allocate = ctxp->osb_limit << 1;
2201
2202                   if (allocate)
2203                     {
2204                       allocate *= sizeof (int);
2205                       if (ctxp->osb_number)
2206                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2207                                                      allocate);
2208                       else
2209                         ctxp->osb_number = xmalloc (allocate);
2210                     }
2211                   ctxp->osb_depth++;
2212                   CURRENT_OSB (ctxp) = 1;
2213                 }
2214 |       dims OSB_TK CSB_TK
2215                 { CURRENT_OSB (ctxp)++; }
2216 |       dims OSB_TK error
2217                 { yyerror ("']' expected"); RECOVER;}
2218 ;
2219
2220 field_access:
2221         primary DOT_TK identifier
2222                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2223                 /*  FIXME - REWRITE TO:
2224                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2225 |       SUPER_TK DOT_TK identifier
2226                 {
2227                   tree super_wfl = build_wfl_node (super_identifier_node);
2228                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2229                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2230                 }
2231 |       SUPER_TK error
2232                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2233 ;
2234
2235 method_invocation:
2236         name OP_TK CP_TK
2237                 { $$ = build_method_invocation ($1, NULL_TREE); }
2238 |       name OP_TK argument_list CP_TK
2239                 { $$ = build_method_invocation ($1, $3); }
2240 |       primary DOT_TK identifier OP_TK CP_TK
2241                 {
2242                   if (TREE_CODE ($1) == THIS_EXPR)
2243                     $$ = build_this_super_qualified_invocation
2244                       (1, $3, NULL_TREE, 0, $2.location);
2245                   else
2246                     {
2247                       tree invok = build_method_invocation ($3, NULL_TREE);
2248                       $$ = make_qualified_primary ($1, invok, $2.location);
2249                     }
2250                 }
2251 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2252                 {
2253                   if (TREE_CODE ($1) == THIS_EXPR)
2254                     $$ = build_this_super_qualified_invocation
2255                       (1, $3, $5, 0, $2.location);
2256                   else
2257                     {
2258                       tree invok = build_method_invocation ($3, $5);
2259                       $$ = make_qualified_primary ($1, invok, $2.location);
2260                     }
2261                 }
2262 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2263                 {
2264                   $$ = build_this_super_qualified_invocation
2265                     (0, $3, NULL_TREE, $1.location, $2.location);
2266                 }
2267 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2268                 {
2269                   $$ = build_this_super_qualified_invocation
2270                     (0, $3, $5, $1.location, $2.location);
2271                 }
2272         /* Screws up thing. I let it here until I'm convinced it can
2273            be removed. FIXME
2274 |       primary DOT_TK error
2275                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2276 |       SUPER_TK DOT_TK error CP_TK
2277                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2278 |       SUPER_TK DOT_TK error DOT_TK
2279                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2280 ;
2281
2282 array_access:
2283         name OSB_TK expression CSB_TK
2284                 { $$ = build_array_ref ($2.location, $1, $3); }
2285 |       primary_no_new_array OSB_TK expression CSB_TK
2286                 { $$ = build_array_ref ($2.location, $1, $3); }
2287 |       array_creation_initialized OSB_TK expression CSB_TK
2288                 { $$ = build_array_ref ($2.location, $1, $3); }
2289 |       name OSB_TK error
2290                 {
2291                   yyerror ("Missing term and ']' expected");
2292                   DRECOVER(array_access);
2293                 }
2294 |       name OSB_TK expression error
2295                 {
2296                   yyerror ("']' expected");
2297                   DRECOVER(array_access);
2298                 }
2299 |       primary_no_new_array OSB_TK error
2300                 {
2301                   yyerror ("Missing term and ']' expected");
2302                   DRECOVER(array_access);
2303                 }
2304 |       primary_no_new_array OSB_TK expression error
2305                 {
2306                   yyerror ("']' expected");
2307                   DRECOVER(array_access);
2308                 }
2309 |       array_creation_initialized OSB_TK error
2310                 {
2311                   yyerror ("Missing term and ']' expected");
2312                   DRECOVER(array_access);
2313                 }
2314 |       array_creation_initialized OSB_TK expression error
2315                 {
2316                   yyerror ("']' expected");
2317                   DRECOVER(array_access);
2318                 }
2319 ;
2320
2321 postfix_expression:
2322         primary
2323 |       name
2324 |       post_increment_expression
2325 |       post_decrement_expression
2326 ;
2327
2328 post_increment_expression:
2329         postfix_expression INCR_TK
2330                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2331 ;
2332
2333 post_decrement_expression:
2334         postfix_expression DECR_TK
2335                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2336 ;
2337
2338 trap_overflow_corner_case:
2339         pre_increment_expression
2340 |       pre_decrement_expression
2341 |       PLUS_TK unary_expression
2342                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2343 |       unary_expression_not_plus_minus
2344 |       PLUS_TK error
2345                 {yyerror ("Missing term"); RECOVER}
2346 ;
2347
2348 unary_expression:
2349         trap_overflow_corner_case
2350                 {
2351                   if ($1)
2352                     error_if_numeric_overflow ($1);
2353                   $$ = $1;
2354                 }
2355 |       MINUS_TK trap_overflow_corner_case
2356                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2357 |       MINUS_TK error
2358                 {yyerror ("Missing term"); RECOVER}
2359 ;
2360
2361 pre_increment_expression:
2362         INCR_TK unary_expression
2363                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2364 |       INCR_TK error
2365                 {yyerror ("Missing term"); RECOVER}
2366 ;
2367
2368 pre_decrement_expression:
2369         DECR_TK unary_expression
2370                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2371 |       DECR_TK error
2372                 {yyerror ("Missing term"); RECOVER}
2373 ;
2374
2375 unary_expression_not_plus_minus:
2376         postfix_expression
2377 |       NOT_TK unary_expression
2378                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2379 |       NEG_TK unary_expression
2380                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2381 |       cast_expression
2382 |       NOT_TK error
2383                 {yyerror ("Missing term"); RECOVER}
2384 |       NEG_TK error
2385                 {yyerror ("Missing term"); RECOVER}
2386 ;
2387
2388 cast_expression:                /* Error handling here is potentially weak */
2389         OP_TK primitive_type dims CP_TK unary_expression
2390                 {
2391                   tree type = $2;
2392                   int osb = pop_current_osb (ctxp);
2393                   while (osb--)
2394                     type = build_java_array_type (type, -1);
2395                   $$ = build_cast ($1.location, type, $5);
2396                 }
2397 |       OP_TK primitive_type CP_TK unary_expression
2398                 { $$ = build_cast ($1.location, $2, $4); }
2399 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2400                 { $$ = build_cast ($1.location, $2, $4); }
2401 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2402                 {
2403                   const char *ptr;
2404                   int osb = pop_current_osb (ctxp);
2405                   obstack_grow (&temporary_obstack,
2406                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2407                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2408                   while (osb--)
2409                     obstack_grow (&temporary_obstack, "[]", 2);
2410                   obstack_1grow (&temporary_obstack, '\0');
2411                   ptr = obstack_finish (&temporary_obstack);
2412                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2413                   $$ = build_cast ($1.location, $2, $5);
2414                 }
2415 |       OP_TK primitive_type OSB_TK error
2416                 {yyerror ("']' expected, invalid type expression");}
2417 |       OP_TK error
2418                 {
2419                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2420                   RECOVER;
2421                 }
2422 |       OP_TK primitive_type dims CP_TK error
2423                 {yyerror ("Missing term"); RECOVER;}
2424 |       OP_TK primitive_type CP_TK error
2425                 {yyerror ("Missing term"); RECOVER;}
2426 |       OP_TK name dims CP_TK error
2427                 {yyerror ("Missing term"); RECOVER;}
2428 ;
2429
2430 multiplicative_expression:
2431         unary_expression
2432 |       multiplicative_expression MULT_TK unary_expression
2433                 {
2434                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2435                                     $2.location, $1, $3);
2436                 }
2437 |       multiplicative_expression DIV_TK unary_expression
2438                 {
2439                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2440                                     $1, $3);
2441                 }
2442 |       multiplicative_expression REM_TK unary_expression
2443                 {
2444                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2445                                     $1, $3);
2446                 }
2447 |       multiplicative_expression MULT_TK error
2448                 {yyerror ("Missing term"); RECOVER;}
2449 |       multiplicative_expression DIV_TK error
2450                 {yyerror ("Missing term"); RECOVER;}
2451 |       multiplicative_expression REM_TK error
2452                 {yyerror ("Missing term"); RECOVER;}
2453 ;
2454
2455 additive_expression:
2456         multiplicative_expression
2457 |       additive_expression PLUS_TK multiplicative_expression
2458                 {
2459                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2460                                     $1, $3);
2461                 }
2462 |       additive_expression MINUS_TK multiplicative_expression
2463                 {
2464                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2465                                     $1, $3);
2466                 }
2467 |       additive_expression PLUS_TK error
2468                 {yyerror ("Missing term"); RECOVER;}
2469 |       additive_expression MINUS_TK error
2470                 {yyerror ("Missing term"); RECOVER;}
2471 ;
2472
2473 shift_expression:
2474         additive_expression
2475 |       shift_expression LS_TK additive_expression
2476                 {
2477                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2478                                     $1, $3);
2479                 }
2480 |       shift_expression SRS_TK additive_expression
2481                 {
2482                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2483                                     $1, $3);
2484                 }
2485 |       shift_expression ZRS_TK additive_expression
2486                 {
2487                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2488                                     $1, $3);
2489                 }
2490 |       shift_expression LS_TK error
2491                 {yyerror ("Missing term"); RECOVER;}
2492 |       shift_expression SRS_TK error
2493                 {yyerror ("Missing term"); RECOVER;}
2494 |       shift_expression ZRS_TK error
2495                 {yyerror ("Missing term"); RECOVER;}
2496 ;
2497
2498 relational_expression:
2499         shift_expression
2500 |       relational_expression LT_TK shift_expression
2501                 {
2502                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2503                                     $1, $3);
2504                 }
2505 |       relational_expression GT_TK shift_expression
2506                 {
2507                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2508                                     $1, $3);
2509                 }
2510 |       relational_expression LTE_TK shift_expression
2511                 {
2512                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2513                                     $1, $3);
2514                 }
2515 |       relational_expression GTE_TK shift_expression
2516                 {
2517                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2518                                     $1, $3);
2519                 }
2520 |       relational_expression INSTANCEOF_TK reference_type
2521                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2522 |       relational_expression LT_TK error
2523                 {yyerror ("Missing term"); RECOVER;}
2524 |       relational_expression GT_TK error
2525                 {yyerror ("Missing term"); RECOVER;}
2526 |       relational_expression LTE_TK error
2527                 {yyerror ("Missing term"); RECOVER;}
2528 |       relational_expression GTE_TK error
2529                 {yyerror ("Missing term"); RECOVER;}
2530 |       relational_expression INSTANCEOF_TK error
2531                 {yyerror ("Invalid reference type"); RECOVER;}
2532 ;
2533
2534 equality_expression:
2535         relational_expression
2536 |       equality_expression EQ_TK relational_expression
2537                 {
2538                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2539                                     $1, $3);
2540                 }
2541 |       equality_expression NEQ_TK relational_expression
2542                 {
2543                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2544                                     $1, $3);
2545                 }
2546 |       equality_expression EQ_TK error
2547                 {yyerror ("Missing term"); RECOVER;}
2548 |       equality_expression NEQ_TK error
2549                 {yyerror ("Missing term"); RECOVER;}
2550 ;
2551
2552 and_expression:
2553         equality_expression
2554 |       and_expression AND_TK equality_expression
2555                 {
2556                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2557                                     $1, $3);
2558                 }
2559 |       and_expression AND_TK error
2560                 {yyerror ("Missing term"); RECOVER;}
2561 ;
2562
2563 exclusive_or_expression:
2564         and_expression
2565 |       exclusive_or_expression XOR_TK and_expression
2566                 {
2567                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2568                                     $1, $3);
2569                 }
2570 |       exclusive_or_expression XOR_TK error
2571                 {yyerror ("Missing term"); RECOVER;}
2572 ;
2573
2574 inclusive_or_expression:
2575         exclusive_or_expression
2576 |       inclusive_or_expression OR_TK exclusive_or_expression
2577                 {
2578                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2579                                     $1, $3);
2580                 }
2581 |       inclusive_or_expression OR_TK error
2582                 {yyerror ("Missing term"); RECOVER;}
2583 ;
2584
2585 conditional_and_expression:
2586         inclusive_or_expression
2587 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2588                 {
2589                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2590                                     $1, $3);
2591                 }
2592 |       conditional_and_expression BOOL_AND_TK error
2593                 {yyerror ("Missing term"); RECOVER;}
2594 ;
2595
2596 conditional_or_expression:
2597         conditional_and_expression
2598 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2599                 {
2600                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2601                                     $1, $3);
2602                 }
2603 |       conditional_or_expression BOOL_OR_TK error
2604                 {yyerror ("Missing term"); RECOVER;}
2605 ;
2606
2607 conditional_expression:         /* Error handling here is weak */
2608         conditional_or_expression
2609 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2610                 {
2611                   $$ = build3 (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2612                   EXPR_WFL_LINECOL ($$) = $2.location;
2613                 }
2614 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2615                 {
2616                   YYERROR_NOW;
2617                   yyerror ("Missing term");
2618                   DRECOVER (1);
2619                 }
2620 |       conditional_or_expression REL_QM_TK error
2621                 {yyerror ("Missing term"); DRECOVER (2);}
2622 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2623                 {yyerror ("Missing term"); DRECOVER (3);}
2624 ;
2625
2626 assignment_expression:
2627         conditional_expression
2628 |       assignment
2629 ;
2630
2631 assignment:
2632         left_hand_side assignment_operator assignment_expression
2633                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2634 |       left_hand_side assignment_operator error
2635                 {
2636                   YYNOT_TWICE yyerror ("Missing term");
2637                   DRECOVER (assign);
2638                 }
2639 ;
2640
2641 left_hand_side:
2642         name
2643 |       field_access
2644 |       array_access
2645 ;
2646
2647 assignment_operator:
2648         ASSIGN_ANY_TK
2649 |       ASSIGN_TK
2650 ;
2651
2652 expression:
2653         assignment_expression
2654 ;
2655
2656 constant_expression:
2657         expression
2658 ;
2659
2660 %%
2661
2662 /* Helper function to retrieve an OSB count. Should be used when the
2663    `dims:' rule is being used.  */
2664
2665 static int
2666 pop_current_osb (struct parser_ctxt *ctxp)
2667 {
2668   int to_return;
2669
2670   if (ctxp->osb_depth < 0)
2671     abort ();
2672
2673   to_return = CURRENT_OSB (ctxp);
2674   ctxp->osb_depth--;
2675
2676   return to_return;
2677 }
2678
2679 \f
2680
2681 /* This section of the code deal with save/restoring parser contexts.
2682    Add mode documentation here. FIXME */
2683
2684 /* Helper function. Create a new parser context. With
2685    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2686    context is copied, otherwise, the new context is zeroed. The newly
2687    created context becomes the current one.  */
2688
2689 static void
2690 create_new_parser_context (int copy_from_previous)
2691 {
2692   struct parser_ctxt *new;
2693
2694   new = ggc_alloc (sizeof (struct parser_ctxt));
2695   if (copy_from_previous)
2696     {
2697       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2698       /* This flag, indicating the context saves global values,
2699          should only be set by java_parser_context_save_global.  */
2700       new->saved_data_ctx = 0;
2701     }
2702   else
2703     memset (new, 0, sizeof (struct parser_ctxt));
2704
2705   new->next = ctxp;
2706   ctxp = new;
2707 }
2708
2709 /* Create a new parser context and make it the current one. */
2710
2711 void
2712 java_push_parser_context (void)
2713 {
2714   create_new_parser_context (0);
2715 }
2716
2717 void
2718 java_pop_parser_context (int generate)
2719 {
2720   tree current;
2721   struct parser_ctxt *toFree, *next;
2722
2723   if (!ctxp)
2724     return;
2725
2726   toFree = ctxp;
2727   next = ctxp->next;
2728   if (next)
2729     {
2730       input_line = ctxp->lineno;
2731       current_class = ctxp->class_type;
2732     }
2733
2734   /* If the old and new lexers differ, then free the old one.  */
2735   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2736     java_destroy_lexer (ctxp->lexer);
2737
2738   /* Set the single import class file flag to 0 for the current list
2739      of imported things */
2740   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2741     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2742
2743   /* And restore those of the previous context */
2744   if ((ctxp = next))            /* Assignment is really meant here */
2745     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2746       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2747
2748   /* If we pushed a context to parse a class intended to be generated,
2749      we keep it so we can remember the class. What we could actually
2750      do is to just update a list of class names.  */
2751   if (generate)
2752     {
2753       toFree->next = ctxp_for_generation;
2754       ctxp_for_generation = toFree;
2755     }
2756 }
2757
2758 /* Create a parser context for the use of saving some global
2759    variables.  */
2760
2761 void
2762 java_parser_context_save_global (void)
2763 {
2764   if (!ctxp)
2765     {
2766       java_push_parser_context ();
2767       ctxp->saved_data_ctx = 1;
2768     }
2769
2770   /* If this context already stores data, create a new one suitable
2771      for data storage. */
2772   else if (ctxp->saved_data)
2773     {
2774       create_new_parser_context (1);
2775       ctxp->saved_data_ctx = 1;
2776     }
2777
2778   ctxp->lineno = input_line;
2779   ctxp->class_type = current_class;
2780   ctxp->filename = input_filename;
2781   ctxp->function_decl = current_function_decl;
2782   ctxp->saved_data = 1;
2783 }
2784
2785 /* Restore some global variables from the previous context. Make the
2786    previous context the current one.  */
2787
2788 void
2789 java_parser_context_restore_global (void)
2790 {
2791   input_line = ctxp->lineno;
2792   current_class = ctxp->class_type;
2793   input_filename = ctxp->filename;
2794   if (wfl_operator)
2795     EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
2796   current_function_decl = ctxp->function_decl;
2797   ctxp->saved_data = 0;
2798   if (ctxp->saved_data_ctx)
2799     java_pop_parser_context (0);
2800 }
2801
2802 /* Suspend vital data for the current class/function being parsed so
2803    that an other class can be parsed. Used to let local/anonymous
2804    classes be parsed.  */
2805
2806 static void
2807 java_parser_context_suspend (void)
2808 {
2809   /* This makes debugging through java_debug_context easier */
2810   static const char *const name = "<inner buffer context>";
2811
2812   /* Duplicate the previous context, use it to save the globals we're
2813      interested in */
2814   create_new_parser_context (1);
2815   ctxp->function_decl = current_function_decl;
2816   ctxp->class_type = current_class;
2817
2818   /* Then create a new context which inherits all data from the
2819      previous one. This will be the new current context  */
2820   create_new_parser_context (1);
2821
2822   /* Help debugging */
2823   ctxp->next->filename = name;
2824 }
2825
2826 /* Resume vital data for the current class/function being parsed so
2827    that an other class can be parsed. Used to let local/anonymous
2828    classes be parsed.  The trick is the data storing file position
2829    informations must be restored to their current value, so parsing
2830    can resume as if no context was ever saved. */
2831
2832 static void
2833 java_parser_context_resume (void)
2834 {
2835   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2836   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2837   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2838
2839   /* We need to inherit the list of classes to complete/generate */
2840   restored->classd_list = old->classd_list;
2841   restored->class_list = old->class_list;
2842
2843   /* Restore the current class and function from the saver */
2844   current_class = saver->class_type;
2845   current_function_decl = saver->function_decl;
2846
2847   /* Retrieve the restored context */
2848   ctxp = restored;
2849
2850   /* Re-installed the data for the parsing to carry on */
2851   memcpy (&ctxp->marker_begining, &old->marker_begining,
2852           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2853 }
2854
2855 /* Add a new anchor node to which all statement(s) initializing static
2856    and non static initialized upon declaration field(s) will be
2857    linked.  */
2858
2859 static void
2860 java_parser_context_push_initialized_field (void)
2861 {
2862   tree node;
2863
2864   node = build_tree_list (NULL_TREE, NULL_TREE);
2865   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2866   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2867
2868   node = build_tree_list (NULL_TREE, NULL_TREE);
2869   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2870   CPC_INITIALIZER_LIST (ctxp) = node;
2871
2872   node = build_tree_list (NULL_TREE, NULL_TREE);
2873   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2874   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2875 }
2876
2877 /* Pop the lists of initialized field. If this lists aren't empty,
2878    remember them so we can use it to create and populate the finit$
2879    or <clinit> functions. */
2880
2881 static void
2882 java_parser_context_pop_initialized_field (void)
2883 {
2884   tree stmts;
2885   tree class_type = TREE_TYPE (GET_CPC ());
2886
2887   if (CPC_INITIALIZER_LIST (ctxp))
2888     {
2889       stmts = CPC_INITIALIZER_STMT (ctxp);
2890       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2891       if (stmts && !java_error_count)
2892         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2893     }
2894
2895   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2896     {
2897       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2898       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2899         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2900       /* Keep initialization in order to enforce 8.5 */
2901       if (stmts && !java_error_count)
2902         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2903     }
2904
2905   /* JDK 1.1 instance initializers */
2906   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2907     {
2908       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2909       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2910         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2911       if (stmts && !java_error_count)
2912         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2913     }
2914 }
2915
2916 static tree
2917 reorder_static_initialized (tree list)
2918 {
2919   /* We have to keep things in order. The alias initializer have to
2920      come first, then the initialized regular field, in reverse to
2921      keep them in lexical order. */
2922   tree marker, previous = NULL_TREE;
2923   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2924     if (TREE_CODE (marker) == TREE_LIST
2925         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2926       break;
2927
2928   /* No static initialized, the list is fine as is */
2929   if (!previous)
2930     list = TREE_CHAIN (marker);
2931
2932   /* No marker? reverse the whole list */
2933   else if (!marker)
2934     list = nreverse (list);
2935
2936   /* Otherwise, reverse what's after the marker and the new reordered
2937      sublist will replace the marker. */
2938   else
2939     {
2940       TREE_CHAIN (previous) = NULL_TREE;
2941       list = nreverse (list);
2942       list = chainon (TREE_CHAIN (marker), list);
2943     }
2944   return list;
2945 }
2946
2947 /* Helper functions to dump the parser context stack.  */
2948
2949 #define TAB_CONTEXT(C) \
2950   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2951
2952 static void
2953 java_debug_context_do (int tab)
2954 {
2955   struct parser_ctxt *copy = ctxp;
2956   while (copy)
2957     {
2958       TAB_CONTEXT (tab);
2959       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2960       TAB_CONTEXT (tab);
2961       fprintf (stderr, "filename: %s\n", copy->filename);
2962       TAB_CONTEXT (tab);
2963       fprintf (stderr, "lineno: %d\n", copy->lineno);
2964       TAB_CONTEXT (tab);
2965       fprintf (stderr, "package: %s\n",
2966                (copy->package ?
2967                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2968       TAB_CONTEXT (tab);
2969       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2970       TAB_CONTEXT (tab);
2971       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2972       copy = copy->next;
2973       tab += 2;
2974     }
2975 }
2976
2977 /* Dump the stacked up parser contexts. Intended to be called from a
2978    debugger.  */
2979
2980 void
2981 java_debug_context (void)
2982 {
2983   java_debug_context_do (0);
2984 }
2985
2986 \f
2987
2988 /* Flag for the error report routine to issue the error the first time
2989    it's called (overriding the default behavior which is to drop the
2990    first invocation and honor the second one, taking advantage of a
2991    richer context.  */
2992 static int force_error = 0;
2993
2994 /* Reporting an constructor invocation error.  */
2995 static void
2996 parse_ctor_invocation_error (void)
2997 {
2998   if (DECL_CONSTRUCTOR_P (current_function_decl))
2999     yyerror ("Constructor invocation must be first thing in a constructor");
3000   else
3001     yyerror ("Only constructors can invoke constructors");
3002 }
3003
3004 /* Reporting JDK1.1 features not implemented.  */
3005
3006 static tree
3007 parse_jdk1_1_error (const char *msg)
3008 {
3009   sorry (": `%s' JDK1.1(TM) feature", msg);
3010   java_error_count++;
3011   return build_java_empty_stmt ();
3012 }
3013
3014 static int do_warning = 0;
3015
3016 void
3017 yyerror (const char *msg)
3018 {
3019   static java_lc elc;
3020   static int  prev_lineno;
3021   static const char *prev_msg;
3022
3023   int save_lineno;
3024   char *remainder, *code_from_source;
3025
3026   if (!force_error && prev_lineno == input_line)
3027     return;
3028
3029   /* Save current error location but report latter, when the context is
3030      richer.  */
3031   if (ctxp->java_error_flag == 0)
3032     {
3033       ctxp->java_error_flag = 1;
3034       elc = ctxp->elc;
3035       /* Do something to use the previous line if we're reaching the
3036          end of the file... */
3037 #ifdef VERBOSE_SKELETON
3038       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3039 #endif
3040       return;
3041     }
3042
3043   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3044   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3045     return;
3046
3047   ctxp->java_error_flag = 0;
3048   if (do_warning)
3049     java_warning_count++;
3050   else
3051     java_error_count++;
3052
3053   if (elc.col == 0 && msg && msg[1] == ';')
3054     {
3055       elc.col  = ctxp->p_line->char_col-1;
3056       elc.line = ctxp->p_line->lineno;
3057     }
3058
3059   save_lineno = input_line;
3060   prev_lineno = input_line = elc.line;
3061   prev_msg = msg;
3062
3063   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3064   obstack_grow0 (&temporary_obstack,
3065                  code_from_source, strlen (code_from_source));
3066   remainder = obstack_finish (&temporary_obstack);
3067   if (do_warning)
3068     warning ("%s.\n%s", msg, remainder);
3069   else
3070     error ("%s.\n%s", msg, remainder);
3071
3072   /* This allow us to cheaply avoid an extra 'Invalid expression
3073      statement' error report when errors have been already reported on
3074      the same line. This occurs when we report an error but don't have
3075      a synchronization point other than ';', which
3076      expression_statement is the only one to take care of.  */
3077   ctxp->prevent_ese = input_line = save_lineno;
3078 }
3079
3080 static void
3081 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3082 {
3083   const char *saved, *saved_input_filename;
3084   char buffer [4096];
3085   vsprintf (buffer, msg, ap);
3086   force_error = 1;
3087
3088   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3089   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3090                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3091
3092   /* We have a CL, that's a good reason for using it if it contains data */
3093   saved = ctxp->filename;
3094   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3095     ctxp->filename = EXPR_WFL_FILENAME (cl);
3096   saved_input_filename = input_filename;
3097   input_filename = ctxp->filename;
3098   java_error (NULL);
3099   java_error (buffer);
3100   ctxp->filename = saved;
3101   input_filename = saved_input_filename;
3102   force_error = 0;
3103 }
3104
3105 /* Issue an error message at a current source line CL */
3106
3107 void
3108 parse_error_context (tree cl, const char *msg, ...)
3109 {
3110   va_list ap;
3111   va_start (ap, msg);
3112   issue_warning_error_from_context (cl, msg, ap);
3113   va_end (ap);
3114 }
3115
3116 /* Issue a warning at a current source line CL */
3117
3118 static void
3119 parse_warning_context (tree cl, const char *msg, ...)
3120 {
3121   va_list ap;
3122   va_start (ap, msg);
3123
3124   force_error = do_warning = 1;
3125   issue_warning_error_from_context (cl, msg, ap);
3126   do_warning = force_error = 0;
3127   va_end (ap);
3128 }
3129
3130 static tree
3131 find_expr_with_wfl (tree node)
3132 {
3133   while (node)
3134     {
3135       enum tree_code_class code;
3136       tree to_return;
3137
3138       switch (TREE_CODE (node))
3139         {
3140         case BLOCK:
3141           node = BLOCK_EXPR_BODY (node);
3142           continue;
3143
3144         case COMPOUND_EXPR:
3145           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3146           if (to_return)
3147             return to_return;
3148           node = TREE_OPERAND (node, 1);
3149           continue;
3150
3151         case LOOP_EXPR:
3152           node = TREE_OPERAND (node, 0);
3153           continue;
3154
3155         case LABELED_BLOCK_EXPR:
3156           node = TREE_OPERAND (node, 1);
3157           continue;
3158
3159         default:
3160           code = TREE_CODE_CLASS (TREE_CODE (node));
3161           if (((code == tcc_unary) || (code == tcc_binary)
3162                || (code == tcc_expression))
3163               && EXPR_WFL_LINECOL (node))
3164             return node;
3165           return NULL_TREE;
3166         }
3167     }
3168   return NULL_TREE;
3169 }
3170
3171 /* Issue a missing return statement error. Uses METHOD to figure the
3172    last line of the method the error occurs in.  */
3173
3174 static void
3175 missing_return_error (tree method)
3176 {
3177   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3178   parse_error_context (wfl_operator, "Missing return statement");
3179 }
3180
3181 /* Issue an unreachable statement error. From NODE, find the next
3182    statement to report appropriately.  */
3183 static void
3184 unreachable_stmt_error (tree node)
3185 {
3186   /* Browse node to find the next expression node that has a WFL. Use
3187      the location to report the error */
3188   if (TREE_CODE (node) == COMPOUND_EXPR)
3189     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3190   else
3191     node = find_expr_with_wfl (node);
3192
3193   if (node)
3194     {
3195       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3196       parse_error_context (wfl_operator, "Unreachable statement");
3197     }
3198   else
3199     abort ();
3200 }
3201
3202 static int
3203 not_accessible_field_error (tree wfl, tree decl)
3204 {
3205   parse_error_context
3206     (wfl, "Can't access %s field `%s.%s' from `%s'",
3207      accessibility_string (get_access_flags_from_decl (decl)),
3208      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3209      IDENTIFIER_POINTER (DECL_NAME (decl)),
3210      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3211   return 1;
3212 }
3213
3214 int
3215 java_report_errors (void)
3216 {
3217   if (java_error_count)
3218     fprintf (stderr, "%d error%s",
3219              java_error_count, (java_error_count == 1 ? "" : "s"));
3220   if (java_warning_count)
3221     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3222              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3223   if (java_error_count || java_warning_count)
3224     putc ('\n', stderr);
3225   return java_error_count;
3226 }
3227
3228 static char *
3229 java_accstring_lookup (int flags)
3230 {
3231   static char buffer [80];
3232 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3233
3234   /* Access modifier looked-up first for easier report on forbidden
3235      access. */
3236   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3237   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3238   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3239   if (flags & ACC_STATIC) COPY_RETURN ("static");
3240   if (flags & ACC_FINAL) COPY_RETURN ("final");
3241   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3242   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3243   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3244   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3245   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3246   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3247
3248   buffer [0] = '\0';
3249   return buffer;
3250 #undef COPY_RETURN
3251 }
3252
3253 /* Returns a string denoting the accessibility of a class or a member as
3254    indicated by FLAGS.  We need a separate function from
3255    java_accstring_lookup, as the latter can return spurious "static", etc.
3256    if package-private access is defined (in which case none of the
3257    relevant access control bits in FLAGS is set).  */
3258
3259 static const char *
3260 accessibility_string (int flags)
3261 {
3262   if (flags & ACC_PRIVATE) return "private";
3263   if (flags & ACC_PROTECTED) return "protected";
3264   if (flags & ACC_PUBLIC) return "public";
3265
3266   return "package-private";
3267 }
3268
3269 /* Issuing error messages upon redefinition of classes, interfaces or
3270    variables. */
3271
3272 static void
3273 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3274 {
3275   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3276                        context, IDENTIFIER_POINTER (id),
3277                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3278   /* Here we should point out where its redefined. It's a unicode. FIXME */
3279 }
3280
3281 static void
3282 variable_redefinition_error (tree context, tree name, tree type, int line)
3283 {
3284   const char *type_name;
3285
3286   /* Figure a proper name for type. We might haven't resolved it */
3287   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3288     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3289   else
3290     type_name = lang_printable_name (type, 0);
3291
3292   parse_error_context (context,
3293                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3294                        IDENTIFIER_POINTER (name),
3295                        type_name, IDENTIFIER_POINTER (name), line);
3296 }
3297
3298 /* If ANAME is terminated with `[]', it indicates an array. This
3299    function returns the number of `[]' found and if this number is
3300    greater than zero, it extracts the array type name and places it in
3301    the node pointed to by TRIMMED unless TRIMMED is null.  */
3302
3303 static int
3304 build_type_name_from_array_name (tree aname, tree *trimmed)
3305 {
3306   const char *name = IDENTIFIER_POINTER (aname);
3307   int len = IDENTIFIER_LENGTH (aname);
3308   int array_dims;
3309
3310   STRING_STRIP_BRACKETS (name, len, array_dims);
3311
3312   if (array_dims && trimmed)
3313     *trimmed = get_identifier_with_length (name, len);
3314
3315   return array_dims;
3316 }
3317
3318 static tree
3319 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3320 {
3321   int more_dims = 0;
3322
3323   /* Eventually get more dims */
3324   more_dims = build_type_name_from_array_name (name, &name);
3325
3326   /* If we have, then craft a new type for this variable */
3327   if (more_dims)
3328     {
3329       tree save = type;
3330
3331       /* If we have a pointer, use its type */
3332       if (TREE_CODE (type) == POINTER_TYPE)
3333         type = TREE_TYPE (type);
3334
3335       /* Building the first dimension of a primitive type uses this
3336          function */
3337       if (JPRIMITIVE_TYPE_P (type))
3338         {
3339           type = build_java_array_type (type, -1);
3340           more_dims--;
3341         }
3342       /* Otherwise, if we have a WFL for this type, use it (the type
3343          is already an array on an unresolved type, and we just keep
3344          on adding dimensions) */
3345       else if (type_wfl)
3346         {
3347           type = type_wfl;
3348           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3349                                                         NULL);
3350         }
3351
3352       /* Add all the dimensions */
3353       while (more_dims--)
3354         type = build_unresolved_array_type (type);
3355
3356       /* The type may have been incomplete in the first place */
3357       if (type_wfl)
3358         type = obtain_incomplete_type (type);
3359     }
3360
3361   if (ret_name)
3362     *ret_name = name;
3363   return type;
3364 }
3365
3366 /* Build something that the type identifier resolver will identify as
3367    being an array to an unresolved type. TYPE_WFL is a WFL on a
3368    identifier. */
3369
3370 static tree
3371 build_unresolved_array_type (tree type_or_wfl)
3372 {
3373   const char *ptr;
3374   tree wfl;
3375
3376   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3377      just create a array type */
3378   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3379     return build_java_array_type (type_or_wfl, -1);
3380
3381   obstack_grow (&temporary_obstack,
3382                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3383                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3384   obstack_grow0 (&temporary_obstack, "[]", 2);
3385   ptr = obstack_finish (&temporary_obstack);
3386   wfl = build_expr_wfl (get_identifier (ptr),
3387                         EXPR_WFL_FILENAME (type_or_wfl),
3388                         EXPR_WFL_LINENO (type_or_wfl),
3389                         EXPR_WFL_COLNO (type_or_wfl));
3390   /* Re-install the existing qualifications so that the type can be
3391      resolved properly. */
3392   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3393   return wfl;
3394 }
3395
3396 static void
3397 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3398 {
3399   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3400     parse_error_context (wfl, "Interface `%s' repeated",
3401                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3402 }
3403
3404 /* Bulk of common class/interface checks. Return 1 if an error was
3405    encountered. TAG is 0 for a class, 1 for an interface.  */
3406
3407 static int
3408 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3409                                 tree qualified_name, tree decl, tree cl)
3410 {
3411   tree node;
3412   int sca = 0;                  /* Static class allowed */
3413   int icaf = 0;                 /* Inner class allowed flags */
3414   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3415
3416   if (!quiet_flag)
3417     fprintf (stderr, " %s%s %s",
3418              (CPC_INNER_P () ? "inner" : ""),
3419              (is_interface ? "interface" : "class"),
3420              IDENTIFIER_POINTER (qualified_name));
3421
3422   /* Scope of an interface/class type name:
3423        - Can't be imported by a single type import
3424        - Can't already exists in the package */
3425   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3426       && (node = find_name_in_single_imports (raw_name))
3427       && !CPC_INNER_P ())
3428     {
3429       parse_error_context
3430         (cl, "%s name `%s' clashes with imported type `%s'",
3431          (is_interface ? "Interface" : "Class"),
3432          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3433       return 1;
3434     }
3435   if (decl && CLASS_COMPLETE_P (decl))
3436     {
3437       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3438                                    qualified_name, decl, cl);
3439       return 1;
3440     }
3441
3442   if (check_inner_class_redefinition (raw_name, cl))
3443     return 1;
3444
3445   /* If public, file name should match class/interface name, except
3446      when dealing with an inner class */
3447   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3448     {
3449       const char *f;
3450
3451       for (f = &input_filename [strlen (input_filename)];
3452            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3453            f--)
3454         ;
3455       if (IS_DIR_SEPARATOR (f[0]))
3456         f++;
3457       if (strncmp (IDENTIFIER_POINTER (raw_name),
3458                    f , IDENTIFIER_LENGTH (raw_name)) ||
3459           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3460         parse_error_context
3461           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3462                              (is_interface ? "interface" : "class"),
3463                              IDENTIFIER_POINTER (qualified_name),
3464                              IDENTIFIER_POINTER (raw_name));
3465     }
3466
3467   /* Static classes can be declared only in top level classes. Note:
3468      once static, a inner class is a top level class. */
3469   if (flags & ACC_STATIC)
3470     {
3471       /* Catch the specific error of declaring an class inner class
3472          with no toplevel enclosing class. Prevent check_modifiers from
3473          complaining a second time */
3474       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3475         {
3476           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3477                                IDENTIFIER_POINTER (qualified_name));
3478           sca = ACC_STATIC;
3479         }
3480       /* Else, in the context of a top-level class declaration, let
3481          `check_modifiers' do its job, otherwise, give it a go */
3482       else
3483         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3484     }
3485
3486   /* Inner classes can be declared private or protected
3487      within their enclosing classes. */
3488   if (CPC_INNER_P ())
3489     {
3490       /* A class which is local to a block can't be public, private,
3491          protected or static. But it is created final, so allow this
3492          one. */
3493       if (current_function_decl)
3494         icaf = sca = uaaf = ACC_FINAL;
3495       else
3496         {
3497           check_modifiers_consistency (flags);
3498           icaf = ACC_PROTECTED;
3499           if (! CLASS_INTERFACE (GET_CPC ()))
3500             icaf |= ACC_PRIVATE;
3501         }
3502     }
3503
3504   if (is_interface)
3505     {
3506       if (CPC_INNER_P ())
3507         uaaf = INTERFACE_INNER_MODIFIERS;
3508       else
3509         uaaf = INTERFACE_MODIFIERS;
3510
3511       check_modifiers ("Illegal modifier `%s' for interface declaration",
3512                        flags, uaaf);
3513     }
3514   else
3515     check_modifiers ((current_function_decl ?
3516                       "Illegal modifier `%s' for local class declaration" :
3517                       "Illegal modifier `%s' for class declaration"),
3518                      flags, uaaf|sca|icaf);
3519   return 0;
3520 }
3521
3522 /* Construct a nested class name.  If the final component starts with
3523    a digit, return true.  Otherwise return false.  */
3524 static int
3525 make_nested_class_name (tree cpc_list)
3526 {
3527   tree name;
3528
3529   if (!cpc_list)
3530     return 0;
3531
3532   make_nested_class_name (TREE_CHAIN (cpc_list));
3533
3534   /* Pick the qualified name when dealing with the first upmost
3535      enclosing class */
3536   name = (TREE_CHAIN (cpc_list)
3537           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3538   obstack_grow (&temporary_obstack,
3539                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3540   obstack_1grow (&temporary_obstack, '$');
3541
3542   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3543 }
3544
3545 /* Can't redefine a class already defined in an earlier scope. */
3546
3547 static int
3548 check_inner_class_redefinition (tree raw_name, tree cl)
3549 {
3550   tree scope_list;
3551
3552   for (scope_list = GET_CPC_LIST (); scope_list;
3553        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3554     if (raw_name == GET_CPC_UN_NODE (scope_list))
3555       {
3556         parse_error_context
3557           (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",
3558            IDENTIFIER_POINTER (raw_name));
3559         return 1;
3560       }
3561   return 0;
3562 }
3563
3564 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3565    we remember ENCLOSING and SUPER.  */
3566
3567 static tree
3568 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3569                      tree *super, tree class_type)
3570 {
3571   tree local_enclosing = *enclosing;
3572   tree local_super = NULL_TREE;
3573
3574   while (local_enclosing)
3575     {
3576       tree intermediate, decl;
3577
3578       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3579         local_enclosing;
3580
3581       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3582         return decl;
3583
3584       intermediate = local_enclosing;
3585       /* Explore enclosing contexts. */
3586       while (INNER_CLASS_DECL_P (intermediate))
3587         {
3588           intermediate = DECL_CONTEXT (intermediate);
3589           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3590             return decl;
3591         }
3592
3593       /* Now go to the upper classes, bail out if necessary.  We will
3594          analyze the returned SUPER and act accordingly (see
3595          do_resolve_class).  */
3596       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3597           || TREE_TYPE (local_enclosing) == void_type_node)
3598         {
3599           parse_error_context (cl, "Qualifier must be a reference");
3600           local_enclosing = NULL_TREE;
3601           break;
3602         }
3603       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3604       if (!local_super || local_super == object_type_node)
3605         break;
3606
3607       if (TREE_CODE (local_super) == POINTER_TYPE)
3608         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3609       else
3610         local_super = TYPE_NAME (local_super);
3611
3612       /* We may not have checked for circular inheritance yet, so do so
3613          here to prevent an infinite loop. */
3614       if (htab_find (circularity_hash, local_super) != NULL)
3615         {
3616           if (!cl)
3617             cl = lookup_cl (local_enclosing);
3618
3619           parse_error_context
3620             (cl, "Cyclic inheritance involving %s",
3621              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3622           local_enclosing = NULL_TREE;
3623         }
3624       else
3625         local_enclosing = local_super;
3626     }
3627
3628   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3629   *super = local_super;
3630   *enclosing = local_enclosing;
3631
3632   return NULL_TREE;
3633 }
3634
3635 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3636    qualified. */
3637
3638 static tree
3639 find_as_inner_class (tree enclosing, tree name, tree cl)
3640 {
3641   tree qual, to_return;
3642   if (!enclosing)
3643     return NULL_TREE;
3644
3645   name = TYPE_NAME (name);
3646
3647   /* First search: within the scope of `enclosing', search for name */
3648   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3649     qual = EXPR_WFL_QUALIFICATION (cl);
3650   else if (cl)
3651     qual = build_tree_list (cl, NULL_TREE);
3652   else
3653     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3654
3655   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3656     return to_return;
3657
3658   /* We're dealing with a qualified name. Try to resolve thing until
3659      we get something that is an enclosing class. */
3660   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3661     {
3662       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3663
3664       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3665            qual = TREE_CHAIN (qual))
3666         {
3667           acc = merge_qualified_name (acc,
3668                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3669           BUILD_PTR_FROM_NAME (ptr, acc);
3670           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3671         }
3672
3673       /* A NULL qual and a decl means that the search ended
3674          successfully?!? We have to do something then. FIXME */
3675
3676       if (decl)
3677         enclosing = decl;
3678       else
3679         qual = EXPR_WFL_QUALIFICATION (cl);
3680     }
3681   /* Otherwise, create a qual for the other part of the resolution. */
3682   else
3683     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3684
3685   return find_as_inner_class_do (qual, enclosing);
3686 }
3687
3688 /* We go inside the list of sub classes and try to find a way
3689    through. */
3690
3691 static tree
3692 find_as_inner_class_do (tree qual, tree enclosing)
3693 {
3694   if (!qual)
3695     return NULL_TREE;
3696
3697   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3698     {
3699       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3700       tree next_enclosing = NULL_TREE;
3701       tree inner_list;
3702
3703       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3704            inner_list; inner_list = TREE_CHAIN (inner_list))
3705         {
3706           if (TREE_VALUE (inner_list) == name_to_match)
3707             {
3708               next_enclosing = TREE_PURPOSE (inner_list);
3709               break;
3710             }
3711         }
3712       enclosing = next_enclosing;
3713     }
3714
3715   return (!qual && enclosing ? enclosing : NULL_TREE);
3716 }
3717
3718 static void
3719 link_nested_class_to_enclosing (void)
3720 {
3721   if (GET_ENCLOSING_CPC ())
3722     {
3723       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3724       DECL_INNER_CLASS_LIST (enclosing) =
3725         tree_cons (GET_CPC (), GET_CPC_UN (),
3726                    DECL_INNER_CLASS_LIST (enclosing));
3727     }
3728 }
3729
3730 static tree
3731 maybe_make_nested_class_name (tree name)
3732 {
3733   tree id = NULL_TREE;
3734
3735   if (CPC_INNER_P ())
3736     {
3737       /* If we're in a function, we must append a number to create the
3738          nested class name.  However, we don't do this if the class we
3739          are constructing is anonymous, because in that case we'll
3740          already have a number as the class name.  */
3741       if (! make_nested_class_name (GET_CPC_LIST ())
3742           && current_function_decl != NULL_TREE
3743           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3744         {
3745           char buf[10];
3746           sprintf (buf, "%d", anonymous_class_counter);
3747           ++anonymous_class_counter;
3748           obstack_grow (&temporary_obstack, buf, strlen (buf));
3749           obstack_1grow (&temporary_obstack, '$');
3750         }
3751       obstack_grow0 (&temporary_obstack,
3752                      IDENTIFIER_POINTER (name),
3753                      IDENTIFIER_LENGTH (name));
3754       id = get_identifier (obstack_finish (&temporary_obstack));
3755       if (ctxp->package)
3756         QUALIFIED_P (id) = 1;
3757     }
3758   return id;
3759 }
3760
3761 /* If DECL is NULL, create and push a new DECL, record the current
3762    line CL and do other maintenance things.  */
3763
3764 static tree
3765 maybe_create_class_interface_decl (tree decl, tree raw_name,
3766                                    tree qualified_name, tree cl)
3767 {
3768   if (!decl)
3769     decl = push_class (make_class (), qualified_name);
3770
3771   /* Take care of the file and line business */
3772   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3773   /* If we're emitting xrefs, store the line/col number information */
3774   if (flag_emit_xref)
3775     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3776   else
3777     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3778   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3779   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3780   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3781     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3782
3783   PUSH_CPC (decl, raw_name);
3784   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3785
3786   /* Link the declaration to the already seen ones */
3787   TREE_CHAIN (decl) = ctxp->class_list;
3788   ctxp->class_list = decl;
3789
3790   /* Create a new nodes in the global lists */
3791   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3792   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3793
3794   /* Install a new dependency list element */
3795   create_jdep_list (ctxp);
3796
3797   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3798                           IDENTIFIER_POINTER (qualified_name)));
3799   return decl;
3800 }
3801
3802 static void
3803 add_superinterfaces (tree decl, tree interface_list)
3804 {
3805   tree node;
3806   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3807      takes care of ensuring that:
3808        - This is an accessible interface type,
3809        - Circularity detection.
3810    parser_add_interface is then called. If present but not defined,
3811    the check operation is delayed until the super interface gets
3812    defined.  */
3813   for (node = interface_list; node; node = TREE_CHAIN (node))
3814     {
3815       tree current = TREE_PURPOSE (node);
3816       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3817       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3818         {
3819           if (!parser_check_super_interface (idecl, decl, current))
3820             parser_add_interface (decl, idecl, current);
3821         }
3822       else
3823         register_incomplete_type (JDEP_INTERFACE,
3824                                   current, decl, NULL_TREE);
3825     }
3826 }
3827
3828 /* Create an interface in pass1 and return its decl. Return the
3829    interface's decl in pass 2.  */
3830
3831 static tree
3832 create_interface (int flags, tree id, tree super)
3833 {
3834   tree raw_name = EXPR_WFL_NODE (id);
3835   tree q_name = parser_qualified_classname (raw_name);
3836   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3837
3838   /* Certain syntax errors are making SUPER be like ID. Avoid this
3839      case. */
3840   if (ctxp->class_err && id == super)
3841     super = NULL;
3842
3843   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3844
3845   /* Basic checks: scope, redefinition, modifiers */
3846   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3847     {
3848       PUSH_ERROR ();
3849       return NULL_TREE;
3850     }
3851
3852   /* Suspend the current parsing context if we're parsing an inner
3853      interface */
3854   if (CPC_INNER_P ())
3855     {
3856       java_parser_context_suspend ();
3857       /* Interface members are public. */
3858       if (CLASS_INTERFACE (GET_CPC ()))
3859         flags |= ACC_PUBLIC;
3860     }
3861
3862   /* Push a new context for (static) initialized upon declaration fields */
3863   java_parser_context_push_initialized_field ();
3864
3865   /* Interface modifiers check
3866        - public/abstract allowed (already done at that point)
3867        - abstract is obsolete (comes first, it's a warning, or should be)
3868        - Can't use twice the same (checked in the modifier rule) */
3869   if ((flags & ACC_ABSTRACT) && flag_redundant)
3870     parse_warning_context
3871       (MODIFIER_WFL (ABSTRACT_TK),
3872        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3873
3874   /* Create a new decl if DECL is NULL, otherwise fix it */
3875   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3876
3877   /* Interfaces are always abstract. */
3878   flags |= ACC_ABSTRACT;
3879
3880   /* Inner interfaces are always static.  */
3881   if (INNER_CLASS_DECL_P (decl))
3882     flags |= ACC_STATIC;
3883
3884   /* Set super info and mark the class a complete */
3885   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3886                   object_type_node, ctxp->interface_number);
3887   ctxp->interface_number = 0;
3888   CLASS_COMPLETE_P (decl) = 1;
3889   add_superinterfaces (decl, super);
3890
3891   /* Eventually sets the @deprecated tag flag */
3892   CHECK_DEPRECATED (decl);
3893
3894   return decl;
3895 }
3896
3897 /* Patch anonymous class CLASS, by either extending or implementing
3898    DEP.  */
3899
3900 static void
3901 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3902 {
3903   tree class = TREE_TYPE (class_decl);
3904   tree type =  TREE_TYPE (type_decl);
3905   tree binfo = TYPE_BINFO (class);
3906
3907   /* If it's an interface, implement it */
3908   if (CLASS_INTERFACE (type_decl))
3909     {
3910       if (parser_check_super_interface (type_decl, class_decl, wfl))
3911         return;
3912
3913       if (!VEC_space (tree, BINFO_BASE_BINFOS (binfo), 1))
3914         {
3915            /* Extend the binfo - by reallocating and copying it. */
3916           tree new_binfo;
3917           tree base_binfo;
3918           int i;
3919
3920           new_binfo = make_tree_binfo ((BINFO_N_BASE_BINFOS (binfo) + 1) * 2);
3921           for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3922             BINFO_BASE_APPEND (new_binfo, base_binfo);
3923           CLASS_HAS_SUPER_FLAG (new_binfo) = CLASS_HAS_SUPER_FLAG (binfo);
3924           BINFO_VTABLE (new_binfo) = BINFO_VTABLE (binfo);
3925           TYPE_BINFO (class) = new_binfo;
3926         }
3927
3928       /* And add the interface */
3929       parser_add_interface (class_decl, type_decl, wfl);
3930     }
3931   /* Otherwise, it's a type we want to extend */
3932   else
3933     {
3934       if (parser_check_super (type_decl, class_decl, wfl))
3935         return;
3936       BINFO_TYPE (BINFO_BASE_BINFO (binfo, 0)) = type;
3937     }
3938 }
3939
3940 /* Create an anonymous class which extends/implements TYPE_NAME, and return
3941    its decl.  */
3942
3943 static tree
3944 create_anonymous_class (tree type_name)
3945 {
3946   char buffer [80];
3947   tree super = NULL_TREE, itf = NULL_TREE;
3948   tree id, type_decl, class;
3949
3950   /* The unqualified name of the anonymous class. It's just a number. */
3951   sprintf (buffer, "%d", anonymous_class_counter++);
3952   id = build_wfl_node (get_identifier (buffer));
3953   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
3954
3955   /* We know about the type to extend/implement. We go ahead */
3956   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3957     {
3958       /* Create a class which either implements on extends the designated
3959          class. The class bears an inaccessible name. */
3960       if (CLASS_INTERFACE (type_decl))
3961         {
3962           /* It's OK to modify it here. It's been already used and
3963              shouldn't be reused */
3964           ctxp->interface_number = 1;
3965           /* Interfaces should presented as a list of WFLs */
3966           itf = build_tree_list (type_name, NULL_TREE);
3967         }
3968       else
3969         super = type_name;
3970     }
3971
3972   class = create_class (ACC_FINAL, id, super, itf);
3973
3974   /* We didn't know anything about the stuff. We register a dependence. */
3975   if (!type_decl)
3976     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3977
3978   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3979   return class;
3980 }
3981
3982 /* Create a class in pass1 and return its decl. Return class
3983    interface's decl in pass 2.  */
3984
3985 static tree
3986 create_class (int flags, tree id, tree super, tree interfaces)
3987 {
3988   tree raw_name = EXPR_WFL_NODE (id);
3989   tree class_id, decl;
3990   tree super_decl_type;
3991
3992   /* Certain syntax errors are making SUPER be like ID. Avoid this
3993      case. */
3994   if (ctxp->class_err && id == super)
3995     super = NULL;
3996
3997   class_id = parser_qualified_classname (raw_name);
3998   decl = IDENTIFIER_CLASS_VALUE (class_id);
3999   EXPR_WFL_NODE (id) = class_id;
4000
4001   /* Basic check: scope, redefinition, modifiers */
4002   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
4003     {
4004       PUSH_ERROR ();
4005       return NULL_TREE;
4006     }
4007
4008   /* Suspend the current parsing context if we're parsing an inner
4009      class or an anonymous class. */
4010   if (CPC_INNER_P ())
4011     {
4012       java_parser_context_suspend ();
4013       /* Interface members are public. */
4014       if (CLASS_INTERFACE (GET_CPC ()))
4015         flags |= ACC_PUBLIC;
4016     }
4017
4018   /* Push a new context for (static) initialized upon declaration fields */
4019   java_parser_context_push_initialized_field ();
4020
4021   /* Class modifier check:
4022        - Allowed modifier (already done at that point)
4023        - abstract AND final forbidden
4024        - Public classes defined in the correct file */
4025   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4026     parse_error_context
4027       (id, "Class `%s' can't be declared both abstract and final",
4028        IDENTIFIER_POINTER (raw_name));
4029
4030   /* Create a new decl if DECL is NULL, otherwise fix it */
4031   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4032
4033   /* If SUPER exists, use it, otherwise use Object */
4034   if (super)
4035     {
4036       /* java.lang.Object can't extend anything.  */
4037       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4038         {
4039           parse_error_context (id, "`java.lang.Object' can't extend anything");
4040           return NULL_TREE;
4041         }
4042
4043       super_decl_type =
4044         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4045     }
4046   else if (TREE_TYPE (decl) != object_type_node)
4047     super_decl_type = object_type_node;
4048   /* We're defining java.lang.Object */
4049   else
4050     super_decl_type = NULL_TREE;
4051
4052   /* A class nested in an interface is implicitly static. */
4053   if (INNER_CLASS_DECL_P (decl)
4054       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4055     {
4056       flags |= ACC_STATIC;
4057     }
4058
4059   /* Set super info and mark the class as complete. */
4060   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4061                   ctxp->interface_number);
4062   ctxp->interface_number = 0;
4063   CLASS_COMPLETE_P (decl) = 1;
4064   add_superinterfaces (decl, interfaces);
4065
4066   /* TYPE_VFIELD' is a compiler-generated field used to point to
4067      virtual function tables.  In gcj, every class has a common base
4068      virtual function table in java.lang.object.  */
4069   TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4070
4071   /* Add the private this$<n> field, Replicate final locals still in
4072      scope as private final fields mangled like val$<local_name>.
4073      This does not occur for top level (static) inner classes. */
4074   if (PURE_INNER_CLASS_DECL_P (decl))
4075     add_inner_class_fields (decl, current_function_decl);
4076
4077   /* If doing xref, store the location at which the inherited class
4078      (if any) was seen. */
4079   if (flag_emit_xref && super)
4080     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4081
4082   /* Eventually sets the @deprecated tag flag */
4083   CHECK_DEPRECATED (decl);
4084
4085   /* Reset the anonymous class counter when declaring non inner classes */
4086   if (!INNER_CLASS_DECL_P (decl))
4087     anonymous_class_counter = 1;
4088
4089   return decl;
4090 }
4091
4092 /* End a class declaration: register the statements used to create
4093    finit$ and <clinit>, pop the current class and resume the prior
4094    parser context if necessary.  */
4095
4096 static void
4097 end_class_declaration (int resume)
4098 {
4099   /* If an error occurred, context weren't pushed and won't need to be
4100      popped by a resume. */
4101   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4102
4103   if (GET_CPC () != error_mark_node)
4104     dump_java_tree (TDI_class, GET_CPC ());
4105
4106   java_parser_context_pop_initialized_field ();
4107   POP_CPC ();
4108   if (resume && no_error_occurred)
4109     java_parser_context_resume ();
4110
4111   /* We're ending a class declaration, this is a good time to reset
4112      the interface cout. Note that might have been already done in
4113      create_interface, but if at that time an inner class was being
4114      dealt with, the interface count was reset in a context created
4115      for the sake of handling inner classes declaration. */
4116   ctxp->interface_number = 0;
4117 }
4118
4119 static void
4120 add_inner_class_fields (tree class_decl, tree fct_decl)
4121 {
4122   tree block, marker, f;
4123
4124   f = add_field (TREE_TYPE (class_decl),
4125                  build_current_thisn (TREE_TYPE (class_decl)),
4126                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4127                  ACC_PRIVATE);
4128   FIELD_THISN (f) = 1;
4129
4130   if (!fct_decl)
4131     return;
4132
4133   for (block = GET_CURRENT_BLOCK (fct_decl);
4134        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4135     {
4136       tree decl;
4137       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4138         {
4139           tree name, pname;
4140           tree wfl, init, list;
4141
4142           /* Avoid non final arguments. */
4143           if (!LOCAL_FINAL_P (decl))
4144             continue;
4145
4146           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4147           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4148           wfl = build_wfl_node (name);
4149           init = build_wfl_node (pname);
4150           /* Build an initialization for the field: it will be
4151              initialized by a parameter added to finit$, bearing a
4152              mangled name of the field itself (param$<n>.) The
4153              parameter is provided to finit$ by the constructor
4154              invoking it (hence the constructor will also feature a
4155              hidden parameter, set to the value of the outer context
4156              local at the time the inner class is created.)
4157
4158              Note: we take into account all possible locals that can
4159              be accessed by the inner class. It's actually not trivial
4160              to minimize these aliases down to the ones really
4161              used. One way to do that would be to expand all regular
4162              methods first, then finit$ to get a picture of what's
4163              used.  It works with the exception that we would have to
4164              go back on all constructor invoked in regular methods to
4165              have their invocation reworked (to include the right amount
4166              of alias initializer parameters.)
4167
4168              The only real way around, I think, is a first pass to
4169              identify locals really used in the inner class. We leave
4170              the flag FIELD_LOCAL_ALIAS_USED around for that future
4171              use.
4172
4173              On the other hand, it only affect local inner classes,
4174              whose constructors (and finit$ call) will be featuring
4175              unnecessary arguments. It's easy for a developer to keep
4176              this number of parameter down by using the `final'
4177              keyword only when necessary. For the time being, we can
4178              issue a warning on unnecessary finals. FIXME */
4179           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4180                                    wfl, init);
4181
4182           /* Register the field. The TREE_LIST holding the part
4183              initialized/initializer will be marked ARG_FINAL_P so
4184              that the created field can be marked
4185              FIELD_LOCAL_ALIAS. */
4186           list = build_tree_list (wfl, init);
4187           ARG_FINAL_P (list) = 1;
4188           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4189         }
4190     }
4191
4192   if (!CPC_INITIALIZER_STMT (ctxp))
4193     return;
4194
4195   /* If we ever registered an alias field, insert and marker to
4196      remember where the list ends. The second part of the list (the one
4197      featuring initialized fields) so it can be later reversed to
4198      enforce 8.5. The marker will be removed during that operation. */
4199   marker = build_tree_list (NULL_TREE, NULL_TREE);
4200   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4201   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4202 }
4203
4204 /* Can't use lookup_field () since we don't want to load the class and
4205    can't set the CLASS_LOADED_P flag */
4206
4207 static tree
4208 find_field (tree class, tree name)
4209 {
4210   tree decl;
4211   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4212     {
4213       if (DECL_NAME (decl) == name)
4214         return decl;
4215     }
4216   return NULL_TREE;
4217 }
4218
4219 /* Wrap around lookup_field that doesn't potentially upset the value
4220    of CLASS */
4221
4222 static tree
4223 lookup_field_wrapper (tree class, tree name)
4224 {
4225   tree type = class;
4226   tree decl = NULL_TREE;
4227   java_parser_context_save_global ();
4228
4229   /* Last chance: if we're within the context of an inner class, we
4230      might be trying to access a local variable defined in an outer
4231      context. We try to look for it now. */
4232   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4233     {
4234       tree new_name;
4235       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4236       decl = lookup_field (&type, new_name);
4237       if (decl && decl != error_mark_node)
4238         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4239     }
4240   if (!decl || decl == error_mark_node)
4241     {
4242       type = class;
4243       decl = lookup_field (&type, name);
4244     }
4245
4246   /* If the field still hasn't been found, try the next enclosing context. */
4247   if (!decl && INNER_CLASS_TYPE_P (class))
4248     {
4249       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4250       decl = lookup_field_wrapper (outer_type, name);
4251     }
4252
4253   java_parser_context_restore_global ();
4254   return decl == error_mark_node ? NULL : decl;
4255 }
4256
4257 /* Find duplicate field within the same class declarations and report
4258    the error. Returns 1 if a duplicated field was found, 0
4259    otherwise.  */
4260
4261 static int
4262 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4263 {
4264   /* This might be modified to work with method decl as well */
4265   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4266   if (decl)
4267     {
4268       char *t1 = xstrdup (purify_type_name
4269                          ((TREE_CODE (new_type) == POINTER_TYPE
4270                            && TREE_TYPE (new_type) == NULL_TREE) ?
4271                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4272                           lang_printable_name (new_type, 1)));
4273       /* The type may not have been completed by the time we report
4274          the error */
4275       char *t2 = xstrdup (purify_type_name
4276                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4277                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4278                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4279                           lang_printable_name (TREE_TYPE (decl), 1)));
4280       parse_error_context
4281         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4282          t1, IDENTIFIER_POINTER (new_field_name),
4283          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4284          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4285       free (t1);
4286       free (t2);
4287       return 1;
4288     }
4289   return 0;
4290 }
4291
4292 /* Field registration routine. If TYPE doesn't exist, field
4293    declarations are linked to the undefined TYPE dependency list, to
4294    be later resolved in java_complete_class () */
4295
4296 static void
4297 register_fields (int flags, tree type, tree variable_list)
4298 {
4299   tree current, saved_type;
4300   tree class_type = NULL_TREE;
4301   int saved_lineno = input_line;
4302   int must_chain = 0;
4303   tree wfl = NULL_TREE;
4304
4305   if (GET_CPC ())
4306     class_type = TREE_TYPE (GET_CPC ());
4307
4308   if (!class_type || class_type == error_mark_node)
4309     return;
4310
4311   /* If we're adding fields to interfaces, those fields are public,
4312      static, final */
4313   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4314     {
4315       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4316                                  flags, ACC_PUBLIC, "interface field(s)");
4317       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4318                                  flags, ACC_STATIC, "interface field(s)");
4319       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4320                                  flags, ACC_FINAL, "interface field(s)");
4321       check_modifiers ("Illegal interface member modifier `%s'", flags,
4322                        INTERFACE_FIELD_MODIFIERS);
4323       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4324     }
4325
4326   /* Obtain a suitable type for resolution, if necessary */
4327   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4328
4329   /* If TYPE is fully resolved and we don't have a reference, make one */
4330   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4331
4332   for (current = variable_list, saved_type = type; current;
4333        current = TREE_CHAIN (current), type = saved_type)
4334     {
4335       tree real_type;
4336       tree field_decl;
4337       tree cl = TREE_PURPOSE (current);
4338       tree init = TREE_VALUE (current);
4339       tree current_name = EXPR_WFL_NODE (cl);
4340
4341       /* Can't declare non-final static fields in inner classes */
4342       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4343           && !(flags & ACC_FINAL))
4344         parse_error_context
4345           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4346            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4347            lang_printable_name (class_type, 0));
4348
4349       /* Process NAME, as it may specify extra dimension(s) for it */
4350       type = build_array_from_name (type, wfl, current_name, &current_name);
4351
4352       /* Type adjustment. We may have just readjusted TYPE because
4353          the variable specified more dimensions. Make sure we have
4354          a reference if we can and don't have one already. Also
4355          change the name if we have an init. */
4356       if (type != saved_type)
4357         {
4358           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4359           if (init)
4360             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4361         }
4362
4363       real_type = GET_REAL_TYPE (type);
4364       /* Check for redeclarations */
4365       if (duplicate_declaration_error_p (current_name, real_type, cl))
4366         continue;
4367
4368       /* Set input_line to the line the field was found and create a
4369          declaration for it. Eventually sets the @deprecated tag flag. */
4370       if (flag_emit_xref)
4371         input_line = EXPR_WFL_LINECOL (cl);
4372       else
4373         input_line = EXPR_WFL_LINENO (cl);
4374       field_decl = add_field (class_type, current_name, real_type, flags);
4375       CHECK_DEPRECATED_NO_RESET (field_decl);
4376
4377       /* If the field denotes a final instance variable, then we
4378          allocate a LANG_DECL_SPECIFIC part to keep track of its
4379          initialization. We also mark whether the field was
4380          initialized upon its declaration. We don't do that if the
4381          created field is an alias to a final local. */
4382       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4383         {
4384           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4385           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4386         }
4387
4388       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4389          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4390          hide parameters to this inner class finit$ and
4391          constructors. It also means that the field isn't final per
4392          say. */
4393       if (ARG_FINAL_P (current))
4394         {
4395           FIELD_LOCAL_ALIAS (field_decl) = 1;
4396           FIELD_FINAL (field_decl) = 0;
4397         }
4398
4399       /* Check if we must chain. */
4400       if (must_chain)
4401         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4402
4403       /* If we have an initialization value tied to the field */
4404       if (init)
4405         {
4406           /* The field is declared static */
4407           if (flags & ACC_STATIC)
4408             {
4409               /* We include the field and its initialization part into
4410                  a list used to generate <clinit>. After <clinit> is
4411                  walked, field initializations will be processed and
4412                  fields initialized with known constants will be taken
4413                  out of <clinit> and have their DECL_INITIAL set
4414                  appropriately. */
4415               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4416               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4417               if (TREE_OPERAND (init, 1)
4418                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4419                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4420             }
4421           /* A non-static field declared with an immediate initialization is
4422              to be initialized in <init>, if any.  This field is remembered
4423              to be processed at the time of the generation of <init>. */
4424           else
4425             {
4426               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4427               SET_CPC_INITIALIZER_STMT (ctxp, init);
4428             }
4429           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4430           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4431         }
4432     }
4433
4434   CLEAR_DEPRECATED;
4435   input_line = saved_lineno;
4436 }
4437
4438 /* Generate finit$, using the list of initialized fields to populate
4439    its body. finit$'s parameter(s) list is adjusted to include the
4440    one(s) used to initialized the field(s) caching outer context
4441    local(s).  */
4442
4443 static tree
4444 generate_finit (tree class_type)
4445 {
4446   int count = 0;
4447   tree list = TYPE_FINIT_STMT_LIST (class_type);
4448   tree mdecl, current, parms;
4449
4450   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4451                                                   class_type, NULL_TREE,
4452                                                   &count);
4453   CRAFTED_PARAM_LIST_FIXUP (parms);
4454   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4455                                     finit_identifier_node, parms);
4456   fix_method_argument_names (parms, mdecl);
4457   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4458                        mdecl, NULL_TREE);
4459   DECL_FUNCTION_NAP (mdecl) = count;
4460   start_artificial_method_body (mdecl);
4461
4462   for (current = list; current; current = TREE_CHAIN (current))
4463     java_method_add_stmt (mdecl,
4464                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4465                                                 current));
4466   end_artificial_method_body (mdecl);
4467   return mdecl;
4468 }
4469
4470 /* Generate a function to run the instance initialization code. The
4471    private method is called `instinit$'. Unless we're dealing with an
4472    anonymous class, we determine whether all ctors of CLASS_TYPE
4473    declare a checked exception in their `throws' clause in order to
4474    see whether it's necessary to encapsulate the instance initializer
4475    statements in a try/catch/rethrow sequence.  */
4476
4477 static tree
4478 generate_instinit (tree class_type)
4479 {
4480   tree current;
4481   tree compound = NULL_TREE;
4482   tree parms = tree_cons (this_identifier_node,
4483                           build_pointer_type (class_type), end_params_node);
4484   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4485                                          void_type_node,
4486                                          instinit_identifier_node, parms);
4487
4488   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4489                        mdecl, NULL_TREE);
4490
4491   /* Gather all the statements in a compound */
4492   for (current = TYPE_II_STMT_LIST (class_type);
4493        current; current = TREE_CHAIN (current))
4494     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4495
4496   /* We need to encapsulate COMPOUND by a try/catch statement to
4497      rethrow exceptions that might occur in the instance initializer.
4498      We do that only if all ctors of CLASS_TYPE are set to catch a
4499      checked exception. This doesn't apply to anonymous classes (since
4500      they don't have declared ctors.) */
4501   if (!ANONYMOUS_CLASS_P (class_type) &&
4502       ctors_unchecked_throws_clause_p (class_type))
4503     {
4504       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4505                                              build1 (THROW_EXPR, NULL_TREE,
4506                                                      build_wfl_node (wpv_id)));
4507       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4508                                                       exception_type_node);
4509     }
4510
4511   start_artificial_method_body (mdecl);
4512   java_method_add_stmt (mdecl, compound);
4513   end_artificial_method_body (mdecl);
4514
4515   return mdecl;
4516 }
4517
4518 /* FIXME */
4519 static tree
4520 build_instinit_invocation (tree class_type)
4521 {
4522   tree to_return = NULL_TREE;
4523
4524   if (TYPE_II_STMT_LIST (class_type))
4525     {
4526       tree parm = build_tree_list (NULL_TREE,
4527                                    build_wfl_node (this_identifier_node));
4528       to_return =
4529         build_method_invocation (build_wfl_node (instinit_identifier_node),
4530                                  parm);
4531     }
4532   return to_return;
4533 }
4534
4535 /* Shared across method_declarator and method_header to remember the
4536    patch stage that was reached during the declaration of the method.
4537    A method DECL is built differently is there is no patch
4538    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4539    pending on the currently defined method.  */
4540
4541 static int patch_stage;
4542
4543 /* Check the method declaration and add the method to its current
4544    class.  If the argument list is known to contain incomplete types,
4545    the method is partially added and the registration will be resume
4546    once the method arguments resolved. If TYPE is NULL, we're dealing
4547    with a constructor.  */
4548
4549 static tree
4550 method_header (int flags, tree type, tree mdecl, tree throws)
4551 {
4552   tree type_wfl = NULL_TREE;
4553   tree meth_name = NULL_TREE;
4554   tree current, orig_arg, this_class = NULL;
4555   tree id, meth;
4556   int saved_lineno;
4557   int constructor_ok = 0, must_chain;
4558   int count;
4559
4560   if (mdecl == error_mark_node)
4561     return error_mark_node;
4562   meth = TREE_VALUE (mdecl);
4563   id = TREE_PURPOSE (mdecl);
4564
4565   check_modifiers_consistency (flags);
4566
4567   if (GET_CPC ())
4568     this_class = TREE_TYPE (GET_CPC ());
4569
4570   if (!this_class || this_class == error_mark_node)
4571     return NULL_TREE;
4572
4573   /* There are some forbidden modifiers for an abstract method and its
4574      class must be abstract as well.  */
4575   if (type && (flags & ACC_ABSTRACT))
4576     {
4577       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4578       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4579       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4580       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4581       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4582       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4583       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4584           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4585         parse_error_context
4586           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4587            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4588            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4589     }
4590
4591   /* A native method can't be strictfp.  */
4592   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4593     parse_error_context (id, "native method `%s' can't be strictfp",
4594                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4595   /* No such thing as a transient or volatile method.  */
4596   if ((flags & ACC_TRANSIENT))
4597     parse_error_context (id, "method `%s' can't be transient",
4598                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4599   if ((flags & ACC_VOLATILE))
4600     parse_error_context (id, "method `%s' can't be volatile",
4601                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4602
4603   /* Things to be checked when declaring a constructor */
4604   if (!type)
4605     {
4606       int ec = java_error_count;
4607       /* 8.6: Constructor declarations: we might be trying to define a
4608          method without specifying a return type. */
4609       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4610         parse_error_context
4611           (id, "Invalid method declaration, return type required");
4612       /* 8.6.3: Constructor modifiers */
4613       else
4614         {
4615           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4616           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4617           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4618           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4619           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4620           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4621         }
4622       /* If we found error here, we don't consider it's OK to tread
4623          the method definition as a constructor, for the rest of this
4624          function */
4625       if (ec == java_error_count)
4626         constructor_ok = 1;
4627     }
4628
4629   /* Method declared within the scope of an interface are implicitly
4630      abstract and public. Conflicts with other erroneously provided
4631      modifiers are checked right after. */
4632
4633   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4634     {
4635       /* If FLAGS isn't set because of a modifier, turn the
4636          corresponding modifier WFL to NULL so we issue a warning on
4637          the obsolete use of the modifier */
4638       if (!(flags & ACC_PUBLIC))
4639         MODIFIER_WFL (PUBLIC_TK) = NULL;
4640       if (!(flags & ACC_ABSTRACT))
4641         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4642       flags |= ACC_PUBLIC;
4643       flags |= ACC_ABSTRACT;
4644     }
4645
4646   /* Inner class can't declare static methods */
4647   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4648     {
4649       parse_error_context
4650         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4651          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4652          lang_printable_name (this_class, 0));
4653     }
4654
4655   /* Modifiers context reset moved up, so abstract method declaration
4656      modifiers can be later checked.  */
4657
4658   /* Set constructor returned type to void and method name to <init>,
4659      unless we found an error identifier the constructor (in which
4660      case we retain the original name) */
4661   if (!type)
4662     {
4663       type = void_type_node;
4664       if (constructor_ok)
4665         meth_name = init_identifier_node;
4666     }
4667   else
4668     meth_name = EXPR_WFL_NODE (id);
4669
4670   /* Do the returned type resolution and registration if necessary */
4671   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4672
4673   if (meth_name)
4674     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4675   EXPR_WFL_NODE (id) = meth_name;
4676   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4677
4678   if (must_chain)
4679     {
4680       patch_stage = JDEP_METHOD_RETURN;
4681       register_incomplete_type (patch_stage, type_wfl, id, type);
4682       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4683     }
4684   else
4685     TREE_TYPE (meth) = type;
4686
4687   saved_lineno = input_line;
4688   /* When defining an abstract or interface method, the curly
4689      bracket at level 1 doesn't exist because there is no function
4690      body */
4691   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4692             EXPR_WFL_LINENO (id));
4693
4694   /* Remember the original argument list */
4695   orig_arg = TYPE_ARG_TYPES (meth);
4696
4697   if (patch_stage)              /* includes ret type and/or all args */
4698     {
4699       jdep *jdep;
4700       meth = add_method_1 (this_class, flags, meth_name, meth);
4701       /* Patch for the return type */
4702       if (patch_stage == JDEP_METHOD_RETURN)
4703         {
4704           jdep = CLASSD_LAST (ctxp->classd_list);
4705           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4706         }
4707       /* This is the stop JDEP. METH allows the function's signature
4708          to be computed. */
4709       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4710     }
4711   else
4712     meth = add_method (this_class, flags, meth_name,
4713                        build_java_signature (meth));
4714
4715   /* Remember final parameters */
4716   MARK_FINAL_PARMS (meth, orig_arg);
4717
4718   /* Fix the method argument list so we have the argument name
4719      information */
4720   fix_method_argument_names (orig_arg, meth);
4721
4722   /* Register the parameter number and re-install the current line
4723      number */
4724   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4725   input_line = saved_lineno;
4726
4727   /* Register exception specified by the `throws' keyword for
4728      resolution and set the method decl appropriate field to the list.
4729      Note: the grammar ensures that what we get here are class
4730      types. */
4731   if (throws)
4732     {
4733       throws = nreverse (throws);
4734       for (current = throws; current; current = TREE_CHAIN (current))
4735         {
4736           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4737                                     NULL_TREE, NULL_TREE);
4738           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4739             &TREE_VALUE (current);
4740         }
4741       DECL_FUNCTION_THROWS (meth) = throws;
4742     }
4743
4744   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4745     DECL_FUNCTION_WFL (meth) = id;
4746
4747   /* Set the flag if we correctly processed a constructor */
4748   if (constructor_ok)
4749     {
4750       DECL_CONSTRUCTOR_P (meth) = 1;
4751       /* Compute and store the number of artificial parameters declared
4752          for this constructor */
4753       for (count = 0, current = TYPE_FIELDS (this_class); current;
4754            current = TREE_CHAIN (current))
4755         if (FIELD_LOCAL_ALIAS (current))
4756           count++;
4757       DECL_FUNCTION_NAP (meth) = count;
4758     }
4759
4760   /* Eventually set the @deprecated tag flag */
4761   CHECK_DEPRECATED (meth);
4762
4763   /* If doing xref, store column and line number information instead
4764      of the line number only. */
4765   if (flag_emit_xref)
4766     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4767
4768   return meth;
4769 }
4770
4771 static void
4772 fix_method_argument_names (tree orig_arg, tree meth)
4773 {
4774   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4775   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4776     {
4777       TREE_PURPOSE (arg) = this_identifier_node;
4778       arg = TREE_CHAIN (arg);
4779     }
4780   while (orig_arg != end_params_node)
4781     {
4782       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4783       orig_arg = TREE_CHAIN (orig_arg);
4784       arg = TREE_CHAIN (arg);
4785     }
4786 }
4787
4788 /* Complete the method declaration with METHOD_BODY.  */
4789
4790 static void
4791 finish_method_declaration (tree method_body)
4792 {
4793   int flags;
4794
4795   if (!current_function_decl)
4796     return;
4797
4798   flags = get_access_flags_from_decl (current_function_decl);
4799
4800   /* 8.4.5 Method Body */
4801   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4802     {
4803       tree name = DECL_NAME (current_function_decl);
4804       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4805                            "%s method `%s' can't have a body defined",
4806                            (METHOD_NATIVE (current_function_decl) ?
4807                             "Native" : "Abstract"),
4808                            IDENTIFIER_POINTER (name));
4809       method_body = NULL_TREE;
4810     }
4811   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4812     {
4813       tree name = DECL_NAME (current_function_decl);
4814       parse_error_context
4815         (DECL_FUNCTION_WFL (current_function_decl),
4816          "Non native and non abstract method `%s' must have a body defined",
4817          IDENTIFIER_POINTER (name));
4818       method_body = NULL_TREE;
4819     }
4820
4821   if (flag_emit_class_files && method_body
4822       && TREE_CODE (method_body) == NOP_EXPR
4823       && TREE_TYPE (current_function_decl)
4824       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4825     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4826
4827   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4828   maybe_absorb_scoping_blocks ();
4829   /* Exit function's body */
4830   exit_block ();
4831   /* Merge last line of the function with first line, directly in the
4832      function decl. It will be used to emit correct debug info. */
4833   if (!flag_emit_xref)
4834     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4835
4836   /* Since function's argument's list are shared, reset the
4837      ARG_FINAL_P parameter that might have been set on some of this
4838      function parameters. */
4839   UNMARK_FINAL_PARMS (current_function_decl);
4840
4841   /* So we don't have an irrelevant function declaration context for
4842      the next static block we'll see. */
4843   current_function_decl = NULL_TREE;
4844 }
4845
4846 /* Build a an error message for constructor circularity errors.  */
4847
4848 static char *
4849 constructor_circularity_msg (tree from, tree to)
4850 {
4851   static char string [4096];
4852   char *t = xstrdup (lang_printable_name (from, 2));
4853   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 2));
4854   free (t);
4855   return string;
4856 }
4857
4858 /* Verify a circular call to METH. Return 1 if an error is found, 0
4859    otherwise.  */
4860
4861 static GTY(()) tree vcc_list;
4862 static int
4863 verify_constructor_circularity (tree meth, tree current)
4864 {
4865   tree c;
4866
4867   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4868     {
4869       if (TREE_VALUE (c) == meth)
4870         {
4871           char *t;
4872           if (vcc_list)
4873             {
4874               tree liste;
4875               vcc_list = nreverse (vcc_list);
4876               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4877                 {
4878                   parse_error_context
4879                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4880                      constructor_circularity_msg
4881                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4882                   java_error_count--;
4883                 }
4884             }
4885           t = xstrdup (lang_printable_name (meth, 2));
4886           parse_error_context (TREE_PURPOSE (c),
4887                                "%s: recursive invocation of constructor `%s'",
4888                                constructor_circularity_msg (current, meth), t);
4889           free (t);
4890           vcc_list = NULL_TREE;
4891           return 1;
4892         }
4893     }
4894   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4895     {
4896       vcc_list = tree_cons (c, current, vcc_list);
4897       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4898         return 1;
4899       vcc_list = TREE_CHAIN (vcc_list);
4900     }
4901   return 0;
4902 }
4903
4904 /* Check modifiers that can be declared but exclusively */
4905
4906 static void
4907 check_modifiers_consistency (int flags)
4908 {
4909   int acc_count = 0;
4910   tree cl = NULL_TREE;
4911
4912   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4913   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4914   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4915   if (acc_count > 1)
4916     parse_error_context
4917       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4918
4919   acc_count = 0;
4920   cl = NULL_TREE;
4921   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4922   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4923   if (acc_count > 1)
4924     parse_error_context (cl,
4925                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4926 }
4927
4928 /* Check the methode header METH for abstract specifics features */
4929
4930 static void
4931 check_abstract_method_header (tree meth)
4932 {
4933   int flags = get_access_flags_from_decl (meth);
4934
4935   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4936                               ACC_ABSTRACT, "abstract method",
4937                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4938   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4939                               ACC_PUBLIC, "abstract method",
4940                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4941
4942   check_modifiers ("Illegal modifier `%s' for interface method",
4943                   flags, INTERFACE_METHOD_MODIFIERS);
4944 }
4945
4946 /* Create a FUNCTION_TYPE node and start augmenting it with the
4947    declared function arguments. Arguments type that can't be resolved
4948    are left as they are, but the returned node is marked as containing
4949    incomplete types.  */
4950
4951 static tree
4952 method_declarator (tree id, tree list)
4953 {
4954   tree arg_types = NULL_TREE, current, node;
4955   tree meth = make_node (FUNCTION_TYPE);
4956   jdep *jdep;
4957
4958   patch_stage = JDEP_NO_PATCH;
4959
4960   if (GET_CPC () == error_mark_node)
4961     return error_mark_node;
4962
4963   /* If we're dealing with an inner class constructor, we hide the
4964      this$<n> decl in the name field of its parameter declaration.  We
4965      also might have to hide the outer context local alias
4966      initializers. Not done when the class is a toplevel class. */
4967   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4968       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4969     {
4970       tree aliases_list, type, thisn;
4971       /* First the aliases, linked to the regular parameters */
4972       aliases_list =
4973         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4974                                                 TREE_TYPE (GET_CPC ()),
4975                                                 NULL_TREE, NULL);
4976       list = chainon (nreverse (aliases_list), list);
4977
4978       /* Then this$<n> */
4979       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4980       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4981       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4982                         list);
4983     }
4984
4985   for (current = list; current; current = TREE_CHAIN (current))
4986     {
4987       int must_chain = 0;
4988       tree wfl_name = TREE_PURPOSE (current);
4989       tree type = TREE_VALUE (current);
4990       tree name = EXPR_WFL_NODE (wfl_name);
4991       tree already, arg_node;
4992       tree type_wfl = NULL_TREE;
4993       tree real_type;
4994
4995       /* Obtain a suitable type for resolution, if necessary */
4996       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4997
4998       /* Process NAME, as it may specify extra dimension(s) for it */
4999       type = build_array_from_name (type, type_wfl, name, &name);
5000       EXPR_WFL_NODE (wfl_name) = name;
5001
5002       real_type = GET_REAL_TYPE (type);
5003       if (TREE_CODE (real_type) == RECORD_TYPE)
5004         {
5005           real_type = promote_type (real_type);
5006           if (TREE_CODE (type) == TREE_LIST)
5007             TREE_PURPOSE (type) = real_type;
5008         }
5009
5010       /* Check redefinition */
5011       for (already = arg_types; already; already = TREE_CHAIN (already))
5012         if (TREE_PURPOSE (already) == name)
5013           {
5014             parse_error_context
5015               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
5016                IDENTIFIER_POINTER (name),
5017                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
5018             break;
5019           }
5020
5021       /* If we've an incomplete argument type, we know there is a location
5022          to patch when the type get resolved, later.  */
5023       jdep = NULL;
5024       if (must_chain)
5025         {
5026           patch_stage = JDEP_METHOD;
5027           type = register_incomplete_type (patch_stage,
5028                                            type_wfl, wfl_name, type);
5029           jdep = CLASSD_LAST (ctxp->classd_list);
5030           JDEP_MISC (jdep) = id;
5031         }
5032
5033       /* The argument node: a name and a (possibly) incomplete type.  */
5034       arg_node = build_tree_list (name, real_type);
5035       /* Remember arguments declared final. */
5036       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5037
5038       if (jdep)
5039         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5040       TREE_CHAIN (arg_node) = arg_types;
5041       arg_types = arg_node;
5042     }
5043   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5044   node = build_tree_list (id, meth);
5045   return node;
5046 }
5047
5048 static int
5049 unresolved_type_p (tree wfl, tree *returned)
5050 {
5051   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5052     {
5053       if (returned)
5054         {
5055           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5056           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5057             *returned = TREE_TYPE (decl);
5058           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5059             *returned = TREE_TYPE (GET_CPC ());
5060           else
5061             *returned = NULL_TREE;
5062         }
5063       return 1;
5064     }
5065   if (returned)
5066     *returned = wfl;
5067   return 0;
5068 }
5069
5070 /* From NAME, build a qualified identifier node using the
5071    qualification from the current package definition. */
5072
5073 static tree
5074 parser_qualified_classname (tree name)
5075 {
5076   tree nested_class_name;
5077
5078   if ((nested_class_name = maybe_make_nested_class_name (name)))
5079     return nested_class_name;
5080
5081   if (ctxp->package)
5082     return merge_qualified_name (ctxp->package, name);
5083   else
5084     return name;
5085 }
5086
5087 /* Called once the type a interface extends is resolved. Returns 0 if
5088    everything is OK.  */
5089
5090 static int
5091 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5092 {
5093   tree super_type = TREE_TYPE (super_decl);
5094
5095   /* Has to be an interface */
5096   if (!CLASS_INTERFACE (super_decl))
5097     {
5098       parse_error_context
5099         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5100          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5101           "Interface" : "Class"),
5102          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5103          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5104          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5105       return 1;
5106     }
5107
5108   /* Check top-level interface access. Inner classes are subject to member
5109      access rules (6.6.1). */
5110   if (! INNER_CLASS_P (super_type)
5111       && check_pkg_class_access (DECL_NAME (super_decl),
5112                                  NULL_TREE, true, this_decl))
5113     return 1;
5114
5115   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5116                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5117                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5118   return 0;
5119 }
5120
5121 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5122    0 if everything is OK.  */
5123
5124 static int
5125 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5126 {
5127   tree super_type = TREE_TYPE (super_decl);
5128
5129   /* SUPER should be a CLASS (neither an array nor an interface) */
5130   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5131     {
5132       parse_error_context
5133         (wfl, "Class `%s' can't subclass %s `%s'",
5134          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5135          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5136          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5137       return 1;
5138     }
5139
5140   if (CLASS_FINAL (TYPE_NAME (super_type)))
5141     {
5142       parse_error_context (wfl, "Can't subclass final classes: %s",
5143                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5144       return 1;
5145     }
5146
5147   /* Check top-level class scope. Inner classes are subject to member access
5148      rules (6.6.1). */
5149   if (! INNER_CLASS_P (super_type)
5150       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5151     return 1;
5152
5153   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5154                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5155                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5156   return 0;
5157 }
5158
5159 /* Create a new dependency list and link it (in a LIFO manner) to the
5160    CTXP list of type dependency list.  */
5161
5162 static void
5163 create_jdep_list (struct parser_ctxt *ctxp)
5164 {
5165   jdeplist *new = xmalloc (sizeof (jdeplist));
5166   new->first = new->last = NULL;
5167   new->next = ctxp->classd_list;
5168   ctxp->classd_list = new;
5169 }
5170
5171 static jdeplist *
5172 reverse_jdep_list (struct parser_ctxt *ctxp)
5173 {
5174   jdeplist *prev = NULL, *current, *next;
5175   for (current = ctxp->classd_list; current; current = next)
5176     {
5177       next = current->next;
5178       current->next = prev;
5179       prev = current;
5180     }
5181   return prev;
5182 }
5183
5184 /* Create a fake pointer based on the ID stored in
5185    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5186    registered again. */
5187
5188 static tree
5189 obtain_incomplete_type (tree type_name)
5190 {
5191   tree ptr = NULL_TREE, name;
5192
5193   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5194     name = EXPR_WFL_NODE (type_name);
5195   else if (INCOMPLETE_TYPE_P (type_name))
5196     name = TYPE_NAME (type_name);
5197   else
5198     abort ();
5199
5200   /* Workaround from build_pointer_type for incomplete types.  */
5201   BUILD_PTR_FROM_NAME (ptr, name);
5202   TYPE_MODE (ptr) = ptr_mode;
5203   layout_type (ptr);
5204
5205   return ptr;
5206 }
5207
5208 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5209    non NULL instead of computing a new fake type based on WFL. The new
5210    dependency is inserted in the current type dependency list, in FIFO
5211    manner.  */
5212
5213 static tree
5214 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5215 {
5216   jdep *new = xmalloc (sizeof (jdep));
5217
5218   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5219     ptr = obtain_incomplete_type (wfl);
5220
5221   JDEP_KIND (new) = kind;
5222   JDEP_DECL (new) = decl;
5223   JDEP_TO_RESOLVE (new) = ptr;
5224   JDEP_WFL (new) = wfl;
5225   JDEP_CHAIN (new) = NULL;
5226   JDEP_MISC (new) = NULL_TREE;
5227   /* For some dependencies, set the enclosing class of the current
5228      class to be the enclosing context */
5229   if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
5230       && GET_ENCLOSING_CPC ())
5231     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5232   else
5233     JDEP_ENCLOSING (new) = GET_CPC ();
5234   JDEP_GET_PATCH (new) = (tree *)NULL;
5235
5236   JDEP_INSERT (ctxp->classd_list, new);
5237
5238   return ptr;
5239 }
5240
5241 /* This checks for circular references with innerclasses. We start
5242    from SOURCE and should never reach TARGET. Extended/implemented
5243    types in SOURCE have their enclosing context checked not to reach
5244    TARGET. When the last enclosing context of SOURCE is reached, its
5245    extended/implemented types are also checked not to reach TARGET.
5246    In case of error, WFL of the offending type is returned; NULL_TREE
5247    otherwise.  */
5248
5249 static tree
5250 check_inner_circular_reference (tree source, tree target)
5251 {
5252   tree base_binfo;
5253   tree ctx, cl;
5254   int i;
5255
5256   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (source), i, base_binfo); i++)
5257     {
5258       tree su;
5259
5260       /* We can end up with a NULL_TREE or an incomplete type here if
5261          we encountered previous type resolution errors. It's safe to
5262          simply ignore these cases.  */
5263       su = BINFO_TYPE (base_binfo);
5264       if (INCOMPLETE_TYPE_P (su))
5265         continue;
5266
5267       if (inherits_from_p (su, target))
5268         return lookup_cl (TYPE_NAME (su));
5269
5270       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5271         {
5272           /* An enclosing context shouldn't be TARGET */
5273           if (ctx == TYPE_NAME (target))
5274             return lookup_cl (TYPE_NAME (su));
5275
5276           /* When we reach the enclosing last context, start a check
5277              on it, with the same target */
5278           if (! DECL_CONTEXT (ctx) &&
5279               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5280             return cl;
5281         }
5282     }
5283   return NULL_TREE;
5284 }
5285
5286 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5287    offending type if a circularity is detected. NULL_TREE is returned
5288    otherwise. TYPE can be an interface or a class.   */
5289
5290 static tree
5291 check_circular_reference (tree type)
5292 {
5293   tree base_binfo;
5294   int i;
5295
5296   if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
5297     return NULL_TREE;
5298
5299   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5300     {
5301       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5302         return lookup_cl (TYPE_NAME (type));
5303       return NULL_TREE;
5304     }
5305
5306   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo); i++)
5307     {
5308       if (BINFO_TYPE (base_binfo) != object_type_node
5309           && interface_of_p (type, BINFO_TYPE (base_binfo)))
5310         return lookup_cl (TYPE_NAME (BINFO_TYPE (base_binfo)));
5311     }
5312   return NULL_TREE;
5313 }
5314
5315 void
5316 java_check_circular_reference (void)
5317 {
5318   tree current;
5319   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5320     {
5321       tree type = TREE_TYPE (current);
5322       tree cl;
5323
5324       cl = check_circular_reference (type);
5325       if (! cl)
5326         cl = check_inner_circular_reference (type, type);
5327       if (cl)
5328         parse_error_context (cl, "Cyclic class inheritance%s",
5329                              (cyclic_inheritance_report ?
5330                               cyclic_inheritance_report : ""));
5331     }
5332 }
5333
5334 /* Augment the parameter list PARM with parameters crafted to
5335    initialize outer context locals aliases. Through ARTIFICIAL, a
5336    count is kept of the number of crafted parameters. MODE governs
5337    what eventually gets created: something suitable for a function
5338    creation or a function invocation, either the constructor or
5339    finit$.  */
5340
5341 static tree
5342 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5343                                         int *artificial)
5344 {
5345   tree field;
5346   tree additional_parms = NULL_TREE;
5347
5348   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5349     if (FIELD_LOCAL_ALIAS (field))
5350       {
5351         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5352         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5353         tree mangled_id;
5354
5355         switch (mode)
5356           {
5357           case AIPL_FUNCTION_DECLARATION:
5358             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5359                                                          &buffer [4]);
5360             purpose = build_wfl_node (mangled_id);
5361             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5362               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5363             else
5364               value = TREE_TYPE (field);
5365             break;
5366
5367           case AIPL_FUNCTION_CREATION:
5368             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5369                                                          &buffer [4]);
5370             value = TREE_TYPE (field);
5371             break;
5372
5373           case AIPL_FUNCTION_FINIT_INVOCATION:
5374             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5375                                                          &buffer [4]);
5376             /* Now, this is wrong. purpose should always be the NAME
5377                of something and value its matching value (decl, type,
5378                etc...) FIXME -- but there is a lot to fix. */
5379
5380             /* When invoked for this kind of operation, we already
5381                know whether a field is used or not. */
5382             purpose = TREE_TYPE (field);
5383             value = build_wfl_node (mangled_id);
5384             break;
5385
5386           case AIPL_FUNCTION_CTOR_INVOCATION:
5387             /* There are two case: the constructor invocation happens
5388                outside the local inner, in which case, locales from the outer
5389                context are directly used.
5390
5391                Otherwise, we fold to using the alias directly. */
5392             if (class_type == current_class)
5393               value = field;
5394             else
5395               {
5396                 name = get_identifier (&buffer[4]);
5397                 value = IDENTIFIER_LOCAL_VALUE (name);
5398               }
5399             break;
5400           }
5401         additional_parms = tree_cons (purpose, value, additional_parms);
5402         if (artificial)
5403           *artificial +=1;
5404       }
5405   if (additional_parms)
5406     {
5407       if (ANONYMOUS_CLASS_P (class_type)
5408           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5409         additional_parms = nreverse (additional_parms);
5410       parm = chainon (additional_parms, parm);
5411     }
5412
5413    return parm;
5414 }
5415
5416 /* Craft a constructor for CLASS_DECL -- what we should do when none
5417    where found. ARGS is non NULL when a special signature must be
5418    enforced. This is the case for anonymous classes.  */
5419
5420 static tree
5421 craft_constructor (tree class_decl, tree args)
5422 {
5423   tree class_type = TREE_TYPE (class_decl);
5424   tree parm = NULL_TREE;
5425   /* Inherit access flags for the constructor from its enclosing class. */
5426   int valid_ctor_flags = ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE;
5427   int flags = (get_access_flags_from_decl (class_decl) & valid_ctor_flags);
5428   int i = 0, artificial = 0;
5429   tree decl, ctor_name;
5430   char buffer [80];
5431
5432   ctor_name = init_identifier_node;
5433
5434   /* If we're dealing with an inner class constructor, we hide the
5435      this$<n> decl in the name field of its parameter declaration. */
5436   if (PURE_INNER_CLASS_TYPE_P (class_type))
5437     {
5438       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5439       parm = tree_cons (build_current_thisn (class_type),
5440                         build_pointer_type (type), parm);
5441
5442       /* Some more arguments to be hidden here. The values of the local
5443          variables of the outer context that the inner class needs to see. */
5444       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5445                                                      class_type, parm,
5446                                                      &artificial);
5447     }
5448
5449   /* Then if there are any args to be enforced, enforce them now */
5450   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5451     {
5452       sprintf (buffer, "parm%d", i++);
5453       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5454     }
5455
5456   CRAFTED_PARAM_LIST_FIXUP (parm);
5457   decl = create_artificial_method (class_type, flags, void_type_node,
5458                                    ctor_name, parm);
5459   fix_method_argument_names (parm, decl);
5460   /* Now, mark the artificial parameters. */
5461   DECL_FUNCTION_NAP (decl) = artificial;
5462   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5463   DECL_INLINE (decl) = 1;
5464   return decl;
5465 }
5466
5467
5468 /* Fix the constructors. This will be called right after circular
5469    references have been checked. It is necessary to fix constructors
5470    early even if no code generation will take place for that class:
5471    some generated constructor might be required by the class whose
5472    compilation triggered this one to be simply loaded.  */
5473
5474 void
5475 java_fix_constructors (void)
5476 {
5477   tree current;
5478
5479   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5480     {
5481       tree class_type = TREE_TYPE (current);
5482       int saw_ctor = 0;
5483       tree decl;
5484
5485       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5486         continue;
5487
5488       output_class = current_class = class_type;
5489       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5490         {
5491           if (DECL_CONSTRUCTOR_P (decl))
5492             {
5493               fix_constructors (decl);
5494               saw_ctor = 1;
5495             }
5496         }
5497
5498       /* Anonymous class constructor can't be generated that early. */
5499       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5500         craft_constructor (current, NULL_TREE);
5501     }
5502 }
5503
5504 /* safe_layout_class just makes sure that we can load a class without
5505    disrupting the current_class, input_file, input_line, etc, information
5506    about the class processed currently.  */
5507
5508 void
5509 safe_layout_class (tree class)
5510 {
5511   tree save_current_class = current_class;
5512   location_t save_location = input_location;
5513
5514   layout_class (class);
5515
5516   current_class = save_current_class;
5517   input_location = save_location;
5518 }
5519
5520 static tree
5521 jdep_resolve_class (jdep *dep)
5522 {
5523   tree decl;
5524
5525   if (JDEP_RESOLVED_P (dep))
5526     decl = JDEP_RESOLVED_DECL (dep);
5527   else
5528     {
5529       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5530                             JDEP_DECL (dep), JDEP_WFL (dep));
5531       JDEP_RESOLVED (dep, decl);
5532       /* If there is no WFL, that's ok.  We generate this warning
5533          elsewhere.  */
5534       if (decl && JDEP_WFL (dep) != NULL_TREE)
5535         check_deprecation (JDEP_WFL (dep), decl);
5536     }
5537
5538   if (!decl)
5539     complete_class_report_errors (dep);
5540   else if (INNER_CLASS_DECL_P (decl))
5541     {
5542       tree inner = TREE_TYPE (decl);
5543       if (! CLASS_LOADED_P (inner))
5544         {
5545           safe_layout_class (inner);
5546           if (TYPE_SIZE (inner) == error_mark_node)
5547             TYPE_SIZE (inner) = NULL_TREE;
5548         }
5549       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5550     }
5551   return decl;
5552 }
5553
5554 /* Complete unsatisfied class declaration and their dependencies */
5555
5556 void
5557 java_complete_class (void)
5558 {
5559   tree cclass;
5560   jdeplist *cclassd;
5561   int error_found;
5562   tree type;
5563
5564   /* Process imports */
5565   process_imports ();
5566
5567   /* Reverse things so we have the right order */
5568   ctxp->class_list = nreverse (ctxp->class_list);
5569   ctxp->classd_list = reverse_jdep_list (ctxp);
5570
5571   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5572        cclass && cclassd;
5573        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5574     {
5575       jdep *dep;
5576
5577       /* We keep the compilation unit imports in the class so that
5578          they can be used later to resolve type dependencies that
5579          aren't necessary to solve now. */
5580       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5581       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5582
5583       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5584         {
5585           tree decl;
5586           if (!(decl = jdep_resolve_class (dep)))
5587             continue;
5588
5589           /* Now it's time to patch */
5590           switch (JDEP_KIND (dep))
5591             {
5592             case JDEP_SUPER:
5593               /* Simply patch super */
5594               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5595                 continue;
5596               BINFO_TYPE (BINFO_BASE_BINFO
5597                           (TYPE_BINFO (TREE_TYPE (JDEP_DECL (dep))), 0))
5598                 = TREE_TYPE (decl);
5599               break;
5600
5601             case JDEP_FIELD:
5602               {
5603                 /* We do part of the job done in add_field */
5604                 tree field_decl = JDEP_DECL (dep);
5605                 tree field_type = TREE_TYPE (decl);
5606                 if (TREE_CODE (field_type) == RECORD_TYPE)
5607                   field_type = promote_type (field_type);
5608                 TREE_TYPE (field_decl) = field_type;
5609                 DECL_ALIGN (field_decl) = 0;
5610                 DECL_USER_ALIGN (field_decl) = 0;
5611                 layout_decl (field_decl, 0);
5612                 SOURCE_FRONTEND_DEBUG
5613                   (("Completed field/var decl `%s' with `%s'",
5614                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5615                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5616                 break;
5617               }
5618             case JDEP_METHOD:   /* We start patching a method */
5619             case JDEP_METHOD_RETURN:
5620               error_found = 0;
5621               while (1)
5622                 {
5623                   if (decl)
5624                     {
5625                       type = TREE_TYPE(decl);
5626                       if (TREE_CODE (type) == RECORD_TYPE)
5627                         type = promote_type (type);
5628                       JDEP_APPLY_PATCH (dep, type);
5629                       SOURCE_FRONTEND_DEBUG
5630                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5631                            "Completing fct `%s' with ret type `%s'":
5632                            "Completing arg `%s' with type `%s'"),
5633                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5634                                               (JDEP_DECL_WFL (dep))),
5635                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5636                     }
5637                   else
5638                     error_found = 1;
5639                   dep = JDEP_CHAIN (dep);
5640                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5641                     break;
5642                   else
5643                     decl = jdep_resolve_class (dep);
5644                 }
5645               if (!error_found)
5646                 {
5647                   tree mdecl = JDEP_DECL (dep), signature;
5648                   /* Recompute and reset the signature, check first that
5649                      all types are now defined. If they're not,
5650                      don't build the signature. */
5651                   if (check_method_types_complete (mdecl))
5652                     {
5653                       signature = build_java_signature (TREE_TYPE (mdecl));
5654                       set_java_signature (TREE_TYPE (mdecl), signature);
5655                     }
5656                 }
5657               else
5658                 continue;
5659               break;
5660
5661             case JDEP_INTERFACE:
5662               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5663                                                 JDEP_WFL (dep)))
5664                 continue;
5665               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5666               break;
5667
5668             case JDEP_PARM:
5669             case JDEP_VARIABLE:
5670               type = TREE_TYPE(decl);
5671               if (TREE_CODE (type) == RECORD_TYPE)
5672                 type = promote_type (type);
5673               JDEP_APPLY_PATCH (dep, type);
5674               break;
5675
5676             case JDEP_TYPE:
5677               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5678               SOURCE_FRONTEND_DEBUG
5679                 (("Completing a random type dependency on a '%s' node",
5680                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5681               break;
5682
5683             case JDEP_EXCEPTION:
5684               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5685               SOURCE_FRONTEND_DEBUG
5686                 (("Completing `%s' `throws' argument node",
5687                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5688               break;
5689
5690             case JDEP_ANONYMOUS:
5691               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5692               break;
5693
5694             default:
5695               abort ();
5696             }
5697         }
5698     }
5699   return;
5700 }
5701
5702 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5703    array.  */
5704
5705 static tree
5706 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5707 {
5708   tree tname = TYPE_NAME (class_type);
5709   tree resolved_type = TREE_TYPE (class_type);
5710   int array_dims = 0;
5711   tree resolved_type_decl;
5712
5713   if (resolved_type != NULL_TREE)
5714     {
5715       tree resolved_type_decl = TYPE_NAME (resolved_type);
5716       if (resolved_type_decl == NULL_TREE
5717           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5718         {
5719           resolved_type_decl = build_decl (TYPE_DECL,
5720                                            TYPE_NAME (class_type),
5721                                            resolved_type);
5722         }
5723       return resolved_type_decl;
5724     }
5725
5726   /* 1- Check to see if we have an array. If true, find what we really
5727      want to resolve  */
5728   if ((array_dims = build_type_name_from_array_name (tname,
5729                                                      &TYPE_NAME (class_type))))
5730     WFL_STRIP_BRACKET (cl, cl);
5731
5732   /* 2- Resolve the bare type */
5733   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5734                                                decl, cl)))
5735     return NULL_TREE;
5736   resolved_type = TREE_TYPE (resolved_type_decl);
5737
5738   /* 3- If we have an array, reconstruct the array down to its nesting */
5739   if (array_dims)
5740     {
5741       for (; array_dims; array_dims--)
5742         resolved_type = build_java_array_type (resolved_type, -1);
5743       resolved_type_decl = TYPE_NAME (resolved_type);
5744     }
5745   TREE_TYPE (class_type) = resolved_type;
5746   return resolved_type_decl;
5747 }
5748
5749 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5750    are used to report error messages; CL must either be NULL_TREE or a
5751    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5752    by a variable, since it is changed by find_in_imports{_on_demand}
5753    and (but it doesn't really matter) qualify_and_find.  */
5754
5755 tree
5756 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5757 {
5758   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5759   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5760   tree decl_result;
5761   htab_t circularity_hash;
5762
5763   if (QUALIFIED_P (TYPE_NAME (class_type)))
5764     {
5765       /* If the type name is of the form `Q . Id', then Q is either a
5766          package name or a class name.  First we try to find Q as a
5767          class and then treat Id as a member type.  If we can't find Q
5768          as a class then we fall through.  */
5769       tree q, left, left_type, right;
5770       if (split_qualified_name (&left, &right, TYPE_NAME (class_type)) == 0)
5771         {
5772           BUILD_PTR_FROM_NAME (left_type, left);
5773           q = do_resolve_class (enclosing, left_type, decl, cl);
5774           if (q)
5775             {
5776               enclosing = q;
5777               saved_enclosing_type = TREE_TYPE (q);
5778               BUILD_PTR_FROM_NAME (class_type, right);
5779             }
5780         }
5781     }
5782
5783   if (enclosing)
5784     {
5785       /* This hash table is used to register the classes we're going
5786          through when searching the current class as an inner class, in
5787          order to detect circular references. Remember to free it before
5788          returning the section 0- of this function. */
5789       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5790                                       NULL);
5791
5792       /* 0- Search in the current class as an inner class.
5793          Maybe some code here should be added to load the class or
5794          something, at least if the class isn't an inner class and ended
5795          being loaded from class file. FIXME. */
5796       while (enclosing)
5797         {
5798           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5799                                                 &super, class_type);
5800           if (new_class_decl)
5801             break;
5802
5803           /* If we haven't found anything because SUPER reached Object and
5804              ENCLOSING happens to be an innerclass, try the enclosing context. */
5805           if ((!super || super == object_type_node) &&
5806               enclosing && INNER_CLASS_DECL_P (enclosing))
5807             enclosing = DECL_CONTEXT (enclosing);
5808           else
5809             enclosing = NULL_TREE;
5810         }
5811
5812       htab_delete (circularity_hash);
5813
5814       if (new_class_decl)
5815         return new_class_decl;
5816     }
5817
5818   /* 1- Check for the type in single imports. This will change
5819      TYPE_NAME() if something relevant is found */
5820   find_in_imports (saved_enclosing_type, class_type);
5821
5822   /* 2- And check for the type in the current compilation unit */
5823   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5824     {
5825       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5826         load_class (TYPE_NAME (class_type), 0);
5827       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5828     }
5829
5830   /* 3- Search according to the current package definition */
5831   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5832     {
5833       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5834                                              TYPE_NAME (class_type))))
5835         return new_class_decl;
5836     }
5837
5838   /* 4- Check the import on demands. Don't allow bar.baz to be
5839      imported from foo.* */
5840   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5841     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5842       return NULL_TREE;
5843
5844   /* If found in find_in_imports_on_demand, the type has already been
5845      loaded. */
5846   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5847     return new_class_decl;
5848
5849   /* 5- Try with a name qualified with the package name we've seen so far */
5850   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5851     {
5852       tree package;
5853
5854       /* If there is a current package (ctxp->package), it's the first
5855          element of package_list and we can skip it. */
5856       for (package = (ctxp->package ?
5857                       TREE_CHAIN (package_list) : package_list);
5858            package; package = TREE_CHAIN (package))
5859         if ((new_class_decl = qualify_and_find (class_type,
5860                                                TREE_PURPOSE (package),
5861                                                TYPE_NAME (class_type))))
5862           return new_class_decl;
5863     }
5864
5865   /* 5- Check another compilation unit that bears the name of type */
5866   load_class (TYPE_NAME (class_type), 0);
5867
5868   if (!cl)
5869     cl = lookup_cl (decl);
5870
5871   /* If we don't have a value for CL, then we're being called recursively.
5872      We can't check package access just yet, but it will be taken care of
5873      by the caller. */
5874   if (cl)
5875     {
5876       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5877         return NULL_TREE;
5878     }
5879
5880   /* 6- Last call for a resolution */
5881   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5882
5883   /* The final lookup might have registered a.b.c into a.b$c If we
5884      failed at the first lookup, progressively change the name if
5885      applicable and use the matching DECL instead. */
5886   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5887     {
5888       char *separator;
5889       tree name = TYPE_NAME (class_type);
5890       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5891
5892       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5893
5894       do {
5895
5896        /* Reach the last '.', and if applicable, replace it by a `$' and
5897           see if this exists as a type. */
5898        if ((separator = strrchr (namebuffer, '.')))
5899          {
5900            *separator = '$';
5901            name = get_identifier (namebuffer);
5902            decl_result = IDENTIFIER_CLASS_VALUE (name);
5903          }
5904       } while (!decl_result && separator);
5905     }
5906   return decl_result;
5907 }
5908
5909 static tree
5910 qualify_and_find (tree class_type, tree package, tree name)
5911 {
5912   tree new_qualified = merge_qualified_name (package, name);
5913   tree new_class_decl;
5914
5915   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5916     load_class (new_qualified, 0);
5917   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5918     {
5919       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5920         load_class (TREE_TYPE (new_class_decl), 0);
5921       TYPE_NAME (class_type) = new_qualified;
5922       return IDENTIFIER_CLASS_VALUE (new_qualified);
5923     }
5924   return NULL_TREE;
5925 }
5926
5927 /* Resolve NAME and lay it out (if not done and if not the current
5928    parsed class). Return a decl node. This function is meant to be
5929    called when type resolution is necessary during the walk pass.  */
5930
5931 static tree
5932 resolve_and_layout (tree something, tree cl)
5933 {
5934   tree decl, decl_type;
5935
5936   /* Don't do that on the current class */
5937   if (something == current_class)
5938     return TYPE_NAME (current_class);
5939
5940   /* Don't do anything for void and other primitive types */
5941   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5942     return NULL_TREE;
5943
5944   /* Pointer types can be reall pointer types or fake pointers. When
5945      finding a real pointer, recheck for primitive types */
5946   if (TREE_CODE (something) == POINTER_TYPE)
5947     {
5948       if (TREE_TYPE (something))
5949         {
5950           something = TREE_TYPE (something);
5951           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5952             return NULL_TREE;
5953         }
5954       else
5955         something = TYPE_NAME (something);
5956     }
5957
5958   /* Don't do anything for arrays of primitive types */
5959   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5960       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5961     return NULL_TREE;
5962
5963   /* Something might be a WFL */
5964   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5965     something = EXPR_WFL_NODE (something);
5966
5967   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5968      TYPE_DECL or a real TYPE */
5969   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5970     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5971             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5972
5973   if (!(decl = resolve_no_layout (something, cl)))
5974     return NULL_TREE;
5975
5976   /* Resolve and layout if necessary */
5977   decl_type = TREE_TYPE (decl);
5978   layout_class_methods (decl_type);
5979   /* Check methods */
5980   if (CLASS_FROM_SOURCE_P (decl_type))
5981     java_check_methods (decl);
5982   /* Layout the type if necessary */
5983   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5984     safe_layout_class (decl_type);
5985
5986   return decl;
5987 }
5988
5989 /* Resolve a class, returns its decl but doesn't perform any
5990    layout. The current parsing context is saved and restored */
5991
5992 static tree
5993 resolve_no_layout (tree name, tree cl)
5994 {
5995   tree ptr, decl;
5996   BUILD_PTR_FROM_NAME (ptr, name);
5997   java_parser_context_save_global ();
5998   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5999   java_parser_context_restore_global ();
6000
6001   return decl;
6002 }
6003
6004 /* Called when reporting errors. Skip the '[]'s in a complex array
6005    type description that failed to be resolved. purify_type_name can't
6006    use an identifier tree.  */
6007
6008 static const char *
6009 purify_type_name (const char *name)
6010 {
6011   int len = strlen (name);
6012   int bracket_found;
6013
6014   STRING_STRIP_BRACKETS (name, len, bracket_found);
6015   if (bracket_found)
6016     {
6017       char *stripped_name = xmemdup (name, len, len+1);
6018       stripped_name [len] = '\0';
6019       return stripped_name;
6020     }
6021   return name;
6022 }
6023
6024 /* The type CURRENT refers to can't be found. We print error messages.  */
6025
6026 static void
6027 complete_class_report_errors (jdep *dep)
6028 {
6029   const char *name;
6030
6031   if (!JDEP_WFL (dep))
6032     return;
6033
6034   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6035   switch (JDEP_KIND (dep))
6036     {
6037     case JDEP_SUPER:
6038       parse_error_context
6039         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6040          purify_type_name (name),
6041          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6042       break;
6043     case JDEP_FIELD:
6044       parse_error_context
6045         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6046          purify_type_name (name),
6047          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6048       break;
6049     case JDEP_METHOD:           /* Covers arguments */
6050       parse_error_context
6051         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6052          purify_type_name (name),
6053          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6054          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6055       break;
6056     case JDEP_METHOD_RETURN:    /* Covers return type */
6057       parse_error_context
6058         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6059          purify_type_name (name),
6060          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6061       break;
6062     case JDEP_INTERFACE:
6063       parse_error_context
6064         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6065          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6066          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6067          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6068       break;
6069     case JDEP_VARIABLE:
6070       parse_error_context
6071         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6072          purify_type_name (IDENTIFIER_POINTER
6073                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6074          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6075       break;
6076     case JDEP_EXCEPTION:        /* As specified by `throws' */
6077       parse_error_context
6078           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6079          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6080       break;
6081     default:
6082       /* Fix for -Wall. Just break doing nothing. The error will be
6083          caught later */
6084       break;
6085     }
6086 }
6087
6088 /* Return a static string containing the DECL prototype string. If
6089    DECL is a constructor, use the class name instead of the form
6090    <init> */
6091
6092 static const char *
6093 get_printable_method_name (tree decl)
6094 {
6095   const char *to_return;
6096   tree name = NULL_TREE;
6097
6098   if (DECL_CONSTRUCTOR_P (decl))
6099     {
6100       name = DECL_NAME (decl);
6101       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6102     }
6103
6104   to_return = lang_printable_name (decl, 2);
6105   if (DECL_CONSTRUCTOR_P (decl))
6106     DECL_NAME (decl) = name;
6107
6108   return to_return;
6109 }
6110
6111 /* Track method being redefined inside the same class. As a side
6112    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6113    function it's a FWL, so we can track errors more accurately.)  */
6114
6115 static int
6116 check_method_redefinition (tree class, tree method)
6117 {
6118   tree redef, sig;
6119
6120   /* There's no need to verify <clinit> and finit$ and instinit$ */
6121   if (DECL_CLINIT_P (method)
6122       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6123     return 0;
6124
6125   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6126   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6127     {
6128       if (redef == method)
6129         break;
6130       if (DECL_NAME (redef) == DECL_NAME (method)
6131           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6132           && !DECL_ARTIFICIAL (method))
6133         {
6134           parse_error_context
6135             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6136              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6137              get_printable_method_name (redef));
6138           return 1;
6139         }
6140     }
6141   return 0;
6142 }
6143
6144 /* Return 1 if check went ok, 0 otherwise.  */
6145 static int
6146 check_abstract_method_definitions (int do_interface, tree class_decl,
6147                                    tree type)
6148 {
6149   tree class = TREE_TYPE (class_decl);
6150   tree method, end_type;
6151   int ok = 1;
6152
6153   end_type = (do_interface ? object_type_node : type);
6154   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6155     {
6156       tree other_super, other_method, method_sig, method_name;
6157       int found = 0;
6158       int end_type_reached = 0;
6159
6160       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6161         continue;
6162
6163       /* Now verify that somewhere in between TYPE and CLASS,
6164          abstract method METHOD gets a non abstract definition
6165          that is inherited by CLASS.  */
6166
6167       method_sig = build_java_signature (TREE_TYPE (method));
6168       method_name = DECL_NAME (method);
6169       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6170         method_name = EXPR_WFL_NODE (method_name);
6171
6172       other_super = class;
6173       do {
6174         if (other_super == end_type)
6175           end_type_reached = 1;
6176
6177         /* Method search */
6178         for (other_method = TYPE_METHODS (other_super); other_method;
6179             other_method = TREE_CHAIN (other_method))
6180           {
6181             tree s = build_java_signature (TREE_TYPE (other_method));
6182             tree other_name = DECL_NAME (other_method);
6183
6184             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6185               other_name = EXPR_WFL_NODE (other_name);
6186             if (!DECL_CLINIT_P (other_method)
6187                 && !DECL_CONSTRUCTOR_P (other_method)
6188                 && method_name == other_name
6189                 && method_sig == s
6190                 && !METHOD_ABSTRACT (other_method))
6191              {
6192                found = 1;
6193                break;
6194              }
6195           }
6196         other_super = CLASSTYPE_SUPER (other_super);
6197       } while (!end_type_reached);
6198
6199       /* Report that abstract METHOD didn't find an implementation
6200          that CLASS can use. */
6201       if (!found)
6202         {
6203           char *t = xstrdup (lang_printable_name
6204                             (TREE_TYPE (TREE_TYPE (method)), 0));
6205           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6206
6207           parse_error_context
6208             (lookup_cl (class_decl),
6209              "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",
6210              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6211              t, lang_printable_name (method, 2),
6212              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6213               "interface" : "class"),
6214              IDENTIFIER_POINTER (ccn),
6215              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6216              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6217           ok = 0;
6218           free (t);
6219         }
6220     }
6221
6222   if (ok && do_interface)
6223     {
6224       /* Check for implemented interfaces. */
6225       int i;
6226       tree base_binfo;
6227
6228       for (i = 1;
6229            ok && BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo);
6230            i++)
6231         ok = check_abstract_method_definitions (1, class_decl,
6232                                                 BINFO_TYPE (base_binfo));
6233     }
6234
6235   return ok;
6236 }
6237
6238 /* Check that CLASS_DECL somehow implements all inherited abstract
6239    methods.  */
6240
6241 static void
6242 java_check_abstract_method_definitions (tree class_decl)
6243 {
6244   tree class = TREE_TYPE (class_decl);
6245   tree super, base_binfo;
6246   int i;
6247
6248   if (CLASS_ABSTRACT (class_decl))
6249     return;
6250
6251   /* Check for inherited types */
6252   super = class;
6253   do {
6254     super = CLASSTYPE_SUPER (super);
6255     check_abstract_method_definitions (0, class_decl, super);
6256   } while (super != object_type_node);
6257
6258   /* Check for implemented interfaces. */
6259   for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6260     check_abstract_method_definitions (1, class_decl, BINFO_TYPE (base_binfo));
6261 }
6262
6263 /* Check all the types method DECL uses and return 1 if all of them
6264    are now complete, 0 otherwise. This is used to check whether its
6265    safe to build a method signature or not.  */
6266
6267 static int
6268 check_method_types_complete (tree decl)
6269 {
6270   tree type = TREE_TYPE (decl);
6271   tree args;
6272
6273   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6274     return 0;
6275
6276   args = TYPE_ARG_TYPES (type);
6277   if (TREE_CODE (type) == METHOD_TYPE)
6278     args = TREE_CHAIN (args);
6279   for (; args != end_params_node; args = TREE_CHAIN (args))
6280     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6281       return 0;
6282
6283   return 1;
6284 }
6285
6286 /* Visible interface to check methods contained in CLASS_DECL */
6287
6288 void
6289 java_check_methods (tree class_decl)
6290 {
6291   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6292     return;
6293
6294   if (CLASS_INTERFACE (class_decl))
6295     java_check_abstract_methods (class_decl);
6296   else
6297     java_check_regular_methods (class_decl);
6298
6299   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6300 }
6301
6302 /* Like not_accessible_p, but doesn't refer to the current class at
6303    all.  */
6304 static bool
6305 hack_is_accessible_p (tree member, tree from_where)
6306 {
6307   int flags = get_access_flags_from_decl (member);
6308
6309   if (from_where == DECL_CONTEXT (member)
6310       || (flags & ACC_PUBLIC))
6311     return true;
6312
6313   if ((flags & ACC_PROTECTED))
6314     {
6315       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6316         return true;
6317     }
6318
6319   if ((flags & ACC_PRIVATE))
6320     return false;
6321
6322   /* Package private, or protected.  */
6323   return in_same_package (TYPE_NAME (from_where),
6324                           TYPE_NAME (DECL_CONTEXT (member)));
6325 }
6326
6327 /* Check all the methods of CLASS_DECL. Methods are first completed
6328    then checked according to regular method existence rules.  If no
6329    constructor for CLASS_DECL were encountered, then build its
6330    declaration.  */
6331 static void
6332 java_check_regular_methods (tree class_decl)
6333 {
6334   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6335   tree method;
6336   tree class = TREE_TYPE (class_decl);
6337   tree found = NULL_TREE;
6338   tree mthrows;
6339
6340   /* It is not necessary to check methods defined in java.lang.Object */
6341   if (class == object_type_node)
6342     return;
6343
6344   if (!TYPE_NVIRTUALS (class))
6345     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6346
6347   /* Should take interfaces into account. FIXME */
6348   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6349     {
6350       tree sig;
6351       tree method_wfl = DECL_FUNCTION_WFL (method);
6352       int aflags;
6353
6354       /* Check for redefinitions */
6355       if (check_method_redefinition (class, method))
6356         continue;
6357
6358       /* We verify things thrown by the method.  They must inherit from
6359          java.lang.Throwable.  */
6360       for (mthrows = DECL_FUNCTION_THROWS (method);
6361            mthrows; mthrows = TREE_CHAIN (mthrows))
6362         {
6363           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6364             parse_error_context
6365               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6366                IDENTIFIER_POINTER
6367                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6368         }
6369
6370       /* If we see one constructor a mark so we don't generate the
6371          default one.  Also skip other verifications: constructors
6372          can't be inherited hence hidden or overridden.  */
6373       if (DECL_CONSTRUCTOR_P (method))
6374         {
6375           saw_constructor = 1;
6376           continue;
6377         }
6378
6379       sig = build_java_argument_signature (TREE_TYPE (method));
6380       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6381                                               SEARCH_SUPER | SEARCH_INTERFACE);
6382
6383       /* Inner class can't declare static methods */
6384       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6385         {
6386           char *t = xstrdup (lang_printable_name (class, 0));
6387           parse_error_context
6388             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6389              lang_printable_name (method, 2), t);
6390           free (t);
6391         }
6392
6393       /* Nothing overrides or it's a private method. */
6394       if (!found)
6395         continue;
6396       if (METHOD_PRIVATE (found))
6397         {
6398           found = NULL_TREE;
6399           continue;
6400         }
6401
6402       /* If `found' is declared in an interface, make sure the
6403          modifier matches. */
6404       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6405           && clinit_identifier_node != DECL_NAME (found)
6406           && !METHOD_PUBLIC (method))
6407         {
6408           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6409           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6410                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6411                                lang_printable_name (method, 2),
6412                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6413         }
6414
6415       /* Can't override a method with the same name and different return
6416          types. */
6417       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6418         {
6419           char *t = xstrdup
6420             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6421           parse_error_context
6422             (method_wfl,
6423              "Method `%s' was defined with return type `%s' in class `%s'",
6424              lang_printable_name (found, 2), t,
6425              IDENTIFIER_POINTER
6426                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6427           free (t);
6428         }
6429
6430       aflags = get_access_flags_from_decl (found);
6431
6432       /* Can't override final. Can't override static. */
6433       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6434         {
6435           /* Static *can* override static */
6436           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6437             continue;
6438           parse_error_context
6439             (method_wfl,
6440              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6441              (METHOD_FINAL (found) ? "Final" : "Static"),
6442              lang_printable_name (found, 2),
6443              (METHOD_FINAL (found) ? "final" : "static"),
6444              IDENTIFIER_POINTER
6445                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6446           continue;
6447         }
6448
6449       /* Static method can't override instance method. */
6450       if (METHOD_STATIC (method))
6451         {
6452           parse_error_context
6453             (method_wfl,
6454              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6455              lang_printable_name (found, 2),
6456              IDENTIFIER_POINTER
6457                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6458           continue;
6459         }
6460
6461       /* - Overriding/hiding public must be public
6462          - Overriding/hiding protected must be protected or public
6463          - If the overridden or hidden method has default (package)
6464            access, then the overriding or hiding method must not be
6465            private; otherwise, a compile-time error occurs.  If
6466            `found' belongs to an interface, things have been already
6467            taken care of.  */
6468       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6469           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6470               || (METHOD_PROTECTED (found)
6471                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6472               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6473                   && METHOD_PRIVATE (method))))
6474         {
6475           parse_error_context
6476             (method_wfl,
6477              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 2),
6478              (METHOD_PUBLIC (method) ? "public" :
6479               (METHOD_PRIVATE (method) ? "private" : "protected")),
6480              IDENTIFIER_POINTER (DECL_NAME
6481                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6482           continue;
6483         }
6484
6485       /* Check this method against all the other implementations it
6486          overrides.  Here we only check the class hierarchy; the rest
6487          of the checking is done later.  If this method is just a
6488          Miranda method, we can skip the check.  */
6489       if (! METHOD_INVISIBLE (method))
6490         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6491     }
6492
6493   /* The above throws clause check only looked at superclasses.  Now
6494      we must also make sure that all methods declared in interfaces
6495      have compatible throws clauses.  FIXME: there are more efficient
6496      ways to organize this checking; we should implement one.  */
6497   check_interface_throws_clauses (class, class);
6498
6499   if (!TYPE_NVIRTUALS (class))
6500     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6501
6502   /* Search for inherited abstract method not yet implemented in this
6503      class.  */
6504   java_check_abstract_method_definitions (class_decl);
6505
6506   if (!saw_constructor)
6507     abort ();
6508 }
6509
6510 /* Check to make sure that all the methods in all the interfaces
6511    implemented by CLASS_DECL are compatible with the concrete
6512    implementations available in CHECK_CLASS_DECL.  */
6513 static void
6514 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6515 {
6516   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6517     {
6518       int i;
6519
6520       if (! CLASS_LOADED_P (class_decl))
6521         {
6522           if (CLASS_FROM_SOURCE_P (class_decl))
6523             safe_layout_class (class_decl);
6524           else
6525             load_class (class_decl, 1);
6526         }
6527
6528       for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (class_decl)) - 1; i > 0; --i)
6529         {
6530           tree interface
6531             = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (class_decl), i));
6532           tree iface_method;
6533
6534           for (iface_method = TYPE_METHODS (interface);
6535                iface_method != NULL_TREE;
6536                iface_method = TREE_CHAIN (iface_method))
6537             {
6538               tree sig, method;
6539
6540               /* First look for a concrete method implemented or
6541                  inherited by this class.  No need to search
6542                  interfaces here, since we're already looking through
6543                  all of them.  */
6544               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6545               method
6546                 = lookup_argument_method_generic (check_class_decl,
6547                                                   DECL_NAME (iface_method),
6548                                                   sig, SEARCH_VISIBLE);
6549               /* If we don't find an implementation, that is ok.  Any
6550                  potential errors from that are diagnosed elsewhere.
6551                  Also, multiple inheritance with conflicting throws
6552                  clauses is fine in the absence of a concrete
6553                  implementation.  */
6554               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6555                   && !METHOD_INVISIBLE (iface_method))
6556                 {
6557                   tree method_wfl = DECL_FUNCTION_WFL (method);
6558                   check_throws_clauses (method, method_wfl, iface_method);
6559                 }
6560             }
6561
6562           /* Now check superinterfaces.  */
6563           check_interface_throws_clauses (check_class_decl, interface);
6564         }
6565     }
6566 }
6567
6568 /* Check throws clauses of a method against the clauses of all the
6569    methods it overrides.  We do this by searching up the class
6570    hierarchy, examining all matching accessible methods.  */
6571 static void
6572 check_concrete_throws_clauses (tree class, tree self_method,
6573                                tree name, tree signature)
6574 {
6575   tree method = lookup_argument_method_generic (class, name, signature,
6576                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6577   while (method != NULL_TREE)
6578     {
6579       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6580         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6581                               method);
6582
6583       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6584                                                name, signature,
6585                                                SEARCH_SUPER | SEARCH_VISIBLE);
6586     }
6587 }
6588
6589 /* Generate an error if the `throws' clause of METHOD (if any) is
6590    incompatible with the `throws' clause of FOUND (if any).  */
6591 static void
6592 check_throws_clauses (tree method, tree method_wfl, tree found)
6593 {
6594   tree mthrows;
6595
6596   /* Can't check these things with class loaded from bytecode. FIXME */
6597   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6598     return;
6599
6600   for (mthrows = DECL_FUNCTION_THROWS (method);
6601        mthrows; mthrows = TREE_CHAIN (mthrows))
6602     {
6603       tree fthrows;
6604
6605       /* We don't verify unchecked expressions */
6606       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6607         continue;
6608       /* Checked expression must be compatible */
6609       for (fthrows = DECL_FUNCTION_THROWS (found);
6610            fthrows; fthrows = TREE_CHAIN (fthrows))
6611         {
6612           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6613             break;
6614         }
6615       if (!fthrows)
6616         {
6617           parse_error_context
6618             (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'",
6619              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6620              lang_printable_name (found, 2),
6621              IDENTIFIER_POINTER
6622              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6623         }
6624     }
6625 }
6626
6627 /* Check abstract method of interface INTERFACE */
6628 static void
6629 java_check_abstract_methods (tree interface_decl)
6630 {
6631   int i;
6632   tree method, found;
6633   tree interface = TREE_TYPE (interface_decl);
6634   tree base_binfo;
6635
6636   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6637     {
6638       /* 2- Check for double definition inside the defining interface */
6639       if (check_method_redefinition (interface, method))
6640         continue;
6641
6642       /* 3- Overriding is OK as far as we preserve the return type.  */
6643       found = lookup_java_interface_method2 (interface, method);
6644       if (found)
6645         {
6646           char *t;
6647           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6648           parse_error_context
6649             (DECL_FUNCTION_WFL (found),
6650              "Method `%s' was defined with return type `%s' in class `%s'",
6651              lang_printable_name (found, 2), t,
6652              IDENTIFIER_POINTER
6653                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6654           free (t);
6655           continue;
6656         }
6657     }
6658
6659   /* 4- Inherited methods can't differ by their returned types */
6660   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (interface), i, base_binfo); i++)
6661     {
6662       tree sub_interface_method, sub_interface;
6663
6664       sub_interface = BINFO_TYPE (base_binfo);
6665       for (sub_interface_method = TYPE_METHODS (sub_interface);
6666            sub_interface_method;
6667            sub_interface_method = TREE_CHAIN (sub_interface_method))
6668         {
6669           found = lookup_java_interface_method2 (interface,
6670                                                  sub_interface_method);
6671           if (found && (found != sub_interface_method))
6672             {
6673               parse_error_context
6674                 (lookup_cl (sub_interface_method),
6675                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6676                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6677                  lang_printable_name (found, 2),
6678                  IDENTIFIER_POINTER
6679                    (DECL_NAME (TYPE_NAME
6680                                (DECL_CONTEXT (sub_interface_method)))),
6681                  IDENTIFIER_POINTER
6682                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6683             }
6684         }
6685     }
6686 }
6687
6688 /* Lookup methods in interfaces using their name and partial
6689    signature. Return a matching method only if their types differ.  */
6690
6691 static tree
6692 lookup_java_interface_method2 (tree class, tree method_decl)
6693 {
6694   int i;
6695   tree base_binfo;
6696   tree to_return;
6697
6698   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6699     {
6700       if ((BINFO_TYPE (base_binfo) != object_type_node)
6701           && (to_return =
6702               lookup_java_method2 (BINFO_TYPE (base_binfo), method_decl, 1)))
6703         return to_return;
6704     }
6705   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6706     {
6707       to_return = lookup_java_interface_method2
6708         (BINFO_TYPE (base_binfo), method_decl);
6709       if (to_return)
6710         return to_return;
6711     }
6712
6713   return NULL_TREE;
6714 }
6715
6716 /* Lookup method using their name and partial signature. Return a
6717    matching method only if their types differ.  */
6718
6719 static tree
6720 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6721 {
6722   tree method, method_signature, method_name, method_type, name;
6723
6724   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6725   name = DECL_NAME (method_decl);
6726   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6727                  EXPR_WFL_NODE (name) : name);
6728   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6729
6730   while (clas != NULL_TREE)
6731     {
6732       for (method = TYPE_METHODS (clas);
6733            method != NULL_TREE;  method = TREE_CHAIN (method))
6734         {
6735           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6736           tree name = DECL_NAME (method);
6737           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6738                EXPR_WFL_NODE (name) : name) == method_name
6739               && method_sig == method_signature
6740               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6741             return method;
6742         }
6743       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6744     }
6745   return NULL_TREE;
6746 }
6747
6748 /* Return the line that matches DECL line number, and try its best to
6749    position the column number. Used during error reports.  */
6750
6751 static GTY(()) tree cl_v;
6752 static tree
6753 lookup_cl (tree decl)
6754 {
6755   char *line, *found;
6756
6757   if (!decl)
6758     return NULL_TREE;
6759
6760   if (cl_v == NULL_TREE)
6761     {
6762       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6763     }
6764
6765   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6766   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6767
6768   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6769                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6770
6771   found = strstr ((const char *)line,
6772                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6773   if (found)
6774     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6775
6776   return cl_v;
6777 }
6778
6779 /* Look for a simple name in the single-type import list */
6780
6781 static tree
6782 find_name_in_single_imports (tree name)
6783 {
6784   tree node;
6785
6786   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6787     if (TREE_VALUE (node) == name)
6788       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6789
6790   return NULL_TREE;
6791 }
6792
6793 /* Process all single-type import. */
6794
6795 static int
6796 process_imports (void)
6797 {
6798   tree import;
6799   int error_found;
6800
6801   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6802     {
6803       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6804       char *original_name;
6805
6806       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6807                                IDENTIFIER_LENGTH (to_be_found),
6808                                IDENTIFIER_LENGTH (to_be_found) + 1);
6809
6810       /* Don't load twice something already defined. */
6811       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6812         continue;
6813
6814       while (1)
6815         {
6816           tree left;
6817
6818           QUALIFIED_P (to_be_found) = 1;
6819           load_class (to_be_found, 0);
6820           error_found =
6821             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6822
6823           /* We found it, we can bail out */
6824           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6825             {
6826               check_deprecation (TREE_PURPOSE (import),
6827                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6828               break;
6829             }
6830
6831           /* We haven't found it. Maybe we're trying to access an
6832              inner class.  The only way for us to know is to try again
6833              after having dropped a qualifier. If we can't break it further,
6834              we have an error. */
6835           if (split_qualified_name (&left, NULL, to_be_found))
6836             break;
6837
6838           to_be_found = left;
6839         }
6840       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6841         {
6842           parse_error_context (TREE_PURPOSE (import),
6843                                "Class or interface `%s' not found in import",
6844                                original_name);
6845           error_found = 1;
6846         }
6847
6848       free (original_name);
6849       if (error_found)
6850         return 1;
6851     }
6852   return 0;
6853 }
6854
6855 /* Possibly find and mark a class imported by a single-type import
6856    statement.  */
6857
6858 static void
6859 find_in_imports (tree enclosing_type, tree class_type)
6860 {
6861   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6862                  ctxp->import_list);
6863   while (import)
6864     {
6865       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6866         {
6867           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6868           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6869           return;
6870         }
6871       import = TREE_CHAIN (import);
6872     }
6873 }
6874
6875 static int
6876 note_possible_classname (const char *name, int len)
6877 {
6878   tree node;
6879   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6880     len = len - 5;
6881   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6882     len = len - 6;
6883   else
6884     return 0;
6885   node = ident_subst (name, len, "", '/', '.', "");
6886   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6887   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6888   return 1;
6889 }
6890
6891 /* Read a import directory, gathering potential match for further type
6892    references. Indifferently reads a filesystem or a ZIP archive
6893    directory.  */
6894
6895 static void
6896 read_import_dir (tree wfl)
6897 {
6898   tree package_id = EXPR_WFL_NODE (wfl);
6899   const char *package_name = IDENTIFIER_POINTER (package_id);
6900   int package_length = IDENTIFIER_LENGTH (package_id);
6901   DIR *dirp = NULL;
6902   JCF *saved_jcf = current_jcf;
6903
6904   int found = 0;
6905   int k;
6906   void *entry;
6907   struct buffer filename[1];
6908
6909   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6910     return;
6911   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6912
6913   BUFFER_INIT (filename);
6914   buffer_grow (filename, package_length + 100);
6915
6916   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6917     {
6918       const char *entry_name = jcf_path_name (entry);
6919       int entry_length = strlen (entry_name);
6920       if (jcf_path_is_zipfile (entry))
6921         {
6922           ZipFile *zipf;
6923           buffer_grow (filename, entry_length);
6924           memcpy (filename->data, entry_name, entry_length - 1);
6925           filename->data[entry_length-1] = '\0';
6926           zipf = opendir_in_zip ((const char *) filename->data, jcf_path_is_system (entry));
6927           if (zipf == NULL)
6928             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6929           else
6930             {
6931               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6932               BUFFER_RESET (filename);
6933               for (k = 0; k < package_length; k++)
6934                 {
6935                   char ch = package_name[k];
6936                   *filename->ptr++ = ch == '.' ? '/' : ch;
6937                 }
6938               *filename->ptr++ = '/';
6939
6940               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6941                 {
6942                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6943                   int current_entry_len = zipd->filename_length;
6944
6945                   if (current_entry_len >= BUFFER_LENGTH (filename)
6946                       && strncmp ((const char *) filename->data, current_entry,
6947                                   BUFFER_LENGTH (filename)) != 0)
6948                     continue;
6949                   found |= note_possible_classname (current_entry,
6950                                                     current_entry_len);
6951                 }
6952             }
6953         }
6954       else
6955         {
6956           BUFFER_RESET (filename);
6957           buffer_grow (filename, entry_length + package_length + 4);
6958           strcpy ((char *) filename->data, entry_name);
6959           filename->ptr = filename->data + entry_length;
6960           for (k = 0; k < package_length; k++)
6961             {
6962               char ch = package_name[k];
6963               *filename->ptr++ = ch == '.' ? '/' : ch;
6964             }
6965           *filename->ptr = '\0';
6966
6967           dirp = opendir ((const char *) filename->data);
6968           if (dirp == NULL)
6969             continue;
6970           *filename->ptr++ = '/';
6971           for (;;)
6972             {
6973               int len;
6974               const char *d_name;
6975               struct dirent *direntp = readdir (dirp);
6976               if (!direntp)
6977                 break;
6978               d_name = direntp->d_name;
6979               len = strlen (direntp->d_name);
6980               buffer_grow (filename, len+1);
6981               strcpy ((char *) filename->ptr, d_name);
6982               found |= note_possible_classname ((const char *) filename->data + entry_length,
6983                                                 package_length+len+1);
6984             }
6985           if (dirp)
6986             closedir (dirp);
6987         }
6988     }
6989
6990   free (filename->data);
6991
6992   /* Here we should have a unified way of retrieving an entry, to be
6993      indexed. */
6994   if (!found)
6995     {
6996       static int first = 1;
6997       if (first)
6998         {
6999           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
7000           java_error_count++;
7001           first = 0;
7002         }
7003       else
7004         parse_error_context (wfl, "Package `%s' not found in import",
7005                              package_name);
7006       current_jcf = saved_jcf;
7007       return;
7008     }
7009   current_jcf = saved_jcf;
7010 }
7011
7012 /* Possibly find a type in the import on demands specified
7013    types. Returns 1 if an error occurred, 0 otherwise. Run through the
7014    entire list, to detected potential double definitions.  */
7015
7016 static int
7017 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7018 {
7019   tree class_type_name = TYPE_NAME (class_type);
7020   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7021                   ctxp->import_demand_list);
7022   tree cl = NULL_TREE;
7023   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7024   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7025   tree node;
7026
7027   for (; import; import = TREE_CHAIN (import))
7028     {
7029       int saved_lineno = input_line;
7030       int access_check;
7031       const char *id_name;
7032       tree decl, type_name_copy;
7033
7034       obstack_grow (&temporary_obstack,
7035                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7036                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7037       obstack_1grow (&temporary_obstack, '.');
7038       obstack_grow0 (&temporary_obstack,
7039                      IDENTIFIER_POINTER (class_type_name),
7040                      IDENTIFIER_LENGTH (class_type_name));
7041       id_name = obstack_finish (&temporary_obstack);
7042
7043       if (! (node = maybe_get_identifier (id_name)))
7044         continue;
7045
7046       /* Setup input_line so that it refers to the line of the import (in
7047          case we parse a class file and encounter errors */
7048       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7049
7050       type_name_copy = TYPE_NAME (class_type);
7051       TYPE_NAME (class_type) = node;
7052       QUALIFIED_P (node) = 1;
7053       decl = IDENTIFIER_CLASS_VALUE (node);
7054       access_check = -1;
7055       /* If there is no DECL set for the class or if the class isn't
7056          loaded and not seen in source yet, then load */
7057       if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
7058         {
7059           load_class (node, 0);
7060           decl = IDENTIFIER_CLASS_VALUE (node);
7061         }
7062       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7063         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7064                                                false, NULL_TREE);
7065       else
7066         /* 6.6.1: Inner classes are subject to member access rules. */
7067         access_check = 0;
7068
7069       input_line = saved_lineno;
7070
7071       /* If the loaded class is not accessible or couldn't be loaded,
7072          we restore the original TYPE_NAME and process the next
7073          import. */
7074       if (access_check || !decl)
7075         {
7076           TYPE_NAME (class_type) = type_name_copy;
7077           continue;
7078         }
7079
7080       /* If the loaded class is accessible, we keep a tab on it to
7081          detect and report multiple inclusions. */
7082       if (IS_A_CLASSFILE_NAME (node))
7083         {
7084           if (seen_once < 0)
7085             {
7086               cl = TREE_PURPOSE (import);
7087               seen_once = 1;
7088             }
7089           else if (seen_once >= 0)
7090             {
7091               tree location = (cl ? cl : TREE_PURPOSE (import));
7092               tree package = (cl ? EXPR_WFL_NODE (cl) :
7093                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7094               seen_once++;
7095               parse_error_context
7096                 (location,
7097                  "Type `%s' also potentially defined in package `%s'",
7098                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7099                  IDENTIFIER_POINTER (package));
7100             }
7101         }
7102       to_return = access_check;
7103     }
7104
7105   if (seen_once == 1)
7106     return to_return;
7107   else
7108     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7109 }
7110
7111 /* Add package NAME to the list of packages encountered so far. To
7112    speed up class lookup in do_resolve_class, we make sure a
7113    particular package is added only once.  */
7114
7115 static void
7116 register_package (tree name)
7117 {
7118   static htab_t pht;
7119   void **e;
7120
7121   if (pht == NULL)
7122     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7123
7124   e = htab_find_slot (pht, name, INSERT);
7125   if (*e == NULL)
7126     {
7127       package_list = chainon (package_list, build_tree_list (name, NULL));
7128       *e = name;
7129     }
7130 }
7131
7132 static tree
7133 resolve_package (tree pkg, tree *next, tree *type_name)
7134 {
7135   tree current;
7136   tree decl = NULL_TREE;
7137   *type_name = NULL_TREE;
7138
7139   /* The trick is to determine when the package name stops and were
7140      the name of something contained in the package starts. Then we
7141      return a fully qualified name of what we want to get. */
7142
7143   *next = EXPR_WFL_QUALIFICATION (pkg);
7144
7145   /* Try to progressively construct a type name */
7146   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7147     for (current = EXPR_WFL_QUALIFICATION (pkg);
7148          current; current = TREE_CHAIN (current))
7149       {
7150         /* If we don't have what we're expecting, exit now. TYPE_NAME
7151            will be null and the error caught later. */
7152         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7153           break;
7154         *type_name =
7155           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7156         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7157           {
7158             /* resolve_package should be used in a loop, hence we
7159                point at this one to naturally process the next one at
7160                the next iteration. */
7161             *next = current;
7162             break;
7163           }
7164       }
7165   return decl;
7166 }
7167
7168
7169 /* Check accessibility of inner classes according to member access rules.
7170    DECL is the inner class, ENCLOSING_DECL is the class from which the
7171    access is being attempted. */
7172
7173 static void
7174 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7175 {
7176   const char *access;
7177   tree enclosing_decl_type;
7178
7179   /* We don't issue an error message when CL is null. CL can be null
7180      as a result of processing a JDEP crafted by source_start_java_method
7181      for the purpose of patching its parm decl. But the error would
7182      have been already trapped when fixing the method's signature.
7183      DECL can also be NULL in case of earlier errors. */
7184   if (!decl || !cl)
7185     return;
7186
7187   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7188
7189   if (CLASS_PRIVATE (decl))
7190     {
7191       /* Access is permitted only within the body of the top-level
7192          class in which DECL is declared. */
7193       tree top_level = decl;
7194       while (DECL_CONTEXT (top_level))
7195         top_level = DECL_CONTEXT (top_level);
7196       while (DECL_CONTEXT (enclosing_decl))
7197         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7198       if (top_level == enclosing_decl)
7199         return;
7200       access = "private";
7201     }
7202   else if (CLASS_PROTECTED (decl))
7203     {
7204       tree decl_context;
7205       /* Access is permitted from within the same package... */
7206       if (in_same_package (decl, enclosing_decl))
7207         return;
7208
7209       /* ... or from within the body of a subtype of the context in which
7210          DECL is declared. */
7211       decl_context = DECL_CONTEXT (decl);
7212       while (enclosing_decl)
7213         {
7214           if (CLASS_INTERFACE (decl))
7215             {
7216               if (interface_of_p (TREE_TYPE (decl_context),
7217                                   enclosing_decl_type))
7218                 return;
7219             }
7220           else
7221             {
7222               /* Eww. The order of the arguments is different!! */
7223               if (inherits_from_p (enclosing_decl_type,
7224                                    TREE_TYPE (decl_context)))
7225                 return;
7226             }
7227           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7228         }
7229       access = "protected";
7230     }
7231   else if (! CLASS_PUBLIC (decl))
7232     {
7233       /* Access is permitted only from within the same package as DECL. */
7234       if (in_same_package (decl, enclosing_decl))
7235         return;
7236       access = "non-public";
7237     }
7238   else
7239     /* Class is public. */
7240     return;
7241
7242   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7243                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7244                        lang_printable_name (decl, 2), access);
7245 }
7246
7247 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7248    foreign package, it must be PUBLIC. Return 0 if no access
7249    violations were found, 1 otherwise. If VERBOSE is true and an error
7250    was found, it is reported and accounted for.  If CL is NULL then
7251    look it up with THIS_DECL.  */
7252
7253 static int
7254 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7255 {
7256   tree type;
7257
7258   if (!IDENTIFIER_CLASS_VALUE (class_name))
7259     return 0;
7260
7261   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7262     return 0;
7263
7264   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7265     {
7266       /* Access to a private class within the same package is
7267          allowed. */
7268       tree l, r;
7269       split_qualified_name (&l, &r, class_name);
7270       if (!QUALIFIED_P (class_name) && !ctxp->package)
7271         /* Both in the empty package. */
7272         return 0;
7273       if (l == ctxp->package)
7274         /* Both in the same package. */
7275         return 0;
7276
7277       if (verbose)
7278         parse_error_context
7279           (cl == NULL ? lookup_cl (this_decl): cl,
7280            "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7281            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7282            IDENTIFIER_POINTER (class_name));
7283       return 1;
7284     }
7285   return 0;
7286 }
7287
7288 /* Local variable declaration. */
7289
7290 static void
7291 declare_local_variables (int modifier, tree type, tree vlist)
7292 {
7293   tree decl, current, saved_type;
7294   tree type_wfl = NULL_TREE;
7295   int must_chain = 0;
7296   int final_p = 0;
7297
7298   /* Push a new block if statements were seen between the last time we
7299      pushed a block and now. Keep a count of blocks to close */
7300   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7301     {
7302       tree b = enter_block ();
7303       BLOCK_IS_IMPLICIT (b) = 1;
7304     }
7305
7306   if (modifier)
7307     {
7308       size_t i;
7309       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7310         if (1 << i & modifier)
7311           break;
7312       if (modifier == ACC_FINAL)
7313         final_p = 1;
7314       else
7315         {
7316           parse_error_context
7317             (ctxp->modifier_ctx [i],
7318              "Only `final' is allowed as a local variables modifier");
7319           return;
7320         }
7321     }
7322
7323   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7324      hold the TYPE value if a new incomplete has to be created (as
7325      opposed to being found already existing and reused). */
7326   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7327
7328   /* If TYPE is fully resolved and we don't have a reference, make one */
7329   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7330
7331   /* Go through all the declared variables */
7332   for (current = vlist, saved_type = type; current;
7333        current = TREE_CHAIN (current), type = saved_type)
7334     {
7335       tree other, real_type;
7336       tree wfl  = TREE_PURPOSE (current);
7337       tree name = EXPR_WFL_NODE (wfl);
7338       tree init = TREE_VALUE (current);
7339
7340       /* Process NAME, as it may specify extra dimension(s) for it */
7341       type = build_array_from_name (type, type_wfl, name, &name);
7342
7343       /* Variable redefinition check */
7344       if ((other = lookup_name_in_blocks (name)))
7345         {
7346           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7347                                        DECL_SOURCE_LINE (other));
7348           continue;
7349         }
7350
7351       /* Type adjustment. We may have just readjusted TYPE because
7352          the variable specified more dimensions. Make sure we have
7353          a reference if we can and don't have one already. */
7354       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7355
7356       real_type = GET_REAL_TYPE (type);
7357       /* Never layout this decl. This will be done when its scope
7358          will be entered */
7359       decl = build_decl (VAR_DECL, name, real_type);
7360       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7361       DECL_FINAL (decl) = final_p;
7362       BLOCK_CHAIN_DECL (decl);
7363
7364       /* If doing xreferencing, replace the line number with the WFL
7365          compound value */
7366       if (flag_emit_xref)
7367         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7368
7369       /* Don't try to use an INIT statement when an error was found */
7370       if (init && java_error_count)
7371         init = NULL_TREE;
7372
7373       /* Remember it if this is an initialized-upon-declaration final
7374          variable.  */
7375       if (init && final_p)
7376         {
7377           DECL_LOCAL_FINAL_IUD (decl) = 1;
7378         }
7379
7380       /* Add the initialization function to the current function's code */
7381       if (init)
7382         {
7383           /* Name might have been readjusted */
7384           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7385           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7386           java_method_add_stmt (current_function_decl,
7387                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7388                                                       init));
7389         }
7390
7391       /* Setup dependency the type of the decl */
7392       if (must_chain)
7393         {
7394           jdep *dep;
7395           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7396           dep = CLASSD_LAST (ctxp->classd_list);
7397           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7398         }
7399     }
7400   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7401 }
7402
7403 /* Called during parsing. Build decls from argument list.  */
7404
7405 static void
7406 source_start_java_method (tree fndecl)
7407 {
7408   tree tem;
7409   tree parm_decl;
7410   int i;
7411
7412   if (!fndecl)
7413     return;
7414
7415   current_function_decl = fndecl;
7416
7417   /* New scope for the function */
7418   enter_block ();
7419   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7420        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7421     {
7422       tree type = TREE_VALUE (tem);
7423       tree name = TREE_PURPOSE (tem);
7424
7425       /* If type is incomplete. Create an incomplete decl and ask for
7426          the decl to be patched later */
7427       if (INCOMPLETE_TYPE_P (type))
7428         {
7429           jdep *jdep;
7430           tree real_type = GET_REAL_TYPE (type);
7431           parm_decl = build_decl (PARM_DECL, name, real_type);
7432           type = obtain_incomplete_type (type);
7433           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7434           jdep = CLASSD_LAST (ctxp->classd_list);
7435           JDEP_MISC (jdep) = name;
7436           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7437         }
7438       else
7439         parm_decl = build_decl (PARM_DECL, name, type);
7440
7441       /* Remember if a local variable was declared final (via its
7442          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7443       if (ARG_FINAL_P (tem))
7444         {
7445           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7446           DECL_FINAL (parm_decl) = 1;
7447         }
7448
7449       BLOCK_CHAIN_DECL (parm_decl);
7450     }
7451   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7452   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7453     nreverse (tem);
7454   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7455   DECL_MAX_LOCALS (current_function_decl) = i;
7456 }
7457
7458 /* Called during parsing. Creates an artificial method declaration.  */
7459
7460 static tree
7461 create_artificial_method (tree class, int flags, tree type,
7462                           tree name, tree args)
7463 {
7464   tree mdecl;
7465
7466   java_parser_context_save_global ();
7467   input_line = 0;
7468   mdecl = make_node (FUNCTION_TYPE);
7469   TREE_TYPE (mdecl) = type;
7470   TYPE_ARG_TYPES (mdecl) = args;
7471   /* We used to compute the signature of MDECL here and then use
7472      add_method(), but that failed because our caller might modify
7473      the type of the returned method, which trashes the cache in
7474      get_type_from_signature().  */
7475   mdecl = add_method_1 (class, flags, name, mdecl);
7476   java_parser_context_restore_global ();
7477   DECL_ARTIFICIAL (mdecl) = 1;
7478   return mdecl;
7479 }
7480
7481 /* Starts the body if an artificial method.  */
7482
7483 static void
7484 start_artificial_method_body (tree mdecl)
7485 {
7486   DECL_SOURCE_LINE (mdecl) = 1;
7487   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7488   source_start_java_method (mdecl);
7489   enter_block ();
7490 }
7491
7492 static void
7493 end_artificial_method_body (tree mdecl)
7494 {
7495   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7496      It has to be evaluated first. (if mdecl is current_function_decl,
7497      we have an undefined behavior if no temporary variable is used.) */
7498   tree b = exit_block ();
7499   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7500   exit_block ();
7501 }
7502
7503 /* Dump a tree of some kind.  This is a convenience wrapper for the
7504    dump_* functions in tree-dump.c.  */
7505 static void
7506 dump_java_tree (enum tree_dump_index phase, tree t)
7507 {
7508   FILE *stream;
7509   int flags;
7510
7511   stream = dump_begin (phase, &flags);
7512   flags |= TDF_SLIM;
7513   if (stream)
7514     {
7515       dump_node (t, flags, stream);
7516       dump_end (phase, stream);
7517     }
7518 }
7519
7520 /* Terminate a function and expand its body.  */
7521
7522 static void
7523 source_end_java_method (void)
7524 {
7525   tree fndecl = current_function_decl;
7526
7527   if (!fndecl)
7528     return;
7529
7530   java_parser_context_save_global ();
7531   input_line = ctxp->last_ccb_indent1;
7532
7533   /* Turn function bodies with only a NOP expr null, so they don't get
7534      generated at all and we won't get warnings when using the -W
7535      -Wall flags. */
7536   if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7537     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7538
7539   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7540       && ! flag_emit_class_files
7541       && ! flag_emit_xref)
7542     finish_method (fndecl);
7543
7544   current_function_decl = NULL_TREE;
7545   java_parser_context_restore_global ();
7546   current_function_decl = NULL_TREE;
7547 }
7548
7549 /* Record EXPR in the current function block. Complements compound
7550    expression second operand if necessary.  */
7551
7552 tree
7553 java_method_add_stmt (tree fndecl, tree expr)
7554 {
7555   if (!GET_CURRENT_BLOCK (fndecl))
7556     return NULL_TREE;
7557   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7558 }
7559
7560 static tree
7561 add_stmt_to_block (tree b, tree type, tree stmt)
7562 {
7563   tree body = BLOCK_EXPR_BODY (b), c;
7564
7565   if (java_error_count)
7566     return body;
7567
7568   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7569     return body;
7570
7571   BLOCK_EXPR_BODY (b) = c;
7572   TREE_SIDE_EFFECTS (c) = 1;
7573   return c;
7574 }
7575
7576 /* Lays out the methods for the classes seen so far.  */
7577
7578 void
7579 java_layout_seen_class_methods (void)
7580 {
7581   tree previous_list = all_class_list;
7582   tree end = NULL_TREE;
7583   tree current;
7584
7585   while (1)
7586     {
7587       for (current = previous_list;
7588            current != end; current = TREE_CHAIN (current))
7589         {
7590           tree cls = TREE_TYPE (TREE_VALUE (current));
7591
7592           if (! CLASS_LOADED_P (cls))
7593             load_class (cls, 0);
7594
7595           layout_class_methods (cls);
7596         }
7597
7598       /* Note that new classes might have been added while laying out
7599          methods, changing the value of all_class_list.  */
7600
7601       if (previous_list != all_class_list)
7602         {
7603           end = previous_list;
7604           previous_list = all_class_list;
7605         }
7606       else
7607         break;
7608     }
7609 }
7610
7611 static GTY(()) tree stop_reordering;
7612 void
7613 java_reorder_fields (void)
7614 {
7615   tree current;
7616
7617   for (current = gclass_list; current; current = TREE_CHAIN (current))
7618     {
7619       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7620
7621       if (current_class == stop_reordering)
7622         break;
7623
7624       /* Reverse the fields, but leave the dummy field in front.
7625          Fields are already ordered for Object and Class */
7626       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7627           && current_class != class_type_node)
7628       {
7629         /* If the dummy field is there, reverse the right fields and
7630            just layout the type for proper fields offset */
7631         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7632           {
7633             tree fields = TYPE_FIELDS (current_class);
7634             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7635             TYPE_SIZE (current_class) = NULL_TREE;
7636           }
7637         /* We don't have a dummy field, we need to layout the class,
7638            after having reversed the fields */
7639         else
7640           {
7641             TYPE_FIELDS (current_class) =
7642               nreverse (TYPE_FIELDS (current_class));
7643             TYPE_SIZE (current_class) = NULL_TREE;
7644           }
7645       }
7646     }
7647   /* There are cases were gclass_list will be empty. */
7648   if (gclass_list)
7649     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7650 }
7651
7652 /* Layout the methods of all classes loaded in one way or another.
7653    Check methods of source parsed classes. Then reorder the
7654    fields and layout the classes or the type of all source parsed
7655    classes */
7656
7657 void
7658 java_layout_classes (void)
7659 {
7660   tree current;
7661   int save_error_count = java_error_count;
7662
7663   /* Layout the methods of all classes seen so far */
7664   java_layout_seen_class_methods ();
7665   java_parse_abort_on_error ();
7666   all_class_list = NULL_TREE;
7667
7668   /* Then check the methods of all parsed classes */
7669   for (current = gclass_list; current; current = TREE_CHAIN (current))
7670     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7671       java_check_methods (TREE_VALUE (current));
7672   java_parse_abort_on_error ();
7673
7674   for (current = gclass_list; current; current = TREE_CHAIN (current))
7675     {
7676       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7677       layout_class (current_class);
7678
7679       /* Error reported by the caller */
7680       if (java_error_count)
7681         return;
7682     }
7683
7684   /* We might have reloaded classes durign the process of laying out
7685      classes for code generation. We must layout the methods of those
7686      late additions, as constructor checks might use them */
7687   java_layout_seen_class_methods ();
7688   java_parse_abort_on_error ();
7689 }
7690
7691 /* Expand methods in the current set of classes remembered for
7692    generation.  */
7693
7694 static void
7695 java_complete_expand_classes (void)
7696 {
7697   tree current;
7698
7699   do_not_fold = flag_emit_xref;
7700
7701   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7702     if (!INNER_CLASS_DECL_P (current))
7703       java_complete_expand_class (current);
7704 }
7705
7706 /* Expand the methods found in OUTER, starting first by OUTER's inner
7707    classes, if any.  */
7708
7709 static void
7710 java_complete_expand_class (tree outer)
7711 {
7712   tree inner_list;
7713
7714   /* We need to go after all inner classes and start expanding them,
7715      starting with most nested ones. We have to do that because nested
7716      classes might add functions to outer classes */
7717
7718   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7719        inner_list; inner_list = TREE_CHAIN (inner_list))
7720     java_complete_expand_class (TREE_PURPOSE (inner_list));
7721
7722   java_complete_expand_methods (outer);
7723 }
7724
7725 /* Expand methods registered in CLASS_DECL. The general idea is that
7726    we expand regular methods first. This allows us get an estimate on
7727    how outer context local alias fields are really used so we can add
7728    to the constructor just enough code to initialize them properly (it
7729    also lets us generate finit$ correctly.) Then we expand the
7730    constructors and then <clinit>.  */
7731
7732 static void
7733 java_complete_expand_methods (tree class_decl)
7734 {
7735   tree clinit, decl, first_decl;
7736
7737   output_class = current_class = TREE_TYPE (class_decl);
7738
7739   /* Pre-expand <clinit> to figure whether we really need it or
7740      not. If we do need it, we pre-expand the static fields so they're
7741      ready to be used somewhere else. <clinit> will be fully expanded
7742      after we processed the constructors. */
7743   first_decl = TYPE_METHODS (current_class);
7744   clinit = maybe_generate_pre_expand_clinit (current_class);
7745
7746   /* Then generate finit$ (if we need to) because constructors will
7747    try to use it.*/
7748   if (TYPE_FINIT_STMT_LIST (current_class))
7749     java_complete_expand_method (generate_finit (current_class));
7750
7751   /* Then generate instinit$ (if we need to) because constructors will
7752      try to use it. */
7753   if (TYPE_II_STMT_LIST (current_class))
7754     java_complete_expand_method (generate_instinit (current_class));
7755
7756   /* Now do the constructors */
7757   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7758     {
7759       if (!DECL_CONSTRUCTOR_P (decl))
7760         continue;
7761       java_complete_expand_method (decl);
7762     }
7763
7764   /* First, do the ordinary methods. */
7765   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7766     {
7767       /* Ctors aren't part of this batch. */
7768       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7769         continue;
7770
7771       /* Skip abstract or native methods -- but do handle native
7772          methods when generating JNI stubs.  */
7773       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7774         {
7775           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7776           continue;
7777         }
7778
7779       if (METHOD_NATIVE (decl))
7780         {
7781           tree body;
7782           current_function_decl = decl;
7783           body = build_jni_stub (decl);
7784           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7785         }
7786
7787       java_complete_expand_method (decl);
7788     }
7789
7790   /* If there is indeed a <clinit>, fully expand it now */
7791   if (clinit)
7792     {
7793       /* Prevent the use of `this' inside <clinit> */
7794       ctxp->explicit_constructor_p = 1;
7795       java_complete_expand_method (clinit);
7796       ctxp->explicit_constructor_p = 0;
7797     }
7798
7799   /* We might have generated a class$ that we now want to expand */
7800   if (TYPE_DOT_CLASS (current_class))
7801     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7802
7803   /* Now verify constructor circularity (stop after the first one we
7804      prove wrong.) */
7805   if (!CLASS_INTERFACE (class_decl))
7806     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7807       if (DECL_CONSTRUCTOR_P (decl)
7808           && verify_constructor_circularity (decl, decl))
7809         break;
7810 }
7811
7812 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7813    safely used in some other methods/constructors.  */
7814
7815 static tree
7816 maybe_generate_pre_expand_clinit (tree class_type)
7817 {
7818   tree current, mdecl;
7819
7820   if (!TYPE_CLINIT_STMT_LIST (class_type))
7821     return NULL_TREE;
7822
7823   /* Go through all static fields and pre expand them */
7824   for (current = TYPE_FIELDS (class_type); current;
7825        current = TREE_CHAIN (current))
7826     if (FIELD_STATIC (current))
7827       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7828
7829   /* Then build the <clinit> method */
7830   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7831                                     clinit_identifier_node, end_params_node);
7832   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7833                        mdecl, NULL_TREE);
7834   start_artificial_method_body (mdecl);
7835
7836   /* We process the list of assignment we produced as the result of
7837      the declaration of initialized static field and add them as
7838      statement to the <clinit> method. */
7839   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7840        current = TREE_CHAIN (current))
7841     {
7842       tree stmt = current;
7843       /* We build the assignment expression that will initialize the
7844          field to its value. There are strict rules on static
7845          initializers (8.5). FIXME */
7846       if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
7847         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7848       java_method_add_stmt (mdecl, stmt);
7849     }
7850
7851   end_artificial_method_body (mdecl);
7852
7853   /* Now we want to place <clinit> as the last method (because we need
7854      it at least for interface so that it doesn't interfere with the
7855      dispatch table based lookup. */
7856   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7857     {
7858       current = TREE_CHAIN (TYPE_METHODS (class_type));
7859       TYPE_METHODS (class_type) = current;
7860
7861       while (TREE_CHAIN (current))
7862         current = TREE_CHAIN (current);
7863
7864       TREE_CHAIN (current) = mdecl;
7865       TREE_CHAIN (mdecl) = NULL_TREE;
7866     }
7867
7868   return mdecl;
7869 }
7870
7871 /* Analyzes a method body and look for something that isn't a
7872    MODIFY_EXPR with a constant value.  */
7873
7874 static int
7875 analyze_clinit_body (tree this_class, tree bbody)
7876 {
7877   while (bbody)
7878     switch (TREE_CODE (bbody))
7879       {
7880       case BLOCK:
7881         bbody = BLOCK_EXPR_BODY (bbody);
7882         break;
7883
7884       case EXPR_WITH_FILE_LOCATION:
7885         bbody = EXPR_WFL_NODE (bbody);
7886         break;
7887
7888       case COMPOUND_EXPR:
7889         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7890           return 1;
7891         bbody = TREE_OPERAND (bbody, 1);
7892         break;
7893
7894       case MODIFY_EXPR:
7895         /* If we're generating to class file and we're dealing with an
7896            array initialization, we return 1 to keep <clinit> */
7897         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7898             && flag_emit_class_files)
7899           return 1;
7900
7901         /* There are a few cases where we're required to keep
7902            <clinit>:
7903            - If this is an assignment whose operand is not constant,
7904            - If this is an assignment to a non-initialized field,
7905            - If this field is not a member of the current class.
7906         */
7907         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7908                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7909                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7910
7911       default:
7912         return 1;
7913       }
7914   return 0;
7915 }
7916
7917
7918 /* See whether we could get rid of <clinit>. Criteria are: all static
7919    final fields have constant initial values and the body of <clinit>
7920    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7921
7922 static int
7923 maybe_yank_clinit (tree mdecl)
7924 {
7925   tree type, current;
7926   tree fbody, bbody;
7927
7928   if (!DECL_CLINIT_P (mdecl))
7929     return 0;
7930
7931   /* If the body isn't empty, then we keep <clinit>. Note that if
7932      we're emitting classfiles, this isn't enough not to rule it
7933      out. */
7934   fbody = DECL_FUNCTION_BODY (mdecl);
7935   bbody = BLOCK_EXPR_BODY (fbody);
7936   if (bbody && bbody != error_mark_node)
7937     bbody = BLOCK_EXPR_BODY (bbody);
7938   else
7939     return 0;
7940   if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
7941     return 0;
7942
7943   type = DECL_CONTEXT (mdecl);
7944   current = TYPE_FIELDS (type);
7945
7946   for (current = (current ? TREE_CHAIN (current) : current);
7947        current; current = TREE_CHAIN (current))
7948     {
7949       tree f_init;
7950
7951       /* We're not interested in non-static fields.  */
7952       if (!FIELD_STATIC (current))
7953         continue;
7954
7955       /* Nor in fields without initializers. */
7956       f_init = DECL_INITIAL (current);
7957       if (f_init == NULL_TREE)
7958         continue;
7959
7960       /* Anything that isn't String or a basic type is ruled out -- or
7961          if we know how to deal with it (when doing things natively) we
7962          should generated an empty <clinit> so that SUID are computed
7963          correctly. */
7964       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7965           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7966         return 0;
7967
7968       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7969         return 0;
7970     }
7971
7972   /* Now we analyze the method body and look for something that
7973      isn't a MODIFY_EXPR */
7974   if (!IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
7975     return 0;
7976
7977   /* Get rid of <clinit> in the class' list of methods */
7978   if (TYPE_METHODS (type) == mdecl)
7979     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7980   else
7981     for (current = TYPE_METHODS (type); current;
7982          current = TREE_CHAIN (current))
7983       if (TREE_CHAIN (current) == mdecl)
7984         {
7985           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7986           break;
7987         }
7988
7989   return 1;
7990 }
7991
7992 /* Install the argument from MDECL. Suitable to completion and
7993    expansion of mdecl's body.  */
7994
7995 void
7996 start_complete_expand_method (tree mdecl)
7997 {
7998   tree tem;
7999
8000   pushlevel (1);                /* Prepare for a parameter push */
8001   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
8002   DECL_ARGUMENTS (mdecl) = tem;
8003
8004   for (; tem; tem = TREE_CHAIN (tem))
8005     {
8006       /* TREE_CHAIN (tem) will change after pushdecl. */
8007       tree next = TREE_CHAIN (tem);
8008       tree type = TREE_TYPE (tem);
8009       if (targetm.calls.promote_prototypes (type)
8010           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8011           && INTEGRAL_TYPE_P (type))
8012         type = integer_type_node;
8013       DECL_ARG_TYPE (tem) = type;
8014       layout_decl (tem, 0);
8015       pushdecl (tem);
8016       /* Re-install the next so that the list is kept and the loop
8017          advances. */
8018       TREE_CHAIN (tem) = next;
8019     }
8020   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8021   input_line = DECL_SOURCE_LINE (mdecl);
8022   build_result_decl (mdecl);
8023 }
8024
8025
8026 /* Complete and expand a method.  */
8027
8028 static void
8029 java_complete_expand_method (tree mdecl)
8030 {
8031   tree fbody, block_body, exception_copy;
8032
8033   current_function_decl = mdecl;
8034   /* Fix constructors before expanding them */
8035   if (DECL_CONSTRUCTOR_P (mdecl))
8036     fix_constructors (mdecl);
8037
8038   /* Expand functions that have a body */
8039   if (!DECL_FUNCTION_BODY (mdecl))
8040     return;
8041
8042   fbody = DECL_FUNCTION_BODY (mdecl);
8043   block_body = BLOCK_EXPR_BODY (fbody);
8044   exception_copy = NULL_TREE;
8045
8046   current_function_decl = mdecl;
8047
8048   if (! quiet_flag)
8049     fprintf (stderr, " [%s.",
8050              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8051   announce_function (mdecl);
8052   if (! quiet_flag)
8053     fprintf (stderr, "]");
8054
8055   /* Prepare the function for tree completion */
8056   start_complete_expand_method (mdecl);
8057
8058   /* Install the current this */
8059   current_this = (!METHOD_STATIC (mdecl) ?
8060                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8061
8062   /* Purge the `throws' list of unchecked exceptions (we save a copy
8063      of the list and re-install it later.) */
8064   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8065   purge_unchecked_exceptions (mdecl);
8066
8067   /* Install exceptions thrown with `throws' */
8068   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8069
8070   if (block_body != NULL_TREE)
8071     {
8072       block_body = java_complete_tree (block_body);
8073
8074       /* Before we check initialization, attached all class initialization
8075          variable to the block_body */
8076       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8077                      attach_init_test_initialization_flags, block_body);
8078
8079       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8080         {
8081           check_for_initialization (block_body, mdecl);
8082
8083           /* Go through all the flags marking the initialization of
8084              static variables and see whether they're definitively
8085              assigned, in which case the type is remembered as
8086              definitively initialized in MDECL. */
8087           if (STATIC_CLASS_INIT_OPT_P ())
8088             {
8089               /* Always register the context as properly initialized in
8090                  MDECL. This used with caution helps removing extra
8091                  initialization of self. */
8092               if (METHOD_STATIC (mdecl))
8093                 {
8094                   *(htab_find_slot
8095                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8096                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8097                 }
8098             }
8099         }
8100       ctxp->explicit_constructor_p = 0;
8101     }
8102
8103   BLOCK_EXPR_BODY (fbody) = block_body;
8104
8105   /* If we saw a return but couldn't evaluate it properly, we'll have
8106      an error_mark_node here. */
8107   if (block_body != error_mark_node
8108       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8109       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8110       && !flag_emit_xref)
8111     missing_return_error (current_function_decl);
8112
8113   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8114   maybe_yank_clinit (mdecl);
8115
8116   /* Pop the current level, with special measures if we found errors. */
8117   if (java_error_count)
8118     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8119   poplevel (1, 0, 1);
8120
8121   /* Pop the exceptions and sanity check */
8122   POP_EXCEPTIONS();
8123   if (currently_caught_type_list)
8124     abort ();
8125
8126   /* Restore the copy of the list of exceptions if emitting xrefs. */
8127   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8128 }
8129
8130 /* For with each class for which there's code to generate. */
8131
8132 static void
8133 java_expand_method_bodies (tree class)
8134 {
8135   tree decl;
8136   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8137     {
8138       tree block;
8139
8140       if (! DECL_FUNCTION_BODY (decl))
8141         continue;
8142
8143       current_function_decl = decl;
8144
8145       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8146
8147       /* Save the function body for gimplify and inlining.  */
8148       DECL_SAVED_TREE (decl) = block;
8149
8150       /* It's time to assign the variable flagging static class
8151          initialization based on which classes invoked static methods
8152          are definitely initializing. This should be flagged. */
8153       if (STATIC_CLASS_INIT_OPT_P ())
8154         {
8155           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8156           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8157             {
8158               /* Executed for each statement calling a static function.
8159                  LIST is a TREE_LIST whose PURPOSE is the called function
8160                  and VALUE is a compound whose second operand can be patched
8161                  with static class initialization flag assignments.  */
8162
8163               tree called_method = TREE_PURPOSE (list);
8164               tree compound = TREE_VALUE (list);
8165               tree assignment_compound_list
8166                 = build_tree_list (called_method, NULL);
8167
8168               /* For each class definitely initialized in
8169                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8170                  assignment to the class initialization flag. */
8171               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8172                              emit_test_initialization,
8173                              assignment_compound_list);
8174
8175               if (TREE_VALUE (assignment_compound_list))
8176                 TREE_OPERAND (compound, 1)
8177                   = TREE_VALUE (assignment_compound_list);
8178             }
8179         }
8180
8181       /* Expand the function body.  */
8182       source_end_java_method ();
8183     }
8184 }
8185
8186 \f
8187
8188 /* This section of the code deals with accessing enclosing context
8189    fields either directly by using the relevant access to this$<n> or
8190    by invoking an access method crafted for that purpose.  */
8191
8192 /* Build the necessary access from an inner class to an outer
8193    class. This routine could be optimized to cache previous result
8194    (decl, current_class and returned access).  When an access method
8195    needs to be generated, it always takes the form of a read. It might
8196    be later turned into a write by calling outer_field_access_fix.  */
8197
8198 static tree
8199 build_outer_field_access (tree id, tree decl)
8200 {
8201   tree access = NULL_TREE;
8202   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8203   tree decl_ctx = DECL_CONTEXT (decl);
8204
8205   /* If the immediate enclosing context of the current class is the
8206      field decl's class or inherits from it; build the access as
8207      `this$<n>.<field>'. Note that we will break the `private' barrier
8208      if we're not emitting bytecodes. */
8209   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8210       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8211     {
8212       tree thisn = build_current_thisn (current_class);
8213       access = make_qualified_primary (build_wfl_node (thisn),
8214                                        id, EXPR_WFL_LINECOL (id));
8215     }
8216   /* Otherwise, generate access methods to outer this and access the
8217      field (either using an access method or by direct access.) */
8218   else
8219     {
8220       int lc = EXPR_WFL_LINECOL (id);
8221
8222       /* Now we chain the required number of calls to the access$0 to
8223          get a hold to the enclosing instance we need, and then we
8224          build the field access. */
8225       access = build_access_to_thisn (current_class, decl_ctx, lc);
8226
8227       /* If the field is private and we're generating bytecode, then
8228          we generate an access method */
8229       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8230         {
8231           tree name = build_outer_field_access_methods (decl);
8232           access = build_outer_field_access_expr (lc, decl_ctx,
8233                                                   name, access, NULL_TREE);
8234         }
8235       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8236          Once again we break the `private' access rule from a foreign
8237          class. */
8238       else
8239         access = make_qualified_primary (access, id, lc);
8240     }
8241   return resolve_expression_name (access, NULL);
8242 }
8243
8244 /* Return a nonzero value if NODE describes an outer field inner
8245    access.  */
8246
8247 static int
8248 outer_field_access_p (tree type, tree decl)
8249 {
8250   if (!INNER_CLASS_TYPE_P (type)
8251       || TREE_CODE (decl) != FIELD_DECL
8252       || DECL_CONTEXT (decl) == type)
8253     return 0;
8254
8255   /* If the inner class extends the declaration context of the field
8256      we're trying to access, then this isn't an outer field access */
8257   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8258     return 0;
8259
8260   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8261        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8262     {
8263       if (type == DECL_CONTEXT (decl))
8264         return 1;
8265
8266       if (!DECL_CONTEXT (TYPE_NAME (type)))
8267         {
8268           /* Before we give up, see whether the field is inherited from
8269              the enclosing context we're considering. */
8270           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8271             return 1;
8272           break;
8273         }
8274     }
8275
8276   return 0;
8277 }
8278
8279 /* Return a nonzero value if NODE represents an outer field inner
8280    access that was been already expanded. As a side effect, it returns
8281    the name of the field being accessed and the argument passed to the
8282    access function, suitable for a regeneration of the access method
8283    call if necessary. */
8284
8285 static int
8286 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8287                                tree *arg)
8288 {
8289   int identified = 0;
8290
8291   if (TREE_CODE (node) != CALL_EXPR)
8292     return 0;
8293
8294   /* Well, gcj generates slightly different tree nodes when compiling
8295      to native or bytecodes. It's the case for function calls. */
8296
8297   if (flag_emit_class_files
8298       && TREE_CODE (node) == CALL_EXPR
8299       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8300     identified = 1;
8301   else if (!flag_emit_class_files)
8302     {
8303       node = TREE_OPERAND (node, 0);
8304
8305       if (node && TREE_OPERAND (node, 0)
8306           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8307         {
8308           node = TREE_OPERAND (node, 0);
8309           if (TREE_OPERAND (node, 0)
8310               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8311               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8312                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8313             identified = 1;
8314         }
8315     }
8316
8317   if (identified && name && arg_type && arg)
8318     {
8319       tree argument = TREE_OPERAND (node, 1);
8320       *name = DECL_NAME (TREE_OPERAND (node, 0));
8321       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8322       *arg = TREE_VALUE (argument);
8323     }
8324   return identified;
8325 }
8326
8327 /* Detect in NODE an outer field read access from an inner class and
8328    transform it into a write with RHS as an argument. This function is
8329    called from the java_complete_lhs when an assignment to a LHS can
8330    be identified. */
8331
8332 static tree
8333 outer_field_access_fix (tree wfl, tree node, tree rhs)
8334 {
8335   tree name, arg_type, arg;
8336
8337   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8338     {
8339       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8340                                             arg_type, name, arg, rhs);
8341       return java_complete_tree (node);
8342     }
8343   return NULL_TREE;
8344 }
8345
8346 /* Construct the expression that calls an access method:
8347      <type>.access$<n>(<arg1> [, <arg2>]);
8348
8349    ARG2 can be NULL and will be omitted in that case. It will denote a
8350    read access.  */
8351
8352 static tree
8353 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8354                                tree arg1, tree arg2)
8355 {
8356   tree args, cn, access;
8357
8358   args = arg1 ? arg1 :
8359     build_wfl_node (build_current_thisn (current_class));
8360   args = build_tree_list (NULL_TREE, args);
8361
8362   if (arg2)
8363     args = tree_cons (NULL_TREE, arg2, args);
8364
8365   access = build_method_invocation (build_wfl_node (access_method_name), args);
8366   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8367   return make_qualified_primary (cn, access, lc);
8368 }
8369
8370 static tree
8371 build_new_access_id (void)
8372 {
8373   static int access_n_counter = 1;
8374   char buffer [128];
8375
8376   sprintf (buffer, "access$%d", access_n_counter++);
8377   return get_identifier (buffer);
8378 }
8379
8380 /* Create the static access functions for the outer field DECL. We define a
8381    read:
8382      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8383        return inst$.field;
8384      }
8385    and a write access:
8386      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8387                                      TREE_TYPE (<field>) value$) {
8388        return inst$.field = value$;
8389      }
8390    We should have a usage flags on the DECL so we can lazily turn the ones
8391    we're using for code generation. FIXME.
8392 */
8393
8394 static tree
8395 build_outer_field_access_methods (tree decl)
8396 {
8397   tree id, args, stmt, mdecl;
8398
8399   if (FIELD_INNER_ACCESS_P (decl))
8400     return FIELD_INNER_ACCESS (decl);
8401
8402   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8403
8404   /* Create the identifier and a function named after it. */
8405   id = build_new_access_id ();
8406
8407   /* The identifier is marked as bearing the name of a generated write
8408      access function for outer field accessed from inner classes. */
8409   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8410
8411   /* Create the read access */
8412   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8413   TREE_CHAIN (args) = end_params_node;
8414   stmt = make_qualified_primary (build_wfl_node (inst_id),
8415                                  build_wfl_node (DECL_NAME (decl)), 0);
8416   stmt = build_return (0, stmt);
8417   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8418                                            TREE_TYPE (decl), id, args, stmt);
8419   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8420
8421   /* Create the write access method. No write access for final variable */
8422   if (!FIELD_FINAL (decl))
8423     {
8424       args = build_tree_list (inst_id,
8425                               build_pointer_type (DECL_CONTEXT (decl)));
8426       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8427       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8428       stmt = make_qualified_primary (build_wfl_node (inst_id),
8429                                      build_wfl_node (DECL_NAME (decl)), 0);
8430       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8431                                                 build_wfl_node (wpv_id)));
8432       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8433                                                TREE_TYPE (decl), id,
8434                                                args, stmt);
8435     }
8436   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8437
8438   /* Return the access name */
8439   return FIELD_INNER_ACCESS (decl) = id;
8440 }
8441
8442 /* Build an field access method NAME.  */
8443
8444 static tree
8445 build_outer_field_access_method (tree class, tree type, tree name,
8446                                  tree args, tree body)
8447 {
8448   tree saved_current_function_decl, mdecl;
8449
8450   /* Create the method */
8451   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8452   fix_method_argument_names (args, mdecl);
8453   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8454
8455   /* Attach the method body. */
8456   saved_current_function_decl = current_function_decl;
8457   start_artificial_method_body (mdecl);
8458   java_method_add_stmt (mdecl, body);
8459   end_artificial_method_body (mdecl);
8460   current_function_decl = saved_current_function_decl;
8461
8462   return mdecl;
8463 }
8464
8465 \f
8466 /* This section deals with building access function necessary for
8467    certain kinds of method invocation from inner classes.  */
8468
8469 static tree
8470 build_outer_method_access_method (tree decl)
8471 {
8472   tree saved_current_function_decl, mdecl;
8473   tree args = NULL_TREE, call_args = NULL_TREE;
8474   tree carg, id, body, class;
8475   char buffer [80];
8476   int parm_id_count = 0;
8477
8478   /* Test this abort with an access to a private field */
8479   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8480     abort ();
8481
8482   /* Check the cache first */
8483   if (DECL_FUNCTION_INNER_ACCESS (decl))
8484     return DECL_FUNCTION_INNER_ACCESS (decl);
8485
8486   class = DECL_CONTEXT (decl);
8487
8488   /* Obtain an access identifier and mark it */
8489   id = build_new_access_id ();
8490   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8491
8492   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8493   /* Create the arguments, as much as the original */
8494   for (; carg && carg != end_params_node;
8495        carg = TREE_CHAIN (carg))
8496     {
8497       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8498       args = chainon (args, build_tree_list (get_identifier (buffer),
8499                                              TREE_VALUE (carg)));
8500     }
8501   args = chainon (args, end_params_node);
8502
8503   /* Create the method */
8504   mdecl = create_artificial_method (class, ACC_STATIC,
8505                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8506   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8507   /* There is a potential bug here. We should be able to use
8508      fix_method_argument_names, but then arg names get mixed up and
8509      eventually a constructor will have its this$0 altered and the
8510      outer context won't be assignment properly. The testcase is
8511      stub.java FIXME */
8512   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8513
8514   /* Attach the method body. */
8515   saved_current_function_decl = current_function_decl;
8516   start_artificial_method_body (mdecl);
8517
8518   /* The actual method invocation uses the same args. When invoking a
8519      static methods that way, we don't want to skip the first
8520      argument. */
8521   carg = args;
8522   if (!METHOD_STATIC (decl))
8523     carg = TREE_CHAIN (carg);
8524   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8525     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8526                            call_args);
8527
8528   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8529                                   call_args);
8530   if (!METHOD_STATIC (decl))
8531     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8532                                    body, 0);
8533   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8534     body = build_return (0, body);
8535   java_method_add_stmt (mdecl,body);
8536   end_artificial_method_body (mdecl);
8537   current_function_decl = saved_current_function_decl;
8538
8539   /* Back tag the access function so it know what it accesses */
8540   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8541
8542   /* Tag the current method so it knows it has an access generated */
8543   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8544 }
8545
8546 \f
8547 /* This section of the code deals with building expressions to access
8548    the enclosing instance of an inner class. The enclosing instance is
8549    kept in a generated field called this$<n>, with <n> being the
8550    inner class nesting level (starting from 0.)  */
8551
8552 /* Build an access to a given this$<n>, always chaining access call to
8553    others. Access methods to this$<n> are build on the fly if
8554    necessary. This CAN'T be used to solely access this$<n-1> from
8555    this$<n> (which alway yield to special cases and optimization, see
8556    for example build_outer_field_access).  */
8557
8558 static tree
8559 build_access_to_thisn (tree from, tree to, int lc)
8560 {
8561   tree access = NULL_TREE;
8562
8563   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8564     {
8565       if (!access)
8566         {
8567           access = build_current_thisn (from);
8568           access = build_wfl_node (access);
8569         }
8570       else
8571         {
8572           tree access0_wfl, cn;
8573
8574           maybe_build_thisn_access_method (from);
8575           access0_wfl = build_wfl_node (access0_identifier_node);
8576           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8577           EXPR_WFL_LINECOL (access0_wfl) = lc;
8578           access = build_tree_list (NULL_TREE, access);
8579           access = build_method_invocation (access0_wfl, access);
8580           access = make_qualified_primary (cn, access, lc);
8581         }
8582
8583       /* If FROM isn't an inner class, that's fine, we've done enough.
8584          What we're looking for can be accessed from there.  */
8585       from = DECL_CONTEXT (TYPE_NAME (from));
8586       if (!from)
8587         break;
8588       from = TREE_TYPE (from);
8589     }
8590   return access;
8591 }
8592
8593 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8594    is returned if nothing needs to be generated. Otherwise, the method
8595    generated and a method decl is returned.
8596
8597    NOTE: These generated methods should be declared in a class file
8598    attribute so that they can't be referred to directly.  */
8599
8600 static tree
8601 maybe_build_thisn_access_method (tree type)
8602 {
8603   tree mdecl, args, stmt, rtype;
8604   tree saved_current_function_decl;
8605
8606   /* If TYPE is a top-level class, no access method is required.
8607      If there already is such an access method, bail out. */
8608   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8609     return NULL_TREE;
8610
8611   /* We generate the method. The method looks like:
8612      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8613   */
8614   args = build_tree_list (inst_id, build_pointer_type (type));
8615   TREE_CHAIN (args) = end_params_node;
8616   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8617   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8618                                     access0_identifier_node, args);
8619   fix_method_argument_names (args, mdecl);
8620   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8621   stmt = build_current_thisn (type);
8622   stmt = make_qualified_primary (build_wfl_node (inst_id),
8623                                  build_wfl_node (stmt), 0);
8624   stmt = build_return (0, stmt);
8625
8626   saved_current_function_decl = current_function_decl;
8627   start_artificial_method_body (mdecl);
8628   java_method_add_stmt (mdecl, stmt);
8629   end_artificial_method_body (mdecl);
8630   current_function_decl = saved_current_function_decl;
8631
8632   CLASS_ACCESS0_GENERATED_P (type) = 1;
8633
8634   return mdecl;
8635 }
8636
8637 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8638    the first level of innerclassing. this$1 for the next one, etc...
8639    This function can be invoked with TYPE to NULL, available and then
8640    has to count the parser context.  */
8641
8642 static GTY(()) tree saved_thisn;
8643 static GTY(()) tree saved_type;
8644
8645 static tree
8646 build_current_thisn (tree type)
8647 {
8648   static int saved_i = -1;
8649   static int saved_type_i = 0;
8650   tree decl;
8651   char buffer [24];
8652   int i = 0;
8653
8654   if (type)
8655     {
8656       if (type == saved_type)
8657         i = saved_type_i;
8658       else
8659         {
8660           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8661                decl; decl = DECL_CONTEXT (decl), i++)
8662             ;
8663
8664           saved_type = type;
8665           saved_type_i = i;
8666         }
8667     }
8668   else
8669     i = list_length (GET_CPC_LIST ())-2;
8670
8671   if (i == saved_i)
8672     return saved_thisn;
8673
8674   sprintf (buffer, "this$%d", i);
8675   saved_i = i;
8676   saved_thisn = get_identifier (buffer);
8677   return saved_thisn;
8678 }
8679
8680 /* Return the assignment to the hidden enclosing context `this$<n>'
8681    by the second incoming parameter to the innerclass constructor. The
8682    form used is `this.this$<n> = this$<n>;'.  */
8683
8684 static tree
8685 build_thisn_assign (void)
8686 {
8687   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8688     {
8689       tree thisn = build_current_thisn (current_class);
8690       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8691                                          build_wfl_node (thisn), 0);
8692       tree rhs = build_wfl_node (thisn);
8693       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8694       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8695     }
8696   return NULL_TREE;
8697 }
8698
8699 \f
8700 /* Building the synthetic `class$' used to implement the `.class' 1.1
8701    extension for non primitive types. This method looks like:
8702
8703     static Class class$(String type) throws NoClassDefFoundError
8704     {
8705       try {return (java.lang.Class.forName (String));}
8706       catch (ClassNotFoundException e) {
8707         throw new NoClassDefFoundError(e.getMessage());}
8708     } */
8709
8710 static GTY(()) tree get_message_wfl;
8711 static GTY(()) tree type_parm_wfl;
8712
8713 static tree
8714 build_dot_class_method (tree class)
8715 {
8716 #define BWF(S) build_wfl_node (get_identifier ((S)))
8717 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8718   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8719   tree stmt, throw_stmt;
8720
8721   if (!get_message_wfl)
8722     {
8723       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8724       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8725     }
8726
8727   /* Build the arguments */
8728   args = build_tree_list (get_identifier ("type$"),
8729                           build_pointer_type (string_type_node));
8730   TREE_CHAIN (args) = end_params_node;
8731
8732   /* Build the qualified name java.lang.Class.forName */
8733   tmp = MQN (MQN (MQN (BWF ("java"),
8734                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8735
8736   /* Create the "class$" function */
8737   mdecl = create_artificial_method (class, ACC_STATIC,
8738                                     build_pointer_type (class_type_node),
8739                                     classdollar_identifier_node, args);
8740   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8741                    BWF ("NoClassDefFoundError"));
8742   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8743   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8744   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8745     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8746
8747   /* We start by building the try block. We need to build:
8748        return (java.lang.Class.forName (type)); */
8749   stmt = build_method_invocation (tmp,
8750                                   build_tree_list (NULL_TREE, type_parm_wfl));
8751   stmt = build_return (0, stmt);
8752
8753   /* Now onto the catch block. We start by building the expression
8754      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8755   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8756                                     get_message_wfl, 0);
8757   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8758
8759   /* Build new NoClassDefFoundError (_.getMessage) */
8760   throw_stmt = build_new_invocation
8761     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8762      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8763
8764   /* Build the throw, (it's too early to use BUILD_THROW) */
8765   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8766
8767   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8768   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8769                    BWF ("ClassNotFoundException"));
8770   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8771
8772   fix_method_argument_names (args, mdecl);
8773   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8774   saved_current_function_decl = current_function_decl;
8775   start_artificial_method_body (mdecl);
8776   java_method_add_stmt (mdecl, stmt);
8777   end_artificial_method_body (mdecl);
8778   current_function_decl = saved_current_function_decl;
8779   TYPE_DOT_CLASS (class) = mdecl;
8780
8781   return mdecl;
8782 }
8783
8784 static tree
8785 build_dot_class_method_invocation (tree this_class, tree type)
8786 {
8787   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8788   tree sig_id, s, t;
8789
8790   if (TYPE_ARRAY_P (type))
8791     sig_id = build_java_signature (type);
8792   else
8793     sig_id = DECL_NAME (TYPE_NAME (type));
8794
8795   /* Ensure that the proper name separator is used */
8796   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8797                                IDENTIFIER_LENGTH (sig_id));
8798
8799   s = build_string (IDENTIFIER_LENGTH (sig_id),
8800                     IDENTIFIER_POINTER (sig_id));
8801   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8802                                build_tree_list (NULL_TREE, s));
8803   if (DECL_CONTEXT (dot_class_method) != this_class)
8804     {
8805       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8806       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8807     }
8808   return t;
8809 }
8810
8811 /* This section of the code deals with constructor.  */
8812
8813 /* Craft a body for default constructor. Patch existing constructor
8814    bodies with call to super() and field initialization statements if
8815    necessary.  */
8816
8817 static void
8818 fix_constructors (tree mdecl)
8819 {
8820   tree iii;                     /* Instance Initializer Invocation */
8821   tree body = DECL_FUNCTION_BODY (mdecl);
8822   tree thisn_assign, compound = NULL_TREE;
8823   tree class_type = DECL_CONTEXT (mdecl);
8824
8825   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8826     return;
8827   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8828
8829   if (!body)
8830     {
8831       /* It is an error for the compiler to generate a default
8832          constructor if the superclass doesn't have a constructor that
8833          takes no argument, or the same args for an anonymous class */
8834       if (verify_constructor_super (mdecl))
8835         {
8836           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8837           tree save = DECL_NAME (mdecl);
8838           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8839           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8840           parse_error_context
8841             (lookup_cl (TYPE_NAME (class_type)),
8842              "No constructor matching `%s' found in class `%s'",
8843              lang_printable_name (mdecl, 2), n);
8844           DECL_NAME (mdecl) = save;
8845         }
8846
8847       /* The constructor body must be crafted by hand. It's the
8848          constructor we defined when we realize we didn't have the
8849          CLASSNAME() constructor */
8850       start_artificial_method_body (mdecl);
8851
8852       /* Insert an assignment to the this$<n> hidden field, if
8853          necessary */
8854       if ((thisn_assign = build_thisn_assign ()))
8855         java_method_add_stmt (mdecl, thisn_assign);
8856
8857       /* We don't generate a super constructor invocation if we're
8858          compiling java.lang.Object. build_super_invocation takes care
8859          of that. */
8860       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8861
8862       /* FIXME */
8863       if ((iii = build_instinit_invocation (class_type)))
8864         java_method_add_stmt (mdecl, iii);
8865
8866       end_artificial_method_body (mdecl);
8867     }
8868   /* Search for an explicit constructor invocation */
8869   else
8870     {
8871       int found = 0;
8872       int invokes_this = 0;
8873       tree found_call = NULL_TREE;
8874       tree main_block = BLOCK_EXPR_BODY (body);
8875
8876       while (body)
8877         switch (TREE_CODE (body))
8878           {
8879           case CALL_EXPR:
8880             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8881             if (CALL_THIS_CONSTRUCTOR_P (body))
8882               invokes_this = 1;
8883             body = NULL_TREE;
8884             break;
8885           case COMPOUND_EXPR:
8886           case EXPR_WITH_FILE_LOCATION:
8887             found_call = body;
8888             body = TREE_OPERAND (body, 0);
8889             break;
8890           case BLOCK:
8891             found_call = body;
8892             body = BLOCK_EXPR_BODY (body);
8893             break;
8894           default:
8895             found = 0;
8896             body = NULL_TREE;
8897           }
8898
8899       /* Generate the assignment to this$<n>, if necessary */
8900       if ((thisn_assign = build_thisn_assign ()))
8901         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8902
8903       /* The constructor is missing an invocation of super() */
8904       if (!found)
8905         compound = add_stmt_to_compound (compound, NULL_TREE,
8906                                          build_super_invocation (mdecl));
8907       /* Explicit super() invocation should take place before the
8908          instance initializer blocks. */
8909       else
8910         {
8911           compound = add_stmt_to_compound (compound, NULL_TREE,
8912                                            TREE_OPERAND (found_call, 0));
8913           TREE_OPERAND (found_call, 0) = build_java_empty_stmt ();
8914         }
8915
8916       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8917
8918       /* Insert the instance initializer block right after. */
8919       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8920         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8921
8922       /* Fix the constructor main block if we're adding extra stmts */
8923       if (compound)
8924         {
8925           compound = add_stmt_to_compound (compound, NULL_TREE,
8926                                            BLOCK_EXPR_BODY (main_block));
8927           BLOCK_EXPR_BODY (main_block) = compound;
8928         }
8929     }
8930 }
8931
8932 /* Browse constructors in the super class, searching for a constructor
8933    that doesn't take any argument. Return 0 if one is found, 1
8934    otherwise.  If the current class is an anonymous inner class, look
8935    for something that has the same signature. */
8936
8937 static int
8938 verify_constructor_super (tree mdecl)
8939 {
8940   tree class = CLASSTYPE_SUPER (current_class);
8941   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8942   tree sdecl;
8943
8944   if (!class)
8945     return 0;
8946
8947   if (ANONYMOUS_CLASS_P (current_class))
8948     {
8949       tree mdecl_arg_type;
8950       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8951       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8952         if (DECL_CONSTRUCTOR_P (sdecl))
8953           {
8954             tree m_arg_type;
8955             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8956             if (super_inner)
8957               arg_type = TREE_CHAIN (arg_type);
8958             for (m_arg_type = mdecl_arg_type;
8959                  (arg_type != end_params_node
8960                   && m_arg_type != end_params_node);
8961                  arg_type = TREE_CHAIN (arg_type),
8962                    m_arg_type = TREE_CHAIN (m_arg_type))
8963               if (!valid_method_invocation_conversion_p
8964                      (TREE_VALUE (arg_type),
8965                       TREE_VALUE (m_arg_type)))
8966                 break;
8967
8968             if (arg_type == end_params_node && m_arg_type == end_params_node)
8969               return 0;
8970           }
8971     }
8972   else
8973     {
8974       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8975         {
8976           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8977           if (super_inner)
8978             arg = TREE_CHAIN (arg);
8979           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8980             return 0;
8981         }
8982     }
8983   return 1;
8984 }
8985
8986 /* Generate code for all context remembered for code generation.  */
8987
8988 static GTY(()) tree reversed_class_list;
8989 void
8990 java_expand_classes (void)
8991 {
8992   int save_error_count = 0;
8993   static struct parser_ctxt *cur_ctxp = NULL;
8994
8995   java_parse_abort_on_error ();
8996   if (!(ctxp = ctxp_for_generation))
8997     return;
8998   java_layout_classes ();
8999   java_parse_abort_on_error ();
9000
9001   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9002     {
9003       tree current;
9004       for (current = cur_ctxp->class_list;
9005            current;
9006            current = TREE_CHAIN (current))
9007         gen_indirect_dispatch_tables (TREE_TYPE (current));
9008     }
9009
9010   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9011     {
9012       ctxp = cur_ctxp;
9013       input_filename = ctxp->filename;
9014       lang_init_source (2);            /* Error msgs have method prototypes */
9015       java_complete_expand_classes (); /* Complete and expand classes */
9016       java_parse_abort_on_error ();
9017     }
9018   input_filename = main_input_filename;
9019
9020   /* Find anonymous classes and expand their constructor. This extra pass is
9021      necessary because the constructor itself is only generated when the
9022      method in which it is defined is expanded. */
9023   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9024     {
9025       tree current;
9026       ctxp = cur_ctxp;
9027       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9028         {
9029           output_class = current_class = TREE_TYPE (current);
9030           if (ANONYMOUS_CLASS_P (current_class))
9031             {
9032               tree d;
9033               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9034                 {
9035                   if (DECL_CONSTRUCTOR_P (d))
9036                     {
9037                       java_complete_expand_method (d);
9038                       break;    /* There is only one constructor. */
9039                     }
9040                 }
9041             }
9042         }
9043     }
9044
9045   /* Expanding the constructors of anonymous classes generates access
9046      methods.  Scan all the methods looking for null DECL_RESULTs --
9047      this will be the case if a method hasn't been expanded.  */
9048   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9049     {
9050       tree current;
9051       ctxp = cur_ctxp;
9052       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9053         {
9054           tree d;
9055           output_class = current_class = TREE_TYPE (current);
9056           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9057             {
9058               if (DECL_RESULT (d) == NULL_TREE)
9059                 java_complete_expand_method (d);
9060             }
9061         }
9062     }
9063
9064   /* ???  Instead of all this we could iterate around the list of
9065      classes until there were no more un-expanded methods.  It would
9066      take a little longer -- one pass over the whole list of methods
9067      -- but it would be simpler.  Like this:  */
9068 #if 0
9069     {
9070       int something_changed;
9071
9072       do
9073         {
9074           something_changed = 0;
9075           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9076             {
9077               tree current;
9078               ctxp = cur_ctxp;
9079               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9080                 {
9081                   tree d;
9082                   output_class = current_class = TREE_TYPE (current);
9083                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9084                     {
9085                       if (DECL_RESULT (d) == NULL_TREE)
9086                         {
9087                           something_changed = 1;
9088                           java_complete_expand_method (d);
9089                         }
9090                     }
9091                 }
9092             }
9093         }
9094       while (something_changed);
9095     }
9096 #endif
9097
9098   /* If we've found error at that stage, don't try to generate
9099      anything, unless we're emitting xrefs or checking the syntax only
9100      (but not using -fsyntax-only for the purpose of generating
9101      bytecode. */
9102   if (java_error_count && !flag_emit_xref
9103       && (!flag_syntax_only && !flag_emit_class_files))
9104     return;
9105
9106   /* Now things are stable, go for generation of the class data. */
9107
9108   /* We pessimistically marked all methods and fields external until
9109      we knew what set of classes we were planning to compile.  Now mark
9110      those that will be generated locally as not external.  */
9111   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9112     {
9113       tree current;
9114       ctxp = cur_ctxp;
9115       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9116         java_mark_class_local (TREE_TYPE (current));
9117     }
9118
9119   /* Compile the classes.  */
9120   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9121     {
9122       tree current;
9123       reversed_class_list = NULL;
9124
9125       ctxp = cur_ctxp;
9126
9127       /* We write out the classes in reverse order.  This ensures that
9128          inner classes are written before their containing classes,
9129          which is important for parallel builds.  Otherwise, the
9130          class file for the outer class may be found, but the class
9131          file for the inner class may not be present.  In that
9132          situation, the compiler cannot fall back to the original
9133          source, having already read the outer class, so we must
9134          prevent that situation.  */
9135       for (current = ctxp->class_list;
9136            current;
9137            current = TREE_CHAIN (current))
9138         reversed_class_list
9139           = tree_cons (NULL_TREE, current, reversed_class_list);
9140
9141       for (current = reversed_class_list;
9142            current;
9143            current = TREE_CHAIN (current))
9144         {
9145           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9146           if (flag_emit_class_files)
9147             write_classfile (current_class);
9148           if (flag_emit_xref)
9149             expand_xref (current_class);
9150           else if (! flag_syntax_only)
9151             java_expand_method_bodies (current_class);
9152         }
9153     }
9154 }
9155
9156 void
9157 java_finish_classes (void)
9158 {
9159   static struct parser_ctxt *cur_ctxp = NULL;
9160   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9161     {
9162       tree current;
9163       ctxp = cur_ctxp;
9164       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9165         {
9166           output_class = current_class = TREE_TYPE (current);
9167           finish_class ();
9168         }
9169     }
9170 }
9171
9172 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9173    a tree list node containing RIGHT. Fore coming RIGHTs will be
9174    chained to this hook. LOCATION contains the location of the
9175    separating `.' operator.  */
9176
9177 static tree
9178 make_qualified_primary (tree primary, tree right, int location)
9179 {
9180   tree wfl;
9181
9182   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9183     wfl = build_wfl_wrap (primary, location);
9184   else
9185     {
9186       wfl = primary;
9187       /* If wfl wasn't qualified, we build a first anchor */
9188       if (!EXPR_WFL_QUALIFICATION (wfl))
9189         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9190     }
9191
9192   /* And chain them */
9193   EXPR_WFL_LINECOL (right) = location;
9194   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9195   PRIMARY_P (wfl) =  1;
9196   return wfl;
9197 }
9198
9199 /* Simple merge of two name separated by a `.' */
9200
9201 static tree
9202 merge_qualified_name (tree left, tree right)
9203 {
9204   tree node;
9205   if (!left && !right)
9206     return NULL_TREE;
9207
9208   if (!left)
9209     return right;
9210
9211   if (!right)
9212     return left;
9213
9214   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9215                 IDENTIFIER_LENGTH (left));
9216   obstack_1grow (&temporary_obstack, '.');
9217   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9218                  IDENTIFIER_LENGTH (right));
9219   node =  get_identifier (obstack_base (&temporary_obstack));
9220   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9221   QUALIFIED_P (node) = 1;
9222   return node;
9223 }
9224
9225 /* Merge the two parts of a qualified name into LEFT.  Set the
9226    location information of the resulting node to LOCATION, usually
9227    inherited from the location information of the `.' operator. */
9228
9229 static tree
9230 make_qualified_name (tree left, tree right, int location)
9231 {
9232 #ifdef USE_COMPONENT_REF
9233   tree node = build3 (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9234   EXPR_WFL_LINECOL (node) = location;
9235   return node;
9236 #else
9237   tree left_id = EXPR_WFL_NODE (left);
9238   tree right_id = EXPR_WFL_NODE (right);
9239   tree wfl, merge;
9240
9241   merge = merge_qualified_name (left_id, right_id);
9242
9243   /* Left wasn't qualified and is now qualified */
9244   if (!QUALIFIED_P (left_id))
9245     {
9246       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9247       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9248       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9249     }
9250
9251   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9252   EXPR_WFL_LINECOL (wfl) = location;
9253   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9254
9255   EXPR_WFL_NODE (left) = merge;
9256   return left;
9257 #endif
9258 }
9259
9260 /* Extract the last identifier component of the qualified in WFL. The
9261    last identifier is removed from the linked list */
9262
9263 static tree
9264 cut_identifier_in_qualified (tree wfl)
9265 {
9266   tree q;
9267   tree previous = NULL_TREE;
9268   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9269     if (!TREE_CHAIN (q))
9270       {
9271         if (!previous)
9272           /* Operating on a non qualified qualified WFL.  */
9273           abort ();
9274
9275         TREE_CHAIN (previous) = NULL_TREE;
9276         return TREE_PURPOSE (q);
9277       }
9278 }
9279
9280 /* Resolve the expression name NAME. Return its decl.  */
9281
9282 static tree
9283 resolve_expression_name (tree id, tree *orig)
9284 {
9285   tree name = EXPR_WFL_NODE (id);
9286   tree decl;
9287
9288   /* 6.5.5.1: Simple expression names */
9289   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9290     {
9291       /* 15.13.1: NAME can appear within the scope of a local variable
9292          declaration */
9293       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9294         return decl;
9295
9296       /* 15.13.1: NAME can appear within a class declaration */
9297       else
9298         {
9299           decl = lookup_field_wrapper (current_class, name);
9300           if (decl)
9301             {
9302               tree access = NULL_TREE;
9303               int fs = FIELD_STATIC (decl);
9304
9305               /* If we're accessing an outer scope local alias, make
9306                  sure we change the name of the field we're going to
9307                  build access to. */
9308               if (FIELD_LOCAL_ALIAS_USED (decl))
9309                 name = DECL_NAME (decl);
9310
9311               check_deprecation (id, decl);
9312
9313               /* Instance variable (8.3.1.1) can't appear within
9314                  static method, static initializer or initializer for
9315                  a static variable. */
9316               if (!fs && METHOD_STATIC (current_function_decl))
9317                 {
9318                   static_ref_err (id, name, current_class);
9319                   return error_mark_node;
9320                 }
9321               /* Instance variables can't appear as an argument of
9322                  an explicit constructor invocation */
9323               if (!fs && ctxp->explicit_constructor_p
9324                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9325                 {
9326                   parse_error_context
9327                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9328                   return error_mark_node;
9329                 }
9330
9331               /* If we're processing an inner class and we're trying
9332                  to access a field belonging to an outer class, build
9333                  the access to the field */
9334               if (!fs && outer_field_access_p (current_class, decl))
9335                 {
9336                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9337                     {
9338                       static_ref_err (id, DECL_NAME (decl), current_class);
9339                       return error_mark_node;
9340                     }
9341                   access = build_outer_field_access (id, decl);
9342                   if (orig)
9343                     *orig = access;
9344                   return access;
9345                 }
9346
9347               /* Otherwise build what it takes to access the field */
9348               access = build_field_ref ((fs ? NULL_TREE : current_this),
9349                                         DECL_CONTEXT (decl), name);
9350               if (fs)
9351                 access = maybe_build_class_init_for_field (decl, access);
9352               /* We may be asked to save the real field access node */
9353               if (orig)
9354                 *orig = access;
9355               /* Last check: can we access the field? */
9356               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9357                 {
9358                   not_accessible_field_error (id, decl);
9359                   return error_mark_node;
9360                 }
9361               /* And we return what we got */
9362               return access;
9363             }
9364           /* Fall down to error report on undefined variable */
9365         }
9366     }
9367   /* 6.5.5.2 Qualified Expression Names */
9368   else
9369     {
9370       if (orig)
9371         *orig = NULL_TREE;
9372       qualify_ambiguous_name (id);
9373       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9374       /* 15.10.2: Accessing Superclass Members using super */
9375       return resolve_field_access (id, orig, NULL);
9376     }
9377
9378   /* We've got an error here */
9379   if (INNER_CLASS_TYPE_P (current_class))
9380     parse_error_context (id,
9381                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9382                          IDENTIFIER_POINTER (name),
9383                          IDENTIFIER_POINTER (DECL_NAME
9384                                              (TYPE_NAME (current_class))));
9385   else
9386     parse_error_context (id, "Undefined variable `%s'",
9387                          IDENTIFIER_POINTER (name));
9388
9389   return error_mark_node;
9390 }
9391
9392 static void
9393 static_ref_err (tree wfl, tree field_id, tree class_type)
9394 {
9395   parse_error_context
9396     (wfl,
9397      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9398      IDENTIFIER_POINTER (field_id),
9399      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9400 }
9401
9402 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9403    We return something suitable to generate the field access. We also
9404    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9405    recipient's address can be null. */
9406
9407 static tree
9408 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9409 {
9410   int is_static = 0;
9411   tree field_ref;
9412   tree decl = NULL_TREE, where_found, type_found;
9413
9414   if (resolve_qualified_expression_name (qual_wfl, &decl,
9415                                          &where_found, &type_found))
9416     return error_mark_node;
9417
9418   /* Resolve the LENGTH field of an array here */
9419   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9420       && type_found && TYPE_ARRAY_P (type_found)
9421       && ! flag_emit_class_files && ! flag_emit_xref)
9422     {
9423       tree length = build_java_array_length_access (where_found);
9424       field_ref = length;
9425
9426       /* In case we're dealing with a static array, we need to
9427          initialize its class before the array length can be fetched.
9428          It's also a good time to create a DECL_RTL for the field if
9429          none already exists, otherwise if the field was declared in a
9430          class found in an external file and hasn't been (and won't
9431          be) accessed for its value, none will be created. */
9432       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9433         {
9434           build_static_field_ref (where_found);
9435           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9436         }
9437     }
9438   /* We might have been trying to resolve field.method(). In which
9439      case, the resolution is over and decl is the answer */
9440   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9441     field_ref = decl;
9442   else if (JDECL_P (decl))
9443     {
9444       if (!type_found)
9445         type_found = DECL_CONTEXT (decl);
9446       is_static = FIELD_STATIC (decl);
9447       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9448                                     NULL_TREE : where_found),
9449                                    type_found, DECL_NAME (decl));
9450       if (field_ref == error_mark_node)
9451         return error_mark_node;
9452       if (is_static)
9453         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9454
9455       /* If we're looking at a static field, we may need to generate a
9456          class initialization for it.  This can happen when the access
9457          looks like `field.ref', where `field' is a static field in an
9458          interface we implement.  */
9459       if (!flag_emit_class_files
9460           && !flag_emit_xref
9461           && TREE_CODE (where_found) == VAR_DECL
9462           && FIELD_STATIC (where_found))
9463         {
9464           build_static_field_ref (where_found);
9465           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9466         }
9467     }
9468   else
9469     field_ref = decl;
9470
9471   if (field_decl)
9472     *field_decl = decl;
9473   if (field_type)
9474     *field_type = (QUAL_DECL_TYPE (decl) ?
9475                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9476   return field_ref;
9477 }
9478
9479 /* If NODE is an access to f static field, strip out the class
9480    initialization part and return the field decl, otherwise, return
9481    NODE. */
9482
9483 static tree
9484 strip_out_static_field_access_decl (tree node)
9485 {
9486   if (TREE_CODE (node) == COMPOUND_EXPR)
9487     {
9488       tree op1 = TREE_OPERAND (node, 1);
9489       if (TREE_CODE (op1) == COMPOUND_EXPR)
9490          {
9491            tree call = TREE_OPERAND (op1, 0);
9492            if (TREE_CODE (call) == CALL_EXPR
9493                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9494                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9495                == soft_initclass_node)
9496              return TREE_OPERAND (op1, 1);
9497          }
9498       else if (JDECL_P (op1))
9499         return op1;
9500     }
9501   return node;
9502 }
9503
9504 /* 6.5.5.2: Qualified Expression Names */
9505
9506 static int
9507 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9508                                    tree *where_found, tree *type_found)
9509 {
9510   int from_type = 0;            /* Field search initiated from a type */
9511   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9512   int previous_call_static = 0;
9513   int is_static;
9514   tree decl = NULL_TREE, type = NULL_TREE, q;
9515   /* For certain for of inner class instantiation */
9516   tree saved_current, saved_this;
9517 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9518   { current_class = saved_current; current_this = saved_this;}
9519
9520   *type_found = *where_found = NULL_TREE;
9521
9522   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9523     {
9524       tree qual_wfl = QUAL_WFL (q);
9525       tree ret_decl;            /* for EH checking */
9526       int location;             /* for EH checking */
9527
9528       /* 15.10.1 Field Access Using a Primary */
9529       switch (TREE_CODE (qual_wfl))
9530         {
9531         case CALL_EXPR:
9532         case NEW_CLASS_EXPR:
9533           /* If the access to the function call is a non static field,
9534              build the code to access it. */
9535           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9536             {
9537               decl = maybe_access_field (decl, *where_found,
9538                                          DECL_CONTEXT (decl));
9539               if (decl == error_mark_node)
9540                 return 1;
9541             }
9542
9543           /* And code for the function call */
9544           if (complete_function_arguments (qual_wfl))
9545             return 1;
9546
9547           /* We might have to setup a new current class and a new this
9548              for the search of an inner class, relative to the type of
9549              a expression resolved as `decl'. The current values are
9550              saved and restored shortly after */
9551           saved_current = current_class;
9552           saved_this = current_this;
9553           if (decl
9554               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9555                   || from_qualified_this))
9556             {
9557               /* If we still have `from_qualified_this', we have the form
9558                  <T>.this.f() and we need to build <T>.this */
9559               if (from_qualified_this)
9560                 {
9561                   decl = build_access_to_thisn (current_class, type, 0);
9562                   decl = java_complete_tree (decl);
9563                   type = TREE_TYPE (TREE_TYPE (decl));
9564                 }
9565               current_class = type;
9566               current_this = decl;
9567               from_qualified_this = 0;
9568             }
9569
9570           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9571             CALL_USING_SUPER (qual_wfl) = 1;
9572           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9573                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9574           *where_found = patch_method_invocation (qual_wfl, decl, type,
9575                                                   from_super,
9576                                                   &is_static, &ret_decl);
9577           from_super = 0;
9578           if (*where_found == error_mark_node)
9579             {
9580               RESTORE_THIS_AND_CURRENT_CLASS;
9581               return 1;
9582             }
9583           *type_found = type = QUAL_DECL_TYPE (*where_found);
9584
9585           *where_found = force_evaluation_order (*where_found);
9586
9587           /* If we're creating an inner class instance, check for that
9588              an enclosing instance is in scope */
9589           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9590               && INNER_ENCLOSING_SCOPE_CHECK (type))
9591             {
9592               parse_error_context
9593                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9594                  lang_printable_name (type, 0),
9595                  (!current_this ? "" :
9596                   "; an explicit one must be provided when creating this inner class"));
9597               RESTORE_THIS_AND_CURRENT_CLASS;
9598               return 1;
9599             }
9600
9601           /* In case we had to change then to resolve a inner class
9602              instantiation using a primary qualified by a `new' */
9603           RESTORE_THIS_AND_CURRENT_CLASS;
9604
9605           if (location)
9606             {
9607               tree arguments = NULL_TREE;
9608               if (TREE_CODE (qual_wfl) == CALL_EXPR
9609                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9610                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9611               check_thrown_exceptions (location, ret_decl, arguments);
9612             }
9613
9614           /* If the previous call was static and this one is too,
9615              build a compound expression to hold the two (because in
9616              that case, previous function calls aren't transported as
9617              forcoming function's argument. */
9618           if (previous_call_static && is_static)
9619             {
9620               /* We must set CAN_COMPLETE_NORMALLY for the first call
9621                  since it is done nowhere else.  */
9622               CAN_COMPLETE_NORMALLY (decl) = 1;
9623               decl = build2 (COMPOUND_EXPR, TREE_TYPE (*where_found),
9624                              decl, *where_found);
9625               TREE_SIDE_EFFECTS (decl) = 1;
9626             }
9627           else
9628             {
9629               previous_call_static = is_static;
9630               decl = *where_found;
9631             }
9632           from_type = 0;
9633           continue;
9634
9635         case NEW_ARRAY_EXPR:
9636         case NEW_ANONYMOUS_ARRAY_EXPR:
9637           *where_found = decl = java_complete_tree (qual_wfl);
9638           if (decl == error_mark_node)
9639             return 1;
9640           *type_found = type = QUAL_DECL_TYPE (decl);
9641           continue;
9642
9643         case CONVERT_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           from_cast = 1;
9649           continue;
9650
9651         case CONDITIONAL_EXPR:
9652         case STRING_CST:
9653         case MODIFY_EXPR:
9654           *where_found = decl = java_complete_tree (qual_wfl);
9655           if (decl == error_mark_node)
9656             return 1;
9657           *type_found = type = QUAL_DECL_TYPE (decl);
9658           continue;
9659
9660         case ARRAY_REF:
9661           /* If the access to the function call is a non static field,
9662              build the code to access it. */
9663           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9664             {
9665               decl = maybe_access_field (decl, *where_found, type);
9666               if (decl == error_mark_node)
9667                 return 1;
9668             }
9669           /* And code for the array reference expression */
9670           decl = java_complete_tree (qual_wfl);
9671           if (decl == error_mark_node)
9672             return 1;
9673           type = QUAL_DECL_TYPE (decl);
9674           continue;
9675
9676         case PLUS_EXPR:
9677           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9678             return 1;
9679           if ((type = patch_string (decl)))
9680             decl = type;
9681           *where_found = QUAL_RESOLUTION (q) = decl;
9682           *type_found = type = TREE_TYPE (decl);
9683           break;
9684
9685         case CLASS_LITERAL:
9686           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9687             return 1;
9688           *where_found = QUAL_RESOLUTION (q) = decl;
9689           *type_found = type = TREE_TYPE (decl);
9690           break;
9691
9692         default:
9693           /* Fix for -Wall Just go to the next statement. Don't
9694              continue */
9695           break;
9696         }
9697
9698       /* If we fall here, we weren't processing a (static) function call. */
9699       previous_call_static = 0;
9700
9701       /* It can be the keyword THIS */
9702       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9703           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9704         {
9705           if (!current_this)
9706             {
9707               parse_error_context
9708                 (wfl, "Keyword `this' used outside allowed context");
9709               return 1;
9710             }
9711           if (ctxp->explicit_constructor_p
9712               && type == current_class)
9713             {
9714               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9715               return 1;
9716             }
9717           /* We have to generate code for intermediate access */
9718           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9719             {
9720               *where_found = decl = current_this;
9721               *type_found = type = QUAL_DECL_TYPE (decl);
9722             }
9723           /* We're trying to access the this from somewhere else. Make sure
9724              it's allowed before doing so. */
9725           else
9726             {
9727               if (!enclosing_context_p (type, current_class))
9728                 {
9729                   char *p  = xstrdup (lang_printable_name (type, 0));
9730                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9731                                        p, p,
9732                                        lang_printable_name (current_class, 0));
9733                   free (p);
9734                   return 1;
9735                 }
9736               from_qualified_this = 1;
9737               /* If there's nothing else after that, we need to
9738                  produce something now, otherwise, the section of the
9739                  code that needs to produce <T>.this will generate
9740                  what is necessary. */
9741               if (!TREE_CHAIN (q))
9742                 {
9743                   decl = build_access_to_thisn (current_class, type, 0);
9744                   *where_found = decl = java_complete_tree (decl);
9745                   *type_found = type = TREE_TYPE (decl);
9746                 }
9747             }
9748
9749           from_type = 0;
9750           continue;
9751         }
9752
9753       /* 15.10.2 Accessing Superclass Members using SUPER */
9754       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9755           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9756         {
9757           tree node;
9758           /* Check on the restricted use of SUPER */
9759           if (METHOD_STATIC (current_function_decl)
9760               || current_class == object_type_node)
9761             {
9762               parse_error_context
9763                 (wfl, "Keyword `super' used outside allowed context");
9764               return 1;
9765             }
9766           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9767           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9768                              CLASSTYPE_SUPER (current_class),
9769                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9770           *where_found = decl = java_complete_tree (node);
9771           if (decl == error_mark_node)
9772             return 1;
9773           *type_found = type = QUAL_DECL_TYPE (decl);
9774           from_super = from_type = 1;
9775           continue;
9776         }
9777
9778       /* 15.13.1: Can't search for field name in packages, so we
9779          assume a variable/class name was meant. */
9780       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9781         {
9782           tree name;
9783           if ((decl = resolve_package (wfl, &q, &name)))
9784             {
9785               tree list;
9786               *where_found = decl;
9787
9788               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9789
9790               /* We want to be absolutely sure that the class is laid
9791                  out. We're going to search something inside it. */
9792               *type_found = type = TREE_TYPE (decl);
9793               layout_class (type);
9794               from_type = 1;
9795
9796               /* Fix them all the way down, if any are left. */
9797               if (q)
9798                 {
9799                   list = TREE_CHAIN (q);
9800                   while (list)
9801                     {
9802                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9803                       list = TREE_CHAIN (list);
9804                     }
9805                 }
9806             }
9807           else
9808             {
9809               if (from_super || from_cast)
9810                 parse_error_context
9811                   ((from_cast ? qual_wfl : wfl),
9812                    "No variable `%s' defined in class `%s'",
9813                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9814                    lang_printable_name (type, 0));
9815               else
9816                 parse_error_context
9817                   (qual_wfl, "Undefined variable or class name: `%s'",
9818                    IDENTIFIER_POINTER (name));
9819               return 1;
9820             }
9821         }
9822
9823       /* We have a type name. It's been already resolved when the
9824          expression was qualified. */
9825       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9826         {
9827           decl = QUAL_RESOLUTION (q);
9828
9829           /* Sneak preview. If next we see a `new', we're facing a
9830              qualification which resulted in a type being selected
9831              instead of a field.  Report the error.  */
9832           if(TREE_CHAIN (q)
9833              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9834             {
9835               parse_error_context (qual_wfl, "Undefined variable `%s'",
9836                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9837               return 1;
9838             }
9839
9840           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9841
9842           check_deprecation (qual_wfl, decl);
9843
9844           type = TREE_TYPE (decl);
9845           from_type = 1;
9846         }
9847       /* We resolve an expression name */
9848       else
9849         {
9850           tree field_decl = NULL_TREE;
9851
9852           /* If there exists an early resolution, use it. That occurs
9853              only once and we know that there are more things to
9854              come. Don't do that when processing something after SUPER
9855              (we need more thing to be put in place below */
9856           if (!from_super && QUAL_RESOLUTION (q))
9857             {
9858               decl = QUAL_RESOLUTION (q);
9859               if (!type)
9860                 {
9861                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9862                     {
9863                       if (current_this)
9864                         *where_found = current_this;
9865                       else
9866                         {
9867                           static_ref_err (qual_wfl, DECL_NAME (decl),
9868                                           current_class);
9869                           return 1;
9870                         }
9871                       if (outer_field_access_p (current_class, decl))
9872                         decl = build_outer_field_access (qual_wfl, decl);
9873                     }
9874                   else
9875                     {
9876                       *where_found = TREE_TYPE (decl);
9877                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9878                         *where_found = TREE_TYPE (*where_found);
9879                     }
9880                 }
9881             }
9882
9883           /* Report and error if we're using a numerical literal as a
9884              qualifier. It can only be an INTEGER_CST. */
9885           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9886             {
9887               parse_error_context
9888                 (wfl, "Can't use type `%s' as a qualifier",
9889                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9890               return 1;
9891             }
9892
9893           /* We have to search for a field, knowing the type of its
9894              container. The flag FROM_TYPE indicates that we resolved
9895              the last member of the expression as a type name, which
9896              means that for the resolution of this field, we'll look
9897              for other errors than if it was resolved as a member of
9898              an other field. */
9899           else
9900             {
9901               int is_static;
9902               tree field_decl_type; /* For layout */
9903
9904               if (!from_type && !JREFERENCE_TYPE_P (type))
9905                 {
9906                   parse_error_context
9907                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9908                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9909                      lang_printable_name (type, 0),
9910                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9911                   return 1;
9912                 }
9913
9914               field_decl = lookup_field_wrapper (type,
9915                                                  EXPR_WFL_NODE (qual_wfl));
9916
9917               /* Maybe what we're trying to access to is an inner
9918                  class, only if decl is a TYPE_DECL. */
9919               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9920                 {
9921                   tree ptr, inner_decl;
9922
9923                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9924                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9925                   if (inner_decl)
9926                     {
9927                       check_inner_class_access (inner_decl, decl, qual_wfl);
9928                       type = TREE_TYPE (inner_decl);
9929                       decl = inner_decl;
9930                       from_type = 1;
9931                       continue;
9932                     }
9933                 }
9934
9935               if (field_decl == NULL_TREE)
9936                 {
9937                   parse_error_context
9938                     (qual_wfl, "No variable `%s' defined in type `%s'",
9939                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9940                      GET_TYPE_NAME (type));
9941                   return 1;
9942                 }
9943               if (field_decl == error_mark_node)
9944                 return 1;
9945
9946               /* Layout the type of field_decl, since we may need
9947                  it. Don't do primitive types or loaded classes. The
9948                  situation of non primitive arrays may not handled
9949                  properly here. FIXME */
9950               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9951                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9952               else
9953                 field_decl_type = TREE_TYPE (field_decl);
9954               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9955                   && !CLASS_LOADED_P (field_decl_type)
9956                   && !TYPE_ARRAY_P (field_decl_type))
9957                 resolve_and_layout (field_decl_type, NULL_TREE);
9958
9959               /* Check on accessibility here */
9960               if (not_accessible_p (current_class, field_decl,
9961                                     *type_found, from_super))
9962                 return not_accessible_field_error (qual_wfl,field_decl);
9963               check_deprecation (qual_wfl, field_decl);
9964
9965               /* There are things to check when fields are accessed
9966                  from type. There are no restrictions on a static
9967                  declaration of the field when it is accessed from an
9968                  interface */
9969               is_static = FIELD_STATIC (field_decl);
9970               if (!from_super && from_type
9971                   && !TYPE_INTERFACE_P (type)
9972                   && !is_static
9973                   && (current_function_decl
9974                       && METHOD_STATIC (current_function_decl)))
9975                 {
9976                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9977                   return 1;
9978                 }
9979               from_cast = from_super = 0;
9980
9981               /* It's an access from a type but it isn't static, we
9982                  make it relative to `this'. */
9983               if (!is_static && from_type)
9984                 decl = current_this;
9985
9986               /* If we need to generate something to get a proper
9987                  handle on what this field is accessed from, do it
9988                  now. */
9989               if (!is_static)
9990                 {
9991                   decl = maybe_access_field (decl, *where_found, *type_found);
9992                   if (decl == error_mark_node)
9993                     return 1;
9994                 }
9995
9996               /* We want to keep the location were found it, and the type
9997                  we found. */
9998               *where_found = decl;
9999               *type_found = type;
10000
10001               /* Generate the correct expression for field access from
10002                  qualified this */
10003               if (from_qualified_this)
10004                 {
10005                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10006                   from_qualified_this = 0;
10007                 }
10008
10009               /* This is the decl found and eventually the next one to
10010                  search from */
10011               decl = field_decl;
10012             }
10013           from_type = 0;
10014           type = QUAL_DECL_TYPE (decl);
10015
10016           /* Sneak preview. If decl is qualified by a `new', report
10017              the error here to be accurate on the peculiar construct */
10018           if (TREE_CHAIN (q)
10019               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10020               && !JREFERENCE_TYPE_P (type))
10021             {
10022               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10023                                    lang_printable_name (type, 0));
10024               return 1;
10025             }
10026         }
10027       /* `q' might have changed due to a after package resolution
10028          re-qualification */
10029       if (!q)
10030         break;
10031     }
10032   *found_decl = decl;
10033   return 0;
10034 }
10035
10036 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10037    can't be accessed from REFERENCE (a record type). If MEMBER
10038    features a protected access, we then use WHERE which, if non null,
10039    holds the type of MEMBER's access that is checked against
10040    6.6.2.1. This function should be used when decl is a field or a
10041    method.  */
10042
10043 static int
10044 not_accessible_p (tree reference, tree member, tree where, int from_super)
10045 {
10046   int access_flag = get_access_flags_from_decl (member);
10047   bool is_static = false;
10048
10049   if (TREE_CODE (member) == FIELD_DECL ||
10050       TREE_CODE (member) == VAR_DECL)
10051     is_static = FIELD_STATIC (member);
10052   else
10053     is_static = METHOD_STATIC (member);
10054
10055   /* Access always granted for members declared public */
10056   if (access_flag & ACC_PUBLIC)
10057     return 0;
10058
10059   /* Check access on protected members */
10060   if (access_flag & ACC_PROTECTED)
10061     {
10062       /* Access granted if it occurs from within the package
10063          containing the class in which the protected member is
10064          declared */
10065       if (class_in_current_package (DECL_CONTEXT (member)))
10066         return 0;
10067
10068       /* If accessed with the form `super.member', then access is granted */
10069       if (from_super)
10070         return 0;
10071
10072       /* If WHERE is active, access was made through a qualifier. For
10073          non-static members, access is granted if the type of the qualifier
10074          is or is a sublass of the type the access is made from (6.6.2.1.)  */
10075       if (where && !is_static)
10076         {
10077           while (reference)
10078             {
10079               if (inherits_from_p (where, reference))
10080                 return 0;
10081               if (INNER_CLASS_TYPE_P (reference))
10082                 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10083               else
10084                 break;
10085             }
10086           return 1;
10087         }
10088
10089       /* Otherwise, access is granted if occurring from within the class
10090          where member is declared, or a subclass of it.  */
10091       while (reference)
10092         {
10093           if (inherits_from_p (reference, DECL_CONTEXT (member)))
10094             return 0;
10095           if (INNER_CLASS_TYPE_P (reference))
10096             reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10097           else
10098             break;
10099         }
10100       return 1;
10101     }
10102
10103   /* Check access on private members. Access is granted only if it
10104      occurs from within the class in which it is declared -- that does
10105      it for innerclasses too. */
10106   if (access_flag & ACC_PRIVATE)
10107     {
10108       if (reference == DECL_CONTEXT (member) ||
10109           common_enclosing_context_p (DECL_CONTEXT (member), reference))
10110         return 0;
10111       return 1;
10112     }
10113
10114   /* Default access is permitted only when occurring from within the
10115      package in which the context (MEMBER) is declared.  */
10116   return !class_in_current_package (DECL_CONTEXT (member));
10117 }
10118
10119 /* Test deprecated decl access.  */
10120 static void
10121 check_deprecation (tree wfl, tree decl)
10122 {
10123   const char *file;
10124   tree elt;
10125
10126   if (! warn_deprecated)
10127     return;
10128
10129   /* We want to look at the element type of arrays here, so we strip
10130      all surrounding array types.  */
10131   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10132     {
10133       elt = TREE_TYPE (decl);
10134       while (TYPE_ARRAY_P (elt))
10135         elt = TYPE_ARRAY_ELEMENT (elt);
10136       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10137          to the record.  */
10138       decl = TYPE_NAME (TREE_TYPE (elt));
10139     }
10140   file = DECL_SOURCE_FILE (decl);
10141
10142   /* Complain if the field is deprecated and the file it was defined
10143      in isn't compiled at the same time the file which contains its
10144      use is */
10145   if (DECL_DEPRECATED (decl)
10146       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10147     {
10148       const char *the;
10149       switch (TREE_CODE (decl))
10150         {
10151         case FUNCTION_DECL:
10152           the = "method";
10153           break;
10154         case FIELD_DECL:
10155         case VAR_DECL:
10156           the = "field";
10157           break;
10158         case TYPE_DECL:
10159           parse_warning_context (wfl, "The class `%s' has been deprecated",
10160                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10161           return;
10162         default:
10163           abort ();
10164         }
10165       /* Don't issue a message if the context as been deprecated as a
10166          whole. */
10167       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10168         parse_warning_context
10169           (wfl, "The %s `%s' in class `%s' has been deprecated",
10170            the, lang_printable_name (decl, 0),
10171            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10172     }
10173 }
10174
10175 /* Returns 1 if class was declared in the current package, 0 otherwise */
10176
10177 static GTY(()) tree cicp_cache;
10178 static int
10179 class_in_current_package (tree class)
10180 {
10181   int qualified_flag;
10182   tree left;
10183
10184   if (cicp_cache == class)
10185     return 1;
10186
10187   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10188
10189   /* If the current package is empty and the name of CLASS is
10190      qualified, class isn't in the current package.  If there is a
10191      current package and the name of the CLASS is not qualified, class
10192      isn't in the current package */
10193   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10194     return 0;
10195
10196   /* If there is not package and the name of CLASS isn't qualified,
10197      they belong to the same unnamed package */
10198   if (!ctxp->package && !qualified_flag)
10199     return 1;
10200
10201   /* Compare the left part of the name of CLASS with the package name */
10202   split_qualified_name (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10203   if (ctxp->package == left)
10204     {
10205       cicp_cache = class;
10206       return 1;
10207     }
10208   return 0;
10209 }
10210
10211 /* This function may generate code to access DECL from WHERE. This is
10212    done only if certain conditions meet.  */
10213
10214 static tree
10215 maybe_access_field (tree decl, tree where, tree type)
10216 {
10217   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10218       && !FIELD_STATIC (decl))
10219     decl = build_field_ref (where ? where : current_this,
10220                             (type ? type : DECL_CONTEXT (decl)),
10221                             DECL_NAME (decl));
10222   return decl;
10223 }
10224
10225 /* Build a method invocation, by patching PATCH. If non NULL
10226    and according to the situation, PRIMARY and WHERE may be
10227    used. IS_STATIC is set to 1 if the invoked function is static. */
10228
10229 static tree
10230 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10231                          int *is_static, tree *ret_decl)
10232 {
10233   tree wfl = TREE_OPERAND (patch, 0);
10234   tree args = TREE_OPERAND (patch, 1);
10235   tree name = EXPR_WFL_NODE (wfl);
10236   tree list;
10237   int is_static_flag = 0;
10238   int is_super_init = 0;
10239   tree this_arg = NULL_TREE;
10240   int is_array_clone_call = 0;
10241
10242   /* Should be overridden if everything goes well. Otherwise, if
10243      something fails, it should keep this value. It stop the
10244      evaluation of a bogus assignment. See java_complete_tree,
10245      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10246      evaluating an assignment */
10247   TREE_TYPE (patch) = error_mark_node;
10248
10249   /* Since lookup functions are messing with line numbers, save the
10250      context now.  */
10251   java_parser_context_save_global ();
10252
10253   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10254
10255   /* Resolution of qualified name, excluding constructors */
10256   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10257     {
10258       tree identifier, identifier_wfl, type, resolved;
10259       /* Extract the last IDENTIFIER of the qualified
10260          expression. This is a wfl and we will use it's location
10261          data during error report. */
10262       identifier_wfl = cut_identifier_in_qualified (wfl);
10263       identifier = EXPR_WFL_NODE (identifier_wfl);
10264
10265       /* Given the context, IDENTIFIER is syntactically qualified
10266          as a MethodName. We need to qualify what's before */
10267       qualify_ambiguous_name (wfl);
10268       resolved = resolve_field_access (wfl, NULL, NULL);
10269
10270       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10271          && FIELD_FINAL (resolved)
10272          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10273          && !flag_emit_class_files && !flag_emit_xref)
10274        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10275
10276       if (resolved == error_mark_node)
10277         PATCH_METHOD_RETURN_ERROR ();
10278
10279       type = GET_SKIP_TYPE (resolved);
10280       resolve_and_layout (type, NULL_TREE);
10281
10282       if (JPRIMITIVE_TYPE_P (type))
10283         {
10284           parse_error_context
10285             (identifier_wfl,
10286              "Can't invoke a method on primitive type `%s'",
10287              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10288           PATCH_METHOD_RETURN_ERROR ();
10289         }
10290
10291       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10292       args = nreverse (args);
10293
10294       /* We're resolving a call from a type */
10295       if (TREE_CODE (resolved) == TYPE_DECL)
10296         {
10297           if (CLASS_INTERFACE (resolved))
10298             {
10299               parse_error_context
10300                 (identifier_wfl,
10301                 "Can't make static reference to method `%s' in interface `%s'",
10302                  IDENTIFIER_POINTER (identifier),
10303                  IDENTIFIER_POINTER (name));
10304               PATCH_METHOD_RETURN_ERROR ();
10305             }
10306           if (list && !METHOD_STATIC (list))
10307             {
10308               char *fct_name = xstrdup (lang_printable_name (list, 2));
10309               parse_error_context
10310                 (identifier_wfl,
10311                  "Can't make static reference to method `%s %s' in class `%s'",
10312                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10313                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10314               free (fct_name);
10315               PATCH_METHOD_RETURN_ERROR ();
10316             }
10317         }
10318       else
10319         this_arg = primary = resolved;
10320
10321       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10322         is_array_clone_call = 1;
10323
10324       /* IDENTIFIER_WFL will be used to report any problem further */
10325       wfl = identifier_wfl;
10326     }
10327   /* Resolution of simple names, names generated after a primary: or
10328      constructors */
10329   else
10330     {
10331       tree class_to_search = NULL_TREE;
10332       int lc;                   /* Looking for Constructor */
10333
10334       /* We search constructor in their target class */
10335       if (CALL_CONSTRUCTOR_P (patch))
10336         {
10337           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10338             class_to_search = EXPR_WFL_NODE (wfl);
10339           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10340                    this_identifier_node)
10341             class_to_search = NULL_TREE;
10342           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10343                    super_identifier_node)
10344             {
10345               is_super_init = 1;
10346               if (CLASSTYPE_SUPER (current_class))
10347                 class_to_search =
10348                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10349               else
10350                 {
10351                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10352                   PATCH_METHOD_RETURN_ERROR ();
10353                 }
10354             }
10355
10356           /* Class to search is NULL if we're searching the current one */
10357           if (class_to_search)
10358             {
10359               class_to_search = resolve_and_layout (class_to_search, wfl);
10360
10361               if (!class_to_search)
10362                 {
10363                   parse_error_context
10364                     (wfl, "Class `%s' not found in type declaration",
10365                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10366                   PATCH_METHOD_RETURN_ERROR ();
10367                 }
10368
10369               /* Can't instantiate an abstract class, but we can
10370                  invoke it's constructor. It's use within the `new'
10371                  context is denied here. */
10372               if (CLASS_ABSTRACT (class_to_search)
10373                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10374                 {
10375                   parse_error_context
10376                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10377                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10378                   PATCH_METHOD_RETURN_ERROR ();
10379                 }
10380
10381               class_to_search = TREE_TYPE (class_to_search);
10382             }
10383           else
10384             class_to_search = current_class;
10385           lc = 1;
10386         }
10387       /* This is a regular search in the local class, unless an
10388          alternate class is specified. */
10389       else
10390         {
10391           if (where != NULL_TREE)
10392             class_to_search = where;
10393           else if (QUALIFIED_P (name))
10394             class_to_search = current_class;
10395           else
10396             {
10397               class_to_search = current_class;
10398
10399               for (;;)
10400                 {
10401                   if (has_method (class_to_search, name))
10402                     break;
10403                   if (! INNER_CLASS_TYPE_P (class_to_search))
10404                     {
10405                       parse_error_context (wfl,
10406                                            "No method named `%s' in scope",
10407                                            IDENTIFIER_POINTER (name));
10408                       PATCH_METHOD_RETURN_ERROR ();
10409                     }
10410                   class_to_search
10411                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10412                 }
10413             }
10414           lc = 0;
10415         }
10416
10417       /* NAME is a simple identifier or comes from a primary. Search
10418          in the class whose declaration contain the method being
10419          invoked. */
10420       resolve_and_layout (class_to_search, NULL_TREE);
10421
10422       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10423       /* Don't continue if no method were found, as the next statement
10424          can't be executed then. */
10425       if (!list)
10426         PATCH_METHOD_RETURN_ERROR ();
10427
10428       if (TYPE_ARRAY_P (class_to_search)
10429           && DECL_NAME (list) == get_identifier ("clone"))
10430         is_array_clone_call = 1;
10431
10432       /* Check for static reference if non static methods */
10433       if (check_for_static_method_reference (wfl, patch, list,
10434                                              class_to_search, primary))
10435         PATCH_METHOD_RETURN_ERROR ();
10436
10437       /* Check for inner classes creation from illegal contexts */
10438       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10439                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10440           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10441           && !DECL_INIT_P (current_function_decl))
10442         {
10443           parse_error_context
10444             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10445              lang_printable_name (class_to_search, 0),
10446              (!current_this ? "" :
10447               "; an explicit one must be provided when creating this inner class"));
10448           PATCH_METHOD_RETURN_ERROR ();
10449         }
10450
10451       /* Non static methods are called with the current object extra
10452          argument. If patch a `new TYPE()', the argument is the value
10453          returned by the object allocator. If method is resolved as a
10454          primary, use the primary otherwise use the current THIS. */
10455       args = nreverse (args);
10456       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10457         {
10458           this_arg = primary ? primary : current_this;
10459
10460           /* If we're using an access method, things are different.
10461              There are two family of cases:
10462
10463              1) We're not generating bytecodes:
10464
10465              - LIST is non static. It's invocation is transformed from
10466                x(a1,...,an) into this$<n>.x(a1,....an).
10467              - LIST is static. It's invocation is transformed from
10468                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10469
10470              2) We're generating bytecodes:
10471
10472              - LIST is non static. It's invocation is transformed from
10473                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10474              - LIST is static. It's invocation is transformed from
10475                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10476
10477              Of course, this$<n> can be arbitrarily complex, ranging from
10478              this$0 (the immediate outer context) to
10479              access$0(access$0(...(this$0))).
10480
10481              maybe_use_access_method returns a nonzero value if the
10482              this_arg has to be moved into the (then generated) stub
10483              argument list. In the meantime, the selected function
10484              might have be replaced by a generated stub. */
10485           if (!primary &&
10486               maybe_use_access_method (is_super_init, &list, &this_arg))
10487             {
10488               args = tree_cons (NULL_TREE, this_arg, args);
10489               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10490             }
10491         }
10492     }
10493
10494   /* Merge point of all resolution schemes. If we have nothing, this
10495      is an error, already signaled */
10496   if (!list)
10497     PATCH_METHOD_RETURN_ERROR ();
10498
10499   /* Check accessibility, position the is_static flag, build and
10500      return the call */
10501   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10502                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10503                          NULL_TREE), from_super)
10504       /* Calls to clone() on array types are permitted as a special-case. */
10505       && !is_array_clone_call)
10506     {
10507       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10508       const char *const access =
10509         accessibility_string (get_access_flags_from_decl (list));
10510       const char *const klass =
10511         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10512       const char *const refklass =
10513         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10514       const char *const what = (DECL_CONSTRUCTOR_P (list)
10515                                 ? "constructor" : "method");
10516       parse_error_context (wfl,
10517                            "Can't access %s %s `%s.%s' from `%s'",
10518                            access, what, klass, fct_name, refklass);
10519       PATCH_METHOD_RETURN_ERROR ();
10520     }
10521
10522   /* Deprecation check: check whether the method being invoked or the
10523      instance-being-created's type are deprecated.  */
10524   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10525     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10526   check_deprecation (wfl, list);
10527
10528   /* If invoking a innerclass constructor, there are hidden parameters
10529      to pass */
10530   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10531       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10532     {
10533       /* And make sure we add the accessed local variables to be saved
10534          in field aliases. */
10535       args = build_alias_initializer_parameter_list
10536         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10537
10538       /* Secretly pass the current_this/primary as a second argument */
10539       if (primary || current_this)
10540         {
10541           tree extra_arg;
10542           tree this_type = (current_this ?
10543                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10544           /* Method's (list) enclosing context */
10545           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10546           /* If we have a primary, use it. */
10547           if (primary)
10548             extra_arg = primary;
10549           /* The current `this' is an inner class but isn't a direct
10550              enclosing context for the inner class we're trying to
10551              create. Build an access to the proper enclosing context
10552              and use it. */
10553           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10554                    && this_type != TREE_TYPE (mec))
10555             {
10556
10557               extra_arg = build_access_to_thisn (current_class,
10558                                                  TREE_TYPE (mec), 0);
10559               extra_arg = java_complete_tree (extra_arg);
10560             }
10561           /* Otherwise, just use the current `this' as an enclosing
10562              context. */
10563           else
10564             extra_arg = current_this;
10565           args = tree_cons (NULL_TREE, extra_arg, args);
10566         }
10567       else
10568         args = tree_cons (NULL_TREE, integer_zero_node, args);
10569     }
10570
10571   /* This handles the situation where a constructor invocation needs
10572      to have an enclosing context passed as a second parameter (the
10573      constructor is one of an inner class). */
10574   if ((is_super_init ||
10575        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10576       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10577     {
10578       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10579       tree extra_arg =
10580         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10581       extra_arg = java_complete_tree (extra_arg);
10582       args = tree_cons (NULL_TREE, extra_arg, args);
10583     }
10584
10585   is_static_flag = METHOD_STATIC (list);
10586   if (! is_static_flag && this_arg != NULL_TREE)
10587     args = tree_cons (NULL_TREE, this_arg, args);
10588
10589   /* In the context of an explicit constructor invocation, we can't
10590      invoke any method relying on `this'. Exceptions are: we're
10591      invoking a static function, primary exists and is not the current
10592      this, we're creating a new object. */
10593   if (ctxp->explicit_constructor_p
10594       && !is_static_flag
10595       && (!primary || primary == current_this)
10596       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10597     {
10598       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10599       PATCH_METHOD_RETURN_ERROR ();
10600     }
10601   java_parser_context_restore_global ();
10602   if (is_static)
10603     *is_static = is_static_flag;
10604   /* Sometimes, we want the decl of the selected method. Such as for
10605      EH checking */
10606   if (ret_decl)
10607     *ret_decl = list;
10608   patch = patch_invoke (patch, list, args);
10609
10610   /* Now is a good time to insert the call to finit$ */
10611   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10612     {
10613       tree finit_parms, finit_call;
10614
10615       /* Prepare to pass hidden parameters to finit$, if any. */
10616       finit_parms = build_alias_initializer_parameter_list
10617         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10618
10619       finit_call =
10620         build_method_invocation (build_wfl_node (finit_identifier_node),
10621                                  finit_parms);
10622
10623       /* Generate the code used to initialize fields declared with an
10624          initialization statement and build a compound statement along
10625          with the super constructor invocation. */
10626       CAN_COMPLETE_NORMALLY (patch) = 1;
10627       patch = build2 (COMPOUND_EXPR, void_type_node, patch,
10628                       java_complete_tree (finit_call));
10629     }
10630   return patch;
10631 }
10632
10633 /* Check that we're not trying to do a static reference to a method in
10634    non static method. Return 1 if it's the case, 0 otherwise. */
10635
10636 static int
10637 check_for_static_method_reference (tree wfl, tree node, tree method,
10638                                    tree where, tree primary)
10639 {
10640   if (METHOD_STATIC (current_function_decl)
10641       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10642     {
10643       char *fct_name = xstrdup (lang_printable_name (method, 0));
10644       parse_error_context
10645         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10646          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10647          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10648       free (fct_name);
10649       return 1;
10650     }
10651   return 0;
10652 }
10653
10654 /* Fix the invocation of *MDECL if necessary in the case of a
10655    invocation from an inner class. *THIS_ARG might be modified
10656    appropriately and an alternative access to *MDECL might be
10657    returned.  */
10658
10659 static int
10660 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10661 {
10662   tree ctx;
10663   tree md = *mdecl, ta = *this_arg;
10664   int to_return = 0;
10665   int non_static_context = !METHOD_STATIC (md);
10666
10667   if (is_super_init
10668       || DECL_CONTEXT (md) == current_class
10669       || !PURE_INNER_CLASS_TYPE_P (current_class)
10670       || DECL_FINIT_P (md)
10671       || DECL_INSTINIT_P (md))
10672     return 0;
10673
10674   /* If we're calling a method found in an enclosing class, generate
10675      what it takes to retrieve the right this. Don't do that if we're
10676      invoking a static method. Note that if MD's type is unrelated to
10677      CURRENT_CLASS, then the current this can be used. */
10678
10679   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10680     {
10681       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10682       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10683         {
10684           ta = build_current_thisn (current_class);
10685           ta = build_wfl_node (ta);
10686         }
10687       else
10688         {
10689           tree type = ctx;
10690           while (type)
10691             {
10692               maybe_build_thisn_access_method (type);
10693               if (inherits_from_p (type, DECL_CONTEXT (md)))
10694                 {
10695                   ta = build_access_to_thisn (ctx, type, 0);
10696                   break;
10697                 }
10698               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10699                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10700             }
10701         }
10702       ta = java_complete_tree (ta);
10703     }
10704
10705   /* We might have to use an access method to get to MD. We can
10706      break the method access rule as far as we're not generating
10707      bytecode */
10708   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10709     {
10710       md = build_outer_method_access_method (md);
10711       to_return = 1;
10712     }
10713
10714   *mdecl = md;
10715   *this_arg = ta;
10716
10717   /* Returning a nonzero value indicates we were doing a non static
10718      method invocation that is now a static invocation. It will have
10719      callee displace `this' to insert it in the regular argument
10720      list. */
10721   return (non_static_context && to_return);
10722 }
10723
10724 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10725    mode.  */
10726
10727 static tree
10728 patch_invoke (tree patch, tree method, tree args)
10729 {
10730   tree dtable, func;
10731   tree original_call, t, ta;
10732   tree check = NULL_TREE;
10733
10734   /* Last step for args: convert build-in types. If we're dealing with
10735      a new TYPE() type call, the first argument to the constructor
10736      isn't found in the incoming argument list, but delivered by
10737      `new' */
10738   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10739   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10740     t = TREE_CHAIN (t);
10741   for (ta = args; t != end_params_node && ta;
10742        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10743     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10744         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10745       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10746
10747   /* Resolve unresolved returned type issues */
10748   t = TREE_TYPE (TREE_TYPE (method));
10749   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10750     resolve_and_layout (TREE_TYPE (t), NULL);
10751
10752   if (flag_emit_class_files || flag_emit_xref)
10753     func = method;
10754   else
10755     {
10756       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10757         {
10758         case INVOKE_VIRTUAL:
10759           dtable = invoke_build_dtable (0, args);
10760           func = build_invokevirtual (dtable, method);
10761           break;
10762
10763         case INVOKE_NONVIRTUAL:
10764           /* If the object for the method call is null, we throw an
10765              exception.  We don't do this if the object is the current
10766              method's `this'.  In other cases we just rely on an
10767              optimization pass to eliminate redundant checks.  */
10768           if (TREE_VALUE (args) != current_this)
10769             {
10770               /* We use a save_expr here to make sure we only evaluate
10771                  the new `self' expression once.  */
10772               tree save_arg = save_expr (TREE_VALUE (args));
10773               TREE_VALUE (args) = save_arg;
10774               check = java_check_reference (save_arg, 1);
10775             }
10776           /* Fall through.  */
10777
10778         case INVOKE_SUPER:
10779         case INVOKE_STATIC:
10780           {
10781             tree signature = build_java_signature (TREE_TYPE (method));
10782             func = build_known_method_ref (method, TREE_TYPE (method),
10783                                            DECL_CONTEXT (method),
10784                                            signature, args);
10785           }
10786           break;
10787
10788         case INVOKE_INTERFACE:
10789           dtable = invoke_build_dtable (1, args);
10790           func = build_invokeinterface (dtable, method);
10791           break;
10792
10793         default:
10794           abort ();
10795         }
10796
10797       /* Ensure self_type is initialized, (invokestatic). FIXME */
10798       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10799     }
10800
10801   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10802   TREE_OPERAND (patch, 0) = func;
10803   TREE_OPERAND (patch, 1) = args;
10804   patch = check_for_builtin (method, patch);
10805   original_call = patch;
10806
10807   /* We're processing a `new TYPE ()' form. New is called and its
10808      returned value is the first argument to the constructor. We build
10809      a COMPOUND_EXPR and use saved expression so that the overall NEW
10810      expression value is a pointer to a newly created and initialized
10811      class. */
10812   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10813     {
10814       tree class = DECL_CONTEXT (method);
10815       tree c1, saved_new, size, new;
10816       tree alloc_node;
10817
10818       if (flag_emit_class_files || flag_emit_xref)
10819         {
10820           TREE_TYPE (patch) = build_pointer_type (class);
10821           return patch;
10822         }
10823       if (!TYPE_SIZE (class))
10824         safe_layout_class (class);
10825       size = size_in_bytes (class);
10826       alloc_node =
10827         (class_has_finalize_method (class) ? alloc_object_node
10828                                            : alloc_no_finalizer_node);
10829       new = build3 (CALL_EXPR, promote_type (class),
10830                     build_address_of (alloc_node),
10831                     build_tree_list (NULL_TREE, build_class_ref (class)),
10832                     NULL_TREE);
10833       saved_new = save_expr (new);
10834       c1 = build_tree_list (NULL_TREE, saved_new);
10835       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10836       TREE_OPERAND (original_call, 1) = c1;
10837       TREE_SET_CODE (original_call, CALL_EXPR);
10838       patch = build2 (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10839     }
10840
10841   /* If CHECK is set, then we are building a check to see if the object
10842      is NULL.  */
10843   if (check != NULL_TREE)
10844     {
10845       /* We have to call force_evaluation_order now because creating a
10846          COMPOUND_EXPR wraps the arg list in a way that makes it
10847          unrecognizable by force_evaluation_order later.  Yuk.  */
10848       patch = build2 (COMPOUND_EXPR, TREE_TYPE (patch), check,
10849                       force_evaluation_order (patch));
10850       TREE_SIDE_EFFECTS (patch) = 1;
10851     }
10852
10853   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10854      put it as the first expression of a COMPOUND_EXPR. The second
10855      expression being an empty statement to be later patched if
10856      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10857      the VALUE is the compound) in a hashtable and return a
10858      COMPOUND_EXPR built so that the result of the evaluation of the
10859      original PATCH node is returned. */
10860   if (STATIC_CLASS_INIT_OPT_P ()
10861       && current_function_decl && METHOD_STATIC (method))
10862     {
10863       tree list;
10864       tree fndecl = current_function_decl;
10865       /* We have to call force_evaluation_order now because creating a
10866          COMPOUND_EXPR wraps the arg list in a way that makes it
10867          unrecognizable by force_evaluation_order later.  Yuk.  */
10868       tree save = force_evaluation_order (patch);
10869       tree type = TREE_TYPE (patch);
10870
10871       patch = build2 (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
10872       list = tree_cons (method, patch,
10873                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10874
10875       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10876
10877       patch = build2 (COMPOUND_EXPR, type, patch, save);
10878     }
10879
10880   return patch;
10881 }
10882
10883 static int
10884 invocation_mode (tree method, int super)
10885 {
10886   int access = get_access_flags_from_decl (method);
10887
10888   if (super)
10889     return INVOKE_SUPER;
10890
10891   if (access & ACC_STATIC)
10892     return INVOKE_STATIC;
10893
10894   /* We have to look for a constructor before we handle nonvirtual
10895      calls; otherwise the constructor will look nonvirtual.  */
10896   if (DECL_CONSTRUCTOR_P (method))
10897     return INVOKE_STATIC;
10898
10899   if (access & ACC_FINAL || access & ACC_PRIVATE)
10900     return INVOKE_NONVIRTUAL;
10901
10902   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10903     return INVOKE_NONVIRTUAL;
10904
10905   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10906     return INVOKE_INTERFACE;
10907
10908   return INVOKE_VIRTUAL;
10909 }
10910
10911 /* Retrieve a refined list of matching methods. It covers the step
10912    15.11.2 (Compile-Time Step 2) */
10913
10914 static tree
10915 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10916 {
10917   tree atl = end_params_node;           /* Arg Type List */
10918   tree method, signature, list, node;
10919   const char *candidates;               /* Used for error report */
10920   char *dup;
10921
10922   /* Fix the arguments */
10923   for (node = arg_list; node; node = TREE_CHAIN (node))
10924     {
10925       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10926       /* Non primitive type may have to be resolved */
10927       if (!JPRIMITIVE_TYPE_P (current_arg))
10928         resolve_and_layout (current_arg, NULL_TREE);
10929       /* And promoted */
10930       if (TREE_CODE (current_arg) == RECORD_TYPE)
10931         current_arg = promote_type (current_arg);
10932       atl = tree_cons (NULL_TREE, current_arg, atl);
10933     }
10934
10935   /* Presto. If we're dealing with an anonymous class and a
10936      constructor call, generate the right constructor now, since we
10937      know the arguments' types. */
10938
10939   if (lc && ANONYMOUS_CLASS_P (class))
10940     {
10941       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10942       /* The anonymous class may have already been laid out, so make sure
10943          the new constructor is laid out here.  */
10944       layout_class_method (class, CLASSTYPE_SUPER (class), mdecl, NULL_TREE);
10945     }
10946
10947   /* Find all candidates and then refine the list, searching for the
10948      most specific method. */
10949   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10950   list = find_most_specific_methods_list (list);
10951   if (list && !TREE_CHAIN (list))
10952     return TREE_VALUE (list);
10953
10954   /* Issue an error. List candidates if any. Candidates are listed
10955      only if accessible (non accessible methods may end-up here for
10956      the sake of a better error report). */
10957   candidates = NULL;
10958   if (list)
10959     {
10960       tree current;
10961       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10962       for (current = list; current; current = TREE_CHAIN (current))
10963         {
10964           tree cm = TREE_VALUE (current);
10965           char string [4096];
10966           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10967             continue;
10968           sprintf
10969             (string, "  `%s' in `%s'%s",
10970              get_printable_method_name (cm),
10971              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10972              (TREE_CHAIN (current) ? "\n" : ""));
10973           obstack_grow (&temporary_obstack, string, strlen (string));
10974         }
10975       obstack_1grow (&temporary_obstack, '\0');
10976       candidates = obstack_finish (&temporary_obstack);
10977     }
10978   /* Issue the error message */
10979   method = make_node (FUNCTION_TYPE);
10980   TYPE_ARG_TYPES (method) = atl;
10981   signature = build_java_argument_signature (method);
10982   dup = xstrdup (lang_printable_name (class, 0));
10983   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10984                        (lc ? "constructor" : "method"),
10985                        (lc ? dup : IDENTIFIER_POINTER (name)),
10986                        IDENTIFIER_POINTER (signature), dup,
10987                        (candidates ? candidates : ""));
10988   free (dup);
10989   return NULL_TREE;
10990 }
10991
10992 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10993    when we're looking for a constructor. */
10994
10995 static tree
10996 find_applicable_accessible_methods_list (int lc, tree class, tree name,
10997                                          tree arglist)
10998 {
10999   static htab_t searched_classes;
11000   static int search_not_done = 0;
11001   tree list = NULL_TREE, all_list = NULL_TREE;
11002   tree base_binfo;
11003   int i;
11004
11005   /* Check the hash table to determine if this class has been searched
11006      already. */
11007   if (searched_classes)
11008     {
11009       if (htab_find (searched_classes, class) != NULL)
11010         return NULL;
11011     }
11012   else
11013     {
11014       searched_classes = htab_create (10, htab_hash_pointer,
11015                                       htab_eq_pointer, NULL);
11016     }
11017
11018   search_not_done++;
11019   *htab_find_slot (searched_classes, class, INSERT) = class;
11020
11021   if (!CLASS_LOADED_P (class))
11022     {
11023       load_class (class, 1);
11024       safe_layout_class (class);
11025     }
11026
11027   /* Search interfaces */
11028   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11029       && CLASS_INTERFACE (TYPE_NAME (class)))
11030     {
11031       search_applicable_methods_list (lc, TYPE_METHODS (class),
11032                                       name, arglist, &list, &all_list);
11033       for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11034         {
11035           tree t = BINFO_TYPE (base_binfo);
11036           tree rlist;
11037
11038           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11039                                                            arglist);
11040           list = chainon (rlist, list);
11041         }
11042     }
11043   /* Search classes */
11044   else
11045     {
11046       search_applicable_methods_list (lc, TYPE_METHODS (class),
11047                                       name, arglist, &list, &all_list);
11048
11049       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11050          that we only search in class. Note that we should have found
11051          something at this point. */
11052       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11053         {
11054           lc = 1;
11055           if (!list)
11056             abort ();
11057         }
11058
11059       /* We must search all interfaces of this class */
11060       if (!lc)
11061         {
11062           for (i = 1;
11063                BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11064             {
11065               tree t = BINFO_TYPE (base_binfo);
11066               if (t != object_type_node)
11067                 {
11068                   tree rlist
11069                     = find_applicable_accessible_methods_list (lc, t,
11070                                                                name, arglist);
11071                   list = chainon (rlist, list);
11072                 }
11073             }
11074         }
11075
11076       /* Search superclass */
11077       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11078         {
11079           tree rlist;
11080           class = CLASSTYPE_SUPER (class);
11081           rlist = find_applicable_accessible_methods_list (lc, class,
11082                                                            name, arglist);
11083           list = chainon (rlist, list);
11084         }
11085     }
11086
11087   search_not_done--;
11088
11089   /* We're done. Reset the searched classes list and finally search
11090      java.lang.Object if it wasn't searched already. */
11091   if (!search_not_done)
11092     {
11093       if (!lc
11094           && TYPE_METHODS (object_type_node)
11095           && htab_find (searched_classes, object_type_node) == NULL)
11096         {
11097           search_applicable_methods_list (lc,
11098                                           TYPE_METHODS (object_type_node),
11099                                           name, arglist, &list, &all_list);
11100         }
11101       htab_delete (searched_classes);
11102       searched_classes = NULL;
11103     }
11104
11105   /* Either return the list obtained or all selected (but
11106      inaccessible) methods for better error report. */
11107   return (!list ? all_list : list);
11108 }
11109
11110 /* Effectively search for the appropriate method in method */
11111
11112 static void
11113 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11114                                 tree *list, tree *all_list)
11115 {
11116   for (; method; method = TREE_CHAIN (method))
11117     {
11118       /* When dealing with constructor, stop here, otherwise search
11119          other classes */
11120       if (lc && !DECL_CONSTRUCTOR_P (method))
11121         continue;
11122       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11123                        || (DECL_NAME (method) != name)))
11124         continue;
11125
11126       if (argument_types_convertible (method, arglist))
11127         {
11128           /* Retain accessible methods only */
11129           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11130                                  method, NULL_TREE, 0))
11131             *list = tree_cons (NULL_TREE, method, *list);
11132           else
11133             /* Also retain all selected method here */
11134             *all_list = tree_cons (NULL_TREE, method, *list);
11135         }
11136     }
11137 }
11138
11139 /* 15.11.2.2 Choose the Most Specific Method */
11140
11141 static tree
11142 find_most_specific_methods_list (tree list)
11143 {
11144   int max = 0;
11145   int abstract, candidates;
11146   tree current, new_list = NULL_TREE;
11147   for (current = list; current; current = TREE_CHAIN (current))
11148     {
11149       tree method;
11150       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11151
11152       for (method = list; method; method = TREE_CHAIN (method))
11153         {
11154           tree method_v, current_v;
11155           /* Don't test a method against itself */
11156           if (method == current)
11157             continue;
11158
11159           method_v = TREE_VALUE (method);
11160           current_v = TREE_VALUE (current);
11161
11162           /* Compare arguments and location where methods where declared */
11163           if (argument_types_convertible (method_v, current_v))
11164             {
11165               if (valid_method_invocation_conversion_p
11166                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11167                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11168                       && enclosing_context_p (DECL_CONTEXT (method_v),
11169                                               DECL_CONTEXT (current_v))))
11170                 {
11171                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11172                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11173                   max = (v > max ? v : max);
11174                 }
11175             }
11176         }
11177     }
11178
11179   /* Review the list and select the maximally specific methods */
11180   for (current = list, abstract = -1, candidates = -1;
11181        current; current = TREE_CHAIN (current))
11182     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11183       {
11184         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11185         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11186         candidates++;
11187       }
11188
11189   /* If we have several and they're all abstract, just pick the
11190      closest one. */
11191   if (candidates > 0 && candidates == abstract)
11192     {
11193       /* FIXME: merge the throws clauses.  There is no convenient way
11194          to do this in gcj right now, since ideally we'd like to
11195          introduce a new METHOD_DECL here, but that is really not
11196          possible.  */
11197       new_list = nreverse (new_list);
11198       TREE_CHAIN (new_list) = NULL_TREE;
11199       return new_list;
11200     }
11201
11202   /* We have several (we couldn't find a most specific), all but one
11203      are abstract, we pick the only non abstract one. */
11204   if (candidates > 0 && (candidates == abstract+1))
11205     {
11206       for (current = new_list; current; current = TREE_CHAIN (current))
11207         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11208           {
11209             TREE_CHAIN (current) = NULL_TREE;
11210             new_list = current;
11211           }
11212     }
11213
11214   /* If we can't find one, lower expectations and try to gather multiple
11215      maximally specific methods */
11216   while (!new_list && max)
11217     {
11218       while (--max > 0)
11219         {
11220           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11221             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11222         }
11223     }
11224
11225   return new_list;
11226 }
11227
11228 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11229    converted by method invocation conversion (5.3) to the type of the
11230    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11231    to change less often than M1. */
11232
11233 static GTY(()) tree m2_arg_value;
11234 static GTY(()) tree m2_arg_cache;
11235
11236 static int
11237 argument_types_convertible (tree m1, tree m2_or_arglist)
11238 {
11239   tree m1_arg, m2_arg;
11240
11241   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11242
11243   if (m2_arg_value == m2_or_arglist)
11244     m2_arg = m2_arg_cache;
11245   else
11246     {
11247       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11248          argument types */
11249       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11250         {
11251           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11252           if (!METHOD_STATIC (m2_or_arglist))
11253             m2_arg = TREE_CHAIN (m2_arg);
11254         }
11255       else
11256         m2_arg = m2_or_arglist;
11257
11258       m2_arg_value = m2_or_arglist;
11259       m2_arg_cache = m2_arg;
11260     }
11261
11262   while (m1_arg != end_params_node && m2_arg != end_params_node)
11263     {
11264       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11265       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11266                                                  TREE_VALUE (m2_arg)))
11267         break;
11268       m1_arg = TREE_CHAIN (m1_arg);
11269       m2_arg = TREE_CHAIN (m2_arg);
11270     }
11271   return m1_arg == end_params_node && m2_arg == end_params_node;
11272 }
11273
11274 /* Qualification routines */
11275
11276 /* Given a name x.y.z, look up x locally.  If it's found, save the
11277    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11278    so that we later try and load the appropriate classes.  */
11279 static void
11280 qualify_ambiguous_name (tree id)
11281 {
11282   tree name, decl;
11283
11284   /* We inspect the first item of the qualification list.  As a sanity
11285      check, make sure that it is an identfier node.  */
11286   tree qual = EXPR_WFL_QUALIFICATION (id);
11287   tree qual_wfl = QUAL_WFL (qual);
11288
11289   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11290     return;
11291
11292   name = EXPR_WFL_NODE (qual_wfl);
11293
11294   /* If we don't have an identifier, or we have a 'this' or 'super',
11295      then field access processing is all we need : there is nothing
11296      for us to do.  */
11297   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11298       name == this_identifier_node ||
11299       name == super_identifier_node)
11300     return;
11301
11302   /* If name appears within the scope of a local variable declaration
11303      or parameter declaration, or is a field within an enclosing
11304      class, then it is an expression name.  Save the decl and let
11305      resolve_field_access do it's work.  */
11306   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11307       (decl = lookup_field_wrapper (current_class, name)))
11308     {
11309       QUAL_RESOLUTION (qual) = decl;
11310       return;
11311     }
11312
11313   /* If name is a known class name (either declared or imported), mark
11314      us as a type name.  */
11315   if ((decl = resolve_and_layout (name, NULL_TREE)))
11316     {
11317       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11318       QUAL_RESOLUTION (qual) = decl;
11319     }
11320
11321   /* Check here that NAME isn't declared by more than one
11322      type-import-on-demand declaration of the compilation unit
11323      containing NAME. FIXME */
11324
11325   /* We couldn't find a declaration for the name.  Assume for now that
11326      we have a qualified class name that needs to be loaded from an
11327      external class file.  */
11328   else
11329     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11330
11331   /* Propagate the qualification across other components of the
11332      qualified name */
11333   for (qual = TREE_CHAIN (qual); qual;
11334        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11335     {
11336       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11337         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11338     }
11339
11340   /* Store the global qualification for the ambiguous part of ID back
11341      into ID fields */
11342   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11343     RESOLVE_TYPE_NAME_P (id) = 1;
11344   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11345     RESOLVE_PACKAGE_NAME_P (id) = 1;
11346 }
11347
11348 /* Patch tree nodes in a function body. When a BLOCK is found, push
11349    local variable decls if present.
11350    Same as java_complete_lhs, but does resolve static finals to values. */
11351
11352 static tree
11353 java_complete_tree (tree node)
11354 {
11355   node = java_complete_lhs (node);
11356   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11357       && DECL_INITIAL (node) != NULL_TREE
11358       && !flag_emit_xref)
11359     {
11360       tree value = fold_constant_for_init (node, node);
11361       if (value != NULL_TREE)
11362         return value;
11363     }
11364   return node;
11365 }
11366
11367 static tree
11368 java_stabilize_reference (tree node)
11369 {
11370   if (TREE_CODE (node) == COMPOUND_EXPR)
11371     {
11372       tree op0 = TREE_OPERAND (node, 0);
11373       tree op1 = TREE_OPERAND (node, 1);
11374       TREE_OPERAND (node, 0) = save_expr (op0);
11375       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11376       return node;
11377     }
11378   return stabilize_reference (node);
11379 }
11380
11381 /* Patch tree nodes in a function body. When a BLOCK is found, push
11382    local variable decls if present.
11383    Same as java_complete_tree, but does not resolve static finals to values. */
11384
11385 static tree
11386 java_complete_lhs (tree node)
11387 {
11388   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11389   int flag;
11390
11391   /* CONVERT_EXPR always has its type set, even though it needs to be
11392      worked out. */
11393   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11394     return node;
11395
11396   /* The switch block implements cases processing container nodes
11397      first.  Contained nodes are always written back. Leaves come
11398      next and return a value. */
11399   switch (TREE_CODE (node))
11400     {
11401     case BLOCK:
11402
11403       /* 1- Block section.
11404          Set the local values on decl names so we can identify them
11405          faster when they're referenced. At that stage, identifiers
11406          are legal so we don't check for declaration errors. */
11407       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11408         {
11409           DECL_CONTEXT (cn) = current_function_decl;
11410           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11411         }
11412       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11413           CAN_COMPLETE_NORMALLY (node) = 1;
11414       else
11415         {
11416           tree stmt = BLOCK_EXPR_BODY (node);
11417           tree *ptr;
11418           int error_seen = 0;
11419           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11420             {
11421               /* Re-order from (((A; B); C); ...; Z) to
11422                  (A; (B; (C ; (...; Z)))).
11423                  This makes it easier to scan the statements left-to-right
11424                  without using recursion (which might overflow the stack
11425                  if the block has many statements. */
11426               for (;;)
11427                 {
11428                   tree left = TREE_OPERAND (stmt, 0);
11429                   if (TREE_CODE (left) != COMPOUND_EXPR)
11430                     break;
11431                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11432                   TREE_OPERAND (left, 1) = stmt;
11433                   stmt = left;
11434                 }
11435               BLOCK_EXPR_BODY (node) = stmt;
11436             }
11437
11438           /* Now do the actual complete, without deep recursion for
11439              long blocks. */
11440           ptr = &BLOCK_EXPR_BODY (node);
11441           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11442                  && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11443             {
11444               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11445               tree *next = &TREE_OPERAND (*ptr, 1);
11446               TREE_OPERAND (*ptr, 0) = cur;
11447               if (IS_EMPTY_STMT (cur))
11448                 {
11449                   /* Optimization;  makes it easier to detect empty bodies.
11450                      Most useful for <clinit> with all-constant initializer. */
11451                   *ptr = *next;
11452                   continue;
11453                 }
11454               if (TREE_CODE (cur) == ERROR_MARK)
11455                 error_seen++;
11456               else if (! CAN_COMPLETE_NORMALLY (cur))
11457                 {
11458                   wfl_op2 = *next;
11459                   for (;;)
11460                     {
11461                       if (TREE_CODE (wfl_op2) == BLOCK)
11462                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11463                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11464                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11465                       else
11466                         break;
11467                     }
11468                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11469                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11470                     unreachable_stmt_error (*ptr);
11471                 }
11472               if (TREE_TYPE (*ptr) == NULL_TREE)
11473                 TREE_TYPE (*ptr) = void_type_node;
11474               ptr = next;
11475             }
11476           *ptr = java_complete_tree (*ptr);
11477
11478           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11479             return error_mark_node;
11480           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11481         }
11482       /* Turn local bindings to null */
11483       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11484         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11485
11486       TREE_TYPE (node) = void_type_node;
11487       break;
11488
11489       /* 2- They are expressions but ultimately deal with statements */
11490
11491     case THROW_EXPR:
11492       wfl_op1 = TREE_OPERAND (node, 0);
11493       COMPLETE_CHECK_OP_0 (node);
11494       /* 14.19 A throw statement cannot complete normally. */
11495       CAN_COMPLETE_NORMALLY (node) = 0;
11496       return patch_throw_statement (node, wfl_op1);
11497
11498     case SYNCHRONIZED_EXPR:
11499       wfl_op1 = TREE_OPERAND (node, 0);
11500       return patch_synchronized_statement (node, wfl_op1);
11501
11502     case TRY_EXPR:
11503       return patch_try_statement (node);
11504
11505     case TRY_FINALLY_EXPR:
11506       COMPLETE_CHECK_OP_0 (node);
11507       COMPLETE_CHECK_OP_1 (node);
11508       if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11509         /* Reduce try/finally nodes with an empty try block.  */
11510         return TREE_OPERAND (node, 1);
11511       if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11512         /* Likewise for an empty finally block.  */
11513         return TREE_OPERAND (node, 0);
11514       CAN_COMPLETE_NORMALLY (node)
11515         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11516            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11517       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11518       return node;
11519
11520     case LABELED_BLOCK_EXPR:
11521       PUSH_LABELED_BLOCK (node);
11522       if (LABELED_BLOCK_BODY (node))
11523         COMPLETE_CHECK_OP_1 (node);
11524       TREE_TYPE (node) = void_type_node;
11525       POP_LABELED_BLOCK ();
11526
11527       if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11528         {
11529           LABELED_BLOCK_BODY (node) = NULL_TREE;
11530           CAN_COMPLETE_NORMALLY (node) = 1;
11531         }
11532       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11533         CAN_COMPLETE_NORMALLY (node) = 1;
11534       return node;
11535
11536     case EXIT_BLOCK_EXPR:
11537       /* We don't complete operand 1, because it's the return value of
11538          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11539       return patch_bc_statement (node);
11540
11541     case CASE_EXPR:
11542       cn = java_complete_tree (TREE_OPERAND (node, 0));
11543       if (cn == error_mark_node)
11544         return cn;
11545
11546       /* First, the case expression must be constant. Values of final
11547          fields are accepted. */
11548       cn = fold (cn);
11549       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11550           && JDECL_P (TREE_OPERAND (cn, 1))
11551           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11552           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11553         {
11554           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11555                                        TREE_OPERAND (cn, 1));
11556         }
11557       /* Accept final locals too. */
11558       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11559                && DECL_INITIAL (cn))
11560         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11561
11562       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11563         {
11564           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11565           parse_error_context (node, "Constant expression required");
11566           return error_mark_node;
11567         }
11568
11569       nn = ctxp->current_loop;
11570
11571       /* It must be assignable to the type of the switch expression. */
11572       if (!try_builtin_assignconv (NULL_TREE,
11573                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11574         {
11575           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11576           parse_error_context
11577             (wfl_operator,
11578              "Incompatible type for case. Can't convert `%s' to `int'",
11579              lang_printable_name (TREE_TYPE (cn), 0));
11580           return error_mark_node;
11581         }
11582
11583       cn = fold (convert (int_type_node, cn));
11584       TREE_CONSTANT_OVERFLOW (cn) = 0;
11585       CAN_COMPLETE_NORMALLY (cn) = 1;
11586
11587       /* Save the label on a list so that we can later check for
11588          duplicates.  */
11589       case_label_list = tree_cons (node, cn, case_label_list);
11590
11591       /* Multiple instance of a case label bearing the same value is
11592          checked later. The case expression is all right so far. */
11593       if (TREE_CODE (cn) == VAR_DECL)
11594         cn = DECL_INITIAL (cn);
11595       TREE_OPERAND (node, 0) = cn;
11596       TREE_TYPE (node) = void_type_node;
11597       CAN_COMPLETE_NORMALLY (node) = 1;
11598       TREE_SIDE_EFFECTS (node) = 1;
11599       break;
11600
11601     case DEFAULT_EXPR:
11602       nn = ctxp->current_loop;
11603       /* Only one default label is allowed per switch statement */
11604       if (SWITCH_HAS_DEFAULT (nn))
11605         {
11606           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11607           parse_error_context (wfl_operator,
11608                                "Duplicate case label: `default'");
11609           return error_mark_node;
11610         }
11611       else
11612         SWITCH_HAS_DEFAULT (nn) = 1;
11613       TREE_TYPE (node) = void_type_node;
11614       TREE_SIDE_EFFECTS (node) = 1;
11615       CAN_COMPLETE_NORMALLY (node) = 1;
11616       break;
11617
11618     case SWITCH_EXPR:
11619     case LOOP_EXPR:
11620       PUSH_LOOP (node);
11621       /* Check whether the loop was enclosed in a labeled
11622          statement. If not, create one, insert the loop in it and
11623          return the node */
11624       nn = patch_loop_statement (node);
11625
11626       /* Anyways, walk the body of the loop */
11627       if (TREE_CODE (node) == LOOP_EXPR)
11628         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11629       /* Switch statement: walk the switch expression and the cases */
11630       else
11631         node = patch_switch_statement (node);
11632
11633       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11634         nn = error_mark_node;
11635       else
11636         {
11637           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11638           /* If we returned something different, that's because we
11639              inserted a label. Pop the label too. */
11640           if (nn != node)
11641             {
11642               if (CAN_COMPLETE_NORMALLY (node))
11643                 CAN_COMPLETE_NORMALLY (nn) = 1;
11644               POP_LABELED_BLOCK ();
11645             }
11646         }
11647       POP_LOOP ();
11648       return nn;
11649
11650     case EXIT_EXPR:
11651       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11652       return patch_exit_expr (node);
11653
11654     case COND_EXPR:
11655       /* Condition */
11656       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11657       if (TREE_OPERAND (node, 0) == error_mark_node)
11658         return error_mark_node;
11659       /* then-else branches */
11660       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11661       if (TREE_OPERAND (node, 1) == error_mark_node)
11662         return error_mark_node;
11663       {
11664         /* This is a special case due to build_assertion().  When
11665            assertions are disabled we build a COND_EXPR in which
11666            Operand 1 is the body of the assertion.  If that happens to
11667            be a string concatenation we'll need to patch it here.  */
11668         tree patched = patch_string (TREE_OPERAND (node, 1));
11669         if (patched)
11670           TREE_OPERAND (node, 1) = patched;
11671       }
11672      TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11673       if (TREE_OPERAND (node, 2) == error_mark_node)
11674         return error_mark_node;
11675       return patch_if_else_statement (node);
11676       break;
11677
11678     case CONDITIONAL_EXPR:
11679       /* Condition */
11680       wfl_op1 = TREE_OPERAND (node, 0);
11681       COMPLETE_CHECK_OP_0 (node);
11682       wfl_op2 = TREE_OPERAND (node, 1);
11683       COMPLETE_CHECK_OP_1 (node);
11684       wfl_op3 = TREE_OPERAND (node, 2);
11685       COMPLETE_CHECK_OP_2 (node);
11686       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11687
11688       /* 3- Expression section */
11689     case COMPOUND_EXPR:
11690       wfl_op2 = TREE_OPERAND (node, 1);
11691       TREE_OPERAND (node, 0) = nn =
11692         java_complete_tree (TREE_OPERAND (node, 0));
11693       if (IS_EMPTY_STMT (wfl_op2))
11694         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11695       else
11696         {
11697           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11698             {
11699               /* An unreachable condition in a do-while statement
11700                  is *not* (technically) an unreachable statement. */
11701               nn = wfl_op2;
11702               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11703                 nn = EXPR_WFL_NODE (nn);
11704               /* NN can be NULL_TREE exactly when UPDATE is, in
11705                  finish_for_loop.  */
11706               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11707                 {
11708                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11709                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11710                     {
11711                       /* Perhaps this warning should have an
11712                          associated flag.  The code being compiled is
11713                          pedantically correct, but useless.  */
11714                       parse_warning_context (wfl_operator,
11715                                              "Unreachable statement");
11716                     }
11717                   else
11718                     parse_error_context (wfl_operator,
11719                                          "Unreachable statement");
11720                 }
11721             }
11722           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11723           if (TREE_OPERAND (node, 1) == error_mark_node)
11724             return error_mark_node;
11725           /* Even though we might allow the case where the first
11726              operand doesn't return normally, we still should compute
11727              CAN_COMPLETE_NORMALLY correctly.  */
11728           CAN_COMPLETE_NORMALLY (node)
11729             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11730                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11731         }
11732       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11733       break;
11734
11735     case RETURN_EXPR:
11736       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11737       return patch_return (node);
11738
11739     case EXPR_WITH_FILE_LOCATION:
11740       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11741           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11742         {
11743           tree wfl = node;
11744           node = resolve_expression_name (node, NULL);
11745           if (node == error_mark_node)
11746             return node;
11747           /* Keep line number information somewhere were it doesn't
11748              disrupt the completion process. */
11749           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11750             {
11751               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11752               TREE_OPERAND (node, 1) = wfl;
11753             }
11754           CAN_COMPLETE_NORMALLY (node) = 1;
11755         }
11756       else
11757         {
11758           tree body;
11759           int save_lineno = input_line;
11760           input_line = EXPR_WFL_LINENO (node);
11761           body = java_complete_tree (EXPR_WFL_NODE (node));
11762           input_line = save_lineno;
11763           EXPR_WFL_NODE (node) = body;
11764           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11765           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11766           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11767             {
11768               /* Makes it easier to constant fold, detect empty bodies. */
11769               return body;
11770             }
11771           if (body == error_mark_node)
11772             {
11773               /* Its important for the evaluation of assignment that
11774                  this mark on the TREE_TYPE is propagated. */
11775               TREE_TYPE (node) = error_mark_node;
11776               return error_mark_node;
11777             }
11778           else
11779             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11780
11781         }
11782       break;
11783
11784     case NEW_ARRAY_EXPR:
11785       /* Patch all the dimensions */
11786       flag = 0;
11787       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11788         {
11789           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11790           tree dim = convert (int_type_node,
11791                               java_complete_tree (TREE_VALUE (cn)));
11792           if (dim == error_mark_node)
11793             {
11794               flag = 1;
11795               continue;
11796             }
11797           else
11798             {
11799               TREE_VALUE (cn) = dim;
11800               /* Setup the location of the current dimension, for
11801                  later error report. */
11802               TREE_PURPOSE (cn) =
11803                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11804               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11805             }
11806         }
11807       /* They complete the array creation expression, if no errors
11808          were found. */
11809       CAN_COMPLETE_NORMALLY (node) = 1;
11810       return (flag ? error_mark_node
11811               : force_evaluation_order (patch_newarray (node)));
11812
11813     case NEW_ANONYMOUS_ARRAY_EXPR:
11814       /* Create the array type if necessary. */
11815       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11816         {
11817           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11818           if (!(type = resolve_type_during_patch (type)))
11819             return error_mark_node;
11820           type = build_array_from_name (type, NULL_TREE,
11821                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11822           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11823         }
11824       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11825                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11826       if (node == error_mark_node)
11827         return error_mark_node;
11828       CAN_COMPLETE_NORMALLY (node) = 1;
11829       return node;
11830
11831     case NEW_CLASS_EXPR:
11832     case CALL_EXPR:
11833       /* Complete function's argument(s) first */
11834       if (complete_function_arguments (node))
11835         return error_mark_node;
11836       else
11837         {
11838           tree decl, wfl = TREE_OPERAND (node, 0);
11839           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11840           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11841                            super_identifier_node);
11842           tree arguments;
11843           int location = EXPR_WFL_LINECOL (node);
11844
11845           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11846                                           from_super, 0, &decl);
11847           if (node == error_mark_node)
11848             return error_mark_node;
11849
11850           if (TREE_CODE (node) == CALL_EXPR
11851               && TREE_OPERAND (node, 1) != NULL_TREE)
11852             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11853           else
11854             arguments = NULL_TREE;
11855           check_thrown_exceptions (location, decl, arguments);
11856           /* If we call this(...), register signature and positions */
11857           if (in_this)
11858             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11859               tree_cons (wfl, decl,
11860                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11861           CAN_COMPLETE_NORMALLY (node) = 1;
11862           return force_evaluation_order (node);
11863         }
11864
11865     case MODIFY_EXPR:
11866       /* Save potential wfls */
11867       wfl_op1 = TREE_OPERAND (node, 0);
11868       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11869
11870       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11871           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11872           && DECL_INITIAL (nn) != NULL_TREE)
11873         {
11874           tree value;
11875
11876           value = fold_constant_for_init (nn, nn);
11877
11878           /* When we have a primitype type, or a string and we're not
11879              emitting a class file, we actually don't want to generate
11880              anything for the assignment. */
11881           if (value != NULL_TREE &&
11882               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11883                (TREE_TYPE (value) == string_ptr_type_node &&
11884                 ! flag_emit_class_files)))
11885             {
11886               /* Prepare node for patch_assignment */
11887               TREE_OPERAND (node, 1) = value;
11888               /* Call patch assignment to verify the assignment */
11889               if (patch_assignment (node, wfl_op1) == error_mark_node)
11890                 return error_mark_node;
11891               /* Set DECL_INITIAL properly (a conversion might have
11892                  been decided by patch_assignment) and return the
11893                  empty statement. */
11894               else
11895                 {
11896                   tree patched = patch_string (TREE_OPERAND (node, 1));
11897                   if (patched)
11898                     DECL_INITIAL (nn) = patched;
11899                   else
11900                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11901                   DECL_FIELD_FINAL_IUD (nn) = 1;
11902                   return build_java_empty_stmt ();
11903                 }
11904             }
11905           if (! flag_emit_class_files)
11906             DECL_INITIAL (nn) = NULL_TREE;
11907         }
11908       wfl_op2 = TREE_OPERAND (node, 1);
11909
11910       if (TREE_OPERAND (node, 0) == error_mark_node)
11911         return error_mark_node;
11912
11913       flag = COMPOUND_ASSIGN_P (wfl_op2);
11914       if (flag)
11915         {
11916           /* This might break when accessing outer field from inner
11917              class. TESTME, FIXME */
11918           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11919
11920           /* Hand stabilize the lhs on both places */
11921           TREE_OPERAND (node, 0) = lvalue;
11922           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11923             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11924
11925           /* 15.25.2.a: Left hand is not an array access. FIXME */
11926           /* Now complete the RHS. We write it back later on. */
11927           nn = java_complete_tree (TREE_OPERAND (node, 1));
11928
11929           if ((cn = patch_string (nn)))
11930             nn = cn;
11931
11932           /* The last part of the rewrite for E1 op= E2 is to have
11933              E1 = (T)(E1 op E2), with T being the type of E1. */
11934           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11935                                                TREE_TYPE (lvalue), nn));
11936
11937           /* If the assignment is compound and has reference type,
11938              then ensure the LHS has type String and nothing else.  */
11939           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
11940               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
11941             parse_error_context (wfl_op2,
11942                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
11943                                  lang_printable_name (TREE_TYPE (lvalue), 0));
11944
11945           /* 15.25.2.b: Left hand is an array access. FIXME */
11946         }
11947
11948       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11949          function to complete this RHS. Note that a NEW_ARRAY_INIT
11950          might have been already fully expanded if created as a result
11951          of processing an anonymous array initializer. We avoid doing
11952          the operation twice by testing whether the node already bears
11953          a type. */
11954       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
11955         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
11956                                    TREE_OPERAND (node, 1));
11957       /* Otherwise we simply complete the RHS */
11958       else
11959         nn = java_complete_tree (TREE_OPERAND (node, 1));
11960
11961       if (nn == error_mark_node)
11962         return error_mark_node;
11963
11964       /* Write back the RHS as we evaluated it. */
11965       TREE_OPERAND (node, 1) = nn;
11966
11967       /* In case we're handling = with a String as a RHS, we need to
11968          produce a String out of the RHS (it might still be a
11969          STRING_CST or a StringBuffer at this stage */
11970       if ((nn = patch_string (TREE_OPERAND (node, 1))))
11971         TREE_OPERAND (node, 1) = nn;
11972
11973       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11974                                         TREE_OPERAND (node, 1))))
11975         {
11976           /* We return error_mark_node if outer_field_access_fix
11977              detects we write into a final. */
11978           if (nn == error_mark_node)
11979             return error_mark_node;
11980           node = nn;
11981         }
11982       else
11983         {
11984           node = patch_assignment (node, wfl_op1);
11985           if (node == error_mark_node)
11986             return error_mark_node;
11987           /* Reorganize the tree if necessary. */
11988           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11989                        || JSTRING_P (TREE_TYPE (node))))
11990             node = java_refold (node);
11991         }
11992
11993       /* Seek to set DECL_INITIAL to a proper value, since it might have
11994          undergone a conversion in patch_assignment. We do that only when
11995          it's necessary to have DECL_INITIAL properly set. */
11996       nn = TREE_OPERAND (node, 0);
11997       if (TREE_CODE (nn) == VAR_DECL
11998           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
11999           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12000           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12001               || TREE_TYPE (nn) == string_ptr_type_node))
12002         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12003
12004       CAN_COMPLETE_NORMALLY (node) = 1;
12005       return node;
12006
12007     case MULT_EXPR:
12008     case PLUS_EXPR:
12009     case MINUS_EXPR:
12010     case LSHIFT_EXPR:
12011     case RSHIFT_EXPR:
12012     case URSHIFT_EXPR:
12013     case BIT_AND_EXPR:
12014     case BIT_XOR_EXPR:
12015     case BIT_IOR_EXPR:
12016     case TRUNC_MOD_EXPR:
12017     case TRUNC_DIV_EXPR:
12018     case RDIV_EXPR:
12019     case TRUTH_ANDIF_EXPR:
12020     case TRUTH_ORIF_EXPR:
12021     case EQ_EXPR:
12022     case NE_EXPR:
12023     case GT_EXPR:
12024     case GE_EXPR:
12025     case LT_EXPR:
12026     case LE_EXPR:
12027       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12028          knows how to handle those cases. */
12029       wfl_op1 = TREE_OPERAND (node, 0);
12030       wfl_op2 = TREE_OPERAND (node, 1);
12031
12032       CAN_COMPLETE_NORMALLY (node) = 1;
12033       /* Don't complete string nodes if dealing with the PLUS operand. */
12034       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12035         {
12036           nn = java_complete_tree (wfl_op1);
12037           if (nn == error_mark_node)
12038             return error_mark_node;
12039
12040           TREE_OPERAND (node, 0) = nn;
12041         }
12042       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12043         {
12044           nn = java_complete_tree (wfl_op2);
12045           if (nn == error_mark_node)
12046             return error_mark_node;
12047
12048           TREE_OPERAND (node, 1) = nn;
12049         }
12050       return patch_binop (node, wfl_op1, wfl_op2);
12051
12052     case INSTANCEOF_EXPR:
12053       wfl_op1 = TREE_OPERAND (node, 0);
12054       COMPLETE_CHECK_OP_0 (node);
12055       if (flag_emit_xref)
12056         {
12057           TREE_TYPE (node) = boolean_type_node;
12058           return node;
12059         }
12060       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12061
12062     case UNARY_PLUS_EXPR:
12063     case NEGATE_EXPR:
12064     case TRUTH_NOT_EXPR:
12065     case BIT_NOT_EXPR:
12066     case PREDECREMENT_EXPR:
12067     case PREINCREMENT_EXPR:
12068     case POSTDECREMENT_EXPR:
12069     case POSTINCREMENT_EXPR:
12070     case CONVERT_EXPR:
12071       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12072          how to handle those cases. */
12073       wfl_op1 = TREE_OPERAND (node, 0);
12074       CAN_COMPLETE_NORMALLY (node) = 1;
12075       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12076       if (TREE_OPERAND (node, 0) == error_mark_node)
12077         return error_mark_node;
12078       node = patch_unaryop (node, wfl_op1);
12079       CAN_COMPLETE_NORMALLY (node) = 1;
12080       break;
12081
12082     case ARRAY_REF:
12083       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12084          how to handle those cases. */
12085       wfl_op1 = TREE_OPERAND (node, 0);
12086       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12087       if (TREE_OPERAND (node, 0) == error_mark_node)
12088         return error_mark_node;
12089       if (!flag_emit_class_files && !flag_emit_xref)
12090         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12091       /* The same applies to wfl_op2 */
12092       wfl_op2 = TREE_OPERAND (node, 1);
12093       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12094       if (TREE_OPERAND (node, 1) == error_mark_node)
12095         return error_mark_node;
12096       if (!flag_emit_class_files && !flag_emit_xref)
12097         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12098       return patch_array_ref (node);
12099
12100     case RECORD_TYPE:
12101       return node;;
12102
12103     case COMPONENT_REF:
12104       /* The first step in the re-write of qualified name handling.  FIXME.
12105          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12106       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12107       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12108         {
12109           tree name = TREE_OPERAND (node, 1);
12110           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12111           if (field == NULL_TREE)
12112             {
12113               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12114               return error_mark_node;
12115             }
12116           if (! FIELD_STATIC (field))
12117             {
12118               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12119               return error_mark_node;
12120             }
12121           return field;
12122         }
12123       else
12124         abort ();
12125       break;
12126
12127     case THIS_EXPR:
12128       /* Can't use THIS in a static environment */
12129       if (!current_this)
12130         {
12131           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12132           parse_error_context (wfl_operator,
12133                                "Keyword `this' used outside allowed context");
12134           TREE_TYPE (node) = error_mark_node;
12135           return error_mark_node;
12136         }
12137       if (ctxp->explicit_constructor_p)
12138         {
12139           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12140           parse_error_context
12141             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12142           TREE_TYPE (node) = error_mark_node;
12143           return error_mark_node;
12144         }
12145       return current_this;
12146
12147     case CLASS_LITERAL:
12148       CAN_COMPLETE_NORMALLY (node) = 1;
12149       node = patch_incomplete_class_ref (node);
12150       if (node == error_mark_node)
12151         return error_mark_node;
12152       break;
12153
12154     default:
12155       CAN_COMPLETE_NORMALLY (node) = 1;
12156       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12157          and it's time to turn it into the appropriate String object */
12158       if ((nn = patch_string (node)))
12159         node = nn;
12160       else
12161         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12162     }
12163   return node;
12164 }
12165
12166 /* Complete function call's argument. Return a nonzero value is an
12167    error was found.  */
12168
12169 static int
12170 complete_function_arguments (tree node)
12171 {
12172   int flag = 0;
12173   tree cn;
12174
12175   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12176   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12177     {
12178       tree wfl = TREE_VALUE (cn), parm, temp;
12179       parm = java_complete_tree (wfl);
12180
12181       if (parm == error_mark_node)
12182         {
12183           flag = 1;
12184           continue;
12185         }
12186       /* If we have a string literal that we haven't transformed yet or a
12187          crafted string buffer, as a result of the use of the String
12188          `+' operator. Build `parm.toString()' and expand it. */
12189       if ((temp = patch_string (parm)))
12190         parm = temp;
12191
12192       TREE_VALUE (cn) = parm;
12193     }
12194   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12195   return flag;
12196 }
12197
12198 /* Sometimes (for loops and variable initialized during their
12199    declaration), we want to wrap a statement around a WFL and turn it
12200    debugable.  */
12201
12202 static tree
12203 build_debugable_stmt (int location, tree stmt)
12204 {
12205   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12206     {
12207       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12208       EXPR_WFL_LINECOL (stmt) = location;
12209     }
12210   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12211   return stmt;
12212 }
12213
12214 static tree
12215 build_expr_block (tree body, tree decls)
12216 {
12217   tree node = make_node (BLOCK);
12218   BLOCK_EXPR_DECLS (node) = decls;
12219   BLOCK_EXPR_BODY (node) = body;
12220   if (body)
12221     TREE_TYPE (node) = TREE_TYPE (body);
12222   TREE_SIDE_EFFECTS (node) = 1;
12223   return node;
12224 }
12225
12226 /* Create a new function block and link it appropriately to current
12227    function block chain */
12228
12229 static tree
12230 enter_block (void)
12231 {
12232   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12233
12234   /* Link block B supercontext to the previous block. The current
12235      function DECL is used as supercontext when enter_a_block is called
12236      for the first time for a given function. The current function body
12237      (DECL_FUNCTION_BODY) is set to be block B.  */
12238
12239   tree fndecl = current_function_decl;
12240
12241   if (!fndecl) {
12242     BLOCK_SUPERCONTEXT (b) = current_static_block;
12243     current_static_block = b;
12244   }
12245
12246   else if (!DECL_FUNCTION_BODY (fndecl))
12247     {
12248       BLOCK_SUPERCONTEXT (b) = fndecl;
12249       DECL_FUNCTION_BODY (fndecl) = b;
12250     }
12251   else
12252     {
12253       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12254       DECL_FUNCTION_BODY (fndecl) = b;
12255     }
12256   return b;
12257 }
12258
12259 /* Exit a block by changing the current function body
12260    (DECL_FUNCTION_BODY) to the current block super context, only if
12261    the block being exited isn't the method's top level one.  */
12262
12263 static tree
12264 exit_block (void)
12265 {
12266   tree b;
12267   if (current_function_decl)
12268     {
12269       b = DECL_FUNCTION_BODY (current_function_decl);
12270       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12271         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12272     }
12273   else
12274     {
12275       b = current_static_block;
12276
12277       if (BLOCK_SUPERCONTEXT (b))
12278         current_static_block = BLOCK_SUPERCONTEXT (b);
12279     }
12280   return b;
12281 }
12282
12283 /* Lookup for NAME in the nested function's blocks, all the way up to
12284    the current toplevel one. It complies with Java's local variable
12285    scoping rules.  */
12286
12287 static tree
12288 lookup_name_in_blocks (tree name)
12289 {
12290   tree b = GET_CURRENT_BLOCK (current_function_decl);
12291
12292   while (b != current_function_decl)
12293     {
12294       tree current;
12295
12296       /* Paranoid sanity check. To be removed */
12297       if (TREE_CODE (b) != BLOCK)
12298         abort ();
12299
12300       for (current = BLOCK_EXPR_DECLS (b); current;
12301            current = TREE_CHAIN (current))
12302         if (DECL_NAME (current) == name)
12303           return current;
12304       b = BLOCK_SUPERCONTEXT (b);
12305     }
12306   return NULL_TREE;
12307 }
12308
12309 static void
12310 maybe_absorb_scoping_blocks (void)
12311 {
12312   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12313     {
12314       tree b = exit_block ();
12315       java_method_add_stmt (current_function_decl, b);
12316       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12317     }
12318 }
12319
12320 \f
12321 /* This section of the source is reserved to build_* functions that
12322    are building incomplete tree nodes and the patch_* functions that
12323    are completing them.  */
12324
12325 /* Wrap a non WFL node around a WFL.  */
12326
12327 static tree
12328 build_wfl_wrap (tree node, int location)
12329 {
12330   tree wfl, node_to_insert = node;
12331
12332   /* We want to process THIS . xxx symbolically, to keep it consistent
12333      with the way we're processing SUPER. A THIS from a primary as a
12334      different form than a SUPER. Turn THIS into something symbolic */
12335   if (TREE_CODE (node) == THIS_EXPR)
12336     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12337   else
12338     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12339
12340   EXPR_WFL_LINECOL (wfl) = location;
12341   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12342   return wfl;
12343 }
12344
12345 /* Build a super() constructor invocation. Returns an empty statement if
12346    we're currently dealing with the class java.lang.Object. */
12347
12348 static tree
12349 build_super_invocation (tree mdecl)
12350 {
12351   if (DECL_CONTEXT (mdecl) == object_type_node)
12352     return build_java_empty_stmt ();
12353   else
12354     {
12355       tree super_wfl = build_wfl_node (super_identifier_node);
12356       tree a = NULL_TREE, t;
12357
12358       /* This is called after parsing is done, so the parser context
12359          won't be accurate. Set location info from current_class decl. */
12360       tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12361       EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12362
12363       /* If we're dealing with an anonymous class, pass the arguments
12364          of the crafted constructor along. */
12365       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12366         {
12367           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12368           for (; t != end_params_node; t = TREE_CHAIN (t))
12369             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12370         }
12371       return build_method_invocation (super_wfl, a);
12372     }
12373 }
12374
12375 /* Build a SUPER/THIS qualified method invocation.  */
12376
12377 static tree
12378 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12379                                        int lloc, int rloc)
12380 {
12381   tree invok;
12382   tree wfl =
12383     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12384   EXPR_WFL_LINECOL (wfl) = lloc;
12385   invok = build_method_invocation (name, args);
12386   return make_qualified_primary (wfl, invok, rloc);
12387 }
12388
12389 /* Build an incomplete CALL_EXPR node. */
12390
12391 static tree
12392 build_method_invocation (tree name, tree args)
12393 {
12394   tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12395   TREE_SIDE_EFFECTS (call) = 1;
12396   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12397   return call;
12398 }
12399
12400 /* Build an incomplete new xxx(...) node. */
12401
12402 static tree
12403 build_new_invocation (tree name, tree args)
12404 {
12405   tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12406   TREE_SIDE_EFFECTS (call) = 1;
12407   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12408   return call;
12409 }
12410
12411 /* Build an incomplete assignment expression. */
12412
12413 static tree
12414 build_assignment (int op, int op_location, tree lhs, tree rhs)
12415 {
12416   tree assignment;
12417   /* Build the corresponding binop if we deal with a Compound
12418      Assignment operator. Mark the binop sub-tree as part of a
12419      Compound Assignment expression */
12420   if (op != ASSIGN_TK)
12421     {
12422       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12423       COMPOUND_ASSIGN_P (rhs) = 1;
12424     }
12425   assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12426   TREE_SIDE_EFFECTS (assignment) = 1;
12427   EXPR_WFL_LINECOL (assignment) = op_location;
12428   return assignment;
12429 }
12430
12431 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12432    the buffer.  This is used only for string conversion.  */
12433 static char *
12434 string_convert_int_cst (tree node)
12435 {
12436   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12437   static char buffer[21];
12438
12439   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12440   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12441   char *p = buffer + sizeof (buffer);
12442   int neg = 0;
12443
12444   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12445                                   << (HOST_BITS_PER_WIDE_INT - 1));
12446
12447   *--p = '\0';
12448
12449   /* If negative, note the fact and negate the value.  */
12450   if ((hi & hibit))
12451     {
12452       lo = ~lo;
12453       hi = ~hi;
12454       if (++lo == 0)
12455         ++hi;
12456       neg = 1;
12457     }
12458
12459   /* Divide by 10 until there are no bits left.  */
12460   do
12461     {
12462       unsigned HOST_WIDE_INT acc = 0;
12463       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12464       unsigned int i;
12465
12466       /* Use long division to compute the result and the remainder.  */
12467       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12468         {
12469           /* Shift a bit into accumulator.  */
12470           acc <<= 1;
12471           if ((hi & hibit))
12472             acc |= 1;
12473
12474           /* Shift the value.  */
12475           hi <<= 1;
12476           if ((lo & hibit))
12477             hi |= 1;
12478           lo <<= 1;
12479
12480           /* Shift the correct bit into the result.  */
12481           outhi <<= 1;
12482           if ((outlo & hibit))
12483             outhi |= 1;
12484           outlo <<= 1;
12485           if (acc >= 10)
12486             {
12487               acc -= 10;
12488               outlo |= 1;
12489             }
12490         }
12491
12492       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12493       *--p = '\060' + acc;
12494
12495       hi = outhi;
12496       lo = outlo;
12497     }
12498   while (hi || lo);
12499
12500   if (neg)
12501     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12502
12503   return p;
12504 }
12505
12506 /* Print an INTEGER_CST node in a static buffer, and return the
12507    buffer.  This is used only for error handling.  */
12508 char *
12509 print_int_node (tree node)
12510 {
12511   static char buffer [80];
12512   if (TREE_CONSTANT_OVERFLOW (node))
12513     sprintf (buffer, "<overflow>");
12514
12515   if (TREE_INT_CST_HIGH (node) == 0)
12516     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12517              TREE_INT_CST_LOW (node));
12518   else if (TREE_INT_CST_HIGH (node) == -1
12519            && TREE_INT_CST_LOW (node) != 0)
12520     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12521              -TREE_INT_CST_LOW (node));
12522   else
12523     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12524              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12525
12526   return buffer;
12527 }
12528
12529 \f
12530 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12531    context.  */
12532
12533 /* 15.25 Assignment operators. */
12534
12535 static tree
12536 patch_assignment (tree node, tree wfl_op1)
12537 {
12538   tree rhs = TREE_OPERAND (node, 1);
12539   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12540   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12541   int error_found = 0;
12542   int lvalue_from_array = 0;
12543   int is_return = 0;
12544
12545   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12546
12547   /* Lhs can be a named variable */
12548   if (JDECL_P (lvalue))
12549     {
12550       lhs_type = TREE_TYPE (lvalue);
12551     }
12552   /* Or Lhs can be an array access. */
12553   else if (TREE_CODE (lvalue) == ARRAY_REF)
12554     {
12555       lhs_type = TREE_TYPE (lvalue);
12556       lvalue_from_array = 1;
12557     }
12558   /* Or a field access */
12559   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12560     lhs_type = TREE_TYPE (lvalue);
12561   /* Or a function return slot */
12562   else if (TREE_CODE (lvalue) == RESULT_DECL)
12563     {
12564       /* If the return type is an integral type, then we create the
12565          RESULT_DECL with a promoted type, but we need to do these
12566          checks against the unpromoted type to ensure type safety.  So
12567          here we look at the real type, not the type of the decl we
12568          are modifying.  */
12569       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12570       is_return = 1;
12571     }
12572   /* Otherwise, we might want to try to write into an optimized static
12573      final, this is an of a different nature, reported further on. */
12574   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12575            && resolve_expression_name (wfl_op1, &llvalue))
12576     {
12577       lhs_type = TREE_TYPE (lvalue);
12578     }
12579   else
12580     {
12581       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12582       error_found = 1;
12583     }
12584
12585   rhs_type = TREE_TYPE (rhs);
12586
12587   /* 5.1 Try the assignment conversion for builtin type. */
12588   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12589
12590   /* 5.2 If it failed, try a reference conversion */
12591   if (!new_rhs)
12592     new_rhs = try_reference_assignconv (lhs_type, rhs);
12593
12594   /* 15.25.2 If we have a compound assignment, convert RHS into the
12595      type of the LHS */
12596   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12597     new_rhs = convert (lhs_type, rhs);
12598
12599   /* Explicit cast required. This is an error */
12600   if (!new_rhs)
12601     {
12602       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12603       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12604       tree wfl;
12605       char operation [32];      /* Max size known */
12606
12607       /* If the assignment is part of a declaration, we use the WFL of
12608          the declared variable to point out the error and call it a
12609          declaration problem. If the assignment is a genuine =
12610          operator, we call is a operator `=' problem, otherwise we
12611          call it an assignment problem. In both of these last cases,
12612          we use the WFL of the operator to indicate the error. */
12613
12614       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12615         {
12616           wfl = wfl_op1;
12617           strcpy (operation, "declaration");
12618         }
12619       else
12620         {
12621           wfl = wfl_operator;
12622           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12623             strcpy (operation, "assignment");
12624           else if (is_return)
12625             strcpy (operation, "`return'");
12626           else
12627             strcpy (operation, "`='");
12628         }
12629
12630       if (!valid_cast_to_p (rhs_type, lhs_type))
12631         parse_error_context
12632           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12633            operation, t1, t2);
12634       else
12635         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12636                              operation, t1, t2);
12637       free (t1); free (t2);
12638       error_found = 1;
12639     }
12640
12641   if (error_found)
12642     return error_mark_node;
12643
12644   /* If we're processing a `return' statement, promote the actual type
12645      to the promoted type.  */
12646   if (is_return)
12647     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12648
12649   /* 10.10: Array Store Exception runtime check */
12650   if (!flag_emit_class_files
12651       && !flag_emit_xref
12652       && lvalue_from_array
12653       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12654     {
12655       tree array, store_check, base, index_expr;
12656
12657       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12658       new_rhs = save_expr (new_rhs);
12659
12660       /* Get the INDIRECT_REF. */
12661       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12662       /* Get the array pointer expr. */
12663       array = TREE_OPERAND (array, 0);
12664       store_check = build_java_arraystore_check (array, new_rhs);
12665
12666       index_expr = TREE_OPERAND (lvalue, 1);
12667
12668       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12669         {
12670           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12671              happen before the store check, so prepare to insert the store
12672              check within the second operand of the existing COMPOUND_EXPR. */
12673           base = index_expr;
12674         }
12675       else
12676         base = lvalue;
12677
12678       index_expr = TREE_OPERAND (base, 1);
12679       TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
12680                                        store_check, index_expr);
12681     }
12682
12683   /* Final locals can be used as case values in switch
12684      statement. Prepare them for this eventuality. */
12685   if (TREE_CODE (lvalue) == VAR_DECL
12686       && DECL_FINAL (lvalue)
12687       && TREE_CONSTANT (new_rhs)
12688       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12689       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12690       )
12691     {
12692       TREE_CONSTANT (lvalue) = 1;
12693       TREE_INVARIANT (lvalue) = 1;
12694       DECL_INITIAL (lvalue) = new_rhs;
12695     }
12696
12697   /* Copy the rhs if it's a reference.  */
12698   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12699     {
12700       switch (TREE_CODE (new_rhs))
12701         {
12702         case ARRAY_REF:
12703         case INDIRECT_REF:
12704         case COMPONENT_REF:
12705           /* Transform a = foo.bar
12706              into a = ({int tmp; tmp = foo.bar;}).
12707              We need to ensure that if a read from memory fails
12708              because of a NullPointerException, a destination variable
12709              will remain unchanged.  An explicit temporary does what
12710              we need.
12711
12712              If flag_check_references is set, this is unnecessary
12713              because we'll check each reference before doing any
12714              reads.  If optimize is not set the result will never be
12715              written to a stack slot that contains the LHS.  */
12716           {
12717             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12718                                    TREE_TYPE (new_rhs));
12719             tree block = make_node (BLOCK);
12720             tree assignment
12721               = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12722             DECL_CONTEXT (tmp) = current_function_decl;
12723             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12724             BLOCK_VARS (block) = tmp;
12725             BLOCK_EXPR_BODY (block) = assignment;
12726             TREE_SIDE_EFFECTS (block) = 1;
12727             new_rhs = block;
12728           }
12729           break;
12730         default:
12731           break;
12732         }
12733     }
12734
12735   TREE_OPERAND (node, 0) = lvalue;
12736   TREE_OPERAND (node, 1) = new_rhs;
12737   TREE_TYPE (node) = lhs_type;
12738   return node;
12739 }
12740
12741 /* Check that type SOURCE can be cast into type DEST. If the cast
12742    can't occur at all, return NULL; otherwise, return a possibly
12743    modified rhs.  */
12744
12745 static tree
12746 try_reference_assignconv (tree lhs_type, tree rhs)
12747 {
12748   tree new_rhs = NULL_TREE;
12749   tree rhs_type = TREE_TYPE (rhs);
12750
12751   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12752     {
12753       /* `null' may be assigned to any reference type */
12754       if (rhs == null_pointer_node)
12755         new_rhs = null_pointer_node;
12756       /* Try the reference assignment conversion */
12757       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12758         new_rhs = rhs;
12759       /* This is a magic assignment that we process differently */
12760       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12761         new_rhs = rhs;
12762     }
12763   return new_rhs;
12764 }
12765
12766 /* Check that RHS can be converted into LHS_TYPE by the assignment
12767    conversion (5.2), for the cases of RHS being a builtin type. Return
12768    NULL_TREE if the conversion fails or if because RHS isn't of a
12769    builtin type. Return a converted RHS if the conversion is possible.  */
12770
12771 static tree
12772 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12773 {
12774   tree new_rhs = NULL_TREE;
12775   tree rhs_type = TREE_TYPE (rhs);
12776
12777   /* Handle boolean specially.  */
12778   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12779       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12780     {
12781       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12782           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12783         new_rhs = rhs;
12784     }
12785
12786   /* 5.1.1 Try Identity Conversion,
12787      5.1.2 Try Widening Primitive Conversion */
12788   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12789     new_rhs = convert (lhs_type, rhs);
12790
12791   /* Try a narrowing primitive conversion (5.1.3):
12792        - expression is a constant expression of type byte, short, char,
12793          or int, AND
12794        - variable is byte, short or char AND
12795        - The value of the expression is representable in the type of the
12796          variable */
12797   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12798             || rhs_type == char_type_node || rhs_type == int_type_node)
12799             && TREE_CONSTANT (rhs)
12800            && (lhs_type == byte_type_node || lhs_type == char_type_node
12801                || lhs_type == short_type_node))
12802     {
12803       if (int_fits_type_p (rhs, lhs_type))
12804         new_rhs = convert (lhs_type, rhs);
12805       else if (wfl_op1)         /* Might be called with a NULL */
12806         parse_warning_context
12807           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12808            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12809       /* Reported a warning that will turn into an error further
12810          down, so we don't return */
12811     }
12812
12813   return new_rhs;
12814 }
12815
12816 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12817    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12818    0 is the conversion test fails.  This implements parts the method
12819    invocation conversion (5.3).  */
12820
12821 static int
12822 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12823 {
12824   /* 5.1.1: This is the identity conversion part. */
12825   if (lhs_type == rhs_type)
12826     return 1;
12827
12828   /* Reject non primitive types and boolean conversions.  */
12829   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12830     return 0;
12831
12832   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12833      than a char can't be converted into a char. Short can't too, but
12834      the < test below takes care of that */
12835   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12836     return 0;
12837
12838   /* Accept all promoted type here. Note, we can't use <= in the test
12839      below, because we still need to bounce out assignments of short
12840      to char and the likes */
12841   if (lhs_type == int_type_node
12842       && (rhs_type == promoted_byte_type_node
12843           || rhs_type == promoted_short_type_node
12844           || rhs_type == promoted_char_type_node
12845           || rhs_type == promoted_boolean_type_node))
12846     return 1;
12847
12848   /* From here, an integral is widened if its precision is smaller
12849      than the precision of the LHS or if the LHS is a floating point
12850      type, or the RHS is a float and the RHS a double. */
12851   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12852        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12853       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12854       || (rhs_type == float_type_node && lhs_type == double_type_node))
12855     return 1;
12856
12857   return 0;
12858 }
12859
12860 /* Check that something of SOURCE type can be assigned or cast to
12861    something of DEST type at runtime. Return 1 if the operation is
12862    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12863    were SOURCE is cast into DEST, which borrows a lot of the
12864    assignment check. */
12865
12866 static int
12867 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12868 {
12869   /* SOURCE or DEST might be null if not from a declared entity. */
12870   if (!source || !dest)
12871     return 0;
12872   if (JNULLP_TYPE_P (source))
12873     return 1;
12874   if (TREE_CODE (source) == POINTER_TYPE)
12875     source = TREE_TYPE (source);
12876   if (TREE_CODE (dest) == POINTER_TYPE)
12877     dest = TREE_TYPE (dest);
12878
12879   /* If source and dest are being compiled from bytecode, they may need to
12880      be loaded. */
12881   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12882     {
12883       load_class (source, 1);
12884       safe_layout_class (source);
12885     }
12886   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12887     {
12888       load_class (dest, 1);
12889       safe_layout_class (dest);
12890     }
12891
12892   /* Case where SOURCE is a class type */
12893   if (TYPE_CLASS_P (source))
12894     {
12895       if (TYPE_CLASS_P (dest))
12896         return  (source == dest
12897                  || inherits_from_p (source, dest)
12898                  || (cast && inherits_from_p (dest, source)));
12899       if (TYPE_INTERFACE_P (dest))
12900         {
12901           /* If doing a cast and SOURCE is final, the operation is
12902              always correct a compile time (because even if SOURCE
12903              does not implement DEST, a subclass of SOURCE might). */
12904           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12905             return 1;
12906           /* Otherwise, SOURCE must implement DEST */
12907           return interface_of_p (dest, source);
12908         }
12909       /* DEST is an array, cast permitted if SOURCE is of Object type */
12910       return (cast && source == object_type_node ? 1 : 0);
12911     }
12912   if (TYPE_INTERFACE_P (source))
12913     {
12914       if (TYPE_CLASS_P (dest))
12915         {
12916           /* If not casting, DEST must be the Object type */
12917           if (!cast)
12918             return dest == object_type_node;
12919           /* We're doing a cast. The cast is always valid is class
12920              DEST is not final, otherwise, DEST must implement SOURCE */
12921           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12922             return 1;
12923           else
12924             return interface_of_p (source, dest);
12925         }
12926       if (TYPE_INTERFACE_P (dest))
12927         {
12928           /* If doing a cast, then if SOURCE and DEST contain method
12929              with the same signature but different return type, then
12930              this is a (compile time) error */
12931           if (cast)
12932             {
12933               tree method_source, method_dest;
12934               tree source_type;
12935               tree source_sig;
12936               tree source_name;
12937               for (method_source = TYPE_METHODS (source); method_source;
12938                    method_source = TREE_CHAIN (method_source))
12939                 {
12940                   source_sig =
12941                     build_java_argument_signature (TREE_TYPE (method_source));
12942                   source_type = TREE_TYPE (TREE_TYPE (method_source));
12943                   source_name = DECL_NAME (method_source);
12944                   for (method_dest = TYPE_METHODS (dest);
12945                        method_dest; method_dest = TREE_CHAIN (method_dest))
12946                     if (source_sig ==
12947                         build_java_argument_signature (TREE_TYPE (method_dest))
12948                         && source_name == DECL_NAME (method_dest)
12949                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12950                       return 0;
12951                 }
12952               return 1;
12953             }
12954           else
12955             return source == dest || interface_of_p (dest, source);
12956         }
12957       else
12958         {
12959           /* Array */
12960           return (cast
12961                   && (DECL_NAME (TYPE_NAME (source))
12962                       == java_lang_cloneable_identifier_node
12963                       || (DECL_NAME (TYPE_NAME (source))
12964                           == java_io_serializable_identifier_node)));
12965         }
12966     }
12967   if (TYPE_ARRAY_P (source))
12968     {
12969       if (TYPE_CLASS_P (dest))
12970         return dest == object_type_node;
12971       /* Can't cast an array to an interface unless the interface is
12972          java.lang.Cloneable or java.io.Serializable.  */
12973       if (TYPE_INTERFACE_P (dest))
12974         return (DECL_NAME (TYPE_NAME (dest))
12975                 == java_lang_cloneable_identifier_node
12976                 || (DECL_NAME (TYPE_NAME (dest))
12977                     == java_io_serializable_identifier_node));
12978       else                      /* Arrays */
12979         {
12980           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12981           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12982
12983           /* In case of severe errors, they turn out null */
12984           if (!dest_element_type || !source_element_type)
12985             return 0;
12986           if (source_element_type == dest_element_type)
12987             return 1;
12988           return valid_ref_assignconv_cast_p (source_element_type,
12989                                               dest_element_type, cast);
12990         }
12991       return 0;
12992     }
12993   return 0;
12994 }
12995
12996 static int
12997 valid_cast_to_p (tree source, tree dest)
12998 {
12999   if (TREE_CODE (source) == POINTER_TYPE)
13000     source = TREE_TYPE (source);
13001   if (TREE_CODE (dest) == POINTER_TYPE)
13002     dest = TREE_TYPE (dest);
13003
13004   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13005     return valid_ref_assignconv_cast_p (source, dest, 1);
13006
13007   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13008     return 1;
13009
13010   else if (TREE_CODE (source) == BOOLEAN_TYPE
13011            && TREE_CODE (dest) == BOOLEAN_TYPE)
13012     return 1;
13013
13014   return 0;
13015 }
13016
13017 static tree
13018 do_unary_numeric_promotion (tree arg)
13019 {
13020   tree type = TREE_TYPE (arg);
13021   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13022       || TREE_CODE (type) == CHAR_TYPE)
13023     arg = convert (int_type_node, arg);
13024   return arg;
13025 }
13026
13027 /* Return a nonzero value if SOURCE can be converted into DEST using
13028    the method invocation conversion rule (5.3).  */
13029 static int
13030 valid_method_invocation_conversion_p (tree dest, tree source)
13031 {
13032   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13033            && valid_builtin_assignconv_identity_widening_p (dest, source))
13034           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13035               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13036               && valid_ref_assignconv_cast_p (source, dest, 0)));
13037 }
13038
13039 /* Build an incomplete binop expression. */
13040
13041 static tree
13042 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13043 {
13044   tree binop = build2 (op, NULL_TREE, op1, op2);
13045   TREE_SIDE_EFFECTS (binop) = 1;
13046   /* Store the location of the operator, for better error report. The
13047      string of the operator will be rebuild based on the OP value. */
13048   EXPR_WFL_LINECOL (binop) = op_location;
13049   return binop;
13050 }
13051
13052 /* Build the string of the operator retained by NODE. If NODE is part
13053    of a compound expression, add an '=' at the end of the string. This
13054    function is called when an error needs to be reported on an
13055    operator. The string is returned as a pointer to a static character
13056    buffer. */
13057
13058 static char *
13059 operator_string (tree node)
13060 {
13061 #define BUILD_OPERATOR_STRING(S)                                        \
13062   {                                                                     \
13063     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13064     return buffer;                                                      \
13065   }
13066
13067   static char buffer [10];
13068   switch (TREE_CODE (node))
13069     {
13070     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13071     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13072     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13073     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13074     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13075     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13076     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13077     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13078     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13079     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13080     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13081     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13082     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13083     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13084     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13085     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13086     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13087     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13088     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13089     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13090     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13091     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13092     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13093     case PREINCREMENT_EXPR:     /* Fall through */
13094     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13095     case PREDECREMENT_EXPR:     /* Fall through */
13096     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13097     default:
13098       internal_error ("unregistered operator %s",
13099                       tree_code_name [TREE_CODE (node)]);
13100     }
13101   return NULL;
13102 #undef BUILD_OPERATOR_STRING
13103 }
13104
13105 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13106
13107 static int
13108 java_decl_equiv (tree var_acc1, tree var_acc2)
13109 {
13110   if (JDECL_P (var_acc1))
13111     return (var_acc1 == var_acc2);
13112
13113   return (TREE_CODE (var_acc1) == COMPONENT_REF
13114           && TREE_CODE (var_acc2) == COMPONENT_REF
13115           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13116              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13117           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13118 }
13119
13120 /* Return a nonzero value if CODE is one of the operators that can be
13121    used in conjunction with the `=' operator in a compound assignment.  */
13122
13123 static int
13124 binop_compound_p (enum tree_code code)
13125 {
13126   int i;
13127   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13128     if (binop_lookup [i] == code)
13129       break;
13130
13131   return i < BINOP_COMPOUND_CANDIDATES;
13132 }
13133
13134 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13135
13136 static tree
13137 java_refold (tree t)
13138 {
13139   tree c, b, ns, decl;
13140
13141   if (TREE_CODE (t) != MODIFY_EXPR)
13142     return t;
13143
13144   c = TREE_OPERAND (t, 1);
13145   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13146          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13147          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13148     return t;
13149
13150   /* Now the left branch of the binary operator. */
13151   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13152   if (! (b && TREE_CODE (b) == NOP_EXPR
13153          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13154     return t;
13155
13156   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13157   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13158          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13159     return t;
13160
13161   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13162   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13163       /* It's got to be the an equivalent decl */
13164       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13165     {
13166       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13167       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13168       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13169       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13170       /* Change the right part of the BINOP_EXPR */
13171       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13172     }
13173
13174   return t;
13175 }
13176
13177 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13178    errors but we modify NODE so that it contains the type computed
13179    according to the expression, when it's fixed. Otherwise, we write
13180    error_mark_node as the type. It allows us to further the analysis
13181    of remaining nodes and detects more errors in certain cases.  */
13182
13183 static tree
13184 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13185 {
13186   tree op1 = TREE_OPERAND (node, 0);
13187   tree op2 = TREE_OPERAND (node, 1);
13188   tree op1_type = TREE_TYPE (op1);
13189   tree op2_type = TREE_TYPE (op2);
13190   tree prom_type = NULL_TREE, cn;
13191   enum tree_code code = TREE_CODE (node);
13192
13193   /* If 1, tell the routine that we have to return error_mark_node
13194      after checking for the initialization of the RHS */
13195   int error_found = 0;
13196
13197   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13198
13199   /* If either op<n>_type are NULL, this might be early signs of an
13200      error situation, unless it's too early to tell (in case we're
13201      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13202      correctly so the error can be later on reported accurately. */
13203   if (! (code == PLUS_EXPR || code == NE_EXPR
13204          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13205     {
13206       tree n;
13207       if (! op1_type)
13208         {
13209           n = java_complete_tree (op1);
13210           op1_type = TREE_TYPE (n);
13211         }
13212       if (! op2_type)
13213         {
13214           n = java_complete_tree (op2);
13215           op2_type = TREE_TYPE (n);
13216         }
13217     }
13218
13219   switch (code)
13220     {
13221     /* 15.16 Multiplicative operators */
13222     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13223     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13224     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13225     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13226       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13227         {
13228           if (!JNUMERIC_TYPE_P (op1_type))
13229             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13230           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13231             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13232           TREE_TYPE (node) = error_mark_node;
13233           error_found = 1;
13234           break;
13235         }
13236       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13237
13238       /* Detect integral division by zero */
13239       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13240           && TREE_CODE (prom_type) == INTEGER_TYPE
13241           && (op2 == integer_zero_node || op2 == long_zero_node ||
13242               (TREE_CODE (op2) == INTEGER_CST &&
13243                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13244         {
13245           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13246           TREE_CONSTANT (node) = 0;
13247           TREE_INVARIANT (node) = 0;
13248         }
13249
13250       /* Change the division operator if necessary */
13251       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13252         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13253
13254       /* Before divisions as is disappear, try to simplify and bail if
13255          applicable, otherwise we won't perform even simple
13256          simplifications like (1-1)/3. We can't do that with floating
13257          point number, folds can't handle them at this stage. */
13258       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13259           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13260         {
13261           TREE_TYPE (node) = prom_type;
13262           node = fold (node);
13263           if (TREE_CODE (node) != code)
13264             return node;
13265         }
13266
13267       if (TREE_CODE (prom_type) == INTEGER_TYPE
13268           && flag_use_divide_subroutine
13269           && ! flag_emit_class_files
13270           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13271         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13272
13273       /* This one is more complicated. FLOATs are processed by a
13274          function call to soft_fmod. Duplicate the value of the
13275          COMPOUND_ASSIGN_P flag. */
13276       if (code == TRUNC_MOD_EXPR)
13277         {
13278           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13279           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13280           return mod;
13281         }
13282       break;
13283
13284     /* 15.17 Additive Operators */
13285     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13286
13287       /* Operation is valid if either one argument is a string
13288          constant, a String object or a StringBuffer crafted for the
13289          purpose of the a previous usage of the String concatenation
13290          operator */
13291
13292       if (TREE_CODE (op1) == STRING_CST
13293           || TREE_CODE (op2) == STRING_CST
13294           || JSTRING_TYPE_P (op1_type)
13295           || JSTRING_TYPE_P (op2_type)
13296           || IS_CRAFTED_STRING_BUFFER_P (op1)
13297           || IS_CRAFTED_STRING_BUFFER_P (op2))
13298         return build_string_concatenation (op1, op2);
13299
13300     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13301                                    Numeric Types */
13302       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13303         {
13304           if (!JNUMERIC_TYPE_P (op1_type))
13305             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13306           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13307             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13308           TREE_TYPE (node) = error_mark_node;
13309           error_found = 1;
13310           break;
13311         }
13312       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13313       break;
13314
13315     /* 15.18 Shift Operators */
13316     case LSHIFT_EXPR:
13317     case RSHIFT_EXPR:
13318     case URSHIFT_EXPR:
13319       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13320         {
13321           if (!JINTEGRAL_TYPE_P (op1_type))
13322             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13323           else
13324             {
13325               if (JNUMERIC_TYPE_P (op2_type))
13326                 parse_error_context (wfl_operator,
13327                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13328                                      operator_string (node),
13329                                      lang_printable_name (op2_type, 0));
13330               else
13331                 parse_error_context (wfl_operator,
13332                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13333                                      operator_string (node),
13334                                      lang_printable_name (op2_type, 0));
13335             }
13336           TREE_TYPE (node) = error_mark_node;
13337           error_found = 1;
13338           break;
13339         }
13340
13341       /* Unary numeric promotion (5.6.1) is performed on each operand
13342          separately */
13343       op1 = do_unary_numeric_promotion (op1);
13344       op2 = do_unary_numeric_promotion (op2);
13345
13346       /* If the right hand side is of type `long', first cast it to
13347          `int'.  */
13348       if (TREE_TYPE (op2) == long_type_node)
13349         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13350
13351       /* The type of the shift expression is the type of the promoted
13352          type of the left-hand operand */
13353       prom_type = TREE_TYPE (op1);
13354
13355       /* Shift int only up to 0x1f and long up to 0x3f */
13356       if (prom_type == int_type_node)
13357         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13358                             build_int_cst (NULL_TREE, 0x1f)));
13359       else
13360         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13361                             build_int_cst (NULL_TREE, 0x3f)));
13362
13363       /* The >>> operator is a >> operating on unsigned quantities */
13364       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13365         {
13366           tree to_return;
13367           tree utype = java_unsigned_type (prom_type);
13368           op1 = convert (utype, op1);
13369           TREE_SET_CODE (node, RSHIFT_EXPR);
13370           TREE_OPERAND (node, 0) = op1;
13371           TREE_OPERAND (node, 1) = op2;
13372           TREE_TYPE (node) = utype;
13373           to_return = convert (prom_type, node);
13374           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13375           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13376           TREE_SIDE_EFFECTS (to_return)
13377             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13378           return to_return;
13379         }
13380       break;
13381
13382       /* 15.19.1 Type Comparison Operator instanceof */
13383     case INSTANCEOF_EXPR:
13384
13385       TREE_TYPE (node) = boolean_type_node;
13386
13387       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13388       if ((cn = patch_string (op1)))
13389         {
13390           op1 = cn;
13391           op1_type = TREE_TYPE (op1);
13392         }
13393       if (op1_type == NULL_TREE)
13394         abort ();
13395
13396       if (!(op2_type = resolve_type_during_patch (op2)))
13397         return error_mark_node;
13398
13399       /* The first operand must be a reference type or the null type */
13400       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13401         error_found = 1;        /* Error reported further below */
13402
13403       /* The second operand must be a reference type */
13404       if (!JREFERENCE_TYPE_P (op2_type))
13405         {
13406           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13407           parse_error_context
13408             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13409              lang_printable_name (op2_type, 0));
13410           error_found = 1;
13411         }
13412
13413       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13414         {
13415           /* If the first operand is null, the result is always false */
13416           if (op1 == null_pointer_node)
13417             return boolean_false_node;
13418           else if (flag_emit_class_files)
13419             {
13420               TREE_OPERAND (node, 1) = op2_type;
13421               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13422               return node;
13423             }
13424           /* Otherwise we have to invoke instance of to figure it out */
13425           else
13426             return build_instanceof (op1, op2_type);
13427         }
13428       /* There is no way the expression operand can be an instance of
13429          the type operand. This is a compile time error. */
13430       else
13431         {
13432           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13433           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13434           parse_error_context
13435             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13436              t1, lang_printable_name (op2_type, 0));
13437           free (t1);
13438           error_found = 1;
13439         }
13440
13441       break;
13442
13443       /* 15.21 Bitwise and Logical Operators */
13444     case BIT_AND_EXPR:
13445     case BIT_XOR_EXPR:
13446     case BIT_IOR_EXPR:
13447       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13448         /* Binary numeric promotion is performed on both operand and the
13449            expression retain that type */
13450         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13451
13452       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13453                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13454         /* The type of the bitwise operator expression is BOOLEAN */
13455         prom_type = boolean_type_node;
13456       else
13457         {
13458           if (!JINTEGRAL_TYPE_P (op1_type))
13459             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13460           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13461             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13462           TREE_TYPE (node) = error_mark_node;
13463           error_found = 1;
13464           /* Insert a break here if adding thing before the switch's
13465              break for this case */
13466         }
13467       break;
13468
13469       /* 15.22 Conditional-And Operator */
13470     case TRUTH_ANDIF_EXPR:
13471       /* 15.23 Conditional-Or Operator */
13472     case TRUTH_ORIF_EXPR:
13473       /* Operands must be of BOOLEAN type */
13474       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13475           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13476         {
13477           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13478             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13479           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13480             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13481           TREE_TYPE (node) = boolean_type_node;
13482           error_found = 1;
13483           break;
13484         }
13485       else if (integer_zerop (op1))
13486         {
13487           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13488         }
13489       else if (integer_onep (op1))
13490         {
13491           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13492         }
13493       /* The type of the conditional operators is BOOLEAN */
13494       prom_type = boolean_type_node;
13495       break;
13496
13497       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13498     case LT_EXPR:
13499     case GT_EXPR:
13500     case LE_EXPR:
13501     case GE_EXPR:
13502       /* The type of each of the operands must be a primitive numeric
13503          type */
13504       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13505         {
13506           if (!JNUMERIC_TYPE_P (op1_type))
13507             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13508           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13509             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13510           TREE_TYPE (node) = boolean_type_node;
13511           error_found = 1;
13512           break;
13513         }
13514       /* Binary numeric promotion is performed on the operands */
13515       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13516       /* The type of the relation expression is always BOOLEAN */
13517       prom_type = boolean_type_node;
13518       break;
13519
13520       /* 15.20 Equality Operator */
13521     case EQ_EXPR:
13522     case NE_EXPR:
13523       /* It's time for us to patch the strings. */
13524       if ((cn = patch_string (op1)))
13525        {
13526          op1 = cn;
13527          op1_type = TREE_TYPE (op1);
13528        }
13529       if ((cn = patch_string (op2)))
13530        {
13531          op2 = cn;
13532          op2_type = TREE_TYPE (op2);
13533        }
13534
13535       /* 15.20.1 Numerical Equality Operators == and != */
13536       /* Binary numeric promotion is performed on the operands */
13537       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13538         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13539
13540       /* 15.20.2 Boolean Equality Operators == and != */
13541       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13542           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13543         ;                       /* Nothing to do here */
13544
13545       /* 15.20.3 Reference Equality Operators == and != */
13546       /* Types have to be either references or the null type. If
13547          they're references, it must be possible to convert either
13548          type to the other by casting conversion. */
13549       else if (op1 == null_pointer_node || op2 == null_pointer_node
13550                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13551                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13552                        || valid_ref_assignconv_cast_p (op2_type,
13553                                                        op1_type, 1))))
13554         ;                       /* Nothing to do here */
13555
13556       /* Else we have an error figure what can't be converted into
13557          what and report the error */
13558       else
13559         {
13560           char *t1;
13561           t1 = xstrdup (lang_printable_name (op1_type, 0));
13562           parse_error_context
13563             (wfl_operator,
13564              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13565              operator_string (node), t1,
13566              lang_printable_name (op2_type, 0));
13567           free (t1);
13568           TREE_TYPE (node) = boolean_type_node;
13569           error_found = 1;
13570           break;
13571         }
13572       prom_type = boolean_type_node;
13573       break;
13574     default:
13575       abort ();
13576     }
13577
13578   if (error_found)
13579     return error_mark_node;
13580
13581   TREE_OPERAND (node, 0) = op1;
13582   TREE_OPERAND (node, 1) = op2;
13583   TREE_TYPE (node) = prom_type;
13584   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13585
13586   if (flag_emit_xref)
13587     return node;
13588
13589   /* fold does not respect side-effect order as required for Java but not C.
13590    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13591    * bytecode.
13592    */
13593   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13594       : ! TREE_SIDE_EFFECTS (node))
13595     node = fold (node);
13596   return node;
13597 }
13598
13599 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13600    zero value, the value of CSTE comes after the valude of STRING */
13601
13602 static tree
13603 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13604 {
13605   const char *old = TREE_STRING_POINTER (cste);
13606   int old_len = TREE_STRING_LENGTH (cste);
13607   int len = old_len + string_len;
13608   char *new = alloca (len+1);
13609
13610   if (after)
13611     {
13612       memcpy (new, string, string_len);
13613       memcpy (&new [string_len], old, old_len);
13614     }
13615   else
13616     {
13617       memcpy (new, old, old_len);
13618       memcpy (&new [old_len], string, string_len);
13619     }
13620   new [len] = '\0';
13621   return build_string (len, new);
13622 }
13623
13624 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13625    new STRING_CST on success, NULL_TREE on failure.  */
13626
13627 static tree
13628 merge_string_cste (tree op1, tree op2, int after)
13629 {
13630   /* Handle two string constants right away.  */
13631   if (TREE_CODE (op2) == STRING_CST)
13632     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13633                                  TREE_STRING_LENGTH (op2), after);
13634
13635   /* Reasonable integer constant can be treated right away.  */
13636   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13637     {
13638       static const char *const boolean_true = "true";
13639       static const char *const boolean_false = "false";
13640       static const char *const null_pointer = "null";
13641       char ch[4];
13642       const char *string;
13643
13644       if (op2 == boolean_true_node)
13645         string = boolean_true;
13646       else if (op2 == boolean_false_node)
13647         string = boolean_false;
13648       else if (op2 == null_pointer_node
13649                || (integer_zerop (op2)
13650                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13651         /* FIXME: null is not a compile-time constant, so it is only safe to
13652            merge if the overall expression is non-constant. However, this
13653            code always merges without checking the overall expression.  */
13654         string = null_pointer;
13655       else if (TREE_TYPE (op2) == char_type_node)
13656         {
13657           /* Convert the character into UTF-8.  */
13658           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13659           unsigned char *p = (unsigned char *) ch;
13660           if (0x01 <= c && c <= 0x7f)
13661             *p++ = (unsigned char) c;
13662           else if (c < 0x7ff)
13663             {
13664               *p++ = (unsigned char) (c >> 6 | 0xc0);
13665               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13666             }
13667           else
13668             {
13669               *p++ = (unsigned char) (c >> 12 | 0xe0);
13670               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13671               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13672             }
13673           *p = '\0';
13674
13675           string = ch;
13676         }
13677       else
13678         string = string_convert_int_cst (op2);
13679
13680       return do_merge_string_cste (op1, string, strlen (string), after);
13681     }
13682   return NULL_TREE;
13683 }
13684
13685 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13686    has to be a STRING_CST and the other part must be a STRING_CST or a
13687    INTEGRAL constant. Return a new STRING_CST if the operation
13688    succeed, NULL_TREE otherwise.
13689
13690    If the case we want to optimize for space, we might want to return
13691    NULL_TREE for each invocation of this routine. FIXME */
13692
13693 static tree
13694 string_constant_concatenation (tree op1, tree op2)
13695 {
13696   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13697     {
13698       tree string, rest;
13699       int invert;
13700
13701       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13702       rest   = (string == op1 ? op2 : op1);
13703       invert = (string == op1 ? 0 : 1 );
13704
13705       /* Walk REST, only if it looks reasonable */
13706       if (TREE_CODE (rest) != STRING_CST
13707           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13708           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13709           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13710         {
13711           rest = java_complete_tree (rest);
13712           if (rest == error_mark_node)
13713             return error_mark_node;
13714           rest = fold (rest);
13715         }
13716       return merge_string_cste (string, rest, invert);
13717     }
13718   return NULL_TREE;
13719 }
13720
13721 /* Implement the `+' operator. Does static optimization if possible,
13722    otherwise create (if necessary) and append elements to a
13723    StringBuffer. The StringBuffer will be carried around until it is
13724    used for a function call or an assignment. Then toString() will be
13725    called on it to turn it into a String object. */
13726
13727 static tree
13728 build_string_concatenation (tree op1, tree op2)
13729 {
13730   tree result;
13731   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13732
13733   if (flag_emit_xref)
13734     return build2 (PLUS_EXPR, string_type_node, op1, op2);
13735
13736   /* Try to do some static optimization */
13737   if ((result = string_constant_concatenation (op1, op2)))
13738     return result;
13739
13740   /* Discard empty strings on either side of the expression */
13741   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13742     {
13743       op1 = op2;
13744       op2 = NULL_TREE;
13745     }
13746   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13747     op2 = NULL_TREE;
13748
13749   /* If operands are string constant, turn then into object references */
13750   if (TREE_CODE (op1) == STRING_CST)
13751     op1 = patch_string_cst (op1);
13752   if (op2 && TREE_CODE (op2) == STRING_CST)
13753     op2 = patch_string_cst (op2);
13754
13755   /* If either one of the constant is null and the other non null
13756      operand is a String constant, return it. */
13757   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13758     return op1;
13759
13760   /* If OP1 isn't already a StringBuffer, create and
13761      initialize a new one */
13762   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13763     {
13764       /* Two solutions here:
13765          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13766          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13767       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13768         op1 = BUILD_STRING_BUFFER (op1);
13769       else
13770         {
13771           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13772           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13773         }
13774     }
13775
13776   if (op2)
13777     {
13778       /* OP1 is no longer the last node holding a crafted StringBuffer */
13779       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13780       /* Create a node for `{new...,xxx}.append (op2)' */
13781       if (op2)
13782         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13783     }
13784
13785   /* Mark the last node holding a crafted StringBuffer */
13786   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13787
13788   TREE_SIDE_EFFECTS (op1) = side_effects;
13789   return op1;
13790 }
13791
13792 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13793    StringBuffer. If no string were found to be patched, return
13794    NULL. */
13795
13796 static tree
13797 patch_string (tree node)
13798 {
13799   if (node == error_mark_node)
13800     return error_mark_node;
13801   if (TREE_CODE (node) == STRING_CST)
13802     return patch_string_cst (node);
13803   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13804     {
13805       int saved = ctxp->explicit_constructor_p;
13806       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13807       tree ret;
13808       /* Temporary disable forbid the use of `this'. */
13809       ctxp->explicit_constructor_p = 0;
13810       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13811       /* String concatenation arguments must be evaluated in order too. */
13812       ret = force_evaluation_order (ret);
13813       /* Restore it at its previous value */
13814       ctxp->explicit_constructor_p = saved;
13815       return ret;
13816     }
13817   return NULL_TREE;
13818 }
13819
13820 /* Build the internal representation of a string constant.  */
13821
13822 static tree
13823 patch_string_cst (tree node)
13824 {
13825   int location;
13826   if (! flag_emit_class_files)
13827     {
13828       node = get_identifier (TREE_STRING_POINTER (node));
13829       location = alloc_name_constant (CONSTANT_String, node);
13830       node = build_ref_from_constant_pool (location);
13831     }
13832   TREE_CONSTANT (node) = 1;
13833   TREE_INVARIANT (node) = 1;
13834
13835   /* ??? Guessing that the class file code can't handle casts.  */
13836   if (! flag_emit_class_files)
13837     node = convert (string_ptr_type_node, node);
13838   else
13839     TREE_TYPE (node) = string_ptr_type_node;
13840
13841   return node;
13842 }
13843
13844 /* Build an incomplete unary operator expression. */
13845
13846 static tree
13847 build_unaryop (int op_token, int op_location, tree op1)
13848 {
13849   enum tree_code op;
13850   tree unaryop;
13851   switch (op_token)
13852     {
13853     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13854     case MINUS_TK: op = NEGATE_EXPR; break;
13855     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13856     case NOT_TK: op = BIT_NOT_EXPR; break;
13857     default: abort ();
13858     }
13859
13860   unaryop = build1 (op, NULL_TREE, op1);
13861   TREE_SIDE_EFFECTS (unaryop) = 1;
13862   /* Store the location of the operator, for better error report. The
13863      string of the operator will be rebuild based on the OP value. */
13864   EXPR_WFL_LINECOL (unaryop) = op_location;
13865   return unaryop;
13866 }
13867
13868 /* Special case for the ++/-- operators, since they require an extra
13869    argument to build, which is set to NULL and patched
13870    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13871
13872 static tree
13873 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13874 {
13875   static const enum tree_code lookup [2][2] =
13876     {
13877       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13878       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13879     };
13880   tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
13881                       NULL_TREE, op1, NULL_TREE);
13882   TREE_SIDE_EFFECTS (node) = 1;
13883   /* Store the location of the operator, for better error report. The
13884      string of the operator will be rebuild based on the OP value. */
13885   EXPR_WFL_LINECOL (node) = op_location;
13886   return node;
13887 }
13888
13889 /* Build an incomplete cast operator, based on the use of the
13890    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13891    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13892    though its type is already set.  */
13893
13894 static tree
13895 build_cast (int location, tree type, tree exp)
13896 {
13897   tree node = build1 (CONVERT_EXPR, type, exp);
13898   EXPR_WFL_LINECOL (node) = location;
13899   return node;
13900 }
13901
13902 /* Build an incomplete class reference operator.  */
13903 static tree
13904 build_incomplete_class_ref (int location, tree class_name)
13905 {
13906   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13907   tree class_decl = GET_CPC ();
13908   tree this_class = TREE_TYPE (class_decl);
13909
13910   /* Generate the synthetic static method `class$'.  (Previously we
13911      deferred this, causing different method tables to be emitted
13912      for native code and bytecode.)  */
13913   if (!TYPE_DOT_CLASS (this_class)
13914       && !JPRIMITIVE_TYPE_P (class_name)
13915       && !(TREE_CODE (class_name) == VOID_TYPE))
13916     {
13917       tree cpc_list = GET_CPC_LIST();
13918       tree cpc = cpc_list;
13919       tree target_class;
13920
13921       /* For inner classes, add a 'class$' method to their outermost
13922          context, creating it if necessary.  */
13923
13924       while (GET_NEXT_ENCLOSING_CPC(cpc))
13925         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
13926       class_decl = TREE_VALUE (cpc);
13927
13928       target_class = TREE_TYPE (class_decl);
13929
13930       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
13931         {
13932           /* For interfaces, adding a static 'class$' method directly
13933              is illegal.  So create an inner class to contain the new
13934              method.  Empirically this matches the behavior of javac.  */
13935           tree t, inner;
13936           /* We want the generated inner class inside the outermost class. */
13937           GET_CPC_LIST() = cpc;
13938           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13939           inner = create_anonymous_class (t);
13940           target_class = TREE_TYPE (inner);
13941           end_class_declaration (1);
13942           GET_CPC_LIST() = cpc_list;
13943         }
13944
13945       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
13946         build_dot_class_method (target_class);
13947
13948       if (this_class != target_class)
13949         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
13950     }
13951
13952   EXPR_WFL_LINECOL (node) = location;
13953   return node;
13954 }
13955
13956 /* Complete an incomplete class reference operator.  */
13957 static tree
13958 patch_incomplete_class_ref (tree node)
13959 {
13960   tree type = TREE_OPERAND (node, 0);
13961   tree ref_type;
13962
13963   if (!(ref_type = resolve_type_during_patch (type)))
13964     return error_mark_node;
13965
13966   /* If we're not emitting class files and we know ref_type is a
13967      compiled class, build a direct reference.  */
13968   if ((! flag_emit_class_files && is_compiled_class (ref_type))
13969       || JPRIMITIVE_TYPE_P (ref_type)
13970       || TREE_CODE (ref_type) == VOID_TYPE)
13971     {
13972       tree dot = build_class_ref (ref_type);
13973       /* A class referenced by `foo.class' is initialized.  */
13974       if (!flag_emit_class_files)
13975        dot = build_class_init (ref_type, dot);
13976       return java_complete_tree (dot);
13977     }
13978
13979   /* If we're emitting class files and we have to deal with non
13980      primitive types, we invoke the synthetic static method `class$'.  */
13981   ref_type = build_dot_class_method_invocation (current_class, ref_type);
13982   return java_complete_tree (ref_type);
13983 }
13984
13985 /* 15.14 Unary operators. We return error_mark_node in case of error,
13986    but preserve the type of NODE if the type is fixed.  */
13987
13988 static tree
13989 patch_unaryop (tree node, tree wfl_op)
13990 {
13991   tree op = TREE_OPERAND (node, 0);
13992   tree op_type = TREE_TYPE (op);
13993   tree prom_type = NULL_TREE, value, decl;
13994   int outer_field_flag = 0;
13995   int code = TREE_CODE (node);
13996   int error_found = 0;
13997
13998   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13999
14000   switch (code)
14001     {
14002       /* 15.13.2 Postfix Increment Operator ++ */
14003     case POSTINCREMENT_EXPR:
14004       /* 15.13.3 Postfix Increment Operator -- */
14005     case POSTDECREMENT_EXPR:
14006       /* 15.14.1 Prefix Increment Operator ++ */
14007     case PREINCREMENT_EXPR:
14008       /* 15.14.2 Prefix Decrement Operator -- */
14009     case PREDECREMENT_EXPR:
14010       op = decl = strip_out_static_field_access_decl (op);
14011       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14012       /* We might be trying to change an outer field accessed using
14013          access method. */
14014       if (outer_field_flag)
14015         {
14016           /* Retrieve the decl of the field we're trying to access. We
14017              do that by first retrieving the function we would call to
14018              access the field. It has been already verified that this
14019              field isn't final */
14020           if (flag_emit_class_files)
14021             decl = TREE_OPERAND (op, 0);
14022           else
14023             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14024           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14025         }
14026       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14027       else if (!JDECL_P (decl)
14028           && TREE_CODE (decl) != COMPONENT_REF
14029           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14030           && TREE_CODE (decl) != INDIRECT_REF
14031           && !(TREE_CODE (decl) == COMPOUND_EXPR
14032                && TREE_OPERAND (decl, 1)
14033                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14034         {
14035           TREE_TYPE (node) = error_mark_node;
14036           error_found = 1;
14037         }
14038
14039       /* From now on, we know that op if a variable and that it has a
14040          valid wfl. We use wfl_op to locate errors related to the
14041          ++/-- operand. */
14042       if (!JNUMERIC_TYPE_P (op_type))
14043         {
14044           parse_error_context
14045             (wfl_op, "Invalid argument type `%s' to `%s'",
14046              lang_printable_name (op_type, 0), operator_string (node));
14047           TREE_TYPE (node) = error_mark_node;
14048           error_found = 1;
14049         }
14050       else
14051         {
14052           /* Before the addition, binary numeric promotion is performed on
14053              both operands, if really necessary */
14054           if (JINTEGRAL_TYPE_P (op_type))
14055             {
14056               value = build_int_cst (op_type, 1);
14057               TREE_TYPE (node) = op_type;
14058             }
14059           else
14060             {
14061               value = build_int_cst (NULL_TREE, 1);
14062               TREE_TYPE (node) =
14063                 binary_numeric_promotion (op_type,
14064                                           TREE_TYPE (value), &op, &value);
14065             }
14066
14067           /* We remember we might be accessing an outer field */
14068           if (outer_field_flag)
14069             {
14070               /* We re-generate an access to the field */
14071               value = build2 (PLUS_EXPR, TREE_TYPE (op),
14072                               build_outer_field_access (wfl_op, decl), value);
14073
14074               /* And we patch the original access$() into a write
14075                  with plus_op as a rhs */
14076               return outer_field_access_fix (node, op, value);
14077             }
14078
14079           /* And write back into the node. */
14080           TREE_OPERAND (node, 0) = op;
14081           TREE_OPERAND (node, 1) = value;
14082           /* Convert the overall back into its original type, if
14083              necessary, and return */
14084           if (JINTEGRAL_TYPE_P (op_type))
14085             return fold (node);
14086           else
14087             return fold (convert (op_type, node));
14088         }
14089       break;
14090
14091       /* 15.14.3 Unary Plus Operator + */
14092     case UNARY_PLUS_EXPR:
14093       /* 15.14.4 Unary Minus Operator - */
14094     case NEGATE_EXPR:
14095       if (!JNUMERIC_TYPE_P (op_type))
14096         {
14097           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14098           TREE_TYPE (node) = error_mark_node;
14099           error_found = 1;
14100         }
14101       /* Unary numeric promotion is performed on operand */
14102       else
14103         {
14104           op = do_unary_numeric_promotion (op);
14105           prom_type = TREE_TYPE (op);
14106           if (code == UNARY_PLUS_EXPR)
14107             return fold (op);
14108         }
14109       break;
14110
14111       /* 15.14.5 Bitwise Complement Operator ~ */
14112     case BIT_NOT_EXPR:
14113       if (!JINTEGRAL_TYPE_P (op_type))
14114         {
14115           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14116           TREE_TYPE (node) = error_mark_node;
14117           error_found = 1;
14118         }
14119       else
14120         {
14121           op = do_unary_numeric_promotion (op);
14122           prom_type = TREE_TYPE (op);
14123         }
14124       break;
14125
14126       /* 15.14.6 Logical Complement Operator ! */
14127     case TRUTH_NOT_EXPR:
14128       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14129         {
14130           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14131           /* But the type is known. We will report an error if further
14132              attempt of a assignment is made with this rhs */
14133           TREE_TYPE (node) = boolean_type_node;
14134           error_found = 1;
14135         }
14136       else
14137         prom_type = boolean_type_node;
14138       break;
14139
14140       /* 15.15 Cast Expression */
14141     case CONVERT_EXPR:
14142       value = patch_cast (node, wfl_operator);
14143       if (value == error_mark_node)
14144         {
14145           /* If this cast is part of an assignment, we tell the code
14146              that deals with it not to complain about a mismatch,
14147              because things have been cast, anyways */
14148           TREE_TYPE (node) = error_mark_node;
14149           error_found = 1;
14150         }
14151       else
14152         {
14153           value = fold (value);
14154           return value;
14155         }
14156       break;
14157     }
14158
14159   if (error_found)
14160     return error_mark_node;
14161
14162   /* There are cases where node has been replaced by something else
14163      and we don't end up returning here: UNARY_PLUS_EXPR,
14164      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14165   TREE_OPERAND (node, 0) = fold (op);
14166   TREE_TYPE (node) = prom_type;
14167   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14168   return fold (node);
14169 }
14170
14171 /* Generic type resolution that sometimes takes place during node
14172    patching. Returned the resolved type or generate an error
14173    message. Return the resolved type or NULL_TREE.  */
14174
14175 static tree
14176 resolve_type_during_patch (tree type)
14177 {
14178   if (unresolved_type_p (type, NULL))
14179     {
14180       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14181       if (!type_decl)
14182         {
14183           parse_error_context (type,
14184                                "Class `%s' not found in type declaration",
14185                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14186           return NULL_TREE;
14187         }
14188
14189       check_deprecation (type, type_decl);
14190
14191       return TREE_TYPE (type_decl);
14192     }
14193   return type;
14194 }
14195
14196 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14197    found. Otherwise NODE or something meant to replace it is returned.  */
14198
14199 static tree
14200 patch_cast (tree node, tree wfl_op)
14201 {
14202   tree op = TREE_OPERAND (node, 0);
14203   tree cast_type = TREE_TYPE (node);
14204   tree patched, op_type;
14205   char *t1;
14206
14207   /* Some string patching might be necessary at this stage */
14208   if ((patched = patch_string (op)))
14209     TREE_OPERAND (node, 0) = op = patched;
14210   op_type = TREE_TYPE (op);
14211
14212   /* First resolve OP_TYPE if unresolved */
14213   if (!(cast_type = resolve_type_during_patch (cast_type)))
14214     return error_mark_node;
14215
14216   /* Check on cast that are proven correct at compile time */
14217   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14218     {
14219       /* Same type */
14220       if (cast_type == op_type)
14221         return node;
14222
14223       /* A narrowing conversion from a floating-point number to an
14224          integral type requires special handling (5.1.3).  */
14225       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14226         if (cast_type != long_type_node)
14227           op = convert (integer_type_node, op);
14228
14229       /* Try widening/narrowing conversion.  Potentially, things need
14230          to be worked out in gcc so we implement the extreme cases
14231          correctly.  fold_convert() needs to be fixed.  */
14232       return convert (cast_type, op);
14233     }
14234
14235   /* It's also valid to cast a boolean into a boolean */
14236   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14237     return node;
14238
14239   /* null can be casted to references */
14240   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14241     return build_null_of_type (cast_type);
14242
14243   /* The remaining legal casts involve conversion between reference
14244      types. Check for their compile time correctness. */
14245   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14246       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14247     {
14248       TREE_TYPE (node) = promote_type (cast_type);
14249       /* Now, the case can be determined correct at compile time if
14250          OP_TYPE can be converted into CAST_TYPE by assignment
14251          conversion (5.2) */
14252
14253       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14254         {
14255           TREE_SET_CODE (node, NOP_EXPR);
14256           return node;
14257         }
14258
14259       if (flag_emit_class_files)
14260         {
14261           TREE_SET_CODE (node, CONVERT_EXPR);
14262           return node;
14263         }
14264
14265       /* The cast requires a run-time check */
14266       return build3 (CALL_EXPR, promote_type (cast_type),
14267                      build_address_of (soft_checkcast_node),
14268                      tree_cons (NULL_TREE, build_class_ref (cast_type),
14269                                 build_tree_list (NULL_TREE, op)),
14270                      NULL_TREE);
14271     }
14272
14273   /* Any other casts are proven incorrect at compile time */
14274   t1 = xstrdup (lang_printable_name (op_type, 0));
14275   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14276                        t1, lang_printable_name (cast_type, 0));
14277   free (t1);
14278   return error_mark_node;
14279 }
14280
14281 /* Build a null constant and give it the type TYPE.  */
14282
14283 static tree
14284 build_null_of_type (tree type)
14285 {
14286   tree node = build_int_cst (promote_type (type), 0);
14287   return node;
14288 }
14289
14290 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14291    a list of indices. */
14292 static tree
14293 build_array_ref (int location, tree array, tree index)
14294 {
14295   tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14296                       NULL_TREE, NULL_TREE);
14297   EXPR_WFL_LINECOL (node) = location;
14298   return node;
14299 }
14300
14301 /* 15.12 Array Access Expression */
14302
14303 static tree
14304 patch_array_ref (tree node)
14305 {
14306   tree array = TREE_OPERAND (node, 0);
14307   tree array_type  = TREE_TYPE (array);
14308   tree index = TREE_OPERAND (node, 1);
14309   tree index_type = TREE_TYPE (index);
14310   int error_found = 0;
14311
14312   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14313
14314   if (TREE_CODE (array_type) == POINTER_TYPE)
14315     array_type = TREE_TYPE (array_type);
14316
14317   /* The array reference must be an array */
14318   if (!TYPE_ARRAY_P (array_type))
14319     {
14320       parse_error_context
14321         (wfl_operator,
14322          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14323          lang_printable_name (array_type, 0));
14324       TREE_TYPE (node) = error_mark_node;
14325       error_found = 1;
14326     }
14327
14328   /* The array index undergoes unary numeric promotion. The promoted
14329      type must be int */
14330   index = do_unary_numeric_promotion (index);
14331   if (TREE_TYPE (index) != int_type_node)
14332     {
14333       if (valid_cast_to_p (index_type, int_type_node))
14334         parse_error_context (wfl_operator,
14335    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14336                              lang_printable_name (index_type, 0));
14337       else
14338         parse_error_context (wfl_operator,
14339           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14340                              lang_printable_name (index_type, 0));
14341       TREE_TYPE (node) = error_mark_node;
14342       error_found = 1;
14343     }
14344
14345   if (error_found)
14346     return error_mark_node;
14347
14348   array_type = TYPE_ARRAY_ELEMENT (array_type);
14349
14350   if (flag_emit_class_files || flag_emit_xref)
14351     {
14352       TREE_OPERAND (node, 0) = array;
14353       TREE_OPERAND (node, 1) = index;
14354     }
14355   else
14356     node = build_java_arrayaccess (array, array_type, index);
14357   TREE_TYPE (node) = array_type;
14358   return node;
14359 }
14360
14361 /* 15.9 Array Creation Expressions */
14362
14363 static tree
14364 build_newarray_node (tree type, tree dims, int extra_dims)
14365 {
14366   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14367                       nreverse (dims),
14368                       build_int_cst (NULL_TREE, extra_dims));
14369   return node;
14370 }
14371
14372 static tree
14373 patch_newarray (tree node)
14374 {
14375   tree type = TREE_OPERAND (node, 0);
14376   tree dims = TREE_OPERAND (node, 1);
14377   tree cdim, array_type;
14378   int error_found = 0;
14379   int ndims = 0;
14380   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14381
14382   /* Dimension types are verified. It's better for the types to be
14383      verified in order. */
14384   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14385     {
14386       int dim_error = 0;
14387       tree dim = TREE_VALUE (cdim);
14388
14389       /* Dim might have been saved during its evaluation */
14390       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14391
14392       /* The type of each specified dimension must be an integral type. */
14393       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14394         dim_error = 1;
14395
14396       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14397          promoted type must be int. */
14398       else
14399         {
14400           dim = do_unary_numeric_promotion (dim);
14401           if (TREE_TYPE (dim) != int_type_node)
14402             dim_error = 1;
14403         }
14404
14405       /* Report errors on types here */
14406       if (dim_error)
14407         {
14408           parse_error_context
14409             (TREE_PURPOSE (cdim),
14410              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14411              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14412               "Explicit cast needed to" : "Can't"),
14413              lang_printable_name (TREE_TYPE (dim), 0));
14414           error_found = 1;
14415         }
14416
14417       TREE_PURPOSE (cdim) = NULL_TREE;
14418     }
14419
14420   /* Resolve array base type if unresolved */
14421   if (!(type = resolve_type_during_patch (type)))
14422     error_found = 1;
14423
14424   if (error_found)
14425     {
14426       /* We don't want further evaluation of this bogus array creation
14427          operation */
14428       TREE_TYPE (node) = error_mark_node;
14429       return error_mark_node;
14430     }
14431
14432   /* Set array_type to the actual (promoted) array type of the result. */
14433   if (TREE_CODE (type) == RECORD_TYPE)
14434     type = build_pointer_type (type);
14435   while (--xdims >= 0)
14436     {
14437       type = promote_type (build_java_array_type (type, -1));
14438     }
14439   dims = nreverse (dims);
14440   array_type = type;
14441   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14442     {
14443       type = array_type;
14444       array_type
14445         = build_java_array_type (type,
14446                                  TREE_CODE (cdim) == INTEGER_CST
14447                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14448                                  : -1);
14449       array_type = promote_type (array_type);
14450     }
14451   dims = nreverse (dims);
14452
14453   /* The node is transformed into a function call. Things are done
14454      differently according to the number of dimensions. If the number
14455      of dimension is equal to 1, then the nature of the base type
14456      (primitive or not) matters. */
14457   if (ndims == 1)
14458     return build_new_array (type, TREE_VALUE (dims));
14459
14460   /* Can't reuse what's already written in expr.c because it uses the
14461      JVM stack representation. Provide a build_multianewarray. FIXME */
14462   return build3 (CALL_EXPR, array_type,
14463                  build_address_of (soft_multianewarray_node),
14464                  tree_cons (NULL_TREE,
14465                             build_class_ref (TREE_TYPE (array_type)),
14466                             tree_cons (NULL_TREE,
14467                                        build_int_cst (NULL_TREE, ndims),
14468                                        dims)),
14469                  NULL_TREE);
14470 }
14471
14472 /* 10.6 Array initializer.  */
14473
14474 /* Build a wfl for array element that don't have one, so we can
14475    pin-point errors.  */
14476
14477 static tree
14478 maybe_build_array_element_wfl (tree node)
14479 {
14480   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14481     return build_expr_wfl (NULL_TREE, ctxp->filename,
14482                            ctxp->elc.line, ctxp->elc.prev_col);
14483   else
14484     return NULL_TREE;
14485 }
14486
14487 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14488    identification of initialized arrays easier to detect during walk
14489    and expansion.  */
14490
14491 static tree
14492 build_new_array_init (int location, tree values)
14493 {
14494   tree constructor = build_constructor (NULL_TREE, values);
14495   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14496   EXPR_WFL_LINECOL (to_return) = location;
14497   return to_return;
14498 }
14499
14500 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14501    occurred.  Otherwise return NODE after having set its type
14502    appropriately.  */
14503
14504 static tree
14505 patch_new_array_init (tree type, tree node)
14506 {
14507   int error_seen = 0;
14508   tree current, element_type;
14509   HOST_WIDE_INT length;
14510   int all_constant = 1;
14511   tree init = TREE_OPERAND (node, 0);
14512
14513   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14514     {
14515       parse_error_context (node,
14516                            "Invalid array initializer for non-array type `%s'",
14517                            lang_printable_name (type, 1));
14518       return error_mark_node;
14519     }
14520   type = TREE_TYPE (type);
14521   element_type = TYPE_ARRAY_ELEMENT (type);
14522
14523   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14524
14525   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14526        current;  length++, current = TREE_CHAIN (current))
14527     {
14528       tree elt = TREE_VALUE (current);
14529       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14530         {
14531           error_seen |= array_constructor_check_entry (element_type, current);
14532           elt = TREE_VALUE (current);
14533           /* When compiling to native code, STRING_CST is converted to
14534              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14535           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14536             all_constant = 0;
14537         }
14538       else
14539         {
14540           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14541           TREE_PURPOSE (current) = NULL_TREE;
14542           all_constant = 0;
14543         }
14544       if (elt && TREE_CODE (elt) == TREE_LIST
14545           && TREE_VALUE (elt) == error_mark_node)
14546         error_seen = 1;
14547     }
14548
14549   if (error_seen)
14550     return error_mark_node;
14551
14552   /* Create a new type. We can't reuse the one we have here by
14553      patching its dimension because it originally is of dimension -1
14554      hence reused by gcc. This would prevent triangular arrays. */
14555   type = build_java_array_type (element_type, length);
14556   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14557   TREE_TYPE (node) = promote_type (type);
14558   TREE_CONSTANT (init) = all_constant;
14559   TREE_INVARIANT (init) = all_constant;
14560   TREE_CONSTANT (node) = all_constant;
14561   TREE_INVARIANT (node) = all_constant;
14562   return node;
14563 }
14564
14565 /* Verify that one entry of the initializer element list can be
14566    assigned to the array base type. Report 1 if an error occurred, 0
14567    otherwise.  */
14568
14569 static int
14570 array_constructor_check_entry (tree type, tree entry)
14571 {
14572   char *array_type_string = NULL;       /* For error reports */
14573   tree value, type_value, new_value, wfl_value, patched;
14574   int error_seen = 0;
14575
14576   new_value = NULL_TREE;
14577   wfl_value = TREE_VALUE (entry);
14578
14579   value = java_complete_tree (TREE_VALUE (entry));
14580   /* patch_string return error_mark_node if arg is error_mark_node */
14581   if ((patched = patch_string (value)))
14582     value = patched;
14583   if (value == error_mark_node)
14584     return 1;
14585
14586   type_value = TREE_TYPE (value);
14587
14588   /* At anytime, try_builtin_assignconv can report a warning on
14589      constant overflow during narrowing. */
14590   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14591   new_value = try_builtin_assignconv (wfl_operator, type, value);
14592   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14593     type_value = promote_type (type);
14594
14595   /* Check and report errors */
14596   if (!new_value)
14597     {
14598       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14599                    "Can't" : "Explicit cast needed to");
14600       if (!array_type_string)
14601         array_type_string = xstrdup (lang_printable_name (type, 1));
14602       parse_error_context
14603         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14604          msg, lang_printable_name (type_value, 1), array_type_string);
14605       error_seen = 1;
14606     }
14607
14608   if (new_value)
14609     TREE_VALUE (entry) = new_value;
14610
14611   if (array_type_string)
14612     free (array_type_string);
14613
14614   TREE_PURPOSE (entry) = NULL_TREE;
14615   return error_seen;
14616 }
14617
14618 static tree
14619 build_this (int location)
14620 {
14621   tree node = build_wfl_node (this_identifier_node);
14622   TREE_SET_CODE (node, THIS_EXPR);
14623   EXPR_WFL_LINECOL (node) = location;
14624   return node;
14625 }
14626
14627 /* 14.15 The return statement. It builds a modify expression that
14628    assigns the returned value to the RESULT_DECL that hold the value
14629    to be returned. */
14630
14631 static tree
14632 build_return (int location, tree op)
14633 {
14634   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14635   EXPR_WFL_LINECOL (node) = location;
14636   node = build_debugable_stmt (location, node);
14637   return node;
14638 }
14639
14640 static tree
14641 patch_return (tree node)
14642 {
14643   tree return_exp = TREE_OPERAND (node, 0);
14644   tree meth = current_function_decl;
14645   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14646   int error_found = 0;
14647
14648   TREE_TYPE (node) = error_mark_node;
14649   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14650
14651   /* It's invalid to have a return value within a function that is
14652      declared with the keyword void or that is a constructor */
14653   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14654     error_found = 1;
14655
14656   /* It's invalid to use a return statement in a static block */
14657   if (DECL_CLINIT_P (current_function_decl))
14658     error_found = 1;
14659
14660   /* It's invalid to have a no return value within a function that
14661      isn't declared with the keyword `void' */
14662   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14663     error_found = 2;
14664
14665   if (DECL_INSTINIT_P (current_function_decl))
14666     error_found = 1;
14667
14668   if (error_found)
14669     {
14670       if (DECL_INSTINIT_P (current_function_decl))
14671         parse_error_context (wfl_operator,
14672                              "`return' inside instance initializer");
14673
14674       else if (DECL_CLINIT_P (current_function_decl))
14675         parse_error_context (wfl_operator,
14676                              "`return' inside static initializer");
14677
14678       else if (!DECL_CONSTRUCTOR_P (meth))
14679         {
14680           char *t = xstrdup (lang_printable_name (mtype, 0));
14681           parse_error_context (wfl_operator,
14682                                "`return' with%s value from `%s %s'",
14683                                (error_found == 1 ? "" : "out"),
14684                                t, lang_printable_name (meth, 2));
14685           free (t);
14686         }
14687       else
14688         parse_error_context (wfl_operator,
14689                              "`return' with value from constructor `%s'",
14690                              lang_printable_name (meth, 2));
14691       return error_mark_node;
14692     }
14693
14694   /* If we have a return_exp, build a modify expression and expand
14695      it. Note: at that point, the assignment is declared valid, but we
14696      may want to carry some more hacks */
14697   if (return_exp)
14698     {
14699       tree exp = java_complete_tree (return_exp);
14700       tree modify, patched;
14701
14702       if ((patched = patch_string (exp)))
14703         exp = patched;
14704
14705       modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14706       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14707       modify = java_complete_tree (modify);
14708
14709       if (modify != error_mark_node)
14710         {
14711           TREE_SIDE_EFFECTS (modify) = 1;
14712           TREE_OPERAND (node, 0) = modify;
14713         }
14714       else
14715         return error_mark_node;
14716     }
14717   TREE_TYPE (node) = void_type_node;
14718   TREE_SIDE_EFFECTS (node) = 1;
14719   return node;
14720 }
14721
14722 /* 14.8 The if Statement */
14723
14724 static tree
14725 build_if_else_statement (int location, tree expression, tree if_body,
14726                          tree else_body)
14727 {
14728   tree node;
14729   if (!else_body)
14730     else_body = build_java_empty_stmt ();
14731   node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14732   EXPR_WFL_LINECOL (node) = location;
14733   node = build_debugable_stmt (location, node);
14734   return node;
14735 }
14736
14737 static tree
14738 patch_if_else_statement (tree node)
14739 {
14740   tree expression = TREE_OPERAND (node, 0);
14741   int can_complete_normally
14742     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14743        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14744
14745   TREE_TYPE (node) = error_mark_node;
14746   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14747
14748   /* The type of expression must be boolean */
14749   if (TREE_TYPE (expression) != boolean_type_node
14750       && TREE_TYPE (expression) != promoted_boolean_type_node)
14751     {
14752       parse_error_context
14753         (wfl_operator,
14754          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14755          lang_printable_name (TREE_TYPE (expression), 0));
14756       return error_mark_node;
14757     }
14758
14759   TREE_TYPE (node) = void_type_node;
14760   TREE_SIDE_EFFECTS (node) = 1;
14761   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14762   return node;
14763 }
14764
14765 /* 14.6 Labeled Statements */
14766
14767 /* Action taken when a labeled statement is parsed. a new
14768    LABELED_BLOCK_EXPR is created. No statement is attached to the
14769    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14770
14771 static tree
14772 build_labeled_block (int location, tree label)
14773 {
14774   tree label_name ;
14775   tree label_decl, node;
14776   if (label == NULL_TREE || label == continue_identifier_node)
14777     label_name = label;
14778   else
14779     {
14780       label_name = merge_qualified_name (label_id, label);
14781       /* Issue an error if we try to reuse a label that was previously
14782          declared */
14783       if (IDENTIFIER_LOCAL_VALUE (label_name))
14784         {
14785           EXPR_WFL_LINECOL (wfl_operator) = location;
14786           parse_error_context (wfl_operator,
14787             "Declaration of `%s' shadows a previous label declaration",
14788                                IDENTIFIER_POINTER (label));
14789           EXPR_WFL_LINECOL (wfl_operator) =
14790             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14791           parse_error_context (wfl_operator,
14792             "This is the location of the previous declaration of label `%s'",
14793                                IDENTIFIER_POINTER (label));
14794           java_error_count--;
14795         }
14796     }
14797
14798   label_decl = create_label_decl (label_name);
14799   node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14800   EXPR_WFL_LINECOL (node) = location;
14801   TREE_SIDE_EFFECTS (node) = 1;
14802   return node;
14803 }
14804
14805 /* A labeled statement LBE is attached a statement.  */
14806
14807 static tree
14808 finish_labeled_statement (tree lbe, /* Labeled block expr */
14809                           tree statement)
14810 {
14811   /* In anyways, tie the loop to its statement */
14812   LABELED_BLOCK_BODY (lbe) = statement;
14813   pop_labeled_block ();
14814   POP_LABELED_BLOCK ();
14815   return lbe;
14816 }
14817
14818 /* 14.10, 14.11, 14.12 Loop Statements */
14819
14820 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14821    list. */
14822
14823 static tree
14824 build_new_loop (tree loop_body)
14825 {
14826   tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
14827   TREE_SIDE_EFFECTS (loop) = 1;
14828   PUSH_LOOP (loop);
14829   return loop;
14830 }
14831
14832 /* Create a loop body according to the following structure:
14833      COMPOUND_EXPR
14834        COMPOUND_EXPR            (loop main body)
14835          EXIT_EXPR              (this order is for while/for loops.
14836          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14837            LABEL_DECL           (a continue occurring here branches at the
14838            BODY                  end of this labeled block)
14839        INCREMENT                (if any)
14840
14841   REVERSED, if nonzero, tells that the loop condition expr comes
14842   after the body, like in the do-while loop.
14843
14844   To obtain a loop, the loop body structure described above is
14845   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14846
14847    LABELED_BLOCK_EXPR
14848      LABEL_DECL                   (use this label to exit the loop)
14849      LOOP_EXPR
14850        <structure described above> */
14851
14852 static tree
14853 build_loop_body (int location, tree condition, int reversed)
14854 {
14855   tree first, second, body;
14856
14857   condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14858   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14859   condition = build_debugable_stmt (location, condition);
14860   TREE_SIDE_EFFECTS (condition) = 1;
14861
14862   body = build_labeled_block (0, continue_identifier_node);
14863   first = (reversed ? body : condition);
14864   second = (reversed ? condition : body);
14865   return build2 (COMPOUND_EXPR, NULL_TREE,
14866                  build2 (COMPOUND_EXPR, NULL_TREE, first, second),
14867                  build_java_empty_stmt ());
14868 }
14869
14870 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14871    their order) on the current loop. Unlink the current loop from the
14872    loop list.  */
14873
14874 static tree
14875 finish_loop_body (int location, tree condition, tree body, int reversed)
14876 {
14877   tree to_return = ctxp->current_loop;
14878   tree loop_body = LOOP_EXPR_BODY (to_return);
14879   if (condition)
14880     {
14881       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14882       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14883          The real EXIT_EXPR is one operand further. */
14884       EXPR_WFL_LINECOL (cnode) = location;
14885       /* This one is for accurate error reports */
14886       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14887       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14888     }
14889   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14890   POP_LOOP ();
14891   return to_return;
14892 }
14893
14894 /* Tailored version of finish_loop_body for FOR loops, when FOR
14895    loops feature the condition part */
14896
14897 static tree
14898 finish_for_loop (int location, tree condition, tree update, tree body)
14899 {
14900   /* Put the condition and the loop body in place */
14901   tree loop = finish_loop_body (location, condition, body, 0);
14902   /* LOOP is the current loop which has been now popped of the loop
14903      stack.  Mark the update block as reachable and install it.  We do
14904      this because the (current interpretation of the) JLS requires
14905      that the update expression be considered reachable even if the
14906      for loop's body doesn't complete normally.  */
14907   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
14908     {
14909       tree up2 = update;
14910       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14911         up2 = EXPR_WFL_NODE (up2);
14912       /* It is possible for the update expression to be an
14913          EXPR_WFL_NODE wrapping nothing.  */
14914       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
14915         {
14916           /* Try to detect constraint violations.  These would be
14917              programming errors somewhere.  */
14918           if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
14919             abort ();
14920           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14921         }
14922     }
14923   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14924   return loop;
14925 }
14926
14927 /* Try to find the loop a block might be related to. This comprises
14928    the case where the LOOP_EXPR is found as the second operand of a
14929    COMPOUND_EXPR, because the loop happens to have an initialization
14930    part, then expressed as the first operand of the COMPOUND_EXPR. If
14931    the search finds something, 1 is returned. Otherwise, 0 is
14932    returned. The search is assumed to start from a
14933    LABELED_BLOCK_EXPR's block.  */
14934
14935 static tree
14936 search_loop (tree statement)
14937 {
14938   if (TREE_CODE (statement) == LOOP_EXPR)
14939     return statement;
14940
14941   if (TREE_CODE (statement) == BLOCK)
14942     statement = BLOCK_SUBBLOCKS (statement);
14943   else
14944     return NULL_TREE;
14945
14946   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14947     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14948       statement = TREE_OPERAND (statement, 1);
14949
14950   return (TREE_CODE (statement) == LOOP_EXPR
14951           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14952 }
14953
14954 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14955    returned otherwise.  */
14956
14957 static int
14958 labeled_block_contains_loop_p (tree block, tree loop)
14959 {
14960   if (!block)
14961     return 0;
14962
14963   if (LABELED_BLOCK_BODY (block) == loop)
14964     return 1;
14965
14966   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
14967     return 1;
14968
14969   return 0;
14970 }
14971
14972 /* If the loop isn't surrounded by a labeled statement, create one and
14973    insert LOOP as its body.  */
14974
14975 static tree
14976 patch_loop_statement (tree loop)
14977 {
14978   tree loop_label;
14979
14980   TREE_TYPE (loop) = void_type_node;
14981   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14982     return loop;
14983
14984   loop_label = build_labeled_block (0, NULL_TREE);
14985   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14986      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
14987   LABELED_BLOCK_BODY (loop_label) = loop;
14988   PUSH_LABELED_BLOCK (loop_label);
14989   return loop_label;
14990 }
14991
14992 /* 14.13, 14.14: break and continue Statements */
14993
14994 /* Build a break or a continue statement. a null NAME indicates an
14995    unlabeled break/continue statement.  */
14996
14997 static tree
14998 build_bc_statement (int location, int is_break, tree name)
14999 {
15000   tree break_continue, label_block_expr = NULL_TREE;
15001
15002   if (name)
15003     {
15004       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15005             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15006         /* Null means that we don't have a target for this named
15007            break/continue. In this case, we make the target to be the
15008            label name, so that the error can be reported accurately in
15009            patch_bc_statement. */
15010         label_block_expr = EXPR_WFL_NODE (name);
15011     }
15012   /* Unlabeled break/continue will be handled during the
15013      break/continue patch operation */
15014   break_continue = build2 (EXIT_BLOCK_EXPR, NULL_TREE,
15015                            label_block_expr, NULL_TREE);
15016
15017   IS_BREAK_STMT_P (break_continue) = is_break;
15018   TREE_SIDE_EFFECTS (break_continue) = 1;
15019   EXPR_WFL_LINECOL (break_continue) = location;
15020   break_continue = build_debugable_stmt (location, break_continue);
15021   return break_continue;
15022 }
15023
15024 /* Verification of a break/continue statement. */
15025
15026 static tree
15027 patch_bc_statement (tree node)
15028 {
15029   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15030   tree labeled_block = ctxp->current_labeled_block;
15031   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15032
15033   /* Having an identifier here means that the target is unknown. */
15034   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15035     {
15036       parse_error_context (wfl_operator, "No label definition found for `%s'",
15037                            IDENTIFIER_POINTER (bc_label));
15038       return error_mark_node;
15039     }
15040   if (! IS_BREAK_STMT_P (node))
15041     {
15042       /* It's a continue statement. */
15043       for (;; labeled_block = TREE_CHAIN (labeled_block))
15044         {
15045           if (labeled_block == NULL_TREE)
15046             {
15047               if (bc_label == NULL_TREE)
15048                 parse_error_context (wfl_operator,
15049                                      "`continue' must be in loop");
15050               else
15051                 parse_error_context
15052                   (wfl_operator, "continue label `%s' does not name a loop",
15053                    IDENTIFIER_POINTER (bc_label));
15054               return error_mark_node;
15055             }
15056           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15057                == continue_identifier_node)
15058               && (bc_label == NULL_TREE
15059                   || TREE_CHAIN (labeled_block) == bc_label))
15060             {
15061               bc_label = labeled_block;
15062               break;
15063             }
15064         }
15065     }
15066   else if (!bc_label)
15067     {
15068       for (;; labeled_block = TREE_CHAIN (labeled_block))
15069         {
15070           if (labeled_block == NULL_TREE)
15071             {
15072               parse_error_context (wfl_operator,
15073                                      "`break' must be in loop or switch");
15074               return error_mark_node;
15075             }
15076           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15077           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15078               || search_loop (target_stmt))
15079             {
15080               bc_label = labeled_block;
15081               break;
15082             }
15083         }
15084     }
15085
15086   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15087   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15088
15089   /* Our break/continue don't return values. */
15090   TREE_TYPE (node) = void_type_node;
15091   /* Encapsulate the break within a compound statement so that it's
15092      expanded all the times by expand_expr (and not clobbered
15093      sometimes, like after a if statement) */
15094   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15095   TREE_SIDE_EFFECTS (node) = 1;
15096   return node;
15097 }
15098
15099 /* Process the exit expression belonging to a loop. Its type must be
15100    boolean.  */
15101
15102 static tree
15103 patch_exit_expr (tree node)
15104 {
15105   tree expression = TREE_OPERAND (node, 0);
15106   TREE_TYPE (node) = error_mark_node;
15107   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15108
15109   /* The type of expression must be boolean */
15110   if (TREE_TYPE (expression) != boolean_type_node)
15111     {
15112       parse_error_context
15113         (wfl_operator,
15114     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15115          lang_printable_name (TREE_TYPE (expression), 0));
15116       return error_mark_node;
15117     }
15118   /* Now we know things are allright, invert the condition, fold and
15119      return */
15120   TREE_OPERAND (node, 0) =
15121     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15122
15123   if (! integer_zerop (TREE_OPERAND (node, 0))
15124       && ctxp->current_loop != NULL_TREE
15125       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15126     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15127   if (! integer_onep (TREE_OPERAND (node, 0)))
15128     CAN_COMPLETE_NORMALLY (node) = 1;
15129
15130
15131   TREE_TYPE (node) = void_type_node;
15132   return node;
15133 }
15134
15135 /* 14.9 Switch statement */
15136
15137 static tree
15138 patch_switch_statement (tree node)
15139 {
15140   tree se = TREE_OPERAND (node, 0), se_type;
15141   tree save, iter;
15142
15143   /* Complete the switch expression */
15144   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15145   se_type = TREE_TYPE (se);
15146   /* The type of the switch expression must be char, byte, short or
15147      int */
15148   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15149     {
15150       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15151       parse_error_context (wfl_operator,
15152           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15153                            lang_printable_name (se_type, 0));
15154       /* This is what java_complete_tree will check */
15155       TREE_OPERAND (node, 0) = error_mark_node;
15156       return error_mark_node;
15157     }
15158
15159   /* Save and restore the outer case label list.  */
15160   save = case_label_list;
15161   case_label_list = NULL_TREE;
15162
15163   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15164
15165   /* See if we've found a duplicate label.  We can't leave this until
15166      code generation, because in `--syntax-only' and `-C' modes we
15167      don't do ordinary code generation.  */
15168   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15169     {
15170       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15171       tree subiter;
15172       for (subiter = TREE_CHAIN (iter);
15173            subiter != NULL_TREE;
15174            subiter = TREE_CHAIN (subiter))
15175         {
15176           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15177           if (val == subval)
15178             {
15179               EXPR_WFL_LINECOL (wfl_operator)
15180                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15181               /* The case_label_list is in reverse order, so print the
15182                  outer label first.  */
15183               parse_error_context (wfl_operator, "duplicate case label: `"
15184                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15185               EXPR_WFL_LINECOL (wfl_operator)
15186                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15187               parse_error_context (wfl_operator, "original label is here");
15188
15189               break;
15190             }
15191         }
15192     }
15193
15194   case_label_list = save;
15195
15196   /* Ready to return */
15197   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15198     {
15199       TREE_TYPE (node) = error_mark_node;
15200       return error_mark_node;
15201     }
15202   TREE_TYPE (node) = void_type_node;
15203   TREE_SIDE_EFFECTS (node) = 1;
15204   CAN_COMPLETE_NORMALLY (node)
15205     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15206       || ! SWITCH_HAS_DEFAULT (node);
15207   return node;
15208 }
15209
15210 /* Assertions.  */
15211
15212 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15213    might be NULL_TREE.  */
15214 static tree
15215 build_assertion (int location, tree condition, tree value)
15216 {
15217   tree node;
15218   tree klass = GET_CPC ();
15219
15220   if (! enable_assertions (klass))
15221     {
15222       condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15223                           boolean_false_node, condition);
15224       if (value == NULL_TREE)
15225         value = build_java_empty_stmt ();
15226       return build_if_else_statement (location, condition,
15227                                       value, NULL_TREE);
15228     }
15229
15230   if (! CLASS_USES_ASSERTIONS (klass))
15231     {
15232       tree field, classdollar, id, call;
15233       tree class_type = TREE_TYPE (klass);
15234
15235       field = add_field (class_type,
15236                          get_identifier ("$assertionsDisabled"),
15237                          boolean_type_node,
15238                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15239       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15240       FIELD_SYNTHETIC (field) = 1;
15241
15242       classdollar = build_incomplete_class_ref (location, class_type);
15243
15244       /* Call CLASS.desiredAssertionStatus().  */
15245       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15246       call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15247       call = make_qualified_primary (classdollar, call, location);
15248       TREE_SIDE_EFFECTS (call) = 1;
15249
15250       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15251          seem odd, but we do it to generate code identical to that of
15252          the JDK.  */
15253       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15254       TREE_SIDE_EFFECTS (call) = 1;
15255       DECL_INITIAL (field) = call;
15256
15257       /* Record the initializer in the initializer statement list.  */
15258       call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15259       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15260       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15261       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15262
15263       CLASS_USES_ASSERTIONS (klass) = 1;
15264     }
15265
15266   if (value != NULL_TREE)
15267     value = tree_cons (NULL_TREE, value, NULL_TREE);
15268
15269   node = build_wfl_node (get_identifier ("java"));
15270   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15271                               location);
15272   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15273                               location);
15274
15275   node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15276   TREE_SIDE_EFFECTS (node) = 1;
15277   /* It is too early to use BUILD_THROW.  */
15278   node = build1 (THROW_EXPR, NULL_TREE, node);
15279   TREE_SIDE_EFFECTS (node) = 1;
15280
15281   /* We invert the condition; if we just put NODE as the `else' part
15282      then we generate weird-looking bytecode.  */
15283   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15284   /* Check $assertionsDisabled.  */
15285   condition
15286     = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15287               build1 (TRUTH_NOT_EXPR, NULL_TREE,
15288                       build_wfl_node (get_identifier ("$assertionsDisabled"))),
15289               condition);
15290   node = build_if_else_statement (location, condition, node, NULL_TREE);
15291   return node;
15292 }
15293
15294 /* 14.18 The try/catch statements */
15295
15296 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15297    catches TYPE and executes CATCH_STMTS.  */
15298
15299 static tree
15300 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15301                             tree catch_stmts)
15302 {
15303   tree try_block, catch_clause_param, catch_block, catch;
15304
15305   /* First build a try block */
15306   try_block = build_expr_block (try_stmts, NULL_TREE);
15307
15308   /* Build a catch block: we need a catch clause parameter */
15309   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15310     {
15311       tree catch_type = obtain_incomplete_type (type_or_name);
15312       jdep *dep;
15313       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15314       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15315                                 catch_clause_param, catch_type);
15316       dep = CLASSD_LAST (ctxp->classd_list);
15317       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15318     }
15319   else
15320     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15321                                      build_pointer_type (type_or_name));
15322
15323   /* And a block */
15324   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15325
15326   /* Initialize the variable and store in the block */
15327   catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15328                   build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15329   add_stmt_to_block (catch_block, NULL_TREE, catch);
15330
15331   /* Add the catch statements */
15332   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15333
15334   /* Now we can build a JAVA_CATCH_EXPR */
15335   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15336
15337   return build_try_statement (location, try_block, catch_block);
15338 }
15339
15340 static tree
15341 build_try_statement (int location, tree try_block, tree catches)
15342 {
15343   tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15344   EXPR_WFL_LINECOL (node) = location;
15345   return node;
15346 }
15347
15348 static tree
15349 build_try_finally_statement (int location, tree try_block, tree finally)
15350 {
15351   tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15352   EXPR_WFL_LINECOL (node) = location;
15353   return node;
15354 }
15355
15356 static tree
15357 patch_try_statement (tree node)
15358 {
15359   int error_found = 0;
15360   tree try = TREE_OPERAND (node, 0);
15361   /* Exception handlers are considered in left to right order */
15362   tree catch = nreverse (TREE_OPERAND (node, 1));
15363   tree current, caught_type_list = NULL_TREE;
15364
15365   /* Check catch clauses, if any. Every time we find an error, we try
15366      to process the next catch clause. We process the catch clause before
15367      the try block so that when processing the try block we can check thrown
15368      exceptions against the caught type list. */
15369   for (current = catch; current; current = TREE_CHAIN (current))
15370     {
15371       tree carg_decl, carg_type;
15372       tree sub_current, catch_block, catch_clause;
15373       int unreachable;
15374
15375       /* At this point, the structure of the catch clause is
15376            JAVA_CATCH_EXPR              (catch node)
15377              BLOCK              (with the decl of the parameter)
15378                COMPOUND_EXPR
15379                  MODIFY_EXPR   (assignment of the catch parameter)
15380                  BLOCK          (catch clause block)
15381        */
15382       catch_clause = TREE_OPERAND (current, 0);
15383       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15384       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15385
15386       /* Catch clauses can't have more than one parameter declared,
15387          but it's already enforced by the grammar. Make sure that the
15388          only parameter of the clause statement in of class Throwable
15389          or a subclass of Throwable, but that was done earlier. The
15390          catch clause parameter type has also been resolved. */
15391
15392       /* Just make sure that the catch clause parameter type inherits
15393          from java.lang.Throwable */
15394       if (!inherits_from_p (carg_type, throwable_type_node))
15395         {
15396           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15397           parse_error_context (wfl_operator,
15398                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15399                                lang_printable_name (carg_type, 0));
15400           error_found = 1;
15401           continue;
15402         }
15403
15404       /* Partial check for unreachable catch statement: The catch
15405          clause is reachable iff is no earlier catch block A in
15406          the try statement such that the type of the catch
15407          clause's parameter is the same as or a subclass of the
15408          type of A's parameter */
15409       unreachable = 0;
15410       for (sub_current = catch;
15411            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15412         {
15413           tree sub_catch_clause, decl;
15414           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15415           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15416
15417           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15418             {
15419               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15420               parse_error_context
15421                 (wfl_operator,
15422                  "`catch' not reached because of the catch clause at line %d",
15423                  EXPR_WFL_LINENO (sub_current));
15424               unreachable = error_found = 1;
15425               break;
15426             }
15427         }
15428       /* Complete the catch clause block */
15429       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15430       if (catch_block == error_mark_node)
15431         {
15432           error_found = 1;
15433           continue;
15434         }
15435       if (CAN_COMPLETE_NORMALLY (catch_block))
15436         CAN_COMPLETE_NORMALLY (node) = 1;
15437       TREE_OPERAND (current, 0) = catch_block;
15438
15439       if (unreachable)
15440         continue;
15441
15442       /* Things to do here: the exception must be thrown */
15443
15444       /* Link this type to the caught type list */
15445       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15446     }
15447
15448   PUSH_EXCEPTIONS (caught_type_list);
15449   if ((try = java_complete_tree (try)) == error_mark_node)
15450     error_found = 1;
15451   if (CAN_COMPLETE_NORMALLY (try))
15452     CAN_COMPLETE_NORMALLY (node) = 1;
15453   POP_EXCEPTIONS ();
15454
15455   /* Verification ends here */
15456   if (error_found)
15457     return error_mark_node;
15458
15459   TREE_OPERAND (node, 0) = try;
15460   TREE_OPERAND (node, 1) = catch;
15461   TREE_TYPE (node) = void_type_node;
15462   return node;
15463 }
15464
15465 /* 14.17 The synchronized Statement */
15466
15467 static tree
15468 patch_synchronized_statement (tree node, tree wfl_op1)
15469 {
15470   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15471   tree block = TREE_OPERAND (node, 1);
15472
15473   tree tmp, enter, exit, expr_decl, assignment;
15474
15475   if (expr == error_mark_node)
15476     {
15477       block = java_complete_tree (block);
15478       return expr;
15479     }
15480
15481   /* We might be trying to synchronize on a STRING_CST */
15482   if ((tmp = patch_string (expr)))
15483     expr = tmp;
15484
15485   /* The TYPE of expr must be a reference type */
15486   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15487     {
15488       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15489       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15490                            lang_printable_name (TREE_TYPE (expr), 0));
15491       return error_mark_node;
15492     }
15493
15494   if (flag_emit_xref)
15495     {
15496       TREE_OPERAND (node, 0) = expr;
15497       TREE_OPERAND (node, 1) = java_complete_tree (block);
15498       CAN_COMPLETE_NORMALLY (node) = 1;
15499       return node;
15500     }
15501
15502   /* Generate a try-finally for the synchronized statement, except
15503      that the handler that catches all throw exception calls
15504      _Jv_MonitorExit and then rethrow the exception.
15505      The synchronized statement is then implemented as:
15506      TRY
15507        {
15508          _Jv_MonitorEnter (expression)
15509          synchronized_block
15510          _Jv_MonitorExit (expression)
15511        }
15512      CATCH_ALL
15513        {
15514          e = _Jv_exception_info ();
15515          _Jv_MonitorExit (expression)
15516          Throw (e);
15517        } */
15518
15519   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15520   BUILD_MONITOR_ENTER (enter, expr_decl);
15521   BUILD_MONITOR_EXIT (exit, expr_decl);
15522   CAN_COMPLETE_NORMALLY (enter) = 1;
15523   CAN_COMPLETE_NORMALLY (exit) = 1;
15524   assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15525   TREE_SIDE_EFFECTS (assignment) = 1;
15526   node = build2 (COMPOUND_EXPR, NULL_TREE,
15527                  build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15528                  build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15529   node = build_expr_block (node, expr_decl);
15530
15531   return java_complete_tree (node);
15532 }
15533
15534 /* 14.16 The throw Statement */
15535
15536 static tree
15537 patch_throw_statement (tree node, tree wfl_op1)
15538 {
15539   tree expr = TREE_OPERAND (node, 0);
15540   tree type = TREE_TYPE (expr);
15541   int unchecked_ok = 0, tryblock_throws_ok = 0;
15542
15543   /* Thrown expression must be assignable to java.lang.Throwable */
15544   if (!try_reference_assignconv (throwable_type_node, expr))
15545     {
15546       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15547       parse_error_context (wfl_operator,
15548     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15549                            lang_printable_name (type, 0));
15550       /* If the thrown expression was a reference, we further the
15551          compile-time check. */
15552       if (!JREFERENCE_TYPE_P (type))
15553         return error_mark_node;
15554     }
15555
15556   /* At least one of the following must be true */
15557
15558   /* The type of the throw expression is a not checked exception,
15559      i.e. is a unchecked expression. */
15560   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15561
15562   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15563   /* An instance can't throw a checked exception unless that exception
15564      is explicitly declared in the `throws' clause of each
15565      constructor. This doesn't apply to anonymous classes, since they
15566      don't have declared constructors. */
15567   if (!unchecked_ok
15568       && DECL_INSTINIT_P (current_function_decl)
15569       && !ANONYMOUS_CLASS_P (current_class))
15570     {
15571       tree current;
15572       for (current = TYPE_METHODS (current_class); current;
15573            current = TREE_CHAIN (current))
15574         if (DECL_CONSTRUCTOR_P (current)
15575             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15576           {
15577             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)",
15578                                  lang_printable_name (TREE_TYPE (expr), 0));
15579             return error_mark_node;
15580           }
15581     }
15582
15583   /* Throw is contained in a try statement and at least one catch
15584      clause can receive the thrown expression or the current method is
15585      declared to throw such an exception. Or, the throw statement is
15586      contained in a method or constructor declaration and the type of
15587      the Expression is assignable to at least one type listed in the
15588      throws clause the declaration. */
15589   if (!unchecked_ok)
15590     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15591   if (!(unchecked_ok || tryblock_throws_ok))
15592     {
15593       /* If there is a surrounding try block that has no matching
15594          clatch clause, report it first. A surrounding try block exits
15595          only if there is something after the list of checked
15596          exception thrown by the current function (if any). */
15597       if (IN_TRY_BLOCK_P ())
15598         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15599                              lang_printable_name (type, 0));
15600       /* If we have no surrounding try statement and the method doesn't have
15601          any throws, report it now. FIXME */
15602
15603       /* We report that the exception can't be throw from a try block
15604          in all circumstances but when the `throw' is inside a static
15605          block. */
15606       else if (!EXCEPTIONS_P (currently_caught_type_list)
15607                && !tryblock_throws_ok)
15608         {
15609           if (DECL_CLINIT_P (current_function_decl))
15610             parse_error_context (wfl_operator,
15611                    "Checked exception `%s' can't be thrown in initializer",
15612                                  lang_printable_name (type, 0));
15613           else
15614             parse_error_context (wfl_operator,
15615                    "Checked exception `%s' isn't thrown from a `try' block",
15616                                  lang_printable_name (type, 0));
15617         }
15618       /* Otherwise, the current method doesn't have the appropriate
15619          throws declaration */
15620       else
15621         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15622                              lang_printable_name (type, 0));
15623       return error_mark_node;
15624     }
15625
15626   if (! flag_emit_class_files && ! flag_emit_xref)
15627     BUILD_THROW (node, expr);
15628
15629   /* If doing xrefs, keep the location where the `throw' was seen. */
15630   if (flag_emit_xref)
15631     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15632   return node;
15633 }
15634
15635 /* Check that exception said to be thrown by method DECL can be
15636    effectively caught from where DECL is invoked.  THIS_EXPR is the
15637    expression that computes `this' for the method call.  */
15638 static void
15639 check_thrown_exceptions (int location, tree decl, tree this_expr)
15640 {
15641   tree throws;
15642   int is_array_call = 0;
15643
15644   /* Skip check within generated methods, such as access$<n>.  */
15645   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15646     return;
15647
15648   if (this_expr != NULL_TREE
15649       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15650       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15651     is_array_call = 1;
15652
15653   /* For all the unchecked exceptions thrown by DECL.  */
15654   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15655        throws = TREE_CHAIN (throws))
15656     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15657       {
15658         /* Suppress errors about cloning arrays.  */
15659         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15660           continue;
15661
15662         EXPR_WFL_LINECOL (wfl_operator) = location;
15663         if (DECL_FINIT_P (current_function_decl))
15664           parse_error_context
15665             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15666              lang_printable_name (TREE_VALUE (throws), 0));
15667         else
15668           {
15669             parse_error_context
15670               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15671                lang_printable_name (TREE_VALUE (throws), 0),
15672                (DECL_INIT_P (current_function_decl) ?
15673                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15674                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15675           }
15676       }
15677 }
15678
15679 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15680    try-catch blocks, OR is listed in the `throws' clause of the
15681    current method.  */
15682
15683 static int
15684 check_thrown_exceptions_do (tree exception)
15685 {
15686   tree list = currently_caught_type_list;
15687   resolve_and_layout (exception, NULL_TREE);
15688   /* First, all the nested try-catch-finally at that stage. The
15689      last element contains `throws' clause exceptions, if any. */
15690   if (IS_UNCHECKED_EXCEPTION_P (exception))
15691     return 1;
15692   while (list)
15693     {
15694       tree caught;
15695       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15696         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15697           return 1;
15698       list = TREE_CHAIN (list);
15699     }
15700   return 0;
15701 }
15702
15703 static void
15704 purge_unchecked_exceptions (tree mdecl)
15705 {
15706   tree throws = DECL_FUNCTION_THROWS (mdecl);
15707   tree new = NULL_TREE;
15708
15709   while (throws)
15710     {
15711       tree next = TREE_CHAIN (throws);
15712       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15713         {
15714           TREE_CHAIN (throws) = new;
15715           new = throws;
15716         }
15717       throws = next;
15718     }
15719   /* List is inverted here, but it doesn't matter */
15720   DECL_FUNCTION_THROWS (mdecl) = new;
15721 }
15722
15723 /* This function goes over all of CLASS_TYPE ctors and checks whether
15724    each of them features at least one unchecked exception in its
15725    `throws' clause. If it's the case, it returns `true', `false'
15726    otherwise.  */
15727
15728 static bool
15729 ctors_unchecked_throws_clause_p (tree class_type)
15730 {
15731   tree current;
15732
15733   for (current = TYPE_METHODS (class_type); current;
15734        current = TREE_CHAIN (current))
15735     {
15736       bool ctu = false; /* Ctor Throws Unchecked */
15737       if (DECL_CONSTRUCTOR_P (current))
15738         {
15739           tree throws;
15740           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15741                throws = TREE_CHAIN (throws))
15742             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15743               ctu = true;
15744         }
15745       /* We return false as we found one ctor that is unfit. */
15746       if (!ctu && DECL_CONSTRUCTOR_P (current))
15747         return false;
15748     }
15749   /* All ctors feature at least one unchecked exception in their
15750      `throws' clause. */
15751   return true;
15752 }
15753
15754 /* 15.24 Conditional Operator ?: */
15755
15756 static tree
15757 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15758 {
15759   tree cond = TREE_OPERAND (node, 0);
15760   tree op1 = TREE_OPERAND (node, 1);
15761   tree op2 = TREE_OPERAND (node, 2);
15762   tree resulting_type = NULL_TREE;
15763   tree t1, t2, patched;
15764   int error_found = 0;
15765
15766   /* Operands of ?: might be StringBuffers crafted as a result of a
15767      string concatenation. Obtain a descent operand here.  */
15768   if ((patched = patch_string (op1)))
15769     TREE_OPERAND (node, 1) = op1 = patched;
15770   if ((patched = patch_string (op2)))
15771     TREE_OPERAND (node, 2) = op2 = patched;
15772
15773   t1 = TREE_TYPE (op1);
15774   t2 = TREE_TYPE (op2);
15775
15776   /* The first expression must be a boolean */
15777   if (TREE_TYPE (cond) != boolean_type_node)
15778     {
15779       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15780       parse_error_context (wfl_operator,
15781                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15782                            lang_printable_name (TREE_TYPE (cond), 0));
15783       error_found = 1;
15784     }
15785
15786   /* Second and third can be numeric, boolean (i.e. primitive),
15787      references or null. Anything else results in an error */
15788   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15789         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15790             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15791         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15792     error_found = 1;
15793
15794   /* Determine the type of the conditional expression. Same types are
15795      easy to deal with */
15796   else if (t1 == t2)
15797     resulting_type = t1;
15798
15799   /* There are different rules for numeric types */
15800   else if (JNUMERIC_TYPE_P (t1))
15801     {
15802       /* if byte/short found, the resulting type is short */
15803       if ((t1 == byte_type_node && t2 == short_type_node)
15804           || (t1 == short_type_node && t2 == byte_type_node))
15805         resulting_type = short_type_node;
15806
15807       /* If t1 is a constant int and t2 is of type byte, short or char
15808          and t1's value fits in t2, then the resulting type is t2 */
15809       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15810           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15811         resulting_type = t2;
15812
15813       /* If t2 is a constant int and t1 is of type byte, short or char
15814          and t2's value fits in t1, then the resulting type is t1 */
15815       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15816           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15817         resulting_type = t1;
15818
15819       /* Otherwise, binary numeric promotion is applied and the
15820          resulting type is the promoted type of operand 1 and 2 */
15821       else
15822         resulting_type = binary_numeric_promotion (t1, t2,
15823                                                    &TREE_OPERAND (node, 1),
15824                                                    &TREE_OPERAND (node, 2));
15825     }
15826
15827   /* Cases of a reference and a null type */
15828   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15829     resulting_type = t1;
15830
15831   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15832     resulting_type = t2;
15833
15834   /* Last case: different reference types. If a type can be converted
15835      into the other one by assignment conversion, the latter
15836      determines the type of the expression */
15837   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15838     resulting_type = promote_type (t1);
15839
15840   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15841     resulting_type = promote_type (t2);
15842
15843   /* If we don't have any resulting type, we're in trouble */
15844   if (!resulting_type)
15845     {
15846       char *t = xstrdup (lang_printable_name (t1, 0));
15847       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15848       parse_error_context (wfl_operator,
15849                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15850                            t, lang_printable_name (t2, 0));
15851       free (t);
15852       error_found = 1;
15853     }
15854
15855   if (error_found)
15856     {
15857       TREE_TYPE (node) = error_mark_node;
15858       return error_mark_node;
15859     }
15860
15861   TREE_TYPE (node) = resulting_type;
15862   TREE_SET_CODE (node, COND_EXPR);
15863   CAN_COMPLETE_NORMALLY (node) = 1;
15864   return node;
15865 }
15866
15867 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15868
15869 static tree
15870 maybe_build_class_init_for_field (tree decl, tree expr)
15871 {
15872   tree clas = DECL_CONTEXT (decl);
15873   if (flag_emit_class_files || flag_emit_xref)
15874     return expr;
15875
15876   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15877       && FIELD_FINAL (decl))
15878     {
15879       tree init = DECL_INITIAL (decl);
15880       if (init != NULL_TREE)
15881         init = fold_constant_for_init (init, decl);
15882       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15883         return expr;
15884     }
15885
15886   return build_class_init (clas, expr);
15887 }
15888
15889 /* Try to constant fold NODE.
15890    If NODE is not a constant expression, return NULL_EXPR.
15891    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15892
15893 static tree
15894 fold_constant_for_init (tree node, tree context)
15895 {
15896   tree op0, op1, val;
15897   enum tree_code code = TREE_CODE (node);
15898
15899   switch (code)
15900     {
15901     case INTEGER_CST:
15902       if (node == null_pointer_node)
15903         return NULL_TREE;
15904     case STRING_CST:
15905     case REAL_CST:
15906       return node;
15907
15908     case PLUS_EXPR:
15909     case MINUS_EXPR:
15910     case MULT_EXPR:
15911     case TRUNC_MOD_EXPR:
15912     case RDIV_EXPR:
15913     case LSHIFT_EXPR:
15914     case RSHIFT_EXPR:
15915     case URSHIFT_EXPR:
15916     case BIT_AND_EXPR:
15917     case BIT_XOR_EXPR:
15918     case BIT_IOR_EXPR:
15919     case TRUTH_ANDIF_EXPR:
15920     case TRUTH_ORIF_EXPR:
15921     case EQ_EXPR:
15922     case NE_EXPR:
15923     case GT_EXPR:
15924     case GE_EXPR:
15925     case LT_EXPR:
15926     case LE_EXPR:
15927       op0 = TREE_OPERAND (node, 0);
15928       op1 = TREE_OPERAND (node, 1);
15929       val = fold_constant_for_init (op0, context);
15930       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15931         return NULL_TREE;
15932       TREE_OPERAND (node, 0) = val;
15933       val = fold_constant_for_init (op1, context);
15934       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15935         return NULL_TREE;
15936       TREE_OPERAND (node, 1) = val;
15937       return patch_binop (node, op0, op1);
15938
15939     case UNARY_PLUS_EXPR:
15940     case NEGATE_EXPR:
15941     case TRUTH_NOT_EXPR:
15942     case BIT_NOT_EXPR:
15943     case CONVERT_EXPR:
15944       op0 = TREE_OPERAND (node, 0);
15945       val = fold_constant_for_init (op0, context);
15946       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15947         return NULL_TREE;
15948       TREE_OPERAND (node, 0) = val;
15949       val = patch_unaryop (node, op0);
15950       if (! TREE_CONSTANT (val))
15951         return NULL_TREE;
15952       return val;
15953
15954       break;
15955
15956     case COND_EXPR:
15957       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
15958       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15959         return NULL_TREE;
15960       TREE_OPERAND (node, 0) = val;
15961       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
15962       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15963         return NULL_TREE;
15964       TREE_OPERAND (node, 1) = val;
15965       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
15966       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15967         return NULL_TREE;
15968       TREE_OPERAND (node, 2) = val;
15969       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
15970         : TREE_OPERAND (node, 2);
15971
15972     case VAR_DECL:
15973     case FIELD_DECL:
15974       if (! FIELD_FINAL (node)
15975           || DECL_INITIAL (node) == NULL_TREE)
15976         return NULL_TREE;
15977       val = DECL_INITIAL (node);
15978       /* Guard against infinite recursion. */
15979       DECL_INITIAL (node) = NULL_TREE;
15980       val = fold_constant_for_init (val, node);
15981       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
15982         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
15983       DECL_INITIAL (node) = val;
15984       return val;
15985
15986     case EXPR_WITH_FILE_LOCATION:
15987       /* Compare java_complete_tree and resolve_expression_name. */
15988       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
15989           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15990         {
15991           tree name = EXPR_WFL_NODE (node);
15992           tree decl;
15993           if (PRIMARY_P (node))
15994             return NULL_TREE;
15995           else if (! QUALIFIED_P (name))
15996             {
15997               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
15998               if (decl == NULL_TREE
15999                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16000                 return NULL_TREE;
16001               return fold_constant_for_init (decl, decl);
16002             }
16003           else
16004             {
16005               tree r = NULL_TREE;
16006               /* Install the proper context for the field resolution.  */
16007               tree saved_current_class = current_class;
16008               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16009               current_class = DECL_CONTEXT (context);
16010               qualify_ambiguous_name (node);
16011               r = resolve_field_access (node, &decl, NULL);
16012               /* Restore prior context.  */
16013               current_class = saved_current_class;
16014               if (r != error_mark_node && decl != NULL_TREE)
16015                 return fold_constant_for_init (decl, decl);
16016               return NULL_TREE;
16017             }
16018         }
16019       else
16020         {
16021           op0 = TREE_OPERAND (node, 0);
16022           val = fold_constant_for_init (op0, context);
16023           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16024             return NULL_TREE;
16025           TREE_OPERAND (node, 0) = val;
16026           return val;
16027         }
16028
16029 #ifdef USE_COMPONENT_REF
16030     case IDENTIFIER:
16031     case COMPONENT_REF:
16032       ?;
16033 #endif
16034
16035     default:
16036       return NULL_TREE;
16037     }
16038 }
16039
16040 #ifdef USE_COMPONENT_REF
16041 /* Context is 'T' for TypeName, 'P' for PackageName,
16042    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16043
16044 tree
16045 resolve_simple_name (tree name, int context)
16046 {
16047 }
16048
16049 tree
16050 resolve_qualified_name (tree name, int context)
16051 {
16052 }
16053 #endif
16054
16055 void
16056 init_src_parse (void)
16057 {
16058   /* Sanity check; we've been bit by this before.  */
16059   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16060     abort ();
16061 }
16062
16063 \f
16064
16065 /* This section deals with the functions that are called when tables
16066    recording class initialization information are traversed.  */
16067
16068 /* Attach to PTR (a block) the declaration found in ENTRY. */
16069
16070 static int
16071 attach_init_test_initialization_flags (void **entry, void *ptr)
16072 {
16073   tree block = (tree)ptr;
16074   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16075
16076   if (block != error_mark_node)
16077     {
16078       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16079       BLOCK_EXPR_DECLS (block) = ite->value;
16080     }
16081   return true;
16082 }
16083
16084 /* This function is called for each class that is known definitely
16085    initialized when a given static method was called. This function
16086    augments a compound expression (INFO) storing all assignment to
16087    initialized static class flags if a flag already existed, otherwise
16088    a new one is created.  */
16089
16090 static int
16091 emit_test_initialization (void **entry_p, void *info)
16092 {
16093   tree l = (tree) info;
16094   tree decl, init;
16095   tree key = (tree) *entry_p;
16096   tree *ite;
16097   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16098
16099   /* If we haven't found a flag and we're dealing with self registered
16100      with current_function_decl, then don't do anything. Self is
16101      always added as definitely initialized but this information is
16102      valid only if used outside the current function. */
16103   if (current_function_decl == TREE_PURPOSE (l)
16104       && java_treetreehash_find (cf_ht, key) == NULL)
16105     return true;
16106
16107   ite = java_treetreehash_new (cf_ht, key);
16108
16109   /* If we don't have a variable, create one and install it. */
16110   if (*ite == NULL)
16111     {
16112       tree block;
16113
16114       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16115       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16116       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16117       DECL_CONTEXT (decl) = current_function_decl;
16118       DECL_INITIAL (decl) = boolean_true_node;
16119       /* Don't emit any symbolic debugging info for this decl.  */
16120       DECL_IGNORED_P (decl) = 1;
16121
16122       /* The trick is to find the right context for it. */
16123       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16124       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16125       BLOCK_EXPR_DECLS (block) = decl;
16126       *ite = decl;
16127     }
16128   else
16129     decl = *ite;
16130
16131   /* Now simply augment the compound that holds all the assignments
16132      pertaining to this method invocation. */
16133   init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16134   TREE_SIDE_EFFECTS (init) = 1;
16135   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16136   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16137
16138   return true;
16139 }
16140
16141 #include "gt-java-parse.h"
16142 #include "gtype-java.h"