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 void  classitf_redefinition_error (const char *,tree, tree, tree);
  80 static void  variable_redefinition_error (tree, tree, tree, int);
  81 static tree  create_class (int, tree, tree, tree);
  82 static tree  create_interface (int, tree, tree);
  83 static void  end_class_declaration (int);
  84 static tree  find_field (tree, tree);
  85 static tree lookup_field_wrapper (tree, tree);
  86 static int   duplicate_declaration_error_p (tree, tree, tree);
  87 static void  register_fields (int, tree, tree);
  88 static tree parser_qualified_classname (tree);
  89 static int  parser_check_super (tree, tree, tree);
  90 static int  parser_check_super_interface (tree, tree, tree);
  91 static void check_modifiers_consistency (int);
  92 static tree lookup_cl (tree);
  93 static tree lookup_java_method2 (tree, tree, int);
  94 static tree method_header (int, tree, tree, tree);
  95 static void fix_method_argument_names (tree ,tree);
  96 static tree method_declarator (tree, tree);
  97 static void parse_warning_context (tree cl, const char *msg, ...)
  98   ATTRIBUTE_PRINTF_2;
  99 static void issue_warning_error_from_context (tree, const char *msg, va_list)
 100   ATTRIBUTE_PRINTF (2, 0);
 101 static void parse_ctor_invocation_error (void);
 102 static tree parse_jdk1_1_error (const char *);
 103 static void complete_class_report_errors (jdep *);
 104 static int process_imports (void);
 105 static void read_import_dir (tree);
 106 static int find_in_imports_on_demand (tree, tree);
 107 static void find_in_imports (tree, tree);
 108 static void check_inner_class_access (tree, tree, tree);
 109 static int check_pkg_class_access (tree, tree, bool);
 110 static void register_package (tree);
 111 static tree resolve_package (tree, tree *, tree *);
 112 static tree resolve_class (tree, tree, tree, tree);
 113 static void declare_local_variables (int, tree, tree);
 114 static void dump_java_tree (enum tree_dump_index, tree);
 115 static void source_start_java_method (tree);
 116 static void source_end_java_method (void);
 117 static tree find_name_in_single_imports (tree);
 118 static void check_abstract_method_header (tree);
 119 static tree lookup_java_interface_method2 (tree, tree);
 120 static tree resolve_expression_name (tree, tree *);
 121 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 122 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 123 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 124 static int breakdown_qualified (tree *, tree *, tree);
 125 static int in_same_package (tree, tree);
 126 static tree resolve_and_layout (tree, tree);
 127 static tree qualify_and_find (tree, tree, tree);
 128 static tree resolve_no_layout (tree, tree);
 129 static int invocation_mode (tree, int);
 130 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 131 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 132 static tree find_most_specific_methods_list (tree);
 133 static int argument_types_convertible (tree, tree);
 134 static tree patch_invoke (tree, tree, tree);
 135 static int maybe_use_access_method (int, tree *, tree *);
 136 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 137 static tree register_incomplete_type (int, tree, tree, tree);
 138 static tree check_inner_circular_reference (tree, tree);
 139 static tree check_circular_reference (tree);
 140 static tree obtain_incomplete_type (tree);
 141 static tree java_complete_lhs (tree);
 142 static tree java_complete_tree (tree);
 143 static tree maybe_generate_pre_expand_clinit (tree);
 144 static int analyze_clinit_body (tree, tree);
 145 static int maybe_yank_clinit (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_compound (tree, tree, tree);
 200 static tree add_stmt_to_block (tree, tree, tree);
 201 static tree patch_exit_expr (tree);
 202 static tree build_labeled_block (int, tree);
 203 static tree finish_labeled_statement (tree, tree);
 204 static tree build_bc_statement (int, int, tree);
 205 static tree patch_bc_statement (tree);
 206 static tree patch_loop_statement (tree);
 207 static tree build_new_loop (tree);
 208 static tree build_loop_body (int, tree, int);
 209 static tree finish_loop_body (int, tree, tree, int);
 210 static tree build_debugable_stmt (int, tree);
 211 static tree finish_for_loop (int, tree, tree, tree);
 212 static tree patch_switch_statement (tree);
 213 static tree string_constant_concatenation (tree, tree);
 214 static tree build_string_concatenation (tree, tree);
 215 static tree patch_string_cst (tree);
 216 static tree patch_string (tree);
 217 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 218 static tree build_assertion (int, tree, tree);
 219 static tree build_try_statement (int, tree, tree);
 220 static tree build_try_finally_statement (int, tree, tree);
 221 static tree patch_try_statement (tree);
 222 static tree patch_synchronized_statement (tree, tree);
 223 static tree patch_throw_statement (tree, tree);
 224 static void check_thrown_exceptions (int, tree, tree);
 225 static int check_thrown_exceptions_do (tree);
 226 static void purge_unchecked_exceptions (tree);
 227 static bool ctors_unchecked_throws_clause_p (tree);
 228 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 229 static void check_throws_clauses (tree, tree, tree);
 230 static void finish_method_declaration (tree);
 231 static tree build_super_invocation (tree);
 232 static int verify_constructor_circularity (tree, tree);
 233 static char *constructor_circularity_msg (tree, tree);
 234 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 235 static const char *get_printable_method_name (tree);
 236 static tree patch_conditional_expr (tree, tree, tree);
 237 static tree generate_finit (tree);
 238 static tree generate_instinit (tree);
 239 static tree build_instinit_invocation (tree);
 240 static void fix_constructors (tree);
 241 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 242 static tree craft_constructor (tree, tree);
 243 static int verify_constructor_super (tree);
 244 static tree create_artificial_method (tree, int, tree, tree, tree);
 245 static void start_artificial_method_body (tree);
 246 static void end_artificial_method_body (tree);
 247 static int check_method_redefinition (tree, tree);
 248 static int check_method_types_complete (tree);
 249 static bool hack_is_accessible_p (tree, tree);
 250 static void java_check_regular_methods (tree);
 251 static void check_interface_throws_clauses (tree, tree);
 252 static void java_check_abstract_methods (tree);
 253 static void unreachable_stmt_error (tree);
 254 static int not_accessible_field_error (tree, tree);
 255 static tree find_expr_with_wfl (tree);
 256 static void missing_return_error (tree);
 257 static tree build_new_array_init (int, tree);
 258 static tree patch_new_array_init (tree, tree);
 259 static tree maybe_build_array_element_wfl (tree);
 260 static int array_constructor_check_entry (tree, tree);
 261 static const char *purify_type_name (const char *);
 262 static tree fold_constant_for_init (tree, tree);
 263 static tree strip_out_static_field_access_decl (tree);
 264 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 265 static void static_ref_err (tree, tree, tree);
 266 static void parser_add_interface (tree, tree, tree);
 267 static void add_superinterfaces (tree, tree);
 268 static tree jdep_resolve_class (jdep *);
 269 static int note_possible_classname (const char *, int);
 270 static void java_complete_expand_classes (void);
 271 static void java_complete_expand_class (tree);
 272 static void java_complete_expand_methods (tree);
 273 static tree cut_identifier_in_qualified (tree);
 274 static tree java_stabilize_reference (tree);
 275 static tree do_unary_numeric_promotion (tree);
 276 static char * operator_string (tree);
 277 static tree do_merge_string_cste (tree, const char *, int, int);
 278 static tree merge_string_cste (tree, tree, int);
 279 static tree java_refold (tree);
 280 static int java_decl_equiv (tree, tree);
 281 static int binop_compound_p (enum tree_code);
 282 static tree search_loop (tree);
 283 static int labeled_block_contains_loop_p (tree, tree);
 284 static int check_abstract_method_definitions (int, tree, tree);
 285 static void java_check_abstract_method_definitions (tree);
 286 static void java_debug_context_do (int);
 287 static void java_parser_context_push_initialized_field (void);
 288 static void java_parser_context_pop_initialized_field (void);
 289 static tree reorder_static_initialized (tree);
 290 static void java_parser_context_suspend (void);
 291 static void java_parser_context_resume (void);
 292 static int pop_current_osb (struct parser_ctxt *);
 293
 294 /* JDK 1.1 work. FIXME */
 295
 296 static tree maybe_make_nested_class_name (tree);
 297 static int make_nested_class_name (tree);
 298 static void set_nested_class_simple_name_value (tree, int);
 299 static void link_nested_class_to_enclosing (void);
 300 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 301 static tree find_as_inner_class (tree, tree, tree);
 302 static tree find_as_inner_class_do (tree, tree);
 303 static int check_inner_class_redefinition (tree, tree);
 304
 305 static tree build_thisn_assign (void);
 306 static tree build_current_thisn (tree);
 307 static tree build_access_to_thisn (tree, tree, int);
 308 static tree maybe_build_thisn_access_method (tree);
 309
 310 static tree build_outer_field_access (tree, tree);
 311 static tree build_outer_field_access_methods (tree);
 312 static tree build_outer_field_access_expr (int, tree, tree,
 313                                                   tree, tree);
 314 static tree build_outer_method_access_method (tree);
 315 static tree build_new_access_id (void);
 316 static tree build_outer_field_access_method (tree, tree, tree,
 317                                                     tree, tree);
 318
 319 static int outer_field_access_p (tree, tree);
 320 static int outer_field_expanded_access_p (tree, tree *,
 321                                                  tree *, tree *);
 322 static tree outer_field_access_fix (tree, tree, tree);
 323 static tree build_incomplete_class_ref (int, tree);
 324 static tree patch_incomplete_class_ref (tree);
 325 static tree create_anonymous_class (int, tree);
 326 static void patch_anonymous_class (tree, tree, tree);
 327 static void add_inner_class_fields (tree, tree);
 328
 329 static tree build_dot_class_method (tree);
 330 static tree build_dot_class_method_invocation (tree, tree);
 331 static void create_new_parser_context (int);
 332 static tree maybe_build_class_init_for_field (tree, tree);
 333
 334 static int attach_init_test_initialization_flags (void **, void *);
 335 static int emit_test_initialization (void **, void *);
 336
 337 static char *string_convert_int_cst (tree);
 338
 339 /* Number of error found so far. */
 340 int java_error_count;
 341 /* Number of warning found so far. */
 342 int java_warning_count;
 343 /* Tell when not to fold, when doing xrefs */
 344 int do_not_fold;
 345 /* Cyclic inheritance report, as it can be set by layout_class */
 346 const char *cyclic_inheritance_report;
 347
 348 /* The current parser context */
 349 struct parser_ctxt *ctxp;
 350
 351 /* List of things that were analyzed for which code will be generated */
 352 struct parser_ctxt *ctxp_for_generation = NULL;
 353
 354 /* binop_lookup maps token to tree_code. It is used where binary
 355    operations are involved and required by the parser. RDIV_EXPR
 356    covers both integral/floating point division. The code is changed
 357    once the type of both operator is worked out.  */
 358
 359 static const enum tree_code binop_lookup[19] =
 360   {
 361     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 362     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 363     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 364     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 365     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 366    };
 367 #define BINOP_LOOKUP(VALUE)                                             \
 368   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 369
 370 /* This is the end index for binary operators that can also be used
 371    in compound assignments. */
 372 #define BINOP_COMPOUND_CANDIDATES 11
 373
 374 /* The "$L" identifier we use to create labels.  */
 375 static GTY(()) tree label_id;
 376
 377 /* The "StringBuffer" identifier used for the String `+' operator. */
 378 static GTY(()) tree wfl_string_buffer;
 379
 380 /* The "append" identifier used for String `+' operator.  */
 381 static GTY(()) tree wfl_append;
 382
 383 /* The "toString" identifier used for String `+' operator. */
 384 static GTY(()) tree wfl_to_string;
 385
 386 /* The "java.lang" import qualified name.  */
 387 static GTY(()) tree java_lang_id;
 388
 389 /* The generated `inst$' identifier used for generated enclosing
 390    instance/field access functions.  */
 391 static GTY(()) tree inst_id;
 392
 393 /* Context and flag for static blocks */
 394 static GTY(()) tree current_static_block;
 395
 396 /* The generated `write_parm_value$' identifier.  */
 397 static GTY(()) tree wpv_id;
 398
 399 /* The list of all packages we've seen so far */
 400 static GTY(()) tree package_list;
 401
 402 /* Hold THIS for the scope of the current method decl.  */
 403 static GTY(()) tree current_this;
 404
 405 /* Hold a list of catch clauses list. The first element of this list is
 406    the list of the catch clauses of the currently analyzed try block. */
 407 static GTY(()) tree currently_caught_type_list;
 408
 409 /* This holds a linked list of all the case labels for the current
 410    switch statement.  It is only used when checking to see if there
 411    are duplicate labels.  FIXME: probably this should just be attached
 412    to the switch itself; then it could be referenced via
 413    `ctxp->current_loop'.  */
 414 static GTY(()) tree case_label_list;
 415
 416 /* Anonymous class counter. Will be reset to 1 every time a non
 417    anonymous class gets created. */
 418 static int anonymous_class_counter = 1;
 419
 420 static GTY(()) tree src_parse_roots[1];
 421
 422 /* All classes seen from source code */
 423 #define gclass_list src_parse_roots[0]
 424
 425 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 426    line and point it out.  */
 427 /* Should point out the one that don't fit. ASCII/unicode, going
 428    backward. FIXME */
 429
 430 #define check_modifiers(__message, __value, __mask) do {        \
 431   if ((__value) & ~(__mask))                                    \
 432     {                                                           \
 433       size_t i, remainder = (__value) & ~(__mask);              \
 434       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 435         if ((1 << i) & remainder)                               \
 436           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 437                                java_accstring_lookup (1 << i)); \
 438     }                                                           \
 439 } while (0)
 440
 441 %}
 442
 443 %union {
 444   tree node;
 445   int sub_token;
 446   struct {
 447     int token;
 448     int location;
 449   } operator;
 450   int value;
 451 }
 452
 453 %{
 454 #include "lex.c"
 455 %}
 456
 457 %pure_parser
 458
 459 /* Things defined here have to match the order of what's in the
 460    binop_lookup table.  */
 461
 462 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 463 %token   LS_TK           SRS_TK          ZRS_TK
 464 %token   AND_TK          XOR_TK          OR_TK
 465 %token   BOOL_AND_TK BOOL_OR_TK
 466 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 467
 468 /* This maps to the same binop_lookup entry than the token above */
 469
 470 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 471 %token   REM_ASSIGN_TK
 472 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 473 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 474
 475
 476 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 477
 478 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 479 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 480 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 481 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 482 %token   MODIFIER_TK
 483
 484 /* Keep those two in order, too */
 485 %token   DECR_TK INCR_TK
 486
 487 /* From now one, things can be in any order */
 488
 489 %token   DEFAULT_TK      IF_TK              THROW_TK
 490 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 491 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 492 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 493 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 494 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 495 %token   SUPER_TK        WHILE_TK           CLASS_TK
 496 %token   SWITCH_TK       CONST_TK           TRY_TK
 497 %token   FOR_TK          NEW_TK             CONTINUE_TK
 498 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 499 %token   ASSERT_TK
 500
 501 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 502 %token   CHAR_TK         INTEGRAL_TK
 503
 504 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 505
 506 %token   ID_TK
 507
 508 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 509
 510 %token   ASSIGN_ANY_TK   ASSIGN_TK
 511 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 512
 513 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 514 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 515
 516 %type    <value>        modifiers MODIFIER_TK final synchronized
 517
 518 %type    <node>         super ID_TK identifier
 519 %type    <node>         name simple_name qualified_name
 520 %type    <node>         type_declaration compilation_unit
 521                         field_declaration method_declaration extends_interfaces
 522                         interfaces interface_type_list
 523                         import_declarations package_declaration
 524                         type_declarations interface_body
 525                         interface_member_declaration constant_declaration
 526                         interface_member_declarations interface_type
 527                         abstract_method_declaration
 528 %type    <node>         class_body_declaration class_member_declaration
 529                         static_initializer constructor_declaration block
 530 %type    <node>         class_body_declarations constructor_header
 531 %type    <node>         class_or_interface_type class_type class_type_list
 532                         constructor_declarator explicit_constructor_invocation
 533 %type    <node>         dim_expr dim_exprs this_or_super throws
 534
 535 %type    <node>         variable_declarator_id variable_declarator
 536                         variable_declarators variable_initializer
 537                         variable_initializers constructor_body
 538                         array_initializer
 539
 540 %type    <node>         class_body block_end constructor_block_end
 541 %type    <node>         statement statement_without_trailing_substatement
 542                         labeled_statement if_then_statement label_decl
 543                         if_then_else_statement while_statement for_statement
 544                         statement_nsi labeled_statement_nsi do_statement
 545                         if_then_else_statement_nsi while_statement_nsi
 546                         for_statement_nsi statement_expression_list for_init
 547                         for_update statement_expression expression_statement
 548                         primary_no_new_array expression primary
 549                         array_creation_expression array_type
 550                         class_instance_creation_expression field_access
 551                         method_invocation array_access something_dot_new
 552                         argument_list postfix_expression while_expression
 553                         post_increment_expression post_decrement_expression
 554                         unary_expression_not_plus_minus unary_expression
 555                         pre_increment_expression pre_decrement_expression
 556                         cast_expression
 557                         multiplicative_expression additive_expression
 558                         shift_expression relational_expression
 559                         equality_expression and_expression
 560                         exclusive_or_expression inclusive_or_expression
 561                         conditional_and_expression conditional_or_expression
 562                         conditional_expression assignment_expression
 563                         left_hand_side assignment for_header for_begin
 564                         constant_expression do_statement_begin empty_statement
 565                         switch_statement synchronized_statement throw_statement
 566                         try_statement assert_statement
 567                         switch_expression switch_block
 568                         catches catch_clause catch_clause_parameter finally
 569                         anonymous_class_creation trap_overflow_corner_case
 570 %type    <node>         return_statement break_statement continue_statement
 571
 572 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 573 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 574 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 575 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 576 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 577 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 578 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 579 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 580 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 581 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 582 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 583 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 584 %type    <operator>     NEW_TK ASSERT_TK
 585
 586 %type    <node>         method_body
 587
 588 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 589                         STRING_LIT_TK NULL_TK VOID_TK
 590
 591 %type    <node>         IF_TK WHILE_TK FOR_TK
 592
 593 %type    <node>         formal_parameter_list formal_parameter
 594                         method_declarator method_header
 595
 596 %type    <node>         primitive_type reference_type type
 597                         BOOLEAN_TK INTEGRAL_TK FP_TK
 598
 599 /* Added or modified JDK 1.1 rule types  */
 600 %type    <node>         type_literals
 601
 602 %%
 603 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 604 goal:  compilation_unit
 605                 {}
 606 ;
 607
 608 /* 19.3 Productions from 3: Lexical structure  */
 609 literal:
 610         INT_LIT_TK
 611 |       FP_LIT_TK
 612 |       BOOL_LIT_TK
 613 |       CHAR_LIT_TK
 614 |       STRING_LIT_TK
 615 |       NULL_TK
 616 ;
 617
 618 /* 19.4 Productions from 4: Types, Values and Variables  */
 619 type:
 620         primitive_type
 621 |       reference_type
 622 ;
 623
 624 primitive_type:
 625         INTEGRAL_TK
 626 |       FP_TK
 627 |       BOOLEAN_TK
 628 ;
 629
 630 reference_type:
 631         class_or_interface_type
 632 |       array_type
 633 ;
 634
 635 class_or_interface_type:
 636         name
 637 ;
 638
 639 class_type:
 640         class_or_interface_type /* Default rule */
 641 ;
 642
 643 interface_type:
 644          class_or_interface_type
 645 ;
 646
 647 array_type:
 648         primitive_type dims
 649                 {
 650                   int osb = pop_current_osb (ctxp);
 651                   tree t = build_java_array_type (($1), -1);
 652                   while (--osb)
 653                     t = build_unresolved_array_type (t);
 654                   $$ = t;
 655                 }
 656 |       name dims
 657                 {
 658                   int osb = pop_current_osb (ctxp);
 659                   tree t = $1;
 660                   while (osb--)
 661                     t = build_unresolved_array_type (t);
 662                   $$ = t;
 663                 }
 664 ;
 665
 666 /* 19.5 Productions from 6: Names  */
 667 name:
 668         simple_name             /* Default rule */
 669 |       qualified_name          /* Default rule */
 670 ;
 671
 672 simple_name:
 673         identifier              /* Default rule */
 674 ;
 675
 676 qualified_name:
 677         name DOT_TK identifier
 678                 { $$ = make_qualified_name ($1, $3, $2.location); }
 679 ;
 680
 681 identifier:
 682         ID_TK
 683 ;
 684
 685 /* 19.6: Production from 7: Packages  */
 686 compilation_unit:
 687                 {$$ = NULL;}
 688 |       package_declaration
 689 |       import_declarations
 690 |       type_declarations
 691 |       package_declaration import_declarations
 692 |       package_declaration type_declarations
 693 |       import_declarations type_declarations
 694 |       package_declaration import_declarations type_declarations
 695 ;
 696
 697 import_declarations:
 698         import_declaration
 699                 {
 700                   $$ = NULL;
 701                 }
 702 |       import_declarations import_declaration
 703                 {
 704                   $$ = NULL;
 705                 }
 706 ;
 707
 708 type_declarations:
 709         type_declaration
 710 |       type_declarations type_declaration
 711 ;
 712
 713 package_declaration:
 714         PACKAGE_TK name SC_TK
 715                 {
 716                   ctxp->package = EXPR_WFL_NODE ($2);
 717                   register_package (ctxp->package);
 718                 }
 719 |       PACKAGE_TK error
 720                 {yyerror ("Missing name"); RECOVER;}
 721 |       PACKAGE_TK name error
 722                 {yyerror ("';' expected"); RECOVER;}
 723 ;
 724
 725 import_declaration:
 726         single_type_import_declaration
 727 |       type_import_on_demand_declaration
 728 ;
 729
 730 single_type_import_declaration:
 731         IMPORT_TK name SC_TK
 732                 {
 733                   tree name = EXPR_WFL_NODE ($2), last_name;
 734                   int   i = IDENTIFIER_LENGTH (name)-1;
 735                   const char *last = &IDENTIFIER_POINTER (name)[i];
 736                   while (last != IDENTIFIER_POINTER (name))
 737                     {
 738                       if (last [0] == '.')
 739                         break;
 740                       last--;
 741                     }
 742                   last_name = get_identifier (++last);
 743                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 744                     {
 745                       tree err = find_name_in_single_imports (last_name);
 746                       if (err && err != name)
 747                         parse_error_context
 748                           ($2, "Ambiguous class: `%s' and `%s'",
 749                            IDENTIFIER_POINTER (name),
 750                            IDENTIFIER_POINTER (err));
 751                       else
 752                         REGISTER_IMPORT ($2, last_name);
 753                     }
 754                   else
 755                     REGISTER_IMPORT ($2, last_name);
 756                 }
 757 |       IMPORT_TK error
 758                 {yyerror ("Missing name"); RECOVER;}
 759 |       IMPORT_TK name error
 760                 {yyerror ("';' expected"); RECOVER;}
 761 ;
 762
 763 type_import_on_demand_declaration:
 764         IMPORT_TK name DOT_TK MULT_TK SC_TK
 765                 {
 766                   tree name = EXPR_WFL_NODE ($2);
 767                   tree it;
 768                   /* Search for duplicates. */
 769                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 770                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 771                       break;
 772                   /* Don't import the same thing more than once, just ignore
 773                      duplicates (7.5.2) */
 774                   if (! it)
 775                     {
 776                       read_import_dir ($2);
 777                       ctxp->import_demand_list =
 778                         chainon (ctxp->import_demand_list,
 779                                  build_tree_list ($2, NULL_TREE));
 780                     }
 781                 }
 782 |       IMPORT_TK name DOT_TK error
 783                 {yyerror ("'*' expected"); RECOVER;}
 784 |       IMPORT_TK name DOT_TK MULT_TK error
 785                 {yyerror ("';' expected"); RECOVER;}
 786 ;
 787
 788 type_declaration:
 789         class_declaration
 790                 { end_class_declaration (0); }
 791 |       interface_declaration
 792                 { end_class_declaration (0); }
 793 |       empty_statement
 794 |       error
 795                 {
 796                   YYERROR_NOW;
 797                   yyerror ("Class or interface declaration expected");
 798                 }
 799 ;
 800
 801 /* 19.7 Shortened from the original:
 802    modifiers: modifier | modifiers modifier
 803    modifier: any of public...  */
 804 modifiers:
 805         MODIFIER_TK
 806                 {
 807                   $$ = (1 << $1);
 808                 }
 809 |       modifiers MODIFIER_TK
 810                 {
 811                   int acc = (1 << $2);
 812                   if ($$ & acc)
 813                     parse_error_context
 814                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 815                        java_accstring_lookup (acc));
 816                   else
 817                     {
 818                       $$ |= acc;
 819                     }
 820                 }
 821 ;
 822
 823 /* 19.8.1 Production from $8.1: Class Declaration */
 824 class_declaration:
 825         modifiers CLASS_TK identifier super interfaces
 826                 { create_class ($1, $3, $4, $5); }
 827         class_body
 828                 {;}
 829 |       CLASS_TK identifier super interfaces
 830                 { create_class (0, $2, $3, $4); }
 831         class_body
 832                 {;}
 833 |       modifiers CLASS_TK error
 834                 { yyerror ("Missing class name"); RECOVER; }
 835 |       CLASS_TK error
 836                 { yyerror ("Missing class name"); RECOVER; }
 837 |       CLASS_TK identifier error
 838                 {
 839                   if (!ctxp->class_err) yyerror ("'{' expected");
 840                   DRECOVER(class1);
 841                 }
 842 |       modifiers CLASS_TK identifier error
 843                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 844 ;
 845
 846 super:
 847                 { $$ = NULL; }
 848 |       EXTENDS_TK class_type
 849                 { $$ = $2; }
 850 |       EXTENDS_TK class_type error
 851                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 852 |       EXTENDS_TK error
 853                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 854 ;
 855
 856 interfaces:
 857                 { $$ = NULL_TREE; }
 858 |       IMPLEMENTS_TK interface_type_list
 859                 { $$ = $2; }
 860 |       IMPLEMENTS_TK error
 861                 {
 862                   ctxp->class_err=1;
 863                   yyerror ("Missing interface name");
 864                 }
 865 ;
 866
 867 interface_type_list:
 868         interface_type
 869                 {
 870                   ctxp->interface_number = 1;
 871                   $$ = build_tree_list ($1, NULL_TREE);
 872                 }
 873 |       interface_type_list C_TK interface_type
 874                 {
 875                   ctxp->interface_number++;
 876                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 877                 }
 878 |       interface_type_list C_TK error
 879                 {yyerror ("Missing interface name"); RECOVER;}
 880 ;
 881
 882 class_body:
 883         OCB_TK CCB_TK
 884                 {
 885                   /* Store the location of the `}' when doing xrefs */
 886                   if (flag_emit_xref)
 887                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 888                       EXPR_WFL_ADD_COL ($2.location, 1);
 889                   $$ = GET_CPC ();
 890                 }
 891 |       OCB_TK class_body_declarations CCB_TK
 892                 {
 893                   /* Store the location of the `}' when doing xrefs */
 894                   if (flag_emit_xref)
 895                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 896                       EXPR_WFL_ADD_COL ($3.location, 1);
 897                   $$ = GET_CPC ();
 898                 }
 899 ;
 900
 901 class_body_declarations:
 902         class_body_declaration
 903 |       class_body_declarations class_body_declaration
 904 ;
 905
 906 class_body_declaration:
 907         class_member_declaration
 908 |       static_initializer
 909 |       constructor_declaration
 910 |       block                   /* Added, JDK1.1, instance initializer */
 911                 {
 912                   if ($1 != empty_stmt_node)
 913                     {
 914                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 915                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 916                     }
 917                 }
 918 ;
 919
 920 class_member_declaration:
 921         field_declaration
 922 |       method_declaration
 923 |       class_declaration       /* Added, JDK1.1 inner classes */
 924                 { end_class_declaration (1); }
 925 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 926                 { end_class_declaration (1); }
 927 |       empty_statement
 928 ;
 929
 930 /* 19.8.2 Productions from 8.3: Field Declarations  */
 931 field_declaration:
 932         type variable_declarators SC_TK
 933                 { register_fields (0, $1, $2); }
 934 |       modifiers type variable_declarators SC_TK
 935                 {
 936                   check_modifiers
 937                     ("Illegal modifier `%s' for field declaration",
 938                      $1, FIELD_MODIFIERS);
 939                   check_modifiers_consistency ($1);
 940                   register_fields ($1, $2, $3);
 941                 }
 942 ;
 943
 944 variable_declarators:
 945         /* Should we use build_decl_list () instead ? FIXME */
 946         variable_declarator     /* Default rule */
 947 |       variable_declarators C_TK variable_declarator
 948                 { $$ = chainon ($1, $3); }
 949 |       variable_declarators C_TK error
 950                 {yyerror ("Missing term"); RECOVER;}
 951 ;
 952
 953 variable_declarator:
 954         variable_declarator_id
 955                 { $$ = build_tree_list ($1, NULL_TREE); }
 956 |       variable_declarator_id ASSIGN_TK variable_initializer
 957                 {
 958                   if (java_error_count)
 959                     $3 = NULL_TREE;
 960                   $$ = build_tree_list
 961                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 962                 }
 963 |       variable_declarator_id ASSIGN_TK error
 964                 {
 965                   yyerror ("Missing variable initializer");
 966                   $$ = build_tree_list ($1, NULL_TREE);
 967                   RECOVER;
 968                 }
 969 |       variable_declarator_id ASSIGN_TK variable_initializer error
 970                 {
 971                   yyerror ("';' expected");
 972                   $$ = build_tree_list ($1, NULL_TREE);
 973                   RECOVER;
 974                 }
 975 ;
 976
 977 variable_declarator_id:
 978         identifier
 979 |       variable_declarator_id OSB_TK CSB_TK
 980                 { $$ = build_unresolved_array_type ($1); }
 981 |       identifier error
 982                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 983 |       variable_declarator_id OSB_TK error
 984                 {
 985                   yyerror ("']' expected");
 986                   DRECOVER(vdi);
 987                 }
 988 |       variable_declarator_id CSB_TK error
 989                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 990 ;
 991
 992 variable_initializer:
 993         expression
 994 |       array_initializer
 995 ;
 996
 997 /* 19.8.3 Productions from 8.4: Method Declarations  */
 998 method_declaration:
 999         method_header
1000                 {
1001                   current_function_decl = $1;
1002                   if (current_function_decl
1003                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1004                     source_start_java_method (current_function_decl);
1005                   else
1006                     current_function_decl = NULL_TREE;
1007                 }
1008         method_body
1009                 { finish_method_declaration ($3); }
1010 |       method_header error
1011                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1012 ;
1013
1014 method_header:
1015         type method_declarator throws
1016                 { $$ = method_header (0, $1, $2, $3); }
1017 |       VOID_TK method_declarator throws
1018                 { $$ = method_header (0, void_type_node, $2, $3); }
1019 |       modifiers type method_declarator throws
1020                 { $$ = method_header ($1, $2, $3, $4); }
1021 |       modifiers VOID_TK method_declarator throws
1022                 { $$ = method_header ($1, void_type_node, $3, $4); }
1023 |       type error
1024                 {
1025                   yyerror ("Invalid method declaration, method name required");
1026                   RECOVER;
1027                 }
1028 |       modifiers type error
1029                 {
1030                   yyerror ("Identifier expected");
1031                   RECOVER;
1032                 }
1033 |       VOID_TK error
1034                 {
1035                   yyerror ("Identifier expected");
1036                   RECOVER;
1037                 }
1038 |       modifiers VOID_TK error
1039                 {
1040                   yyerror ("Identifier expected");
1041                   RECOVER;
1042                 }
1043 |       modifiers error
1044                 {
1045                   yyerror ("Invalid method declaration, return type required");
1046                   RECOVER;
1047                 }
1048 ;
1049
1050 method_declarator:
1051         identifier OP_TK CP_TK
1052                 {
1053                   ctxp->formal_parameter_number = 0;
1054                   $$ = method_declarator ($1, NULL_TREE);
1055                 }
1056 |       identifier OP_TK formal_parameter_list CP_TK
1057                 { $$ = method_declarator ($1, $3); }
1058 |       method_declarator OSB_TK CSB_TK
1059                 {
1060                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1061                   TREE_PURPOSE ($1) =
1062                     build_unresolved_array_type (TREE_PURPOSE ($1));
1063                   parse_warning_context
1064                     (wfl_operator,
1065                      "Discouraged form of returned type specification");
1066                 }
1067 |       identifier OP_TK error
1068                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1069 |       method_declarator OSB_TK error
1070                 {yyerror ("']' expected"); RECOVER;}
1071 ;
1072
1073 formal_parameter_list:
1074         formal_parameter
1075                 {
1076                   ctxp->formal_parameter_number = 1;
1077                 }
1078 |       formal_parameter_list C_TK formal_parameter
1079                 {
1080                   ctxp->formal_parameter_number += 1;
1081                   $$ = chainon ($1, $3);
1082                 }
1083 |       formal_parameter_list C_TK error
1084                 { yyerror ("Missing formal parameter term"); RECOVER; }
1085 ;
1086
1087 formal_parameter:
1088         type variable_declarator_id
1089                 {
1090                   $$ = build_tree_list ($2, $1);
1091                 }
1092 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1093                 {
1094                   $$ = build_tree_list ($3, $2);
1095                   ARG_FINAL_P ($$) = 1;
1096                 }
1097 |       type error
1098                 {
1099                   yyerror ("Missing identifier"); RECOVER;
1100                   $$ = NULL_TREE;
1101                 }
1102 |       final type error
1103                 {
1104                   yyerror ("Missing identifier"); RECOVER;
1105                   $$ = NULL_TREE;
1106                 }
1107 ;
1108
1109 final:
1110         modifiers
1111                 {
1112                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1113                                    $1, ACC_FINAL);
1114                   if ($1 != ACC_FINAL)
1115                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1116                 }
1117 ;
1118
1119 throws:
1120                 { $$ = NULL_TREE; }
1121 |       THROWS_TK class_type_list
1122                 { $$ = $2; }
1123 |       THROWS_TK error
1124                 {yyerror ("Missing class type term"); RECOVER;}
1125 ;
1126
1127 class_type_list:
1128         class_type
1129                 { $$ = build_tree_list ($1, $1); }
1130 |       class_type_list C_TK class_type
1131                 { $$ = tree_cons ($3, $3, $1); }
1132 |       class_type_list C_TK error
1133                 {yyerror ("Missing class type term"); RECOVER;}
1134 ;
1135
1136 method_body:
1137         block
1138 |       SC_TK { $$ = NULL_TREE; }
1139 ;
1140
1141 /* 19.8.4 Productions from 8.5: Static Initializers  */
1142 static_initializer:
1143         static block
1144                 {
1145                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1146                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1147                   current_static_block = NULL_TREE;
1148                 }
1149 ;
1150
1151 static:                         /* Test lval.sub_token here */
1152         modifiers
1153                 {
1154                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1155                   /* Can't have a static initializer in an innerclass */
1156                   if ($1 | ACC_STATIC &&
1157                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1158                     parse_error_context
1159                       (MODIFIER_WFL (STATIC_TK),
1160                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1161                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1162                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1163                 }
1164 ;
1165
1166 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1167 constructor_declaration:
1168         constructor_header
1169                 {
1170                   current_function_decl = $1;
1171                   source_start_java_method (current_function_decl);
1172                 }
1173         constructor_body
1174                 { finish_method_declaration ($3); }
1175 ;
1176
1177 constructor_header:
1178         constructor_declarator throws
1179                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1180 |       modifiers constructor_declarator throws
1181                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1182 ;
1183
1184 constructor_declarator:
1185         simple_name OP_TK CP_TK
1186                 {
1187                   ctxp->formal_parameter_number = 0;
1188                   $$ = method_declarator ($1, NULL_TREE);
1189                 }
1190 |       simple_name OP_TK formal_parameter_list CP_TK
1191                 { $$ = method_declarator ($1, $3); }
1192 ;
1193
1194 constructor_body:
1195         /* Unlike regular method, we always need a complete (empty)
1196            body so we can safely perform all the required code
1197            addition (super invocation and field initialization) */
1198         block_begin constructor_block_end
1199                 {
1200                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1201                   $$ = $2;
1202                 }
1203 |       block_begin explicit_constructor_invocation constructor_block_end
1204                 { $$ = $3; }
1205 |       block_begin block_statements constructor_block_end
1206                 { $$ = $3; }
1207 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1208                 { $$ = $4; }
1209 ;
1210
1211 constructor_block_end:
1212         block_end
1213 ;
1214
1215 /* Error recovery for that rule moved down expression_statement: rule.  */
1216 explicit_constructor_invocation:
1217         this_or_super OP_TK CP_TK SC_TK
1218                 {
1219                   $$ = build_method_invocation ($1, NULL_TREE);
1220                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1221                   $$ = java_method_add_stmt (current_function_decl, $$);
1222                 }
1223 |       this_or_super OP_TK argument_list CP_TK SC_TK
1224                 {
1225                   $$ = build_method_invocation ($1, $3);
1226                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1227                   $$ = java_method_add_stmt (current_function_decl, $$);
1228                 }
1229         /* Added, JDK1.1 inner classes. Modified because the rule
1230            'primary' couldn't work.  */
1231 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1232                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1233 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1234                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1235 ;
1236
1237 this_or_super:                  /* Added, simplifies error diagnostics */
1238         THIS_TK
1239                 {
1240                   tree wfl = build_wfl_node (this_identifier_node);
1241                   EXPR_WFL_LINECOL (wfl) = $1.location;
1242                   $$ = wfl;
1243                 }
1244 |       SUPER_TK
1245                 {
1246                   tree wfl = build_wfl_node (super_identifier_node);
1247                   EXPR_WFL_LINECOL (wfl) = $1.location;
1248                   $$ = wfl;
1249                 }
1250 ;
1251
1252 /* 19.9 Productions from 9: Interfaces  */
1253 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1254 interface_declaration:
1255         INTERFACE_TK identifier
1256                 { create_interface (0, $2, NULL_TREE); }
1257         interface_body
1258                 { ; }
1259 |       modifiers INTERFACE_TK identifier
1260                 { create_interface ($1, $3, NULL_TREE); }
1261         interface_body
1262                 { ; }
1263 |       INTERFACE_TK identifier extends_interfaces
1264                 { create_interface (0, $2, $3); }
1265         interface_body
1266                 { ; }
1267 |       modifiers INTERFACE_TK identifier extends_interfaces
1268                 { create_interface ($1, $3, $4); }
1269         interface_body
1270                 { ; }
1271 |       INTERFACE_TK identifier error
1272                 { yyerror ("'{' expected"); RECOVER; }
1273 |       modifiers INTERFACE_TK identifier error
1274                 { yyerror ("'{' expected"); RECOVER; }
1275 ;
1276
1277 extends_interfaces:
1278         EXTENDS_TK interface_type
1279                 {
1280                   ctxp->interface_number = 1;
1281                   $$ = build_tree_list ($2, NULL_TREE);
1282                 }
1283 |       extends_interfaces C_TK interface_type
1284                 {
1285                   ctxp->interface_number++;
1286                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1287                 }
1288 |       EXTENDS_TK error
1289                 {yyerror ("Invalid interface type"); RECOVER;}
1290 |       extends_interfaces C_TK error
1291                 {yyerror ("Missing term"); RECOVER;}
1292 ;
1293
1294 interface_body:
1295         OCB_TK CCB_TK
1296                 { $$ = NULL_TREE; }
1297 |       OCB_TK interface_member_declarations CCB_TK
1298                 { $$ = NULL_TREE; }
1299 ;
1300
1301 interface_member_declarations:
1302         interface_member_declaration
1303 |       interface_member_declarations interface_member_declaration
1304 ;
1305
1306 interface_member_declaration:
1307         constant_declaration
1308 |       abstract_method_declaration
1309 |       class_declaration       /* Added, JDK1.1 inner classes */
1310                 { end_class_declaration (1); }
1311 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1312                 { end_class_declaration (1); }
1313 ;
1314
1315 constant_declaration:
1316         field_declaration
1317 ;
1318
1319 abstract_method_declaration:
1320         method_header SC_TK
1321                 {
1322                   check_abstract_method_header ($1);
1323                   current_function_decl = NULL_TREE; /* FIXME ? */
1324                 }
1325 |       method_header error
1326                 {yyerror ("';' expected"); RECOVER;}
1327 ;
1328
1329 /* 19.10 Productions from 10: Arrays  */
1330 array_initializer:
1331         OCB_TK CCB_TK
1332                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1333 |       OCB_TK C_TK CCB_TK
1334                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1335 |       OCB_TK variable_initializers CCB_TK
1336                 { $$ = build_new_array_init ($1.location, $2); }
1337 |       OCB_TK variable_initializers C_TK CCB_TK
1338                 { $$ = build_new_array_init ($1.location, $2); }
1339 ;
1340
1341 variable_initializers:
1342         variable_initializer
1343                 {
1344                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1345                                   $1, NULL_TREE);
1346                 }
1347 |       variable_initializers C_TK variable_initializer
1348                 {
1349                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1350                 }
1351 |       variable_initializers C_TK error
1352                 {yyerror ("Missing term"); RECOVER;}
1353 ;
1354
1355 /* 19.11 Production from 14: Blocks and Statements  */
1356 block:
1357         block_begin block_end
1358                 { $$ = $2; }
1359 |       block_begin block_statements block_end
1360                 { $$ = $3; }
1361 ;
1362
1363 block_begin:
1364         OCB_TK
1365                 { enter_block (); }
1366 ;
1367
1368 block_end:
1369         CCB_TK
1370                 {
1371                   maybe_absorb_scoping_blocks ();
1372                   /* Store the location of the `}' when doing xrefs */
1373                   if (current_function_decl && flag_emit_xref)
1374                     DECL_END_SOURCE_LINE (current_function_decl) =
1375                       EXPR_WFL_ADD_COL ($1.location, 1);
1376                   $$ = exit_block ();
1377                   if (!BLOCK_SUBBLOCKS ($$))
1378                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1379                 }
1380 ;
1381
1382 block_statements:
1383         block_statement
1384 |       block_statements block_statement
1385 ;
1386
1387 block_statement:
1388         local_variable_declaration_statement
1389 |       statement
1390                 { java_method_add_stmt (current_function_decl, $1); }
1391 |       class_declaration       /* Added, JDK1.1 local classes */
1392                 {
1393                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1394                   end_class_declaration (1);
1395                 }
1396 ;
1397
1398 local_variable_declaration_statement:
1399         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1400 ;
1401
1402 local_variable_declaration:
1403         type variable_declarators
1404                 { declare_local_variables (0, $1, $2); }
1405 |       final type variable_declarators /* Added, JDK1.1 final locals */
1406                 { declare_local_variables ($1, $2, $3); }
1407 ;
1408
1409 statement:
1410         statement_without_trailing_substatement
1411 |       labeled_statement
1412 |       if_then_statement
1413 |       if_then_else_statement
1414 |       while_statement
1415 |       for_statement
1416                 { $$ = exit_block (); }
1417 ;
1418
1419 statement_nsi:
1420         statement_without_trailing_substatement
1421 |       labeled_statement_nsi
1422 |       if_then_else_statement_nsi
1423 |       while_statement_nsi
1424 |       for_statement_nsi
1425                 { $$ = exit_block (); }
1426 ;
1427
1428 statement_without_trailing_substatement:
1429         block
1430 |       empty_statement
1431 |       expression_statement
1432 |       switch_statement
1433 |       do_statement
1434 |       break_statement
1435 |       continue_statement
1436 |       return_statement
1437 |       synchronized_statement
1438 |       throw_statement
1439 |       try_statement
1440 |       assert_statement
1441 ;
1442
1443 empty_statement:
1444         SC_TK
1445                 {
1446                   if (flag_extraneous_semicolon
1447                       && ! current_static_block
1448                       && (! current_function_decl ||
1449                           /* Verify we're not in a inner class declaration */
1450                           (GET_CPC () != TYPE_NAME
1451                            (DECL_CONTEXT (current_function_decl)))))
1452
1453                     {
1454                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1455                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1456                     }
1457                   $$ = empty_stmt_node;
1458                 }
1459 ;
1460
1461 label_decl:
1462         identifier REL_CL_TK
1463                 {
1464                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1465                                             EXPR_WFL_NODE ($1));
1466                   pushlevel (2);
1467                   push_labeled_block ($$);
1468                   PUSH_LABELED_BLOCK ($$);
1469                 }
1470 ;
1471
1472 labeled_statement:
1473         label_decl statement
1474                 { $$ = finish_labeled_statement ($1, $2); }
1475 |       identifier error
1476                 {yyerror ("':' expected"); RECOVER;}
1477 ;
1478
1479 labeled_statement_nsi:
1480         label_decl statement_nsi
1481                 { $$ = finish_labeled_statement ($1, $2); }
1482 ;
1483
1484 /* We concentrate here a bunch of error handling rules that we couldn't write
1485    earlier, because expression_statement catches a missing ';'.  */
1486 expression_statement:
1487         statement_expression SC_TK
1488                 {
1489                   /* We have a statement. Generate a WFL around it so
1490                      we can debug it */
1491                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1492                   /* We know we have a statement, so set the debug
1493                      info to be eventually generate here. */
1494                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1495                 }
1496 |       error SC_TK
1497                 {
1498                   YYNOT_TWICE yyerror ("Invalid expression statement");
1499                   DRECOVER (expr_stmt);
1500                 }
1501 |       error OCB_TK
1502                 {
1503                   YYNOT_TWICE yyerror ("Invalid expression statement");
1504                   DRECOVER (expr_stmt);
1505                 }
1506 |       error CCB_TK
1507                 {
1508                   YYNOT_TWICE yyerror ("Invalid expression statement");
1509                   DRECOVER (expr_stmt);
1510                 }
1511 |       this_or_super OP_TK error
1512                 {yyerror ("')' expected"); RECOVER;}
1513 |       this_or_super OP_TK CP_TK error
1514                 {
1515                   parse_ctor_invocation_error ();
1516                   RECOVER;
1517                 }
1518 |       this_or_super OP_TK argument_list error
1519                 {yyerror ("')' expected"); RECOVER;}
1520 |       this_or_super OP_TK argument_list CP_TK error
1521                 {
1522                   parse_ctor_invocation_error ();
1523                   RECOVER;
1524                 }
1525 |       name DOT_TK SUPER_TK error
1526                 {yyerror ("'(' expected"); RECOVER;}
1527 |       name DOT_TK SUPER_TK OP_TK error
1528                 {yyerror ("')' expected"); RECOVER;}
1529 |       name DOT_TK SUPER_TK OP_TK argument_list error
1530                 {yyerror ("')' expected"); RECOVER;}
1531 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1532                 {yyerror ("';' expected"); RECOVER;}
1533 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1534                 {yyerror ("';' expected"); RECOVER;}
1535 ;
1536
1537 statement_expression:
1538         assignment
1539 |       pre_increment_expression
1540 |       pre_decrement_expression
1541 |       post_increment_expression
1542 |       post_decrement_expression
1543 |       method_invocation
1544 |       class_instance_creation_expression
1545 ;
1546
1547 if_then_statement:
1548         IF_TK OP_TK expression CP_TK statement
1549                 {
1550                   $$ = build_if_else_statement ($2.location, $3,
1551                                                 $5, NULL_TREE);
1552                 }
1553 |       IF_TK error
1554                 {yyerror ("'(' expected"); RECOVER;}
1555 |       IF_TK OP_TK error
1556                 {yyerror ("Missing term"); RECOVER;}
1557 |       IF_TK OP_TK expression error
1558                 {yyerror ("')' expected"); RECOVER;}
1559 ;
1560
1561 if_then_else_statement:
1562         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1563                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1564 ;
1565
1566 if_then_else_statement_nsi:
1567         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1568                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1569 ;
1570
1571 switch_statement:
1572         switch_expression
1573                 {
1574                   enter_block ();
1575                 }
1576         switch_block
1577                 {
1578                   /* Make into "proper list" of COMPOUND_EXPRs.
1579                      I.e. make the last statement also have its own
1580                      COMPOUND_EXPR. */
1581                   maybe_absorb_scoping_blocks ();
1582                   TREE_OPERAND ($1, 1) = exit_block ();
1583                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1584                 }
1585 ;
1586
1587 switch_expression:
1588         SWITCH_TK OP_TK expression CP_TK
1589                 {
1590                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1591                   EXPR_WFL_LINECOL ($$) = $2.location;
1592                 }
1593 |       SWITCH_TK error
1594                 {yyerror ("'(' expected"); RECOVER;}
1595 |       SWITCH_TK OP_TK error
1596                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1597 |       SWITCH_TK OP_TK expression CP_TK error
1598                 {yyerror ("'{' expected"); RECOVER;}
1599 ;
1600
1601 /* Default assignment is there to avoid type node on switch_block
1602    node. */
1603
1604 switch_block:
1605         OCB_TK CCB_TK
1606                 { $$ = NULL_TREE; }
1607 |       OCB_TK switch_labels CCB_TK
1608                 { $$ = NULL_TREE; }
1609 |       OCB_TK switch_block_statement_groups CCB_TK
1610                 { $$ = NULL_TREE; }
1611 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1612                 { $$ = NULL_TREE; }
1613 ;
1614
1615 switch_block_statement_groups:
1616         switch_block_statement_group
1617 |       switch_block_statement_groups switch_block_statement_group
1618 ;
1619
1620 switch_block_statement_group:
1621         switch_labels block_statements
1622 ;
1623
1624 switch_labels:
1625         switch_label
1626 |       switch_labels switch_label
1627 ;
1628
1629 switch_label:
1630         CASE_TK constant_expression REL_CL_TK
1631                 {
1632                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1633                   EXPR_WFL_LINECOL (lab) = $1.location;
1634                   java_method_add_stmt (current_function_decl, lab);
1635                 }
1636 |       DEFAULT_TK REL_CL_TK
1637                 {
1638                   tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1639                   EXPR_WFL_LINECOL (lab) = $1.location;
1640                   java_method_add_stmt (current_function_decl, lab);
1641                 }
1642 |       CASE_TK error
1643                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1644 |       CASE_TK constant_expression error
1645                 {yyerror ("':' expected"); RECOVER;}
1646 |       DEFAULT_TK error
1647                 {yyerror ("':' expected"); RECOVER;}
1648 ;
1649
1650 while_expression:
1651         WHILE_TK OP_TK expression CP_TK
1652                 {
1653                   tree body = build_loop_body ($2.location, $3, 0);
1654                   $$ = build_new_loop (body);
1655                 }
1656 ;
1657
1658 while_statement:
1659         while_expression statement
1660                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1661 |       WHILE_TK error
1662                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1663 |       WHILE_TK OP_TK error
1664                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1665 |       WHILE_TK OP_TK expression error
1666                 {yyerror ("')' expected"); RECOVER;}
1667 ;
1668
1669 while_statement_nsi:
1670         while_expression statement_nsi
1671                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1672 ;
1673
1674 do_statement_begin:
1675         DO_TK
1676                 {
1677                   tree body = build_loop_body (0, NULL_TREE, 1);
1678                   $$ = build_new_loop (body);
1679                 }
1680         /* Need error handing here. FIXME */
1681 ;
1682
1683 do_statement:
1684         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1685                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1686 ;
1687
1688 for_statement:
1689         for_begin SC_TK expression SC_TK for_update CP_TK statement
1690                 {
1691                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1692                     $3 = build_wfl_node ($3);
1693                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1694                 }
1695 |       for_begin SC_TK SC_TK for_update CP_TK statement
1696                 {
1697                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1698                   /* We have not condition, so we get rid of the EXIT_EXPR */
1699                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1700                     empty_stmt_node;
1701                 }
1702 |       for_begin SC_TK error
1703                 {yyerror ("Invalid control expression"); RECOVER;}
1704 |       for_begin SC_TK expression SC_TK error
1705                 {yyerror ("Invalid update expression"); RECOVER;}
1706 |       for_begin SC_TK SC_TK error
1707                 {yyerror ("Invalid update expression"); RECOVER;}
1708 ;
1709
1710 for_statement_nsi:
1711         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1712                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1713 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1714                 {
1715                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1716                   /* We have not condition, so we get rid of the EXIT_EXPR */
1717                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1718                     empty_stmt_node;
1719                 }
1720 ;
1721
1722 for_header:
1723         FOR_TK OP_TK
1724                 {
1725                   /* This scope defined for local variable that may be
1726                      defined within the scope of the for loop */
1727                   enter_block ();
1728                 }
1729 |       FOR_TK error
1730                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1731 |       FOR_TK OP_TK error
1732                 {yyerror ("Invalid init statement"); RECOVER;}
1733 ;
1734
1735 for_begin:
1736         for_header for_init
1737                 {
1738                   /* We now declare the loop body. The loop is
1739                      declared as a for loop. */
1740                   tree body = build_loop_body (0, NULL_TREE, 0);
1741                   $$ =  build_new_loop (body);
1742                   FOR_LOOP_P ($$) = 1;
1743                   /* The loop is added to the current block the for
1744                      statement is defined within */
1745                   java_method_add_stmt (current_function_decl, $$);
1746                 }
1747 ;
1748 for_init:                       /* Can be empty */
1749                 { $$ = empty_stmt_node; }
1750 |       statement_expression_list
1751                 {
1752                   /* Init statement recorded within the previously
1753                      defined block scope */
1754                   $$ = java_method_add_stmt (current_function_decl, $1);
1755                 }
1756 |       local_variable_declaration
1757                 {
1758                   /* Local variable are recorded within the previously
1759                      defined block scope */
1760                   $$ = NULL_TREE;
1761                 }
1762 |       statement_expression_list error
1763                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1764 ;
1765
1766 for_update:                     /* Can be empty */
1767                 {$$ = empty_stmt_node;}
1768 |       statement_expression_list
1769                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1770 ;
1771
1772 statement_expression_list:
1773         statement_expression
1774                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1775 |       statement_expression_list C_TK statement_expression
1776                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1777 |       statement_expression_list C_TK error
1778                 {yyerror ("Missing term"); RECOVER;}
1779 ;
1780
1781 break_statement:
1782         BREAK_TK SC_TK
1783                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1784 |       BREAK_TK identifier SC_TK
1785                 { $$ = build_bc_statement ($1.location, 1, $2); }
1786 |       BREAK_TK error
1787                 {yyerror ("Missing term"); RECOVER;}
1788 |       BREAK_TK identifier error
1789                 {yyerror ("';' expected"); RECOVER;}
1790 ;
1791
1792 continue_statement:
1793         CONTINUE_TK SC_TK
1794                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1795 |       CONTINUE_TK identifier SC_TK
1796                 { $$ = build_bc_statement ($1.location, 0, $2); }
1797 |       CONTINUE_TK error
1798                 {yyerror ("Missing term"); RECOVER;}
1799 |       CONTINUE_TK identifier error
1800                 {yyerror ("';' expected"); RECOVER;}
1801 ;
1802
1803 return_statement:
1804         RETURN_TK SC_TK
1805                 { $$ = build_return ($1.location, NULL_TREE); }
1806 |       RETURN_TK expression SC_TK
1807                 { $$ = build_return ($1.location, $2); }
1808 |       RETURN_TK error
1809                 {yyerror ("Missing term"); RECOVER;}
1810 |       RETURN_TK expression error
1811                 {yyerror ("';' expected"); RECOVER;}
1812 ;
1813
1814 throw_statement:
1815         THROW_TK expression SC_TK
1816                 {
1817                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1818                   EXPR_WFL_LINECOL ($$) = $1.location;
1819                 }
1820 |       THROW_TK error
1821                 {yyerror ("Missing term"); RECOVER;}
1822 |       THROW_TK expression error
1823                 {yyerror ("';' expected"); RECOVER;}
1824 ;
1825
1826 assert_statement:
1827         ASSERT_TK expression REL_CL_TK expression SC_TK
1828                 {
1829                   $$ = build_assertion ($1.location, $2, $4);
1830                 }
1831 |       ASSERT_TK expression SC_TK
1832                 {
1833                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1834                 }
1835 |       ASSERT_TK error
1836                 {yyerror ("Missing term"); RECOVER;}
1837 |       ASSERT_TK expression error
1838                 {yyerror ("';' expected"); RECOVER;}
1839 ;
1840
1841 synchronized_statement:
1842         synchronized OP_TK expression CP_TK block
1843                 {
1844                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1845                   EXPR_WFL_LINECOL ($$) =
1846                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1847                 }
1848 |       synchronized OP_TK expression CP_TK error
1849                 {yyerror ("'{' expected"); RECOVER;}
1850 |       synchronized error
1851                 {yyerror ("'(' expected"); RECOVER;}
1852 |       synchronized OP_TK error CP_TK
1853                 {yyerror ("Missing term"); RECOVER;}
1854 |       synchronized OP_TK error
1855                 {yyerror ("Missing term"); RECOVER;}
1856 ;
1857
1858 synchronized:
1859         modifiers
1860                 {
1861                   check_modifiers (
1862              "Illegal modifier `%s'. Only `synchronized' was expected here",
1863                                    $1, ACC_SYNCHRONIZED);
1864                   if ($1 != ACC_SYNCHRONIZED)
1865                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1866                       build_wfl_node (NULL_TREE);
1867                 }
1868 ;
1869
1870 try_statement:
1871         TRY_TK block catches
1872                 { $$ = build_try_statement ($1.location, $2, $3); }
1873 |       TRY_TK block finally
1874                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1875 |       TRY_TK block catches finally
1876                 { $$ = build_try_finally_statement
1877                     ($1.location, build_try_statement ($1.location,
1878                                                        $2, $3), $4);
1879                 }
1880 |       TRY_TK error
1881                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1882 ;
1883
1884 catches:
1885         catch_clause
1886 |       catches catch_clause
1887                 {
1888                   TREE_CHAIN ($2) = $1;
1889                   $$ = $2;
1890                 }
1891 ;
1892
1893 catch_clause:
1894         catch_clause_parameter block
1895                 {
1896                   java_method_add_stmt (current_function_decl, $2);
1897                   exit_block ();
1898                   $$ = $1;
1899                 }
1900 ;
1901
1902 catch_clause_parameter:
1903         CATCH_TK OP_TK formal_parameter CP_TK
1904                 {
1905                   /* We add a block to define a scope for
1906                      formal_parameter (CCBP). The formal parameter is
1907                      declared initialized by the appropriate function
1908                      call */
1909                   tree ccpb;
1910                   tree init;
1911                   if ($3)
1912                     {
1913                       ccpb = enter_block ();
1914                       init = build_assignment
1915                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1916                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1917                       declare_local_variables (0, TREE_VALUE ($3),
1918                                                build_tree_list
1919                                                (TREE_PURPOSE ($3), init));
1920                       $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1921                       EXPR_WFL_LINECOL ($$) = $1.location;
1922                     }
1923                   else
1924                     {
1925                       $$ = error_mark_node;
1926                     }
1927                 }
1928 |       CATCH_TK error
1929                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1930 |       CATCH_TK OP_TK error
1931                 {
1932                   yyerror ("Missing term or ')' expected");
1933                   RECOVER; $$ = NULL_TREE;
1934                 }
1935 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1936                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1937 ;
1938
1939 finally:
1940         FINALLY_TK block
1941                 { $$ = $2; }
1942 |       FINALLY_TK error
1943                 {yyerror ("'{' expected"); RECOVER; }
1944 ;
1945
1946 /* 19.12 Production from 15: Expressions  */
1947 primary:
1948         primary_no_new_array
1949 |       array_creation_expression
1950 ;
1951
1952 primary_no_new_array:
1953         literal
1954 |       THIS_TK
1955                 { $$ = build_this ($1.location); }
1956 |       OP_TK expression CP_TK
1957                 {$$ = $2;}
1958 |       class_instance_creation_expression
1959 |       field_access
1960 |       method_invocation
1961 |       array_access
1962 |       type_literals
1963         /* Added, JDK1.1 inner classes. Documentation is wrong
1964            refering to a 'ClassName' (class_name) rule that doesn't
1965            exist. Used name: instead.  */
1966 |       name DOT_TK THIS_TK
1967                 {
1968                   tree wfl = build_wfl_node (this_identifier_node);
1969                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1970                 }
1971 |       OP_TK expression error
1972                 {yyerror ("')' expected"); RECOVER;}
1973 |       name DOT_TK error
1974                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1975 |       primitive_type DOT_TK error
1976                 {yyerror ("'class' expected" ); RECOVER;}
1977 |       VOID_TK DOT_TK error
1978                 {yyerror ("'class' expected" ); RECOVER;}
1979 ;
1980
1981 type_literals:
1982         name DOT_TK CLASS_TK
1983                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1984 |       array_type DOT_TK CLASS_TK
1985                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1986 |       primitive_type DOT_TK CLASS_TK
1987                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1988 |       VOID_TK DOT_TK CLASS_TK
1989                 {
1990                    $$ = build_incomplete_class_ref ($2.location,
1991                                                    void_type_node);
1992                 }
1993 ;
1994
1995 class_instance_creation_expression:
1996         NEW_TK class_type OP_TK argument_list CP_TK
1997                 { $$ = build_new_invocation ($2, $4); }
1998 |       NEW_TK class_type OP_TK CP_TK
1999                 { $$ = build_new_invocation ($2, NULL_TREE); }
2000 |       anonymous_class_creation
2001         /* Added, JDK1.1 inner classes, modified to use name or
2002            primary instead of primary solely which couldn't work in
2003            all situations.  */
2004 |       something_dot_new identifier OP_TK CP_TK
2005                 {
2006                   tree ctor = build_new_invocation ($2, NULL_TREE);
2007                   $$ = make_qualified_primary ($1, ctor,
2008                                                EXPR_WFL_LINECOL ($1));
2009                 }
2010 |       something_dot_new identifier OP_TK CP_TK class_body
2011 |       something_dot_new identifier OP_TK argument_list CP_TK
2012                 {
2013                   tree ctor = build_new_invocation ($2, $4);
2014                   $$ = make_qualified_primary ($1, ctor,
2015                                                EXPR_WFL_LINECOL ($1));
2016                 }
2017 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2018 |       NEW_TK error SC_TK
2019                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2020 |       NEW_TK class_type error
2021                 {yyerror ("'(' expected"); RECOVER;}
2022 |       NEW_TK class_type OP_TK error
2023                 {yyerror ("')' or term expected"); RECOVER;}
2024 |       NEW_TK class_type OP_TK argument_list error
2025                 {yyerror ("')' expected"); RECOVER;}
2026 |       something_dot_new error
2027                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2028 |       something_dot_new identifier error
2029                 {yyerror ("'(' expected"); RECOVER;}
2030 ;
2031
2032 /* Created after JDK1.1 rules originally added to
2033    class_instance_creation_expression, but modified to use
2034    'class_type' instead of 'TypeName' (type_name) which is mentioned
2035    in the documentation but doesn't exist. */
2036
2037 anonymous_class_creation:
2038         NEW_TK class_type OP_TK argument_list CP_TK
2039                 { create_anonymous_class ($1.location, $2); }
2040         class_body
2041                 {
2042                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2043                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2044
2045                   end_class_declaration (1);
2046
2047                   /* Now we can craft the new expression */
2048                   $$ = build_new_invocation (id, $4);
2049
2050                   /* Note that we can't possibly be here if
2051                      `class_type' is an interface (in which case the
2052                      anonymous class extends Object and implements
2053                      `class_type', hence its constructor can't have
2054                      arguments.) */
2055
2056                   /* Otherwise, the innerclass must feature a
2057                      constructor matching `argument_list'. Anonymous
2058                      classes are a bit special: it's impossible to
2059                      define constructor for them, hence constructors
2060                      must be generated following the hints provided by
2061                      the `new' expression. Whether a super constructor
2062                      of that nature exists or not is to be verified
2063                      later on in verify_constructor_super.
2064
2065                      It's during the expansion of a `new' statement
2066                      refering to an anonymous class that a ctor will
2067                      be generated for the anonymous class, with the
2068                      right arguments. */
2069
2070                 }
2071 |       NEW_TK class_type OP_TK CP_TK
2072                 { create_anonymous_class ($1.location, $2); }
2073         class_body
2074                 {
2075                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2076                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2077
2078                   end_class_declaration (1);
2079
2080                   /* Now we can craft the new expression. The
2081                      statement doesn't need to be remember so that a
2082                      constructor can be generated, since its signature
2083                      is already known. */
2084                   $$ = build_new_invocation (id, NULL_TREE);
2085                 }
2086 ;
2087
2088 something_dot_new:              /* Added, not part of the specs. */
2089         name DOT_TK NEW_TK
2090                 { $$ = $1; }
2091 |       primary DOT_TK NEW_TK
2092                 { $$ = $1; }
2093 ;
2094
2095 argument_list:
2096         expression
2097                 {
2098                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2099                   ctxp->formal_parameter_number = 1;
2100                 }
2101 |       argument_list C_TK expression
2102                 {
2103                   ctxp->formal_parameter_number += 1;
2104                   $$ = tree_cons (NULL_TREE, $3, $1);
2105                 }
2106 |       argument_list C_TK error
2107                 {yyerror ("Missing term"); RECOVER;}
2108 ;
2109
2110 array_creation_expression:
2111         NEW_TK primitive_type dim_exprs
2112                 { $$ = build_newarray_node ($2, $3, 0); }
2113 |       NEW_TK class_or_interface_type dim_exprs
2114                 { $$ = build_newarray_node ($2, $3, 0); }
2115 |       NEW_TK primitive_type dim_exprs dims
2116                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2117 |       NEW_TK class_or_interface_type dim_exprs dims
2118                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2119         /* Added, JDK1.1 anonymous array. Initial documentation rule
2120            modified */
2121 |       NEW_TK class_or_interface_type dims array_initializer
2122                 {
2123                   char *sig;
2124                   int osb = pop_current_osb (ctxp);
2125                   while (osb--)
2126                     obstack_grow (&temporary_obstack, "[]", 2);
2127                   obstack_1grow (&temporary_obstack, '\0');
2128                   sig = obstack_finish (&temporary_obstack);
2129                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2130                               $2, get_identifier (sig), $4);
2131                 }
2132 |       NEW_TK primitive_type dims array_initializer
2133                 {
2134                   int osb = pop_current_osb (ctxp);
2135                   tree type = $2;
2136                   while (osb--)
2137                     type = build_java_array_type (type, -1);
2138                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2139                               build_pointer_type (type), NULL_TREE, $4);
2140                 }
2141 |       NEW_TK error CSB_TK
2142                 {yyerror ("'[' expected"); DRECOVER ("]");}
2143 |       NEW_TK error OSB_TK
2144                 {yyerror ("']' expected"); RECOVER;}
2145 ;
2146
2147 dim_exprs:
2148         dim_expr
2149                 { $$ = build_tree_list (NULL_TREE, $1); }
2150 |       dim_exprs dim_expr
2151                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2152 ;
2153
2154 dim_expr:
2155         OSB_TK expression CSB_TK
2156                 {
2157                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2158                     {
2159                       $2 = build_wfl_node ($2);
2160                       TREE_TYPE ($2) = NULL_TREE;
2161                     }
2162                   EXPR_WFL_LINECOL ($2) = $1.location;
2163                   $$ = $2;
2164                 }
2165 |       OSB_TK expression error
2166                 {yyerror ("']' expected"); RECOVER;}
2167 |       OSB_TK error
2168                 {
2169                   yyerror ("Missing term");
2170                   yyerror ("']' expected");
2171                   RECOVER;
2172                 }
2173 ;
2174
2175 dims:
2176         OSB_TK CSB_TK
2177                 {
2178                   int allocate = 0;
2179                   /* If not initialized, allocate memory for the osb
2180                      numbers stack */
2181                   if (!ctxp->osb_limit)
2182                     {
2183                       allocate = ctxp->osb_limit = 32;
2184                       ctxp->osb_depth = -1;
2185                     }
2186                   /* If capacity overflown, reallocate a bigger chunk */
2187                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2188                     allocate = ctxp->osb_limit << 1;
2189
2190                   if (allocate)
2191                     {
2192                       allocate *= sizeof (int);
2193                       if (ctxp->osb_number)
2194                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2195                                                      allocate);
2196                       else
2197                         ctxp->osb_number = xmalloc (allocate);
2198                     }
2199                   ctxp->osb_depth++;
2200                   CURRENT_OSB (ctxp) = 1;
2201                 }
2202 |       dims OSB_TK CSB_TK
2203                 { CURRENT_OSB (ctxp)++; }
2204 |       dims OSB_TK error
2205                 { yyerror ("']' expected"); RECOVER;}
2206 ;
2207
2208 field_access:
2209         primary DOT_TK identifier
2210                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2211                 /*  FIXME - REWRITE TO:
2212                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2213 |       SUPER_TK DOT_TK identifier
2214                 {
2215                   tree super_wfl = build_wfl_node (super_identifier_node);
2216                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2217                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2218                 }
2219 |       SUPER_TK error
2220                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2221 ;
2222
2223 method_invocation:
2224         name OP_TK CP_TK
2225                 { $$ = build_method_invocation ($1, NULL_TREE); }
2226 |       name OP_TK argument_list CP_TK
2227                 { $$ = build_method_invocation ($1, $3); }
2228 |       primary DOT_TK identifier OP_TK CP_TK
2229                 {
2230                   if (TREE_CODE ($1) == THIS_EXPR)
2231                     $$ = build_this_super_qualified_invocation
2232                       (1, $3, NULL_TREE, 0, $2.location);
2233                   else
2234                     {
2235                       tree invok = build_method_invocation ($3, NULL_TREE);
2236                       $$ = make_qualified_primary ($1, invok, $2.location);
2237                     }
2238                 }
2239 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2240                 {
2241                   if (TREE_CODE ($1) == THIS_EXPR)
2242                     $$ = build_this_super_qualified_invocation
2243                       (1, $3, $5, 0, $2.location);
2244                   else
2245                     {
2246                       tree invok = build_method_invocation ($3, $5);
2247                       $$ = make_qualified_primary ($1, invok, $2.location);
2248                     }
2249                 }
2250 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2251                 {
2252                   $$ = build_this_super_qualified_invocation
2253                     (0, $3, NULL_TREE, $1.location, $2.location);
2254                 }
2255 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2256                 {
2257                   $$ = build_this_super_qualified_invocation
2258                     (0, $3, $5, $1.location, $2.location);
2259                 }
2260         /* Screws up thing. I let it here until I'm convinced it can
2261            be removed. FIXME
2262 |       primary DOT_TK error
2263                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2264 |       SUPER_TK DOT_TK error CP_TK
2265                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2266 |       SUPER_TK DOT_TK error DOT_TK
2267                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2268 ;
2269
2270 array_access:
2271         name OSB_TK expression CSB_TK
2272                 { $$ = build_array_ref ($2.location, $1, $3); }
2273 |       primary_no_new_array OSB_TK expression CSB_TK
2274                 { $$ = build_array_ref ($2.location, $1, $3); }
2275 |       name OSB_TK error
2276                 {
2277                   yyerror ("Missing term and ']' expected");
2278                   DRECOVER(array_access);
2279                 }
2280 |       name OSB_TK expression error
2281                 {
2282                   yyerror ("']' expected");
2283                   DRECOVER(array_access);
2284                 }
2285 |       primary_no_new_array OSB_TK error
2286                 {
2287                   yyerror ("Missing term and ']' expected");
2288                   DRECOVER(array_access);
2289                 }
2290 |       primary_no_new_array OSB_TK expression error
2291                 {
2292                   yyerror ("']' expected");
2293                   DRECOVER(array_access);
2294                 }
2295 ;
2296
2297 postfix_expression:
2298         primary
2299 |       name
2300 |       post_increment_expression
2301 |       post_decrement_expression
2302 ;
2303
2304 post_increment_expression:
2305         postfix_expression INCR_TK
2306                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2307 ;
2308
2309 post_decrement_expression:
2310         postfix_expression DECR_TK
2311                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2312 ;
2313
2314 trap_overflow_corner_case:
2315         pre_increment_expression
2316 |       pre_decrement_expression
2317 |       PLUS_TK unary_expression
2318                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2319 |       unary_expression_not_plus_minus
2320 |       PLUS_TK error
2321                 {yyerror ("Missing term"); RECOVER}
2322 ;
2323
2324 unary_expression:
2325         trap_overflow_corner_case
2326                 {
2327                   error_if_numeric_overflow ($1);
2328                   $$ = $1;
2329                 }
2330 |       MINUS_TK trap_overflow_corner_case
2331                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2332 |       MINUS_TK error
2333                 {yyerror ("Missing term"); RECOVER}
2334 ;
2335
2336 pre_increment_expression:
2337         INCR_TK unary_expression
2338                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2339 |       INCR_TK error
2340                 {yyerror ("Missing term"); RECOVER}
2341 ;
2342
2343 pre_decrement_expression:
2344         DECR_TK unary_expression
2345                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2346 |       DECR_TK error
2347                 {yyerror ("Missing term"); RECOVER}
2348 ;
2349
2350 unary_expression_not_plus_minus:
2351         postfix_expression
2352 |       NOT_TK unary_expression
2353                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2354 |       NEG_TK unary_expression
2355                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2356 |       cast_expression
2357 |       NOT_TK error
2358                 {yyerror ("Missing term"); RECOVER}
2359 |       NEG_TK error
2360                 {yyerror ("Missing term"); RECOVER}
2361 ;
2362
2363 cast_expression:                /* Error handling here is potentially weak */
2364         OP_TK primitive_type dims CP_TK unary_expression
2365                 {
2366                   tree type = $2;
2367                   int osb = pop_current_osb (ctxp);
2368                   while (osb--)
2369                     type = build_java_array_type (type, -1);
2370                   $$ = build_cast ($1.location, type, $5);
2371                 }
2372 |       OP_TK primitive_type CP_TK unary_expression
2373                 { $$ = build_cast ($1.location, $2, $4); }
2374 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2375                 { $$ = build_cast ($1.location, $2, $4); }
2376 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2377                 {
2378                   const char *ptr;
2379                   int osb = pop_current_osb (ctxp);
2380                   obstack_grow (&temporary_obstack,
2381                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2382                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2383                   while (osb--)
2384                     obstack_grow (&temporary_obstack, "[]", 2);
2385                   obstack_1grow (&temporary_obstack, '\0');
2386                   ptr = obstack_finish (&temporary_obstack);
2387                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2388                   $$ = build_cast ($1.location, $2, $5);
2389                 }
2390 |       OP_TK primitive_type OSB_TK error
2391                 {yyerror ("']' expected, invalid type expression");}
2392 |       OP_TK error
2393                 {
2394                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2395                   RECOVER;
2396                 }
2397 |       OP_TK primitive_type dims CP_TK error
2398                 {yyerror ("Missing term"); RECOVER;}
2399 |       OP_TK primitive_type CP_TK error
2400                 {yyerror ("Missing term"); RECOVER;}
2401 |       OP_TK name dims CP_TK error
2402                 {yyerror ("Missing term"); RECOVER;}
2403 ;
2404
2405 multiplicative_expression:
2406         unary_expression
2407 |       multiplicative_expression MULT_TK unary_expression
2408                 {
2409                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2410                                     $2.location, $1, $3);
2411                 }
2412 |       multiplicative_expression DIV_TK unary_expression
2413                 {
2414                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2415                                     $1, $3);
2416                 }
2417 |       multiplicative_expression REM_TK unary_expression
2418                 {
2419                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2420                                     $1, $3);
2421                 }
2422 |       multiplicative_expression MULT_TK error
2423                 {yyerror ("Missing term"); RECOVER;}
2424 |       multiplicative_expression DIV_TK error
2425                 {yyerror ("Missing term"); RECOVER;}
2426 |       multiplicative_expression REM_TK error
2427                 {yyerror ("Missing term"); RECOVER;}
2428 ;
2429
2430 additive_expression:
2431         multiplicative_expression
2432 |       additive_expression PLUS_TK multiplicative_expression
2433                 {
2434                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2435                                     $1, $3);
2436                 }
2437 |       additive_expression MINUS_TK multiplicative_expression
2438                 {
2439                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2440                                     $1, $3);
2441                 }
2442 |       additive_expression PLUS_TK error
2443                 {yyerror ("Missing term"); RECOVER;}
2444 |       additive_expression MINUS_TK error
2445                 {yyerror ("Missing term"); RECOVER;}
2446 ;
2447
2448 shift_expression:
2449         additive_expression
2450 |       shift_expression LS_TK additive_expression
2451                 {
2452                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2453                                     $1, $3);
2454                 }
2455 |       shift_expression SRS_TK additive_expression
2456                 {
2457                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2458                                     $1, $3);
2459                 }
2460 |       shift_expression ZRS_TK additive_expression
2461                 {
2462                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2463                                     $1, $3);
2464                 }
2465 |       shift_expression LS_TK error
2466                 {yyerror ("Missing term"); RECOVER;}
2467 |       shift_expression SRS_TK error
2468                 {yyerror ("Missing term"); RECOVER;}
2469 |       shift_expression ZRS_TK error
2470                 {yyerror ("Missing term"); RECOVER;}
2471 ;
2472
2473 relational_expression:
2474         shift_expression
2475 |       relational_expression LT_TK shift_expression
2476                 {
2477                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2478                                     $1, $3);
2479                 }
2480 |       relational_expression GT_TK shift_expression
2481                 {
2482                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2483                                     $1, $3);
2484                 }
2485 |       relational_expression LTE_TK shift_expression
2486                 {
2487                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2488                                     $1, $3);
2489                 }
2490 |       relational_expression GTE_TK shift_expression
2491                 {
2492                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2493                                     $1, $3);
2494                 }
2495 |       relational_expression INSTANCEOF_TK reference_type
2496                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2497 |       relational_expression LT_TK error
2498                 {yyerror ("Missing term"); RECOVER;}
2499 |       relational_expression GT_TK error
2500                 {yyerror ("Missing term"); RECOVER;}
2501 |       relational_expression LTE_TK error
2502                 {yyerror ("Missing term"); RECOVER;}
2503 |       relational_expression GTE_TK error
2504                 {yyerror ("Missing term"); RECOVER;}
2505 |       relational_expression INSTANCEOF_TK error
2506                 {yyerror ("Invalid reference type"); RECOVER;}
2507 ;
2508
2509 equality_expression:
2510         relational_expression
2511 |       equality_expression EQ_TK relational_expression
2512                 {
2513                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2514                                     $1, $3);
2515                 }
2516 |       equality_expression NEQ_TK relational_expression
2517                 {
2518                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2519                                     $1, $3);
2520                 }
2521 |       equality_expression EQ_TK error
2522                 {yyerror ("Missing term"); RECOVER;}
2523 |       equality_expression NEQ_TK error
2524                 {yyerror ("Missing term"); RECOVER;}
2525 ;
2526
2527 and_expression:
2528         equality_expression
2529 |       and_expression AND_TK equality_expression
2530                 {
2531                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2532                                     $1, $3);
2533                 }
2534 |       and_expression AND_TK error
2535                 {yyerror ("Missing term"); RECOVER;}
2536 ;
2537
2538 exclusive_or_expression:
2539         and_expression
2540 |       exclusive_or_expression XOR_TK and_expression
2541                 {
2542                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2543                                     $1, $3);
2544                 }
2545 |       exclusive_or_expression XOR_TK error
2546                 {yyerror ("Missing term"); RECOVER;}
2547 ;
2548
2549 inclusive_or_expression:
2550         exclusive_or_expression
2551 |       inclusive_or_expression OR_TK exclusive_or_expression
2552                 {
2553                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2554                                     $1, $3);
2555                 }
2556 |       inclusive_or_expression OR_TK error
2557                 {yyerror ("Missing term"); RECOVER;}
2558 ;
2559
2560 conditional_and_expression:
2561         inclusive_or_expression
2562 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2563                 {
2564                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2565                                     $1, $3);
2566                 }
2567 |       conditional_and_expression BOOL_AND_TK error
2568                 {yyerror ("Missing term"); RECOVER;}
2569 ;
2570
2571 conditional_or_expression:
2572         conditional_and_expression
2573 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2574                 {
2575                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2576                                     $1, $3);
2577                 }
2578 |       conditional_or_expression BOOL_OR_TK error
2579                 {yyerror ("Missing term"); RECOVER;}
2580 ;
2581
2582 conditional_expression:         /* Error handling here is weak */
2583         conditional_or_expression
2584 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2585                 {
2586                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2587                   EXPR_WFL_LINECOL ($$) = $2.location;
2588                 }
2589 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2590                 {
2591                   YYERROR_NOW;
2592                   yyerror ("Missing term");
2593                   DRECOVER (1);
2594                 }
2595 |       conditional_or_expression REL_QM_TK error
2596                 {yyerror ("Missing term"); DRECOVER (2);}
2597 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2598                 {yyerror ("Missing term"); DRECOVER (3);}
2599 ;
2600
2601 assignment_expression:
2602         conditional_expression
2603 |       assignment
2604 ;
2605
2606 assignment:
2607         left_hand_side assignment_operator assignment_expression
2608                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2609 |       left_hand_side assignment_operator error
2610                 {
2611                   YYNOT_TWICE yyerror ("Missing term");
2612                   DRECOVER (assign);
2613                 }
2614 ;
2615
2616 left_hand_side:
2617         name
2618 |       field_access
2619 |       array_access
2620 ;
2621
2622 assignment_operator:
2623         ASSIGN_ANY_TK
2624 |       ASSIGN_TK
2625 ;
2626
2627 expression:
2628         assignment_expression
2629 ;
2630
2631 constant_expression:
2632         expression
2633 ;
2634
2635 %%
2636
2637 /* Helper function to retrieve an OSB count. Should be used when the
2638    `dims:' rule is being used.  */
2639
2640 static int
2641 pop_current_osb (struct parser_ctxt *ctxp)
2642 {
2643   int to_return;
2644
2645   if (ctxp->osb_depth < 0)
2646     abort ();
2647
2648   to_return = CURRENT_OSB (ctxp);
2649   ctxp->osb_depth--;
2650
2651   return to_return;
2652 }
2653
2654 \f
2655
2656 /* This section of the code deal with save/restoring parser contexts.
2657    Add mode documentation here. FIXME */
2658
2659 /* Helper function. Create a new parser context. With
2660    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2661    context is copied, otherwise, the new context is zeroed. The newly
2662    created context becomes the current one.  */
2663
2664 static void
2665 create_new_parser_context (int copy_from_previous)
2666 {
2667   struct parser_ctxt *new;
2668
2669   new = ggc_alloc (sizeof (struct parser_ctxt));
2670   if (copy_from_previous)
2671     {
2672       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2673       /* This flag, indicating the context saves global values,
2674          should only be set by java_parser_context_save_global.  */
2675       new->saved_data_ctx = 0;
2676     }
2677   else
2678     memset (new, 0, sizeof (struct parser_ctxt));
2679
2680   new->next = ctxp;
2681   ctxp = new;
2682 }
2683
2684 /* Create a new parser context and make it the current one. */
2685
2686 void
2687 java_push_parser_context (void)
2688 {
2689   create_new_parser_context (0);
2690 }
2691
2692 void
2693 java_pop_parser_context (int generate)
2694 {
2695   tree current;
2696   struct parser_ctxt *toFree, *next;
2697
2698   if (!ctxp)
2699     return;
2700
2701   toFree = ctxp;
2702   next = ctxp->next;
2703   if (next)
2704     {
2705       input_line = ctxp->lineno;
2706       current_class = ctxp->class_type;
2707     }
2708
2709   /* If the old and new lexers differ, then free the old one.  */
2710   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2711     java_destroy_lexer (ctxp->lexer);
2712
2713   /* Set the single import class file flag to 0 for the current list
2714      of imported things */
2715   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2716     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2717
2718   /* And restore those of the previous context */
2719   if ((ctxp = next))            /* Assignment is really meant here */
2720     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2721       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2722
2723   /* If we pushed a context to parse a class intended to be generated,
2724      we keep it so we can remember the class. What we could actually
2725      do is to just update a list of class names.  */
2726   if (generate)
2727     {
2728       toFree->next = ctxp_for_generation;
2729       ctxp_for_generation = toFree;
2730     }
2731 }
2732
2733 /* Create a parser context for the use of saving some global
2734    variables.  */
2735
2736 void
2737 java_parser_context_save_global (void)
2738 {
2739   if (!ctxp)
2740     {
2741       java_push_parser_context ();
2742       ctxp->saved_data_ctx = 1;
2743     }
2744
2745   /* If this context already stores data, create a new one suitable
2746      for data storage. */
2747   else if (ctxp->saved_data)
2748     {
2749       create_new_parser_context (1);
2750       ctxp->saved_data_ctx = 1;
2751     }
2752
2753   ctxp->lineno = input_line;
2754   ctxp->class_type = current_class;
2755   ctxp->filename = input_filename;
2756   ctxp->function_decl = current_function_decl;
2757   ctxp->saved_data = 1;
2758 }
2759
2760 /* Restore some global variables from the previous context. Make the
2761    previous context the current one.  */
2762
2763 void
2764 java_parser_context_restore_global (void)
2765 {
2766   input_line = ctxp->lineno;
2767   current_class = ctxp->class_type;
2768   input_filename = ctxp->filename;
2769   if (wfl_operator)
2770     {
2771       tree s;
2772       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2773       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2774     }
2775   current_function_decl = ctxp->function_decl;
2776   ctxp->saved_data = 0;
2777   if (ctxp->saved_data_ctx)
2778     java_pop_parser_context (0);
2779 }
2780
2781 /* Suspend vital data for the current class/function being parsed so
2782    that an other class can be parsed. Used to let local/anonymous
2783    classes be parsed.  */
2784
2785 static void
2786 java_parser_context_suspend (void)
2787 {
2788   /* This makes debugging through java_debug_context easier */
2789   static const char *const name = "<inner buffer context>";
2790
2791   /* Duplicate the previous context, use it to save the globals we're
2792      interested in */
2793   create_new_parser_context (1);
2794   ctxp->function_decl = current_function_decl;
2795   ctxp->class_type = current_class;
2796
2797   /* Then create a new context which inherits all data from the
2798      previous one. This will be the new current context  */
2799   create_new_parser_context (1);
2800
2801   /* Help debugging */
2802   ctxp->next->filename = name;
2803 }
2804
2805 /* Resume vital data for the current class/function being parsed so
2806    that an other class can be parsed. Used to let local/anonymous
2807    classes be parsed.  The trick is the data storing file position
2808    informations must be restored to their current value, so parsing
2809    can resume as if no context was ever saved. */
2810
2811 static void
2812 java_parser_context_resume (void)
2813 {
2814   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2815   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2816   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2817
2818   /* We need to inherit the list of classes to complete/generate */
2819   restored->classd_list = old->classd_list;
2820   restored->class_list = old->class_list;
2821
2822   /* Restore the current class and function from the saver */
2823   current_class = saver->class_type;
2824   current_function_decl = saver->function_decl;
2825
2826   /* Retrieve the restored context */
2827   ctxp = restored;
2828
2829   /* Re-installed the data for the parsing to carry on */
2830   memcpy (&ctxp->marker_begining, &old->marker_begining,
2831           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2832 }
2833
2834 /* Add a new anchor node to which all statement(s) initializing static
2835    and non static initialized upon declaration field(s) will be
2836    linked.  */
2837
2838 static void
2839 java_parser_context_push_initialized_field (void)
2840 {
2841   tree node;
2842
2843   node = build_tree_list (NULL_TREE, NULL_TREE);
2844   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2845   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2846
2847   node = build_tree_list (NULL_TREE, NULL_TREE);
2848   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2849   CPC_INITIALIZER_LIST (ctxp) = node;
2850
2851   node = build_tree_list (NULL_TREE, NULL_TREE);
2852   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2853   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2854 }
2855
2856 /* Pop the lists of initialized field. If this lists aren't empty,
2857    remember them so we can use it to create and populate the finit$
2858    or <clinit> functions. */
2859
2860 static void
2861 java_parser_context_pop_initialized_field (void)
2862 {
2863   tree stmts;
2864   tree class_type = TREE_TYPE (GET_CPC ());
2865
2866   if (CPC_INITIALIZER_LIST (ctxp))
2867     {
2868       stmts = CPC_INITIALIZER_STMT (ctxp);
2869       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2870       if (stmts && !java_error_count)
2871         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2872     }
2873
2874   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2875     {
2876       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2877       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2878         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2879       /* Keep initialization in order to enforce 8.5 */
2880       if (stmts && !java_error_count)
2881         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2882     }
2883
2884   /* JDK 1.1 instance initializers */
2885   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2886     {
2887       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2888       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2889         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2890       if (stmts && !java_error_count)
2891         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2892     }
2893 }
2894
2895 static tree
2896 reorder_static_initialized (tree list)
2897 {
2898   /* We have to keep things in order. The alias initializer have to
2899      come first, then the initialized regular field, in reverse to
2900      keep them in lexical order. */
2901   tree marker, previous = NULL_TREE;
2902   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2903     if (TREE_CODE (marker) == TREE_LIST
2904         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2905       break;
2906
2907   /* No static initialized, the list is fine as is */
2908   if (!previous)
2909     list = TREE_CHAIN (marker);
2910
2911   /* No marker? reverse the whole list */
2912   else if (!marker)
2913     list = nreverse (list);
2914
2915   /* Otherwise, reverse what's after the marker and the new reordered
2916      sublist will replace the marker. */
2917   else
2918     {
2919       TREE_CHAIN (previous) = NULL_TREE;
2920       list = nreverse (list);
2921       list = chainon (TREE_CHAIN (marker), list);
2922     }
2923   return list;
2924 }
2925
2926 /* Helper functions to dump the parser context stack.  */
2927
2928 #define TAB_CONTEXT(C) \
2929   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2930
2931 static void
2932 java_debug_context_do (int tab)
2933 {
2934   struct parser_ctxt *copy = ctxp;
2935   while (copy)
2936     {
2937       TAB_CONTEXT (tab);
2938       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2939       TAB_CONTEXT (tab);
2940       fprintf (stderr, "filename: %s\n", copy->filename);
2941       TAB_CONTEXT (tab);
2942       fprintf (stderr, "lineno: %d\n", copy->lineno);
2943       TAB_CONTEXT (tab);
2944       fprintf (stderr, "package: %s\n",
2945                (copy->package ?
2946                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2947       TAB_CONTEXT (tab);
2948       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2949       TAB_CONTEXT (tab);
2950       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2951       copy = copy->next;
2952       tab += 2;
2953     }
2954 }
2955
2956 /* Dump the stacked up parser contexts. Intended to be called from a
2957    debugger.  */
2958
2959 void
2960 java_debug_context (void)
2961 {
2962   java_debug_context_do (0);
2963 }
2964
2965 \f
2966
2967 /* Flag for the error report routine to issue the error the first time
2968    it's called (overriding the default behavior which is to drop the
2969    first invocation and honor the second one, taking advantage of a
2970    richer context.  */
2971 static int force_error = 0;
2972
2973 /* Reporting an constructor invocation error.  */
2974 static void
2975 parse_ctor_invocation_error (void)
2976 {
2977   if (DECL_CONSTRUCTOR_P (current_function_decl))
2978     yyerror ("Constructor invocation must be first thing in a constructor");
2979   else
2980     yyerror ("Only constructors can invoke constructors");
2981 }
2982
2983 /* Reporting JDK1.1 features not implemented.  */
2984
2985 static tree
2986 parse_jdk1_1_error (const char *msg)
2987 {
2988   sorry (": `%s' JDK1.1(TM) feature", msg);
2989   java_error_count++;
2990   return empty_stmt_node;
2991 }
2992
2993 static int do_warning = 0;
2994
2995 void
2996 yyerror (const char *msg)
2997 {
2998   static java_lc elc;
2999   static int  prev_lineno;
3000   static const char *prev_msg;
3001
3002   int save_lineno;
3003   char *remainder, *code_from_source;
3004
3005   if (!force_error && prev_lineno == input_line)
3006     return;
3007
3008   /* Save current error location but report latter, when the context is
3009      richer.  */
3010   if (ctxp->java_error_flag == 0)
3011     {
3012       ctxp->java_error_flag = 1;
3013       elc = ctxp->elc;
3014       /* Do something to use the previous line if we're reaching the
3015          end of the file... */
3016 #ifdef VERBOSE_SKELETON
3017       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3018 #endif
3019       return;
3020     }
3021
3022   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3023   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3024     return;
3025
3026   ctxp->java_error_flag = 0;
3027   if (do_warning)
3028     java_warning_count++;
3029   else
3030     java_error_count++;
3031
3032   if (elc.col == 0 && msg && msg[1] == ';')
3033     {
3034       elc.col  = ctxp->p_line->char_col-1;
3035       elc.line = ctxp->p_line->lineno;
3036     }
3037
3038   save_lineno = input_line;
3039   prev_lineno = input_line = elc.line;
3040   prev_msg = msg;
3041
3042   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3043   obstack_grow0 (&temporary_obstack,
3044                  code_from_source, strlen (code_from_source));
3045   remainder = obstack_finish (&temporary_obstack);
3046   if (do_warning)
3047     warning ("%s.\n%s", msg, remainder);
3048   else
3049     error ("%s.\n%s", msg, remainder);
3050
3051   /* This allow us to cheaply avoid an extra 'Invalid expression
3052      statement' error report when errors have been already reported on
3053      the same line. This occurs when we report an error but don't have
3054      a synchronization point other than ';', which
3055      expression_statement is the only one to take care of.  */
3056   ctxp->prevent_ese = input_line = save_lineno;
3057 }
3058
3059 static void
3060 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3061 {
3062   const char *saved, *saved_input_filename;
3063   char buffer [4096];
3064   vsprintf (buffer, msg, ap);
3065   force_error = 1;
3066
3067   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3068   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3069                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3070
3071   /* We have a CL, that's a good reason for using it if it contains data */
3072   saved = ctxp->filename;
3073   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3074     ctxp->filename = EXPR_WFL_FILENAME (cl);
3075   saved_input_filename = input_filename;
3076   input_filename = ctxp->filename;
3077   java_error (NULL);
3078   java_error (buffer);
3079   ctxp->filename = saved;
3080   input_filename = saved_input_filename;
3081   force_error = 0;
3082 }
3083
3084 /* Issue an error message at a current source line CL */
3085
3086 void
3087 parse_error_context (tree cl, const char *msg, ...)
3088 {
3089   va_list ap;
3090   va_start (ap, msg);
3091   issue_warning_error_from_context (cl, msg, ap);
3092   va_end (ap);
3093 }
3094
3095 /* Issue a warning at a current source line CL */
3096
3097 static void
3098 parse_warning_context (tree cl, const char *msg, ...)
3099 {
3100   va_list ap;
3101   va_start (ap, msg);
3102
3103   force_error = do_warning = 1;
3104   issue_warning_error_from_context (cl, msg, ap);
3105   do_warning = force_error = 0;
3106   va_end (ap);
3107 }
3108
3109 static tree
3110 find_expr_with_wfl (tree node)
3111 {
3112   while (node)
3113     {
3114       char code;
3115       tree to_return;
3116
3117       switch (TREE_CODE (node))
3118         {
3119         case BLOCK:
3120           node = BLOCK_EXPR_BODY (node);
3121           continue;
3122
3123         case COMPOUND_EXPR:
3124           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3125           if (to_return)
3126             return to_return;
3127           node = TREE_OPERAND (node, 1);
3128           continue;
3129
3130         case LOOP_EXPR:
3131           node = TREE_OPERAND (node, 0);
3132           continue;
3133
3134         case LABELED_BLOCK_EXPR:
3135           node = TREE_OPERAND (node, 1);
3136           continue;
3137
3138         default:
3139           code = TREE_CODE_CLASS (TREE_CODE (node));
3140           if (((code == '1') || (code == '2') || (code == 'e'))
3141               && EXPR_WFL_LINECOL (node))
3142             return node;
3143           return NULL_TREE;
3144         }
3145     }
3146   return NULL_TREE;
3147 }
3148
3149 /* Issue a missing return statement error. Uses METHOD to figure the
3150    last line of the method the error occurs in.  */
3151
3152 static void
3153 missing_return_error (tree method)
3154 {
3155   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3156   parse_error_context (wfl_operator, "Missing return statement");
3157 }
3158
3159 /* Issue an unreachable statement error. From NODE, find the next
3160    statement to report appropriately.  */
3161 static void
3162 unreachable_stmt_error (tree node)
3163 {
3164   /* Browse node to find the next expression node that has a WFL. Use
3165      the location to report the error */
3166   if (TREE_CODE (node) == COMPOUND_EXPR)
3167     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3168   else
3169     node = find_expr_with_wfl (node);
3170
3171   if (node)
3172     {
3173       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3174       parse_error_context (wfl_operator, "Unreachable statement");
3175     }
3176   else
3177     abort ();
3178 }
3179
3180 static int
3181 not_accessible_field_error (tree wfl, tree decl)
3182 {
3183   parse_error_context
3184     (wfl, "Can't access %s field `%s.%s' from `%s'",
3185      java_accstring_lookup (get_access_flags_from_decl (decl)),
3186      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3187      IDENTIFIER_POINTER (DECL_NAME (decl)),
3188      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3189   return 1;
3190 }
3191
3192 int
3193 java_report_errors (void)
3194 {
3195   if (java_error_count)
3196     fprintf (stderr, "%d error%s",
3197              java_error_count, (java_error_count == 1 ? "" : "s"));
3198   if (java_warning_count)
3199     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3200              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3201   if (java_error_count || java_warning_count)
3202     putc ('\n', stderr);
3203   return java_error_count;
3204 }
3205
3206 static char *
3207 java_accstring_lookup (int flags)
3208 {
3209   static char buffer [80];
3210 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3211
3212   /* Access modifier looked-up first for easier report on forbidden
3213      access. */
3214   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3215   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3216   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3217   if (flags & ACC_STATIC) COPY_RETURN ("static");
3218   if (flags & ACC_FINAL) COPY_RETURN ("final");
3219   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3220   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3221   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3222   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3223   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3224   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3225
3226   buffer [0] = '\0';
3227   return buffer;
3228 #undef COPY_RETURN
3229 }
3230
3231 /* Issuing error messages upon redefinition of classes, interfaces or
3232    variables. */
3233
3234 static void
3235 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3236 {
3237   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3238                        context, IDENTIFIER_POINTER (id),
3239                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3240   /* Here we should point out where its redefined. It's a unicode. FIXME */
3241 }
3242
3243 static void
3244 variable_redefinition_error (tree context, tree name, tree type, int line)
3245 {
3246   const char *type_name;
3247
3248   /* Figure a proper name for type. We might haven't resolved it */
3249   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3250     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3251   else
3252     type_name = lang_printable_name (type, 0);
3253
3254   parse_error_context (context,
3255                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3256                        IDENTIFIER_POINTER (name),
3257                        type_name, IDENTIFIER_POINTER (name), line);
3258 }
3259
3260 /* If ANAME is terminated with `[]', it indicates an array. This
3261    function returns the number of `[]' found and if this number is
3262    greater than zero, it extracts the array type name and places it in
3263    the node pointed to by TRIMMED unless TRIMMED is null.  */
3264
3265 static int
3266 build_type_name_from_array_name (tree aname, tree *trimmed)
3267 {
3268   const char *name = IDENTIFIER_POINTER (aname);
3269   int len = IDENTIFIER_LENGTH (aname);
3270   int array_dims;
3271
3272   STRING_STRIP_BRACKETS (name, len, array_dims);
3273
3274   if (array_dims && trimmed)
3275     *trimmed = get_identifier_with_length (name, len);
3276
3277   return array_dims;
3278 }
3279
3280 static tree
3281 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3282 {
3283   int more_dims = 0;
3284
3285   /* Eventually get more dims */
3286   more_dims = build_type_name_from_array_name (name, &name);
3287
3288   /* If we have, then craft a new type for this variable */
3289   if (more_dims)
3290     {
3291       tree save = type;
3292
3293       /* If we have a pointer, use its type */
3294       if (TREE_CODE (type) == POINTER_TYPE)
3295         type = TREE_TYPE (type);
3296
3297       /* Building the first dimension of a primitive type uses this
3298          function */
3299       if (JPRIMITIVE_TYPE_P (type))
3300         {
3301           type = build_java_array_type (type, -1);
3302           more_dims--;
3303         }
3304       /* Otherwise, if we have a WFL for this type, use it (the type
3305          is already an array on an unresolved type, and we just keep
3306          on adding dimensions) */
3307       else if (type_wfl)
3308         {
3309           type = type_wfl;
3310           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3311                                                         NULL);
3312         }
3313
3314       /* Add all the dimensions */
3315       while (more_dims--)
3316         type = build_unresolved_array_type (type);
3317
3318       /* The type may have been incomplete in the first place */
3319       if (type_wfl)
3320         type = obtain_incomplete_type (type);
3321     }
3322
3323   if (ret_name)
3324     *ret_name = name;
3325   return type;
3326 }
3327
3328 /* Build something that the type identifier resolver will identify as
3329    being an array to an unresolved type. TYPE_WFL is a WFL on a
3330    identifier. */
3331
3332 static tree
3333 build_unresolved_array_type (tree type_or_wfl)
3334 {
3335   const char *ptr;
3336   tree wfl;
3337
3338   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3339      just create a array type */
3340   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3341     return build_java_array_type (type_or_wfl, -1);
3342
3343   obstack_grow (&temporary_obstack,
3344                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3345                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3346   obstack_grow0 (&temporary_obstack, "[]", 2);
3347   ptr = obstack_finish (&temporary_obstack);
3348   wfl = build_expr_wfl (get_identifier (ptr),
3349                         EXPR_WFL_FILENAME (type_or_wfl),
3350                         EXPR_WFL_LINENO (type_or_wfl),
3351                         EXPR_WFL_COLNO (type_or_wfl));
3352   /* Re-install the existing qualifications so that the type can be
3353      resolved properly. */
3354   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3355   return wfl;
3356 }
3357
3358 static void
3359 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3360 {
3361   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3362     parse_error_context (wfl, "Interface `%s' repeated",
3363                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3364 }
3365
3366 /* Bulk of common class/interface checks. Return 1 if an error was
3367    encountered. TAG is 0 for a class, 1 for an interface.  */
3368
3369 static int
3370 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3371                                 tree qualified_name, tree decl, tree cl)
3372 {
3373   tree node;
3374   int sca = 0;                  /* Static class allowed */
3375   int icaf = 0;                 /* Inner class allowed flags */
3376   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3377
3378   if (!quiet_flag)
3379     fprintf (stderr, " %s%s %s",
3380              (CPC_INNER_P () ? "inner" : ""),
3381              (is_interface ? "interface" : "class"),
3382              IDENTIFIER_POINTER (qualified_name));
3383
3384   /* Scope of an interface/class type name:
3385        - Can't be imported by a single type import
3386        - Can't already exists in the package */
3387   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3388       && (node = find_name_in_single_imports (raw_name))
3389       && !CPC_INNER_P ())
3390     {
3391       parse_error_context
3392         (cl, "%s name `%s' clashes with imported type `%s'",
3393          (is_interface ? "Interface" : "Class"),
3394          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3395       return 1;
3396     }
3397   if (decl && CLASS_COMPLETE_P (decl))
3398     {
3399       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3400                                    qualified_name, decl, cl);
3401       return 1;
3402     }
3403
3404   if (check_inner_class_redefinition (raw_name, cl))
3405     return 1;
3406
3407   /* If public, file name should match class/interface name, except
3408      when dealing with an inner class */
3409   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3410     {
3411       const char *f;
3412
3413       for (f = &input_filename [strlen (input_filename)];
3414            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3415            f--)
3416         ;
3417       if (IS_DIR_SEPARATOR (f[0]))
3418         f++;
3419       if (strncmp (IDENTIFIER_POINTER (raw_name),
3420                    f , IDENTIFIER_LENGTH (raw_name)) ||
3421           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3422         parse_error_context
3423           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3424                              (is_interface ? "interface" : "class"),
3425                              IDENTIFIER_POINTER (qualified_name),
3426                              IDENTIFIER_POINTER (raw_name));
3427     }
3428
3429   /* Static classes can be declared only in top level classes. Note:
3430      once static, a inner class is a top level class. */
3431   if (flags & ACC_STATIC)
3432     {
3433       /* Catch the specific error of declaring an class inner class
3434          with no toplevel enclosing class. Prevent check_modifiers from
3435          complaining a second time */
3436       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3437         {
3438           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3439                                IDENTIFIER_POINTER (qualified_name));
3440           sca = ACC_STATIC;
3441         }
3442       /* Else, in the context of a top-level class declaration, let
3443          `check_modifiers' do its job, otherwise, give it a go */
3444       else
3445         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3446     }
3447
3448   /* Inner classes can be declared private or protected
3449      within their enclosing classes. */
3450   if (CPC_INNER_P ())
3451     {
3452       /* A class which is local to a block can't be public, private,
3453          protected or static. But it is created final, so allow this
3454          one. */
3455       if (current_function_decl)
3456         icaf = sca = uaaf = ACC_FINAL;
3457       else
3458         {
3459           check_modifiers_consistency (flags);
3460           icaf = ACC_PROTECTED;
3461           if (! CLASS_INTERFACE (GET_CPC ()))
3462             icaf |= ACC_PRIVATE;
3463         }
3464     }
3465
3466   if (is_interface)
3467     {
3468       if (CPC_INNER_P ())
3469         uaaf = INTERFACE_INNER_MODIFIERS;
3470       else
3471         uaaf = INTERFACE_MODIFIERS;
3472
3473       check_modifiers ("Illegal modifier `%s' for interface declaration",
3474                        flags, uaaf);
3475     }
3476   else
3477     check_modifiers ((current_function_decl ?
3478                       "Illegal modifier `%s' for local class declaration" :
3479                       "Illegal modifier `%s' for class declaration"),
3480                      flags, uaaf|sca|icaf);
3481   return 0;
3482 }
3483
3484 /* Construct a nested class name.  If the final component starts with
3485    a digit, return true.  Otherwise return false.  */
3486 static int
3487 make_nested_class_name (tree cpc_list)
3488 {
3489   tree name;
3490
3491   if (!cpc_list)
3492     return 0;
3493
3494   make_nested_class_name (TREE_CHAIN (cpc_list));
3495
3496   /* Pick the qualified name when dealing with the first upmost
3497      enclosing class */
3498   name = (TREE_CHAIN (cpc_list)
3499           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3500   obstack_grow (&temporary_obstack,
3501                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3502   obstack_1grow (&temporary_obstack, '$');
3503
3504   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3505 }
3506
3507 /* Can't redefine a class already defined in an earlier scope. */
3508
3509 static int
3510 check_inner_class_redefinition (tree raw_name, tree cl)
3511 {
3512   tree scope_list;
3513
3514   for (scope_list = GET_CPC_LIST (); scope_list;
3515        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3516     if (raw_name == GET_CPC_UN_NODE (scope_list))
3517       {
3518         parse_error_context
3519           (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",
3520            IDENTIFIER_POINTER (raw_name));
3521         return 1;
3522       }
3523   return 0;
3524 }
3525
3526 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3527    we remember ENCLOSING and SUPER.  */
3528
3529 static tree
3530 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3531                      tree *super, tree class_type)
3532 {
3533   tree local_enclosing = *enclosing;
3534   tree local_super = NULL_TREE;
3535
3536   while (local_enclosing)
3537     {
3538       tree intermediate, decl;
3539
3540       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3541         local_enclosing;
3542
3543       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3544         return decl;
3545
3546       intermediate = local_enclosing;
3547       /* Explore enclosing contexts. */
3548       while (INNER_CLASS_DECL_P (intermediate))
3549         {
3550           intermediate = DECL_CONTEXT (intermediate);
3551           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3552             return decl;
3553         }
3554
3555       /* Now go to the upper classes, bail out if necessary.  We will
3556          analyze the returned SUPER and act accordingly (see
3557          do_resolve_class).  */
3558       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3559           || TREE_TYPE (local_enclosing) == void_type_node)
3560         {
3561           parse_error_context (cl, "Qualifier must be a reference");
3562           local_enclosing = NULL_TREE;
3563           break;
3564         }
3565       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3566       if (!local_super || local_super == object_type_node)
3567         break;
3568
3569       if (TREE_CODE (local_super) == POINTER_TYPE)
3570         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3571       else
3572         local_super = TYPE_NAME (local_super);
3573
3574       /* We may not have checked for circular inheritance yet, so do so
3575          here to prevent an infinite loop. */
3576       if (htab_find (circularity_hash, local_super) != NULL)
3577         {
3578           if (!cl)
3579             cl = lookup_cl (local_enclosing);
3580
3581           parse_error_context
3582             (cl, "Cyclic inheritance involving %s",
3583              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3584           local_enclosing = NULL_TREE;
3585         }
3586       else
3587         local_enclosing = local_super;
3588     }
3589
3590   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3591   *super = local_super;
3592   *enclosing = local_enclosing;
3593
3594   return NULL_TREE;
3595 }
3596
3597 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3598    qualified. */
3599
3600 static tree
3601 find_as_inner_class (tree enclosing, tree name, tree cl)
3602 {
3603   tree qual, to_return;
3604   if (!enclosing)
3605     return NULL_TREE;
3606
3607   name = TYPE_NAME (name);
3608
3609   /* First search: within the scope of `enclosing', search for name */
3610   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3611     qual = EXPR_WFL_QUALIFICATION (cl);
3612   else if (cl)
3613     qual = build_tree_list (cl, NULL_TREE);
3614   else
3615     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3616
3617   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3618     return to_return;
3619
3620   /* We're dealing with a qualified name. Try to resolve thing until
3621      we get something that is an enclosing class. */
3622   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3623     {
3624       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3625
3626       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3627            qual = TREE_CHAIN (qual))
3628         {
3629           acc = merge_qualified_name (acc,
3630                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3631           BUILD_PTR_FROM_NAME (ptr, acc);
3632           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3633         }
3634
3635       /* A NULL qual and a decl means that the search ended
3636          successfully?!? We have to do something then. FIXME */
3637
3638       if (decl)
3639         enclosing = decl;
3640       else
3641         qual = EXPR_WFL_QUALIFICATION (cl);
3642     }
3643   /* Otherwise, create a qual for the other part of the resolution. */
3644   else
3645     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3646
3647   return find_as_inner_class_do (qual, enclosing);
3648 }
3649
3650 /* We go inside the list of sub classes and try to find a way
3651    through. */
3652
3653 static tree
3654 find_as_inner_class_do (tree qual, tree enclosing)
3655 {
3656   if (!qual)
3657     return NULL_TREE;
3658
3659   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3660     {
3661       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3662       tree next_enclosing = NULL_TREE;
3663       tree inner_list;
3664
3665       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3666            inner_list; inner_list = TREE_CHAIN (inner_list))
3667         {
3668           if (TREE_VALUE (inner_list) == name_to_match)
3669             {
3670               next_enclosing = TREE_PURPOSE (inner_list);
3671               break;
3672             }
3673         }
3674       enclosing = next_enclosing;
3675     }
3676
3677   return (!qual && enclosing ? enclosing : NULL_TREE);
3678 }
3679
3680 /* Reach all inner classes and tie their unqualified name to a
3681    DECL. */
3682
3683 static void
3684 set_nested_class_simple_name_value (tree outer, int set)
3685 {
3686   tree l;
3687
3688   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3689     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3690                                                 TREE_PURPOSE (l) : NULL_TREE);
3691 }
3692
3693 static void
3694 link_nested_class_to_enclosing (void)
3695 {
3696   if (GET_ENCLOSING_CPC ())
3697     {
3698       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3699       DECL_INNER_CLASS_LIST (enclosing) =
3700         tree_cons (GET_CPC (), GET_CPC_UN (),
3701                    DECL_INNER_CLASS_LIST (enclosing));
3702     }
3703 }
3704
3705 static tree
3706 maybe_make_nested_class_name (tree name)
3707 {
3708   tree id = NULL_TREE;
3709
3710   if (CPC_INNER_P ())
3711     {
3712       /* If we're in a function, we must append a number to create the
3713          nested class name.  However, we don't do this if the class we
3714          are constructing is anonymous, because in that case we'll
3715          already have a number as the class name.  */
3716       if (! make_nested_class_name (GET_CPC_LIST ())
3717           && current_function_decl != NULL_TREE
3718           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3719         {
3720           char buf[10];
3721           sprintf (buf, "%d", anonymous_class_counter);
3722           ++anonymous_class_counter;
3723           obstack_grow (&temporary_obstack, buf, strlen (buf));
3724           obstack_1grow (&temporary_obstack, '$');
3725         }
3726       obstack_grow0 (&temporary_obstack,
3727                      IDENTIFIER_POINTER (name),
3728                      IDENTIFIER_LENGTH (name));
3729       id = get_identifier (obstack_finish (&temporary_obstack));
3730       if (ctxp->package)
3731         QUALIFIED_P (id) = 1;
3732     }
3733   return id;
3734 }
3735
3736 /* If DECL is NULL, create and push a new DECL, record the current
3737    line CL and do other maintenance things.  */
3738
3739 static tree
3740 maybe_create_class_interface_decl (tree decl, tree raw_name,
3741                                    tree qualified_name, tree cl)
3742 {
3743   if (!decl)
3744     decl = push_class (make_class (), qualified_name);
3745
3746   /* Take care of the file and line business */
3747   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3748   /* If we're emitting xrefs, store the line/col number information */
3749   if (flag_emit_xref)
3750     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3751   else
3752     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3753   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3754   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3755   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3756     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3757
3758   PUSH_CPC (decl, raw_name);
3759   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3760
3761   /* Link the declaration to the already seen ones */
3762   TREE_CHAIN (decl) = ctxp->class_list;
3763   ctxp->class_list = decl;
3764
3765   /* Create a new nodes in the global lists */
3766   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3767   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3768
3769   /* Install a new dependency list element */
3770   create_jdep_list (ctxp);
3771
3772   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3773                           IDENTIFIER_POINTER (qualified_name)));
3774   return decl;
3775 }
3776
3777 static void
3778 add_superinterfaces (tree decl, tree interface_list)
3779 {
3780   tree node;
3781   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3782      takes care of ensuring that:
3783        - This is an accessible interface type,
3784        - Circularity detection.
3785    parser_add_interface is then called. If present but not defined,
3786    the check operation is delayed until the super interface gets
3787    defined.  */
3788   for (node = interface_list; node; node = TREE_CHAIN (node))
3789     {
3790       tree current = TREE_PURPOSE (node);
3791       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3792       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3793         {
3794           if (!parser_check_super_interface (idecl, decl, current))
3795             parser_add_interface (decl, idecl, current);
3796         }
3797       else
3798         register_incomplete_type (JDEP_INTERFACE,
3799                                   current, decl, NULL_TREE);
3800     }
3801 }
3802
3803 /* Create an interface in pass1 and return its decl. Return the
3804    interface's decl in pass 2.  */
3805
3806 static tree
3807 create_interface (int flags, tree id, tree super)
3808 {
3809   tree raw_name = EXPR_WFL_NODE (id);
3810   tree q_name = parser_qualified_classname (raw_name);
3811   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3812
3813   /* Certain syntax errors are making SUPER be like ID. Avoid this
3814      case. */
3815   if (ctxp->class_err && id == super)
3816     super = NULL;
3817
3818   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3819
3820   /* Basic checks: scope, redefinition, modifiers */
3821   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3822     {
3823       PUSH_ERROR ();
3824       return NULL_TREE;
3825     }
3826
3827   /* Suspend the current parsing context if we're parsing an inner
3828      interface */
3829   if (CPC_INNER_P ())
3830     {
3831       java_parser_context_suspend ();
3832       /* Interface members are public. */
3833       if (CLASS_INTERFACE (GET_CPC ()))
3834         flags |= ACC_PUBLIC;
3835     }
3836
3837   /* Push a new context for (static) initialized upon declaration fields */
3838   java_parser_context_push_initialized_field ();
3839
3840   /* Interface modifiers check
3841        - public/abstract allowed (already done at that point)
3842        - abstract is obsolete (comes first, it's a warning, or should be)
3843        - Can't use twice the same (checked in the modifier rule) */
3844   if ((flags & ACC_ABSTRACT) && flag_redundant)
3845     parse_warning_context
3846       (MODIFIER_WFL (ABSTRACT_TK),
3847        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3848
3849   /* Create a new decl if DECL is NULL, otherwise fix it */
3850   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3851
3852   /* Set super info and mark the class a complete */
3853   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3854                   object_type_node, ctxp->interface_number);
3855   ctxp->interface_number = 0;
3856   CLASS_COMPLETE_P (decl) = 1;
3857   add_superinterfaces (decl, super);
3858
3859   /* Eventually sets the @deprecated tag flag */
3860   CHECK_DEPRECATED (decl);
3861
3862   return decl;
3863 }
3864
3865 /* Patch anonymous class CLASS, by either extending or implementing
3866    DEP.  */
3867
3868 static void
3869 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3870 {
3871   tree class = TREE_TYPE (class_decl);
3872   tree type =  TREE_TYPE (type_decl);
3873   tree binfo = TYPE_BINFO (class);
3874
3875   /* If it's an interface, implement it */
3876   if (CLASS_INTERFACE (type_decl))
3877     {
3878       tree s_binfo;
3879       int length;
3880
3881       if (parser_check_super_interface (type_decl, class_decl, wfl))
3882         return;
3883
3884       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3885       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3886       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3887       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3888       /* And add the interface */
3889       parser_add_interface (class_decl, type_decl, wfl);
3890     }
3891   /* Otherwise, it's a type we want to extend */
3892   else
3893     {
3894       if (parser_check_super (type_decl, class_decl, wfl))
3895         return;
3896       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3897     }
3898 }
3899
3900 static tree
3901 create_anonymous_class (int location, tree type_name)
3902 {
3903   char buffer [80];
3904   tree super = NULL_TREE, itf = NULL_TREE;
3905   tree id, type_decl, class;
3906
3907   /* The unqualified name of the anonymous class. It's just a number. */
3908   sprintf (buffer, "%d", anonymous_class_counter++);
3909   id = build_wfl_node (get_identifier (buffer));
3910   EXPR_WFL_LINECOL (id) = location;
3911
3912   /* We know about the type to extend/implement. We go ahead */
3913   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3914     {
3915       /* Create a class which either implements on extends the designated
3916          class. The class bears an inaccessible name. */
3917       if (CLASS_INTERFACE (type_decl))
3918         {
3919           /* It's OK to modify it here. It's been already used and
3920              shouldn't be reused */
3921           ctxp->interface_number = 1;
3922           /* Interfaces should presented as a list of WFLs */
3923           itf = build_tree_list (type_name, NULL_TREE);
3924         }
3925       else
3926         super = type_name;
3927     }
3928
3929   class = create_class (ACC_FINAL, id, super, itf);
3930
3931   /* We didn't know anything about the stuff. We register a dependence. */
3932   if (!type_decl)
3933     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3934
3935   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3936   return class;
3937 }
3938
3939 /* Create a class in pass1 and return its decl. Return class
3940    interface's decl in pass 2.  */
3941
3942 static tree
3943 create_class (int flags, tree id, tree super, tree interfaces)
3944 {
3945   tree raw_name = EXPR_WFL_NODE (id);
3946   tree class_id, decl;
3947   tree super_decl_type;
3948
3949   /* Certain syntax errors are making SUPER be like ID. Avoid this
3950      case. */
3951   if (ctxp->class_err && id == super)
3952     super = NULL;
3953
3954   class_id = parser_qualified_classname (raw_name);
3955   decl = IDENTIFIER_CLASS_VALUE (class_id);
3956   EXPR_WFL_NODE (id) = class_id;
3957
3958   /* Basic check: scope, redefinition, modifiers */
3959   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3960     {
3961       PUSH_ERROR ();
3962       return NULL_TREE;
3963     }
3964
3965   /* Suspend the current parsing context if we're parsing an inner
3966      class or an anonymous class. */
3967   if (CPC_INNER_P ())
3968     {
3969       java_parser_context_suspend ();
3970       /* Interface members are public. */
3971       if (CLASS_INTERFACE (GET_CPC ()))
3972         flags |= ACC_PUBLIC;
3973     }
3974
3975   /* Push a new context for (static) initialized upon declaration fields */
3976   java_parser_context_push_initialized_field ();
3977
3978   /* Class modifier check:
3979        - Allowed modifier (already done at that point)
3980        - abstract AND final forbidden
3981        - Public classes defined in the correct file */
3982   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3983     parse_error_context
3984       (id, "Class `%s' can't be declared both abstract and final",
3985        IDENTIFIER_POINTER (raw_name));
3986
3987   /* Create a new decl if DECL is NULL, otherwise fix it */
3988   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3989
3990   /* If SUPER exists, use it, otherwise use Object */
3991   if (super)
3992     {
3993       /* Can't extend java.lang.Object */
3994       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3995         {
3996           parse_error_context (id, "Can't extend `java.lang.Object'");
3997           return NULL_TREE;
3998         }
3999
4000       super_decl_type =
4001         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4002     }
4003   else if (TREE_TYPE (decl) != object_type_node)
4004     super_decl_type = object_type_node;
4005   /* We're defining java.lang.Object */
4006   else
4007     super_decl_type = NULL_TREE;
4008
4009   /* A class nested in an interface is implicitly static. */
4010   if (INNER_CLASS_DECL_P (decl)
4011       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4012     {
4013       flags |= ACC_STATIC;
4014     }
4015
4016   /* Set super info and mark the class as complete. */
4017   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4018                   ctxp->interface_number);
4019   ctxp->interface_number = 0;
4020   CLASS_COMPLETE_P (decl) = 1;
4021   add_superinterfaces (decl, interfaces);
4022
4023   /* Add the private this$<n> field, Replicate final locals still in
4024      scope as private final fields mangled like val$<local_name>.
4025      This doesn't not occur for top level (static) inner classes. */
4026   if (PURE_INNER_CLASS_DECL_P (decl))
4027     add_inner_class_fields (decl, current_function_decl);
4028
4029   /* If doing xref, store the location at which the inherited class
4030      (if any) was seen. */
4031   if (flag_emit_xref && super)
4032     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4033
4034   /* Eventually sets the @deprecated tag flag */
4035   CHECK_DEPRECATED (decl);
4036
4037   /* Reset the anonymous class counter when declaring non inner classes */
4038   if (!INNER_CLASS_DECL_P (decl))
4039     anonymous_class_counter = 1;
4040
4041   return decl;
4042 }
4043
4044 /* End a class declaration: register the statements used to create
4045    finit$ and <clinit>, pop the current class and resume the prior
4046    parser context if necessary.  */
4047
4048 static void
4049 end_class_declaration (int resume)
4050 {
4051   /* If an error occurred, context weren't pushed and won't need to be
4052      popped by a resume. */
4053   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4054
4055   if (GET_CPC () != error_mark_node)
4056     dump_java_tree (TDI_class, GET_CPC ());
4057
4058   java_parser_context_pop_initialized_field ();
4059   POP_CPC ();
4060   if (resume && no_error_occurred)
4061     java_parser_context_resume ();
4062
4063   /* We're ending a class declaration, this is a good time to reset
4064      the interface cout. Note that might have been already done in
4065      create_interface, but if at that time an inner class was being
4066      dealt with, the interface count was reset in a context created
4067      for the sake of handling inner classes declaration. */
4068   ctxp->interface_number = 0;
4069 }
4070
4071 static void
4072 add_inner_class_fields (tree class_decl, tree fct_decl)
4073 {
4074   tree block, marker, f;
4075
4076   f = add_field (TREE_TYPE (class_decl),
4077                  build_current_thisn (TREE_TYPE (class_decl)),
4078                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4079                  ACC_PRIVATE);
4080   FIELD_THISN (f) = 1;
4081
4082   if (!fct_decl)
4083     return;
4084
4085   for (block = GET_CURRENT_BLOCK (fct_decl);
4086        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4087     {
4088       tree decl;
4089       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4090         {
4091           tree name, pname;
4092           tree wfl, init, list;
4093
4094           /* Avoid non final arguments. */
4095           if (!LOCAL_FINAL_P (decl))
4096             continue;
4097
4098           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4099           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4100           wfl = build_wfl_node (name);
4101           init = build_wfl_node (pname);
4102           /* Build an initialization for the field: it will be
4103              initialized by a parameter added to finit$, bearing a
4104              mangled name of the field itself (param$<n>.) The
4105              parameter is provided to finit$ by the constructor
4106              invoking it (hence the constructor will also feature a
4107              hidden parameter, set to the value of the outer context
4108              local at the time the inner class is created.)
4109
4110              Note: we take into account all possible locals that can
4111              be accessed by the inner class. It's actually not trivial
4112              to minimize these aliases down to the ones really
4113              used. One way to do that would be to expand all regular
4114              methods first, then finit$ to get a picture of what's
4115              used.  It works with the exception that we would have to
4116              go back on all constructor invoked in regular methods to
4117              have their invocation reworked (to include the right amount
4118              of alias initializer parameters.)
4119
4120              The only real way around, I think, is a first pass to
4121              identify locals really used in the inner class. We leave
4122              the flag FIELD_LOCAL_ALIAS_USED around for that future
4123              use.
4124
4125              On the other hand, it only affect local inner classes,
4126              whose constructors (and finit$ call) will be featuring
4127              unnecessary arguments. It's easy for a developer to keep
4128              this number of parameter down by using the `final'
4129              keyword only when necessary. For the time being, we can
4130              issue a warning on unnecessary finals. FIXME */
4131           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4132                                    wfl, init);
4133
4134           /* Register the field. The TREE_LIST holding the part
4135              initialized/initializer will be marked ARG_FINAL_P so
4136              that the created field can be marked
4137              FIELD_LOCAL_ALIAS. */
4138           list = build_tree_list (wfl, init);
4139           ARG_FINAL_P (list) = 1;
4140           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4141         }
4142     }
4143
4144   if (!CPC_INITIALIZER_STMT (ctxp))
4145     return;
4146
4147   /* If we ever registered an alias field, insert and marker to
4148      remember where the list ends. The second part of the list (the one
4149      featuring initialized fields) so it can be later reversed to
4150      enforce 8.5. The marker will be removed during that operation. */
4151   marker = build_tree_list (NULL_TREE, NULL_TREE);
4152   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4153   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4154 }
4155
4156 /* Can't use lookup_field () since we don't want to load the class and
4157    can't set the CLASS_LOADED_P flag */
4158
4159 static tree
4160 find_field (tree class, tree name)
4161 {
4162   tree decl;
4163   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4164     {
4165       if (DECL_NAME (decl) == name)
4166         return decl;
4167     }
4168   return NULL_TREE;
4169 }
4170
4171 /* Wrap around lookup_field that doesn't potentially upset the value
4172    of CLASS */
4173
4174 static tree
4175 lookup_field_wrapper (tree class, tree name)
4176 {
4177   tree type = class;
4178   tree decl = NULL_TREE;
4179   java_parser_context_save_global ();
4180
4181   /* Last chance: if we're within the context of an inner class, we
4182      might be trying to access a local variable defined in an outer
4183      context. We try to look for it now. */
4184   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4185     {
4186       tree new_name;
4187       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4188       decl = lookup_field (&type, new_name);
4189       if (decl && decl != error_mark_node)
4190         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4191     }
4192   if (!decl || decl == error_mark_node)
4193     {
4194       type = class;
4195       decl = lookup_field (&type, name);
4196     }
4197
4198   /* If the field still hasn't been found, try the next enclosing context. */
4199   if (!decl && INNER_CLASS_TYPE_P (class))
4200     {
4201       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4202       decl = lookup_field_wrapper (outer_type, name);
4203     }
4204
4205   java_parser_context_restore_global ();
4206   return decl == error_mark_node ? NULL : decl;
4207 }
4208
4209 /* Find duplicate field within the same class declarations and report
4210    the error. Returns 1 if a duplicated field was found, 0
4211    otherwise.  */
4212
4213 static int
4214 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4215 {
4216   /* This might be modified to work with method decl as well */
4217   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4218   if (decl)
4219     {
4220       char *t1 = xstrdup (purify_type_name
4221                          ((TREE_CODE (new_type) == POINTER_TYPE
4222                            && TREE_TYPE (new_type) == NULL_TREE) ?
4223                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4224                           lang_printable_name (new_type, 1)));
4225       /* The type may not have been completed by the time we report
4226          the error */
4227       char *t2 = xstrdup (purify_type_name
4228                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4229                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4230                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4231                           lang_printable_name (TREE_TYPE (decl), 1)));
4232       parse_error_context
4233         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4234          t1, IDENTIFIER_POINTER (new_field_name),
4235          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4236          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4237       free (t1);
4238       free (t2);
4239       return 1;
4240     }
4241   return 0;
4242 }
4243
4244 /* Field registration routine. If TYPE doesn't exist, field
4245    declarations are linked to the undefined TYPE dependency list, to
4246    be later resolved in java_complete_class () */
4247
4248 static void
4249 register_fields (int flags, tree type, tree variable_list)
4250 {
4251   tree current, saved_type;
4252   tree class_type = NULL_TREE;
4253   int saved_lineno = input_line;
4254   int must_chain = 0;
4255   tree wfl = NULL_TREE;
4256
4257   if (GET_CPC ())
4258     class_type = TREE_TYPE (GET_CPC ());
4259
4260   if (!class_type || class_type == error_mark_node)
4261     return;
4262
4263   /* If we're adding fields to interfaces, those fields are public,
4264      static, final */
4265   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4266     {
4267       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4268                                  flags, ACC_PUBLIC, "interface field(s)");
4269       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4270                                  flags, ACC_STATIC, "interface field(s)");
4271       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4272                                  flags, ACC_FINAL, "interface field(s)");
4273       check_modifiers ("Illegal interface member modifier `%s'", flags,
4274                        INTERFACE_FIELD_MODIFIERS);
4275       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4276     }
4277
4278   /* Obtain a suitable type for resolution, if necessary */
4279   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4280
4281   /* If TYPE is fully resolved and we don't have a reference, make one */
4282   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4283
4284   for (current = variable_list, saved_type = type; current;
4285        current = TREE_CHAIN (current), type = saved_type)
4286     {
4287       tree real_type;
4288       tree field_decl;
4289       tree cl = TREE_PURPOSE (current);
4290       tree init = TREE_VALUE (current);
4291       tree current_name = EXPR_WFL_NODE (cl);
4292
4293       /* Can't declare non-final static fields in inner classes */
4294       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4295           && !(flags & ACC_FINAL))
4296         parse_error_context
4297           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4298            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4299            lang_printable_name (class_type, 0));
4300
4301       /* Process NAME, as it may specify extra dimension(s) for it */
4302       type = build_array_from_name (type, wfl, current_name, &current_name);
4303
4304       /* Type adjustment. We may have just readjusted TYPE because
4305          the variable specified more dimensions. Make sure we have
4306          a reference if we can and don't have one already. Also
4307          change the name if we have an init. */
4308       if (type != saved_type)
4309         {
4310           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4311           if (init)
4312             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4313         }
4314
4315       real_type = GET_REAL_TYPE (type);
4316       /* Check for redeclarations */
4317       if (duplicate_declaration_error_p (current_name, real_type, cl))
4318         continue;
4319
4320       /* Set lineno to the line the field was found and create a
4321          declaration for it. Eventually sets the @deprecated tag flag. */
4322       if (flag_emit_xref)
4323         input_line = EXPR_WFL_LINECOL (cl);
4324       else
4325         input_line = EXPR_WFL_LINENO (cl);
4326       field_decl = add_field (class_type, current_name, real_type, flags);
4327       CHECK_DEPRECATED_NO_RESET (field_decl);
4328
4329       /* If the field denotes a final instance variable, then we
4330          allocate a LANG_DECL_SPECIFIC part to keep track of its
4331          initialization. We also mark whether the field was
4332          initialized upon its declaration. We don't do that if the
4333          created field is an alias to a final local. */
4334       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4335         {
4336           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4337           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4338         }
4339
4340       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4341          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4342          hide parameters to this inner class finit$ and
4343          constructors. It also means that the field isn't final per
4344          say. */
4345       if (ARG_FINAL_P (current))
4346         {
4347           FIELD_LOCAL_ALIAS (field_decl) = 1;
4348           FIELD_FINAL (field_decl) = 0;
4349         }
4350
4351       /* Check if we must chain. */
4352       if (must_chain)
4353         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4354
4355       /* If we have an initialization value tied to the field */
4356       if (init)
4357         {
4358           /* The field is declared static */
4359           if (flags & ACC_STATIC)
4360             {
4361               /* We include the field and its initialization part into
4362                  a list used to generate <clinit>. After <clinit> is
4363                  walked, field initializations will be processed and
4364                  fields initialized with known constants will be taken
4365                  out of <clinit> and have their DECL_INITIAL set
4366                  appropriately. */
4367               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4368               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4369               if (TREE_OPERAND (init, 1)
4370                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4371                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4372             }
4373           /* A non-static field declared with an immediate initialization is
4374              to be initialized in <init>, if any.  This field is remembered
4375              to be processed at the time of the generation of <init>. */
4376           else
4377             {
4378               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4379               SET_CPC_INITIALIZER_STMT (ctxp, init);
4380             }
4381           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4382           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4383         }
4384     }
4385
4386   CLEAR_DEPRECATED;
4387   input_line = saved_lineno;
4388 }
4389
4390 /* Generate finit$, using the list of initialized fields to populate
4391    its body. finit$'s parameter(s) list is adjusted to include the
4392    one(s) used to initialized the field(s) caching outer context
4393    local(s).  */
4394
4395 static tree
4396 generate_finit (tree class_type)
4397 {
4398   int count = 0;
4399   tree list = TYPE_FINIT_STMT_LIST (class_type);
4400   tree mdecl, current, parms;
4401
4402   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4403                                                   class_type, NULL_TREE,
4404                                                   &count);
4405   CRAFTED_PARAM_LIST_FIXUP (parms);
4406   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4407                                     finit_identifier_node, parms);
4408   fix_method_argument_names (parms, mdecl);
4409   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4410                        mdecl, NULL_TREE);
4411   DECL_FUNCTION_NAP (mdecl) = count;
4412   start_artificial_method_body (mdecl);
4413
4414   for (current = list; current; current = TREE_CHAIN (current))
4415     java_method_add_stmt (mdecl,
4416                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4417                                                 current));
4418   end_artificial_method_body (mdecl);
4419   return mdecl;
4420 }
4421
4422 /* Generate a function to run the instance initialization code. The
4423    private method is called `instinit$'. Unless we're dealing with an
4424    anonymous class, we determine whether all ctors of CLASS_TYPE
4425    declare a checked exception in their `throws' clause in order to
4426    see whether it's necessary to encapsulate the instance initializer
4427    statements in a try/catch/rethrow sequence.  */
4428
4429 static tree
4430 generate_instinit (tree class_type)
4431 {
4432   tree current;
4433   tree compound = NULL_TREE;
4434   tree parms = tree_cons (this_identifier_node,
4435                           build_pointer_type (class_type), end_params_node);
4436   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4437                                          void_type_node,
4438                                          instinit_identifier_node, parms);
4439
4440   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4441                        mdecl, NULL_TREE);
4442
4443   /* Gather all the statements in a compound */
4444   for (current = TYPE_II_STMT_LIST (class_type);
4445        current; current = TREE_CHAIN (current))
4446     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4447
4448   /* We need to encapsulate COMPOUND by a try/catch statement to
4449      rethrow exceptions that might occur in the instance initializer.
4450      We do that only if all ctors of CLASS_TYPE are set to catch a
4451      checked exception. This doesn't apply to anonymous classes (since
4452      they don't have declared ctors.) */
4453   if (!ANONYMOUS_CLASS_P (class_type) &&
4454       ctors_unchecked_throws_clause_p (class_type))
4455     {
4456       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4457                                              build1 (THROW_EXPR, NULL_TREE,
4458                                                      build_wfl_node (wpv_id)));
4459       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4460                                                       exception_type_node);
4461     }
4462
4463   start_artificial_method_body (mdecl);
4464   java_method_add_stmt (mdecl, compound);
4465   end_artificial_method_body (mdecl);
4466
4467   return mdecl;
4468 }
4469
4470 /* FIXME */
4471 static tree
4472 build_instinit_invocation (tree class_type)
4473 {
4474   tree to_return = NULL_TREE;
4475
4476   if (TYPE_II_STMT_LIST (class_type))
4477     {
4478       tree parm = build_tree_list (NULL_TREE,
4479                                    build_wfl_node (this_identifier_node));
4480       to_return =
4481         build_method_invocation (build_wfl_node (instinit_identifier_node),
4482                                  parm);
4483     }
4484   return to_return;
4485 }
4486
4487 /* Shared across method_declarator and method_header to remember the
4488    patch stage that was reached during the declaration of the method.
4489    A method DECL is built differently is there is no patch
4490    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4491    pending on the currently defined method.  */
4492
4493 static int patch_stage;
4494
4495 /* Check the method declaration and add the method to its current
4496    class.  If the argument list is known to contain incomplete types,
4497    the method is partially added and the registration will be resume
4498    once the method arguments resolved. If TYPE is NULL, we're dealing
4499    with a constructor.  */
4500
4501 static tree
4502 method_header (int flags, tree type, tree mdecl, tree throws)
4503 {
4504   tree type_wfl = NULL_TREE;
4505   tree meth_name = NULL_TREE;
4506   tree current, orig_arg, this_class = NULL;
4507   tree id, meth;
4508   int saved_lineno;
4509   int constructor_ok = 0, must_chain;
4510   int count;
4511
4512   if (mdecl == error_mark_node)
4513     return error_mark_node;
4514   meth = TREE_VALUE (mdecl);
4515   id = TREE_PURPOSE (mdecl);
4516
4517   check_modifiers_consistency (flags);
4518
4519   if (GET_CPC ())
4520     this_class = TREE_TYPE (GET_CPC ());
4521
4522   if (!this_class || this_class == error_mark_node)
4523     return NULL_TREE;
4524
4525   /* There are some forbidden modifiers for an abstract method and its
4526      class must be abstract as well.  */
4527   if (type && (flags & ACC_ABSTRACT))
4528     {
4529       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4530       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4531       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4532       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4533       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4534       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4535       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4536           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4537         parse_error_context
4538           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4539            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4540            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4541     }
4542
4543   /* A native method can't be strictfp.  */
4544   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4545     parse_error_context (id, "native method `%s' can't be strictfp",
4546                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4547   /* No such thing as a transient or volatile method.  */
4548   if ((flags & ACC_TRANSIENT))
4549     parse_error_context (id, "method `%s' can't be transient",
4550                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4551   if ((flags & ACC_VOLATILE))
4552     parse_error_context (id, "method `%s' can't be volatile",
4553                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4554
4555   /* Things to be checked when declaring a constructor */
4556   if (!type)
4557     {
4558       int ec = java_error_count;
4559       /* 8.6: Constructor declarations: we might be trying to define a
4560          method without specifying a return type. */
4561       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4562         parse_error_context
4563           (id, "Invalid method declaration, return type required");
4564       /* 8.6.3: Constructor modifiers */
4565       else
4566         {
4567           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4568           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4569           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4570           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4571           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4572           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4573         }
4574       /* If we found error here, we don't consider it's OK to tread
4575          the method definition as a constructor, for the rest of this
4576          function */
4577       if (ec == java_error_count)
4578         constructor_ok = 1;
4579     }
4580
4581   /* Method declared within the scope of an interface are implicitly
4582      abstract and public. Conflicts with other erroneously provided
4583      modifiers are checked right after. */
4584
4585   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4586     {
4587       /* If FLAGS isn't set because of a modifier, turn the
4588          corresponding modifier WFL to NULL so we issue a warning on
4589          the obsolete use of the modifier */
4590       if (!(flags & ACC_PUBLIC))
4591         MODIFIER_WFL (PUBLIC_TK) = NULL;
4592       if (!(flags & ACC_ABSTRACT))
4593         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4594       flags |= ACC_PUBLIC;
4595       flags |= ACC_ABSTRACT;
4596     }
4597
4598   /* Inner class can't declare static methods */
4599   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4600     {
4601       parse_error_context
4602         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4603          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4604          lang_printable_name (this_class, 0));
4605     }
4606
4607   /* Modifiers context reset moved up, so abstract method declaration
4608      modifiers can be later checked.  */
4609
4610   /* Set constructor returned type to void and method name to <init>,
4611      unless we found an error identifier the constructor (in which
4612      case we retain the original name) */
4613   if (!type)
4614     {
4615       type = void_type_node;
4616       if (constructor_ok)
4617         meth_name = init_identifier_node;
4618     }
4619   else
4620     meth_name = EXPR_WFL_NODE (id);
4621
4622   /* Do the returned type resolution and registration if necessary */
4623   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4624
4625   if (meth_name)
4626     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4627   EXPR_WFL_NODE (id) = meth_name;
4628   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4629
4630   if (must_chain)
4631     {
4632       patch_stage = JDEP_METHOD_RETURN;
4633       register_incomplete_type (patch_stage, type_wfl, id, type);
4634       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4635     }
4636   else
4637     TREE_TYPE (meth) = type;
4638
4639   saved_lineno = input_line;
4640   /* When defining an abstract or interface method, the curly
4641      bracket at level 1 doesn't exist because there is no function
4642      body */
4643   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4644             EXPR_WFL_LINENO (id));
4645
4646   /* Remember the original argument list */
4647   orig_arg = TYPE_ARG_TYPES (meth);
4648
4649   if (patch_stage)              /* includes ret type and/or all args */
4650     {
4651       jdep *jdep;
4652       meth = add_method_1 (this_class, flags, meth_name, meth);
4653       /* Patch for the return type */
4654       if (patch_stage == JDEP_METHOD_RETURN)
4655         {
4656           jdep = CLASSD_LAST (ctxp->classd_list);
4657           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4658         }
4659       /* This is the stop JDEP. METH allows the function's signature
4660          to be computed. */
4661       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4662     }
4663   else
4664     meth = add_method (this_class, flags, meth_name,
4665                        build_java_signature (meth));
4666
4667   /* Remember final parameters */
4668   MARK_FINAL_PARMS (meth, orig_arg);
4669
4670   /* Fix the method argument list so we have the argument name
4671      information */
4672   fix_method_argument_names (orig_arg, meth);
4673
4674   /* Register the parameter number and re-install the current line
4675      number */
4676   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4677   input_line = saved_lineno;
4678
4679   /* Register exception specified by the `throws' keyword for
4680      resolution and set the method decl appropriate field to the list.
4681      Note: the grammar ensures that what we get here are class
4682      types. */
4683   if (throws)
4684     {
4685       throws = nreverse (throws);
4686       for (current = throws; current; current = TREE_CHAIN (current))
4687         {
4688           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4689                                     NULL_TREE, NULL_TREE);
4690           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4691             &TREE_VALUE (current);
4692         }
4693       DECL_FUNCTION_THROWS (meth) = throws;
4694     }
4695
4696   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4697     DECL_FUNCTION_WFL (meth) = id;
4698
4699   /* Set the flag if we correctly processed a constructor */
4700   if (constructor_ok)
4701     {
4702       DECL_CONSTRUCTOR_P (meth) = 1;
4703       /* Compute and store the number of artificial parameters declared
4704          for this constructor */
4705       for (count = 0, current = TYPE_FIELDS (this_class); current;
4706            current = TREE_CHAIN (current))
4707         if (FIELD_LOCAL_ALIAS (current))
4708           count++;
4709       DECL_FUNCTION_NAP (meth) = count;
4710     }
4711
4712   /* Eventually set the @deprecated tag flag */
4713   CHECK_DEPRECATED (meth);
4714
4715   /* If doing xref, store column and line number information instead
4716      of the line number only. */
4717   if (flag_emit_xref)
4718     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4719
4720   return meth;
4721 }
4722
4723 static void
4724 fix_method_argument_names (tree orig_arg, tree meth)
4725 {
4726   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4727   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4728     {
4729       TREE_PURPOSE (arg) = this_identifier_node;
4730       arg = TREE_CHAIN (arg);
4731     }
4732   while (orig_arg != end_params_node)
4733     {
4734       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4735       orig_arg = TREE_CHAIN (orig_arg);
4736       arg = TREE_CHAIN (arg);
4737     }
4738 }
4739
4740 /* Complete the method declaration with METHOD_BODY.  */
4741
4742 static void
4743 finish_method_declaration (tree method_body)
4744 {
4745   int flags;
4746
4747   if (!current_function_decl)
4748     return;
4749
4750   flags = get_access_flags_from_decl (current_function_decl);
4751
4752   /* 8.4.5 Method Body */
4753   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4754     {
4755       tree name = DECL_NAME (current_function_decl);
4756       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4757                            "%s method `%s' can't have a body defined",
4758                            (METHOD_NATIVE (current_function_decl) ?
4759                             "Native" : "Abstract"),
4760                            IDENTIFIER_POINTER (name));
4761       method_body = NULL_TREE;
4762     }
4763   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4764     {
4765       tree name = DECL_NAME (current_function_decl);
4766       parse_error_context
4767         (DECL_FUNCTION_WFL (current_function_decl),
4768          "Non native and non abstract method `%s' must have a body defined",
4769          IDENTIFIER_POINTER (name));
4770       method_body = NULL_TREE;
4771     }
4772
4773   if (flag_emit_class_files && method_body
4774       && TREE_CODE (method_body) == NOP_EXPR
4775       && TREE_TYPE (current_function_decl)
4776       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4777     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4778
4779   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4780   maybe_absorb_scoping_blocks ();
4781   /* Exit function's body */
4782   exit_block ();
4783   /* Merge last line of the function with first line, directly in the
4784      function decl. It will be used to emit correct debug info. */
4785   if (!flag_emit_xref)
4786     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4787
4788   /* Since function's argument's list are shared, reset the
4789      ARG_FINAL_P parameter that might have been set on some of this
4790      function parameters. */
4791   UNMARK_FINAL_PARMS (current_function_decl);
4792
4793   /* So we don't have an irrelevant function declaration context for
4794      the next static block we'll see. */
4795   current_function_decl = NULL_TREE;
4796 }
4797
4798 /* Build a an error message for constructor circularity errors.  */
4799
4800 static char *
4801 constructor_circularity_msg (tree from, tree to)
4802 {
4803   static char string [4096];
4804   char *t = xstrdup (lang_printable_name (from, 0));
4805   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4806   free (t);
4807   return string;
4808 }
4809
4810 /* Verify a circular call to METH. Return 1 if an error is found, 0
4811    otherwise.  */
4812
4813 static GTY(()) tree vcc_list;
4814 static int
4815 verify_constructor_circularity (tree meth, tree current)
4816 {
4817   tree c;
4818
4819   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4820     {
4821       if (TREE_VALUE (c) == meth)
4822         {
4823           char *t;
4824           if (vcc_list)
4825             {
4826               tree liste;
4827               vcc_list = nreverse (vcc_list);
4828               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4829                 {
4830                   parse_error_context
4831                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4832                      constructor_circularity_msg
4833                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4834                   java_error_count--;
4835                 }
4836             }
4837           t = xstrdup (lang_printable_name (meth, 0));
4838           parse_error_context (TREE_PURPOSE (c),
4839                                "%s: recursive invocation of constructor `%s'",
4840                                constructor_circularity_msg (current, meth), t);
4841           free (t);
4842           vcc_list = NULL_TREE;
4843           return 1;
4844         }
4845     }
4846   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4847     {
4848       vcc_list = tree_cons (c, current, vcc_list);
4849       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4850         return 1;
4851       vcc_list = TREE_CHAIN (vcc_list);
4852     }
4853   return 0;
4854 }
4855
4856 /* Check modifiers that can be declared but exclusively */
4857
4858 static void
4859 check_modifiers_consistency (int flags)
4860 {
4861   int acc_count = 0;
4862   tree cl = NULL_TREE;
4863
4864   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4865   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4866   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4867   if (acc_count > 1)
4868     parse_error_context
4869       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4870
4871   acc_count = 0;
4872   cl = NULL_TREE;
4873   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4874   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4875   if (acc_count > 1)
4876     parse_error_context (cl,
4877                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4878 }
4879
4880 /* Check the methode header METH for abstract specifics features */
4881
4882 static void
4883 check_abstract_method_header (tree meth)
4884 {
4885   int flags = get_access_flags_from_decl (meth);
4886
4887   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4888                               ACC_ABSTRACT, "abstract method",
4889                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4890   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4891                               ACC_PUBLIC, "abstract method",
4892                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4893
4894   check_modifiers ("Illegal modifier `%s' for interface method",
4895                   flags, INTERFACE_METHOD_MODIFIERS);
4896 }
4897
4898 /* Create a FUNCTION_TYPE node and start augmenting it with the
4899    declared function arguments. Arguments type that can't be resolved
4900    are left as they are, but the returned node is marked as containing
4901    incomplete types.  */
4902
4903 static tree
4904 method_declarator (tree id, tree list)
4905 {
4906   tree arg_types = NULL_TREE, current, node;
4907   tree meth = make_node (FUNCTION_TYPE);
4908   jdep *jdep;
4909
4910   patch_stage = JDEP_NO_PATCH;
4911
4912   if (GET_CPC () == error_mark_node)
4913     return error_mark_node;
4914
4915   /* If we're dealing with an inner class constructor, we hide the
4916      this$<n> decl in the name field of its parameter declaration.  We
4917      also might have to hide the outer context local alias
4918      initializers. Not done when the class is a toplevel class. */
4919   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4920       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4921     {
4922       tree aliases_list, type, thisn;
4923       /* First the aliases, linked to the regular parameters */
4924       aliases_list =
4925         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4926                                                 TREE_TYPE (GET_CPC ()),
4927                                                 NULL_TREE, NULL);
4928       list = chainon (nreverse (aliases_list), list);
4929
4930       /* Then this$<n> */
4931       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4932       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4933       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4934                         list);
4935     }
4936
4937   for (current = list; current; current = TREE_CHAIN (current))
4938     {
4939       int must_chain = 0;
4940       tree wfl_name = TREE_PURPOSE (current);
4941       tree type = TREE_VALUE (current);
4942       tree name = EXPR_WFL_NODE (wfl_name);
4943       tree already, arg_node;
4944       tree type_wfl = NULL_TREE;
4945       tree real_type;
4946
4947       /* Obtain a suitable type for resolution, if necessary */
4948       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4949
4950       /* Process NAME, as it may specify extra dimension(s) for it */
4951       type = build_array_from_name (type, type_wfl, name, &name);
4952       EXPR_WFL_NODE (wfl_name) = name;
4953
4954       real_type = GET_REAL_TYPE (type);
4955       if (TREE_CODE (real_type) == RECORD_TYPE)
4956         {
4957           real_type = promote_type (real_type);
4958           if (TREE_CODE (type) == TREE_LIST)
4959             TREE_PURPOSE (type) = real_type;
4960         }
4961
4962       /* Check redefinition */
4963       for (already = arg_types; already; already = TREE_CHAIN (already))
4964         if (TREE_PURPOSE (already) == name)
4965           {
4966             parse_error_context
4967               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4968                IDENTIFIER_POINTER (name),
4969                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4970             break;
4971           }
4972
4973       /* If we've an incomplete argument type, we know there is a location
4974          to patch when the type get resolved, later.  */
4975       jdep = NULL;
4976       if (must_chain)
4977         {
4978           patch_stage = JDEP_METHOD;
4979           type = register_incomplete_type (patch_stage,
4980                                            type_wfl, wfl_name, type);
4981           jdep = CLASSD_LAST (ctxp->classd_list);
4982           JDEP_MISC (jdep) = id;
4983         }
4984
4985       /* The argument node: a name and a (possibly) incomplete type.  */
4986       arg_node = build_tree_list (name, real_type);
4987       /* Remember arguments declared final. */
4988       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4989
4990       if (jdep)
4991         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4992       TREE_CHAIN (arg_node) = arg_types;
4993       arg_types = arg_node;
4994     }
4995   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4996   node = build_tree_list (id, meth);
4997   return node;
4998 }
4999
5000 static int
5001 unresolved_type_p (tree wfl, tree *returned)
5002
5003 {
5004   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5005     {
5006       if (returned)
5007         {
5008           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5009           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5010             *returned = TREE_TYPE (decl);
5011           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5012             *returned = TREE_TYPE (GET_CPC ());
5013           else
5014             *returned = NULL_TREE;
5015         }
5016       return 1;
5017     }
5018   if (returned)
5019     *returned = wfl;
5020   return 0;
5021 }
5022
5023 /* From NAME, build a qualified identifier node using the
5024    qualification from the current package definition. */
5025
5026 static tree
5027 parser_qualified_classname (tree name)
5028 {
5029   tree nested_class_name;
5030
5031   if ((nested_class_name = maybe_make_nested_class_name (name)))
5032     return nested_class_name;
5033
5034   if (ctxp->package)
5035     return merge_qualified_name (ctxp->package, name);
5036   else
5037     return name;
5038 }
5039
5040 /* Called once the type a interface extends is resolved. Returns 0 if
5041    everything is OK.  */
5042
5043 static int
5044 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5045 {
5046   tree super_type = TREE_TYPE (super_decl);
5047
5048   /* Has to be an interface */
5049   if (!CLASS_INTERFACE (super_decl))
5050     {
5051       parse_error_context
5052         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5053          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5054           "Interface" : "Class"),
5055          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5056          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5057          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5058       return 1;
5059     }
5060
5061   /* Check top-level interface access. Inner classes are subject to member
5062      access rules (6.6.1). */
5063   if (! INNER_CLASS_P (super_type)
5064       && check_pkg_class_access (DECL_NAME (super_decl),
5065                                  lookup_cl (this_decl), true))
5066     return 1;
5067
5068   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5069                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5070                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5071   return 0;
5072 }
5073
5074 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5075    0 if everything is OK.  */
5076
5077 static int
5078 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5079 {
5080   tree super_type = TREE_TYPE (super_decl);
5081
5082   /* SUPER should be a CLASS (neither an array nor an interface) */
5083   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5084     {
5085       parse_error_context
5086         (wfl, "Class `%s' can't subclass %s `%s'",
5087          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5088          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5089          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5090       return 1;
5091     }
5092
5093   if (CLASS_FINAL (TYPE_NAME (super_type)))
5094     {
5095       parse_error_context (wfl, "Can't subclass final classes: %s",
5096                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5097       return 1;
5098     }
5099
5100   /* Check top-level class scope. Inner classes are subject to member access
5101      rules (6.6.1). */
5102   if (! INNER_CLASS_P (super_type)
5103       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5104     return 1;
5105
5106   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5107                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5108                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5109   return 0;
5110 }
5111
5112 /* Create a new dependency list and link it (in a LIFO manner) to the
5113    CTXP list of type dependency list.  */
5114
5115 static void
5116 create_jdep_list (struct parser_ctxt *ctxp)
5117 {
5118   jdeplist *new = xmalloc (sizeof (jdeplist));
5119   new->first = new->last = NULL;
5120   new->next = ctxp->classd_list;
5121   ctxp->classd_list = new;
5122 }
5123
5124 static jdeplist *
5125 reverse_jdep_list (struct parser_ctxt *ctxp)
5126 {
5127   jdeplist *prev = NULL, *current, *next;
5128   for (current = ctxp->classd_list; current; current = next)
5129     {
5130       next = current->next;
5131       current->next = prev;
5132       prev = current;
5133     }
5134   return prev;
5135 }
5136
5137 /* Create a fake pointer based on the ID stored in
5138    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5139    registered again. */
5140
5141 static tree
5142 obtain_incomplete_type (tree type_name)
5143 {
5144   tree ptr = NULL_TREE, name;
5145
5146   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5147     name = EXPR_WFL_NODE (type_name);
5148   else if (INCOMPLETE_TYPE_P (type_name))
5149     name = TYPE_NAME (type_name);
5150   else
5151     abort ();
5152
5153   /* Workaround from build_pointer_type for incomplete types.  */
5154   BUILD_PTR_FROM_NAME (ptr, name);
5155   TYPE_MODE (ptr) = ptr_mode;
5156   layout_type (ptr);
5157
5158   return ptr;
5159 }
5160
5161 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5162    non NULL instead of computing a new fake type based on WFL. The new
5163    dependency is inserted in the current type dependency list, in FIFO
5164    manner.  */
5165
5166 static tree
5167 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5168 {
5169   jdep *new = xmalloc (sizeof (jdep));
5170
5171   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5172     ptr = obtain_incomplete_type (wfl);
5173
5174   JDEP_KIND (new) = kind;
5175   JDEP_DECL (new) = decl;
5176   JDEP_TO_RESOLVE (new) = ptr;
5177   JDEP_WFL (new) = wfl;
5178   JDEP_CHAIN (new) = NULL;
5179   JDEP_MISC (new) = NULL_TREE;
5180   /* For some dependencies, set the enclosing class of the current
5181      class to be the enclosing context */
5182   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5183       && GET_ENCLOSING_CPC ())
5184     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5185   else if (kind == JDEP_SUPER)
5186     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5187                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5188   else
5189     JDEP_ENCLOSING (new) = GET_CPC ();
5190   JDEP_GET_PATCH (new) = (tree *)NULL;
5191
5192   JDEP_INSERT (ctxp->classd_list, new);
5193
5194   return ptr;
5195 }
5196
5197 /* This checks for circular references with innerclasses. We start
5198    from SOURCE and should never reach TARGET. Extended/implemented
5199    types in SOURCE have their enclosing context checked not to reach
5200    TARGET. When the last enclosing context of SOURCE is reached, its
5201    extended/implemented types are also checked not to reach TARGET.
5202    In case of error, WFL of the offending type is returned; NULL_TREE
5203    otherwise.  */
5204
5205 static tree
5206 check_inner_circular_reference (tree source, tree target)
5207 {
5208   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5209   tree ctx, cl;
5210   int i;
5211
5212   if (!basetype_vec)
5213     return NULL_TREE;
5214
5215   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5216     {
5217       tree su;
5218
5219       /* We can end up with a NULL_TREE or an incomplete type here if
5220          we encountered previous type resolution errors. It's safe to
5221          simply ignore these cases.  */
5222       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5223         continue;
5224       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5225       if (INCOMPLETE_TYPE_P (su))
5226         continue;
5227
5228       if (inherits_from_p (su, target))
5229         return lookup_cl (TYPE_NAME (su));
5230
5231       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5232         {
5233           /* An enclosing context shouldn't be TARGET */
5234           if (ctx == TYPE_NAME (target))
5235             return lookup_cl (TYPE_NAME (su));
5236
5237           /* When we reach the enclosing last context, start a check
5238              on it, with the same target */
5239           if (! DECL_CONTEXT (ctx) &&
5240               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5241             return cl;
5242         }
5243     }
5244   return NULL_TREE;
5245 }
5246
5247 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5248    offending type if a circularity is detected. NULL_TREE is returned
5249    otherwise. TYPE can be an interface or a class.   */
5250
5251 static tree
5252 check_circular_reference (tree type)
5253 {
5254   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5255   int i;
5256
5257   if (!basetype_vec)
5258     return NULL_TREE;
5259
5260   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5261     {
5262       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5263         return lookup_cl (TYPE_NAME (type));
5264       return NULL_TREE;
5265     }
5266
5267   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5268     {
5269       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5270       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5271           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5272         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5273     }
5274   return NULL_TREE;
5275 }
5276
5277 void
5278 java_check_circular_reference (void)
5279 {
5280   tree current;
5281   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5282     {
5283       tree type = TREE_TYPE (current);
5284       tree cl;
5285
5286       cl = check_circular_reference (type);
5287       if (! cl)
5288         cl = check_inner_circular_reference (type, type);
5289       if (cl)
5290         parse_error_context (cl, "Cyclic class inheritance%s",
5291                              (cyclic_inheritance_report ?
5292                               cyclic_inheritance_report : ""));
5293     }
5294 }
5295
5296 /* Augment the parameter list PARM with parameters crafted to
5297    initialize outer context locals aliases. Through ARTIFICIAL, a
5298    count is kept of the number of crafted parameters. MODE governs
5299    what eventually gets created: something suitable for a function
5300    creation or a function invocation, either the constructor or
5301    finit$.  */
5302
5303 static tree
5304 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5305                                         int *artificial)
5306 {
5307   tree field;
5308   tree additional_parms = NULL_TREE;
5309
5310   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5311     if (FIELD_LOCAL_ALIAS (field))
5312       {
5313         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5314         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5315         tree mangled_id;
5316
5317         switch (mode)
5318           {
5319           case AIPL_FUNCTION_DECLARATION:
5320             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5321                                                          &buffer [4]);
5322             purpose = build_wfl_node (mangled_id);
5323             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5324               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5325             else
5326               value = TREE_TYPE (field);
5327             break;
5328
5329           case AIPL_FUNCTION_CREATION:
5330             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5331                                                          &buffer [4]);
5332             value = TREE_TYPE (field);
5333             break;
5334
5335           case AIPL_FUNCTION_FINIT_INVOCATION:
5336             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5337                                                          &buffer [4]);
5338             /* Now, this is wrong. purpose should always be the NAME
5339                of something and value its matching value (decl, type,
5340                etc...) FIXME -- but there is a lot to fix. */
5341
5342             /* When invoked for this kind of operation, we already
5343                know whether a field is used or not. */
5344             purpose = TREE_TYPE (field);
5345             value = build_wfl_node (mangled_id);
5346             break;
5347
5348           case AIPL_FUNCTION_CTOR_INVOCATION:
5349             /* There are two case: the constructor invocation happens
5350                outside the local inner, in which case, locales from the outer
5351                context are directly used.
5352
5353                Otherwise, we fold to using the alias directly. */
5354             if (class_type == current_class)
5355               value = field;
5356             else
5357               {
5358                 name = get_identifier (&buffer[4]);
5359                 value = IDENTIFIER_LOCAL_VALUE (name);
5360               }
5361             break;
5362           }
5363         additional_parms = tree_cons (purpose, value, additional_parms);
5364         if (artificial)
5365           *artificial +=1;
5366       }
5367   if (additional_parms)
5368     {
5369       if (ANONYMOUS_CLASS_P (class_type)
5370           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5371         additional_parms = nreverse (additional_parms);
5372       parm = chainon (additional_parms, parm);
5373     }
5374
5375    return parm;
5376 }
5377
5378 /* Craft a constructor for CLASS_DECL -- what we should do when none
5379    where found. ARGS is non NULL when a special signature must be
5380    enforced. This is the case for anonymous classes.  */
5381
5382 static tree
5383 craft_constructor (tree class_decl, tree args)
5384 {
5385   tree class_type = TREE_TYPE (class_decl);
5386   tree parm = NULL_TREE;
5387   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5388                ACC_PUBLIC : 0);
5389   int i = 0, artificial = 0;
5390   tree decl, ctor_name;
5391   char buffer [80];
5392
5393   /* The constructor name is <init> unless we're dealing with an
5394      anonymous class, in which case the name will be fixed after having
5395      be expanded. */
5396   if (ANONYMOUS_CLASS_P (class_type))
5397     ctor_name = DECL_NAME (class_decl);
5398   else
5399     ctor_name = init_identifier_node;
5400
5401   /* If we're dealing with an inner class constructor, we hide the
5402      this$<n> decl in the name field of its parameter declaration. */
5403   if (PURE_INNER_CLASS_TYPE_P (class_type))
5404     {
5405       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5406       parm = tree_cons (build_current_thisn (class_type),
5407                         build_pointer_type (type), parm);
5408
5409       /* Some more arguments to be hidden here. The values of the local
5410          variables of the outer context that the inner class needs to see. */
5411       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5412                                                      class_type, parm,
5413                                                      &artificial);
5414     }
5415
5416   /* Then if there are any args to be enforced, enforce them now */
5417   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5418     {
5419       sprintf (buffer, "parm%d", i++);
5420       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5421     }
5422
5423   CRAFTED_PARAM_LIST_FIXUP (parm);
5424   decl = create_artificial_method (class_type, flags, void_type_node,
5425                                    ctor_name, parm);
5426   fix_method_argument_names (parm, decl);
5427   /* Now, mark the artificial parameters. */
5428   DECL_FUNCTION_NAP (decl) = artificial;
5429   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5430   DECL_INLINE (decl) = 1;
5431   return decl;
5432 }
5433
5434
5435 /* Fix the constructors. This will be called right after circular
5436    references have been checked. It is necessary to fix constructors
5437    early even if no code generation will take place for that class:
5438    some generated constructor might be required by the class whose
5439    compilation triggered this one to be simply loaded.  */
5440
5441 void
5442 java_fix_constructors (void)
5443 {
5444   tree current;
5445
5446   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5447     {
5448       tree class_type = TREE_TYPE (current);
5449       int saw_ctor = 0;
5450       tree decl;
5451
5452       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5453         continue;
5454
5455       output_class = current_class = class_type;
5456       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5457         {
5458           if (DECL_CONSTRUCTOR_P (decl))
5459             {
5460               fix_constructors (decl);
5461               saw_ctor = 1;
5462             }
5463         }
5464
5465       /* Anonymous class constructor can't be generated that early. */
5466       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5467         craft_constructor (current, NULL_TREE);
5468     }
5469 }
5470
5471 /* safe_layout_class just makes sure that we can load a class without
5472    disrupting the current_class, input_file, lineno, etc, information
5473    about the class processed currently.  */
5474
5475 void
5476 safe_layout_class (tree class)
5477 {
5478   tree save_current_class = current_class;
5479   location_t save_location = input_location;
5480
5481   layout_class (class);
5482
5483   current_class = save_current_class;
5484   input_location = save_location;
5485 }
5486
5487 static tree
5488 jdep_resolve_class (jdep *dep)
5489 {
5490   tree decl;
5491
5492   if (JDEP_RESOLVED_P (dep))
5493     decl = JDEP_RESOLVED_DECL (dep);
5494   else
5495     {
5496       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5497                             JDEP_DECL (dep), JDEP_WFL (dep));
5498       JDEP_RESOLVED (dep, decl);
5499       /* If there is no WFL, that's ok.  We generate this warning
5500          elsewhere.  */
5501       if (decl && JDEP_WFL (dep) != NULL_TREE)
5502         check_deprecation (JDEP_WFL (dep), decl);
5503     }
5504
5505   if (!decl)
5506     complete_class_report_errors (dep);
5507   else if (PURE_INNER_CLASS_DECL_P (decl))
5508     {
5509       tree inner = TREE_TYPE (decl);
5510       if (! CLASS_LOADED_P (inner))
5511         {
5512           safe_layout_class (inner);
5513           if (TYPE_SIZE (inner) == error_mark_node)
5514             TYPE_SIZE (inner) = NULL_TREE;
5515         }
5516       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5517     }
5518   return decl;
5519 }
5520
5521 /* Complete unsatisfied class declaration and their dependencies */
5522
5523 void
5524 java_complete_class (void)
5525 {
5526   tree cclass;
5527   jdeplist *cclassd;
5528   int error_found;
5529   tree type;
5530
5531   /* Process imports */
5532   process_imports ();
5533
5534   /* Reverse things so we have the right order */
5535   ctxp->class_list = nreverse (ctxp->class_list);
5536   ctxp->classd_list = reverse_jdep_list (ctxp);
5537
5538   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5539        cclass && cclassd;
5540        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5541     {
5542       jdep *dep;
5543
5544       /* We keep the compilation unit imports in the class so that
5545          they can be used later to resolve type dependencies that
5546          aren't necessary to solve now. */
5547       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5548       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5549
5550       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5551         {
5552           tree decl;
5553           if (!(decl = jdep_resolve_class (dep)))
5554             continue;
5555
5556           /* Now it's time to patch */
5557           switch (JDEP_KIND (dep))
5558             {
5559             case JDEP_SUPER:
5560               /* Simply patch super */
5561               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5562                 continue;
5563               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5564                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5565               break;
5566
5567             case JDEP_FIELD:
5568               {
5569                 /* We do part of the job done in add_field */
5570                 tree field_decl = JDEP_DECL (dep);
5571                 tree field_type = TREE_TYPE (decl);
5572                 if (TREE_CODE (field_type) == RECORD_TYPE)
5573                   field_type = promote_type (field_type);
5574                 TREE_TYPE (field_decl) = field_type;
5575                 DECL_ALIGN (field_decl) = 0;
5576                 DECL_USER_ALIGN (field_decl) = 0;
5577                 layout_decl (field_decl, 0);
5578                 SOURCE_FRONTEND_DEBUG
5579                   (("Completed field/var decl `%s' with `%s'",
5580                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5581                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5582                 break;
5583               }
5584             case JDEP_METHOD:   /* We start patching a method */
5585             case JDEP_METHOD_RETURN:
5586               error_found = 0;
5587               while (1)
5588                 {
5589                   if (decl)
5590                     {
5591                       type = TREE_TYPE(decl);
5592                       if (TREE_CODE (type) == RECORD_TYPE)
5593                         type = promote_type (type);
5594                       JDEP_APPLY_PATCH (dep, type);
5595                       SOURCE_FRONTEND_DEBUG
5596                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5597                            "Completing fct `%s' with ret type `%s'":
5598                            "Completing arg `%s' with type `%s'"),
5599                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5600                                               (JDEP_DECL_WFL (dep))),
5601                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5602                     }
5603                   else
5604                     error_found = 1;
5605                   dep = JDEP_CHAIN (dep);
5606                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5607                     break;
5608                   else
5609                     decl = jdep_resolve_class (dep);
5610                 }
5611               if (!error_found)
5612                 {
5613                   tree mdecl = JDEP_DECL (dep), signature;
5614                   /* Recompute and reset the signature, check first that
5615                      all types are now defined. If they're not,
5616                      don't build the signature. */
5617                   if (check_method_types_complete (mdecl))
5618                     {
5619                       signature = build_java_signature (TREE_TYPE (mdecl));
5620                       set_java_signature (TREE_TYPE (mdecl), signature);
5621                     }
5622                 }
5623               else
5624                 continue;
5625               break;
5626
5627             case JDEP_INTERFACE:
5628               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5629                                                 JDEP_WFL (dep)))
5630                 continue;
5631               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5632               break;
5633
5634             case JDEP_PARM:
5635             case JDEP_VARIABLE:
5636               type = TREE_TYPE(decl);
5637               if (TREE_CODE (type) == RECORD_TYPE)
5638                 type = promote_type (type);
5639               JDEP_APPLY_PATCH (dep, type);
5640               break;
5641
5642             case JDEP_TYPE:
5643               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5644               SOURCE_FRONTEND_DEBUG
5645                 (("Completing a random type dependency on a '%s' node",
5646                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5647               break;
5648
5649             case JDEP_EXCEPTION:
5650               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5651               SOURCE_FRONTEND_DEBUG
5652                 (("Completing `%s' `throws' argument node",
5653                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5654               break;
5655
5656             case JDEP_ANONYMOUS:
5657               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5658               break;
5659
5660             default:
5661               abort ();
5662             }
5663         }
5664     }
5665   return;
5666 }
5667
5668 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5669    array.  */
5670
5671 static tree
5672 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5673 {
5674   tree tname = TYPE_NAME (class_type);
5675   tree resolved_type = TREE_TYPE (class_type);
5676   int array_dims = 0;
5677   tree resolved_type_decl;
5678
5679   if (resolved_type != NULL_TREE)
5680     {
5681       tree resolved_type_decl = TYPE_NAME (resolved_type);
5682       if (resolved_type_decl == NULL_TREE
5683           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5684         {
5685           resolved_type_decl = build_decl (TYPE_DECL,
5686                                            TYPE_NAME (class_type),
5687                                            resolved_type);
5688         }
5689       return resolved_type_decl;
5690     }
5691
5692   /* 1- Check to see if we have an array. If true, find what we really
5693      want to resolve  */
5694   if ((array_dims = build_type_name_from_array_name (tname,
5695                                                      &TYPE_NAME (class_type))))
5696     WFL_STRIP_BRACKET (cl, cl);
5697
5698   /* 2- Resolve the bare type */
5699   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5700                                                decl, cl)))
5701     return NULL_TREE;
5702   resolved_type = TREE_TYPE (resolved_type_decl);
5703
5704   /* 3- If we have an array, reconstruct the array down to its nesting */
5705   if (array_dims)
5706     {
5707       for (; array_dims; array_dims--)
5708         resolved_type = build_java_array_type (resolved_type, -1);
5709       resolved_type_decl = TYPE_NAME (resolved_type);
5710     }
5711   TREE_TYPE (class_type) = resolved_type;
5712   return resolved_type_decl;
5713 }
5714
5715 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5716    are used to report error messages; CL must either be NULL_TREE or a
5717    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5718    by a variable, since it is changed by find_in_imports{_on_demand}
5719    and (but it doesn't really matter) qualify_and_find.  */
5720
5721 tree
5722 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5723 {
5724   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5725   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5726   tree decl_result;
5727   htab_t circularity_hash;
5728
5729   if (QUALIFIED_P (TYPE_NAME (class_type)))
5730     {
5731       /* If the type name is of the form `Q . Id', then Q is either a
5732          package name or a class name.  First we try to find Q as a
5733          class and then treat Id as a member type.  If we can't find Q
5734          as a class then we fall through.  */
5735       tree q, left, left_type, right;
5736       if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5737         {
5738           BUILD_PTR_FROM_NAME (left_type, left);
5739           q = do_resolve_class (enclosing, left_type, decl, cl);
5740           if (q)
5741             {
5742               enclosing = q;
5743               saved_enclosing_type = TREE_TYPE (q);
5744               BUILD_PTR_FROM_NAME (class_type, right);
5745             }
5746         }
5747     }
5748
5749   if (enclosing)
5750     {
5751       /* This hash table is used to register the classes we're going
5752          through when searching the current class as an inner class, in
5753          order to detect circular references. Remember to free it before
5754          returning the section 0- of this function. */
5755       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5756                                       NULL);
5757
5758       /* 0- Search in the current class as an inner class.
5759          Maybe some code here should be added to load the class or
5760          something, at least if the class isn't an inner class and ended
5761          being loaded from class file. FIXME. */
5762       while (enclosing)
5763         {
5764           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5765                                                 &super, class_type);
5766           if (new_class_decl)
5767             break;
5768
5769           /* If we haven't found anything because SUPER reached Object and
5770              ENCLOSING happens to be an innerclass, try the enclosing context. */
5771           if ((!super || super == object_type_node) &&
5772               enclosing && INNER_CLASS_DECL_P (enclosing))
5773             enclosing = DECL_CONTEXT (enclosing);
5774           else
5775             enclosing = NULL_TREE;
5776         }
5777
5778       htab_delete (circularity_hash);
5779
5780       if (new_class_decl)
5781         return new_class_decl;
5782     }
5783
5784   /* 1- Check for the type in single imports. This will change
5785      TYPE_NAME() if something relevant is found */
5786   find_in_imports (saved_enclosing_type, class_type);
5787
5788   /* 2- And check for the type in the current compilation unit */
5789   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5790     {
5791       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5792           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5793         load_class (TYPE_NAME (class_type), 0);
5794       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5795     }
5796
5797   /* 3- Search according to the current package definition */
5798   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5799     {
5800       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5801                                              TYPE_NAME (class_type))))
5802         return new_class_decl;
5803     }
5804
5805   /* 4- Check the import on demands. Don't allow bar.baz to be
5806      imported from foo.* */
5807   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5808     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5809       return NULL_TREE;
5810
5811   /* If found in find_in_imports_on_demand, the type has already been
5812      loaded. */
5813   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5814     return new_class_decl;
5815
5816   /* 5- Try with a name qualified with the package name we've seen so far */
5817   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5818     {
5819       tree package;
5820
5821       /* If there is a current package (ctxp->package), it's the first
5822          element of package_list and we can skip it. */
5823       for (package = (ctxp->package ?
5824                       TREE_CHAIN (package_list) : package_list);
5825            package; package = TREE_CHAIN (package))
5826         if ((new_class_decl = qualify_and_find (class_type,
5827                                                TREE_PURPOSE (package),
5828                                                TYPE_NAME (class_type))))
5829           return new_class_decl;
5830     }
5831
5832   /* 5- Check another compilation unit that bears the name of type */
5833   load_class (TYPE_NAME (class_type), 0);
5834
5835   if (!cl)
5836     cl = lookup_cl (decl);
5837
5838   /* If we don't have a value for CL, then we're being called recursively.
5839      We can't check package access just yet, but it will be taken care of
5840      by the caller. */
5841   if (cl)
5842     {
5843       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5844         return NULL_TREE;
5845     }
5846
5847   /* 6- Last call for a resolution */
5848   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5849
5850   /* The final lookup might have registered a.b.c into a.b$c If we
5851      failed at the first lookup, progressively change the name if
5852      applicable and use the matching DECL instead. */
5853   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5854     {
5855       char *separator;
5856       tree name = TYPE_NAME (class_type);
5857       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5858
5859       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5860
5861       do {
5862
5863        /* Reach the last '.', and if applicable, replace it by a `$' and
5864           see if this exists as a type. */
5865        if ((separator = strrchr (namebuffer, '.')))
5866          {
5867            *separator = '$';
5868            name = get_identifier (namebuffer);
5869            decl_result = IDENTIFIER_CLASS_VALUE (name);
5870          }
5871       } while (!decl_result && separator);
5872     }
5873   return decl_result;
5874 }
5875
5876 static tree
5877 qualify_and_find (tree class_type, tree package, tree name)
5878 {
5879   tree new_qualified = merge_qualified_name (package, name);
5880   tree new_class_decl;
5881
5882   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5883     load_class (new_qualified, 0);
5884   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5885     {
5886       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5887           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5888         load_class (new_qualified, 0);
5889       TYPE_NAME (class_type) = new_qualified;
5890       return IDENTIFIER_CLASS_VALUE (new_qualified);
5891     }
5892   return NULL_TREE;
5893 }
5894
5895 /* Resolve NAME and lay it out (if not done and if not the current
5896    parsed class). Return a decl node. This function is meant to be
5897    called when type resolution is necessary during the walk pass.  */
5898
5899 static tree
5900 resolve_and_layout (tree something, tree cl)
5901 {
5902   tree decl, decl_type;
5903
5904   /* Don't do that on the current class */
5905   if (something == current_class)
5906     return TYPE_NAME (current_class);
5907
5908   /* Don't do anything for void and other primitive types */
5909   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5910     return NULL_TREE;
5911
5912   /* Pointer types can be reall pointer types or fake pointers. When
5913      finding a real pointer, recheck for primitive types */
5914   if (TREE_CODE (something) == POINTER_TYPE)
5915     {
5916       if (TREE_TYPE (something))
5917         {
5918           something = TREE_TYPE (something);
5919           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5920             return NULL_TREE;
5921         }
5922       else
5923         something = TYPE_NAME (something);
5924     }
5925
5926   /* Don't do anything for arrays of primitive types */
5927   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5928       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5929     return NULL_TREE;
5930
5931   /* Something might be a WFL */
5932   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5933     something = EXPR_WFL_NODE (something);
5934
5935   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5936      TYPE_DECL or a real TYPE */
5937   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5938     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5939             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5940
5941   if (!(decl = resolve_no_layout (something, cl)))
5942     return NULL_TREE;
5943
5944   /* Resolve and layout if necessary */
5945   decl_type = TREE_TYPE (decl);
5946   layout_class_methods (decl_type);
5947   /* Check methods */
5948   if (CLASS_FROM_SOURCE_P (decl_type))
5949     java_check_methods (decl);
5950   /* Layout the type if necessary */
5951   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5952     safe_layout_class (decl_type);
5953
5954   return decl;
5955 }
5956
5957 /* Resolve a class, returns its decl but doesn't perform any
5958    layout. The current parsing context is saved and restored */
5959
5960 static tree
5961 resolve_no_layout (tree name, tree cl)
5962 {
5963   tree ptr, decl;
5964   BUILD_PTR_FROM_NAME (ptr, name);
5965   java_parser_context_save_global ();
5966   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5967   java_parser_context_restore_global ();
5968
5969   return decl;
5970 }
5971
5972 /* Called when reporting errors. Skip the '[]'s in a complex array
5973    type description that failed to be resolved. purify_type_name can't
5974    use an identifier tree.  */
5975
5976 static const char *
5977 purify_type_name (const char *name)
5978 {
5979   int len = strlen (name);
5980   int bracket_found;
5981
5982   STRING_STRIP_BRACKETS (name, len, bracket_found);
5983   if (bracket_found)
5984     {
5985       char *stripped_name = xmemdup (name, len, len+1);
5986       stripped_name [len] = '\0';
5987       return stripped_name;
5988     }
5989   return name;
5990 }
5991
5992 /* The type CURRENT refers to can't be found. We print error messages.  */
5993
5994 static void
5995 complete_class_report_errors (jdep *dep)
5996 {
5997   const char *name;
5998
5999   if (!JDEP_WFL (dep))
6000     return;
6001
6002   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6003   switch (JDEP_KIND (dep))
6004     {
6005     case JDEP_SUPER:
6006       parse_error_context
6007         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6008          purify_type_name (name),
6009          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6010       break;
6011     case JDEP_FIELD:
6012       parse_error_context
6013         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6014          purify_type_name (name),
6015          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6016       break;
6017     case JDEP_METHOD:           /* Covers arguments */
6018       parse_error_context
6019         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6020          purify_type_name (name),
6021          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6022          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6023       break;
6024     case JDEP_METHOD_RETURN:    /* Covers return type */
6025       parse_error_context
6026         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6027          purify_type_name (name),
6028          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6029       break;
6030     case JDEP_INTERFACE:
6031       parse_error_context
6032         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6033          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6034          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6035          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6036       break;
6037     case JDEP_VARIABLE:
6038       parse_error_context
6039         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6040          purify_type_name (IDENTIFIER_POINTER
6041                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6042          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6043       break;
6044     case JDEP_EXCEPTION:        /* As specified by `throws' */
6045       parse_error_context
6046           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6047          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6048       break;
6049     default:
6050       /* Fix for -Wall. Just break doing nothing. The error will be
6051          caught later */
6052       break;
6053     }
6054 }
6055
6056 /* Return a static string containing the DECL prototype string. If
6057    DECL is a constructor, use the class name instead of the form
6058    <init> */
6059
6060 static const char *
6061 get_printable_method_name (tree decl)
6062 {
6063   const char *to_return;
6064   tree name = NULL_TREE;
6065
6066   if (DECL_CONSTRUCTOR_P (decl))
6067     {
6068       name = DECL_NAME (decl);
6069       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6070     }
6071
6072   to_return = lang_printable_name (decl, 0);
6073   if (DECL_CONSTRUCTOR_P (decl))
6074     DECL_NAME (decl) = name;
6075
6076   return to_return;
6077 }
6078
6079 /* Track method being redefined inside the same class. As a side
6080    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6081    function it's a FWL, so we can track errors more accurately.)  */
6082
6083 static int
6084 check_method_redefinition (tree class, tree method)
6085 {
6086   tree redef, sig;
6087
6088   /* There's no need to verify <clinit> and finit$ and instinit$ */
6089   if (DECL_CLINIT_P (method)
6090       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6091     return 0;
6092
6093   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6094   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6095     {
6096       if (redef == method)
6097         break;
6098       if (DECL_NAME (redef) == DECL_NAME (method)
6099           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6100           && !DECL_ARTIFICIAL (method))
6101         {
6102           parse_error_context
6103             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6104              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6105              get_printable_method_name (redef));
6106           return 1;
6107         }
6108     }
6109   return 0;
6110 }
6111
6112 /* Return 1 if check went ok, 0 otherwise.  */
6113 static int
6114 check_abstract_method_definitions (int do_interface, tree class_decl,
6115                                    tree type)
6116 {
6117   tree class = TREE_TYPE (class_decl);
6118   tree method, end_type;
6119   int ok = 1;
6120
6121   end_type = (do_interface ? object_type_node : type);
6122   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6123     {
6124       tree other_super, other_method, method_sig, method_name;
6125       int found = 0;
6126       int end_type_reached = 0;
6127
6128       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6129         continue;
6130
6131       /* Now verify that somewhere in between TYPE and CLASS,
6132          abstract method METHOD gets a non abstract definition
6133          that is inherited by CLASS.  */
6134
6135       method_sig = build_java_signature (TREE_TYPE (method));
6136       method_name = DECL_NAME (method);
6137       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6138         method_name = EXPR_WFL_NODE (method_name);
6139
6140       other_super = class;
6141       do {
6142         if (other_super == end_type)
6143           end_type_reached = 1;
6144
6145         /* Method search */
6146         for (other_method = TYPE_METHODS (other_super); other_method;
6147             other_method = TREE_CHAIN (other_method))
6148           {
6149             tree s = build_java_signature (TREE_TYPE (other_method));
6150             tree other_name = DECL_NAME (other_method);
6151
6152             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6153               other_name = EXPR_WFL_NODE (other_name);
6154             if (!DECL_CLINIT_P (other_method)
6155                 && !DECL_CONSTRUCTOR_P (other_method)
6156                 && method_name == other_name
6157                 && method_sig == s
6158                 && !METHOD_ABSTRACT (other_method))
6159              {
6160                found = 1;
6161                break;
6162              }
6163           }
6164         other_super = CLASSTYPE_SUPER (other_super);
6165       } while (!end_type_reached);
6166
6167       /* Report that abstract METHOD didn't find an implementation
6168          that CLASS can use. */
6169       if (!found)
6170         {
6171           char *t = xstrdup (lang_printable_name
6172                             (TREE_TYPE (TREE_TYPE (method)), 0));
6173           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6174
6175           parse_error_context
6176             (lookup_cl (class_decl),
6177              "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",
6178              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6179              t, lang_printable_name (method, 0),
6180              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6181               "interface" : "class"),
6182              IDENTIFIER_POINTER (ccn),
6183              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6184              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6185           ok = 0;
6186           free (t);
6187         }
6188     }
6189
6190   if (ok && do_interface)
6191     {
6192       /* Check for implemented interfaces. */
6193       int i;
6194       tree vector = TYPE_BINFO_BASETYPES (type);
6195       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6196         {
6197           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6198           ok = check_abstract_method_definitions (1, class_decl, super);
6199         }
6200     }
6201
6202   return ok;
6203 }
6204
6205 /* Check that CLASS_DECL somehow implements all inherited abstract
6206    methods.  */
6207
6208 static void
6209 java_check_abstract_method_definitions (tree class_decl)
6210 {
6211   tree class = TREE_TYPE (class_decl);
6212   tree super, vector;
6213   int i;
6214
6215   if (CLASS_ABSTRACT (class_decl))
6216     return;
6217
6218   /* Check for inherited types */
6219   super = class;
6220   do {
6221     super = CLASSTYPE_SUPER (super);
6222     check_abstract_method_definitions (0, class_decl, super);
6223   } while (super != object_type_node);
6224
6225   /* Check for implemented interfaces. */
6226   vector = TYPE_BINFO_BASETYPES (class);
6227   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6228     {
6229       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6230       check_abstract_method_definitions (1, class_decl, super);
6231     }
6232 }
6233
6234 /* Check all the types method DECL uses and return 1 if all of them
6235    are now complete, 0 otherwise. This is used to check whether its
6236    safe to build a method signature or not.  */
6237
6238 static int
6239 check_method_types_complete (tree decl)
6240 {
6241   tree type = TREE_TYPE (decl);
6242   tree args;
6243
6244   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6245     return 0;
6246
6247   args = TYPE_ARG_TYPES (type);
6248   if (TREE_CODE (type) == METHOD_TYPE)
6249     args = TREE_CHAIN (args);
6250   for (; args != end_params_node; args = TREE_CHAIN (args))
6251     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6252       return 0;
6253
6254   return 1;
6255 }
6256
6257 /* Visible interface to check methods contained in CLASS_DECL */
6258
6259 void
6260 java_check_methods (tree class_decl)
6261 {
6262   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6263     return;
6264
6265   if (CLASS_INTERFACE (class_decl))
6266     java_check_abstract_methods (class_decl);
6267   else
6268     java_check_regular_methods (class_decl);
6269
6270   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6271 }
6272
6273 /* Like not_accessible_p, but doesn't refer to the current class at
6274    all.  */
6275 static bool
6276 hack_is_accessible_p (tree member, tree from_where)
6277 {
6278   int flags = get_access_flags_from_decl (member);
6279
6280   if (from_where == DECL_CONTEXT (member)
6281       || (flags & ACC_PUBLIC))
6282     return true;
6283
6284   if ((flags & ACC_PROTECTED))
6285     {
6286       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6287         return true;
6288     }
6289
6290   if ((flags & ACC_PRIVATE))
6291     return false;
6292
6293   /* Package private, or protected.  */
6294   return in_same_package (TYPE_NAME (from_where),
6295                           TYPE_NAME (DECL_CONTEXT (member)));
6296 }
6297
6298 /* Check all the methods of CLASS_DECL. Methods are first completed
6299    then checked according to regular method existence rules.  If no
6300    constructor for CLASS_DECL were encountered, then build its
6301    declaration.  */
6302 static void
6303 java_check_regular_methods (tree class_decl)
6304 {
6305   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6306   tree method;
6307   tree class = TREE_TYPE (class_decl);
6308   tree found = NULL_TREE;
6309   tree mthrows;
6310
6311   /* It is not necessary to check methods defined in java.lang.Object */
6312   if (class == object_type_node)
6313     return;
6314
6315   if (!TYPE_NVIRTUALS (class))
6316     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6317
6318   /* Should take interfaces into account. FIXME */
6319   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6320     {
6321       tree sig;
6322       tree method_wfl = DECL_FUNCTION_WFL (method);
6323       int aflags;
6324
6325       /* Check for redefinitions */
6326       if (check_method_redefinition (class, method))
6327         continue;
6328
6329       /* We verify things thrown by the method.  They must inherit from
6330          java.lang.Throwable.  */
6331       for (mthrows = DECL_FUNCTION_THROWS (method);
6332            mthrows; mthrows = TREE_CHAIN (mthrows))
6333         {
6334           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6335             parse_error_context
6336               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6337                IDENTIFIER_POINTER
6338                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6339         }
6340
6341       /* If we see one constructor a mark so we don't generate the
6342          default one.  Also skip other verifications: constructors
6343          can't be inherited hence hidden or overridden.  */
6344       if (DECL_CONSTRUCTOR_P (method))
6345         {
6346           saw_constructor = 1;
6347           continue;
6348         }
6349
6350       sig = build_java_argument_signature (TREE_TYPE (method));
6351       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6352                                               SEARCH_SUPER | SEARCH_INTERFACE);
6353
6354       /* Inner class can't declare static methods */
6355       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6356         {
6357           char *t = xstrdup (lang_printable_name (class, 0));
6358           parse_error_context
6359             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6360              lang_printable_name (method, 0), t);
6361           free (t);
6362         }
6363
6364       /* Nothing overrides or it's a private method. */
6365       if (!found)
6366         continue;
6367       if (METHOD_PRIVATE (found))
6368         {
6369           found = NULL_TREE;
6370           continue;
6371         }
6372
6373       /* If `found' is declared in an interface, make sure the
6374          modifier matches. */
6375       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6376           && clinit_identifier_node != DECL_NAME (found)
6377           && !METHOD_PUBLIC (method))
6378         {
6379           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6380           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6381                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6382                                lang_printable_name (method, 0),
6383                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6384         }
6385
6386       /* Can't override a method with the same name and different return
6387          types. */
6388       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6389         {
6390           char *t = xstrdup
6391             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6392           parse_error_context
6393             (method_wfl,
6394              "Method `%s' was defined with return type `%s' in class `%s'",
6395              lang_printable_name (found, 0), t,
6396              IDENTIFIER_POINTER
6397                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6398           free (t);
6399         }
6400
6401       aflags = get_access_flags_from_decl (found);
6402
6403       /* Can't override final. Can't override static. */
6404       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6405         {
6406           /* Static *can* override static */
6407           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6408             continue;
6409           parse_error_context
6410             (method_wfl,
6411              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6412              (METHOD_FINAL (found) ? "Final" : "Static"),
6413              lang_printable_name (found, 0),
6414              (METHOD_FINAL (found) ? "final" : "static"),
6415              IDENTIFIER_POINTER
6416                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6417           continue;
6418         }
6419
6420       /* Static method can't override instance method. */
6421       if (METHOD_STATIC (method))
6422         {
6423           parse_error_context
6424             (method_wfl,
6425              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6426              lang_printable_name (found, 0),
6427              IDENTIFIER_POINTER
6428                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6429           continue;
6430         }
6431
6432       /* - Overriding/hiding public must be public
6433          - Overriding/hiding protected must be protected or public
6434          - If the overridden or hidden method has default (package)
6435            access, then the overriding or hiding method must not be
6436            private; otherwise, a compile-time error occurs.  If
6437            `found' belongs to an interface, things have been already
6438            taken care of.  */
6439       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6440           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6441               || (METHOD_PROTECTED (found)
6442                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6443               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6444                   && METHOD_PRIVATE (method))))
6445         {
6446           parse_error_context
6447             (method_wfl,
6448              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6449              (METHOD_PUBLIC (method) ? "public" :
6450               (METHOD_PRIVATE (method) ? "private" : "protected")),
6451              IDENTIFIER_POINTER (DECL_NAME
6452                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6453           continue;
6454         }
6455
6456       /* Check this method against all the other implementations it
6457          overrides.  Here we only check the class hierarchy; the rest
6458          of the checking is done later.  If this method is just a
6459          Miranda method, we can skip the check.  */
6460       if (! METHOD_INVISIBLE (method))
6461         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6462     }
6463
6464   /* The above throws clause check only looked at superclasses.  Now
6465      we must also make sure that all methods declared in interfaces
6466      have compatible throws clauses.  FIXME: there are more efficient
6467      ways to organize this checking; we should implement one.  */
6468   check_interface_throws_clauses (class, class);
6469
6470   if (!TYPE_NVIRTUALS (class))
6471     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6472
6473   /* Search for inherited abstract method not yet implemented in this
6474      class.  */
6475   java_check_abstract_method_definitions (class_decl);
6476
6477   if (!saw_constructor)
6478     abort ();
6479 }
6480
6481 /* Check to make sure that all the methods in all the interfaces
6482    implemented by CLASS_DECL are compatible with the concrete
6483    implementations available in CHECK_CLASS_DECL.  */
6484 static void
6485 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6486 {
6487   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6488     {
6489       tree bases;
6490       int iface_len;
6491       int i;
6492
6493       if (! CLASS_LOADED_P (class_decl))
6494         {
6495           if (CLASS_FROM_SOURCE_P (class_decl))
6496             safe_layout_class (class_decl);
6497           else
6498             load_class (class_decl, 1);
6499         }
6500
6501       bases = TYPE_BINFO_BASETYPES (class_decl);
6502       iface_len = TREE_VEC_LENGTH (bases) - 1;
6503       for (i = iface_len; i > 0; --i)
6504         {
6505           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6506           tree iface_method;
6507
6508           for (iface_method = TYPE_METHODS (interface);
6509                iface_method != NULL_TREE;
6510                iface_method = TREE_CHAIN (iface_method))
6511             {
6512               tree sig, method;
6513
6514               /* First look for a concrete method implemented or
6515                  inherited by this class.  No need to search
6516                  interfaces here, since we're already looking through
6517                  all of them.  */
6518               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6519               method
6520                 = lookup_argument_method_generic (check_class_decl,
6521                                                   DECL_NAME (iface_method),
6522                                                   sig, SEARCH_VISIBLE);
6523               /* If we don't find an implementation, that is ok.  Any
6524                  potential errors from that are diagnosed elsewhere.
6525                  Also, multiple inheritance with conflicting throws
6526                  clauses is fine in the absence of a concrete
6527                  implementation.  */
6528               if (method != NULL_TREE && !METHOD_ABSTRACT (method))
6529                 {
6530                   tree method_wfl = DECL_FUNCTION_WFL (method);
6531                   check_throws_clauses (method, method_wfl, iface_method);
6532                 }
6533             }
6534
6535           /* Now check superinterfaces.  */
6536           check_interface_throws_clauses (check_class_decl, interface);
6537         }
6538     }
6539 }
6540
6541 /* Check throws clauses of a method against the clauses of all the
6542    methods it overrides.  We do this by searching up the class
6543    hierarchy, examining all matching accessible methods.  */
6544 static void
6545 check_concrete_throws_clauses (tree class, tree self_method,
6546                                tree name, tree signature)
6547 {
6548   tree method = lookup_argument_method_generic (class, name, signature,
6549                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6550   while (method != NULL_TREE)
6551     {
6552       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6553         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6554                               method);
6555
6556       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6557                                                name, signature,
6558                                                SEARCH_SUPER | SEARCH_VISIBLE);
6559     }
6560 }
6561
6562 /* Generate an error if the `throws' clause of METHOD (if any) is
6563    incompatible with the `throws' clause of FOUND (if any).  */
6564 static void
6565 check_throws_clauses (tree method, tree method_wfl, tree found)
6566 {
6567   tree mthrows;
6568
6569   /* Can't check these things with class loaded from bytecode. FIXME */
6570   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6571     return;
6572
6573   for (mthrows = DECL_FUNCTION_THROWS (method);
6574        mthrows; mthrows = TREE_CHAIN (mthrows))
6575     {
6576       tree fthrows;
6577
6578       /* We don't verify unchecked expressions */
6579       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6580         continue;
6581       /* Checked expression must be compatible */
6582       for (fthrows = DECL_FUNCTION_THROWS (found);
6583            fthrows; fthrows = TREE_CHAIN (fthrows))
6584         {
6585           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6586             break;
6587         }
6588       if (!fthrows)
6589         {
6590           parse_error_context
6591             (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'",
6592              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6593              lang_printable_name (found, 0),
6594              IDENTIFIER_POINTER
6595              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6596         }
6597     }
6598 }
6599
6600 /* Check abstract method of interface INTERFACE */
6601 static void
6602 java_check_abstract_methods (tree interface_decl)
6603 {
6604   int i, n;
6605   tree method, basetype_vec, found;
6606   tree interface = TREE_TYPE (interface_decl);
6607
6608   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6609     {
6610       /* 2- Check for double definition inside the defining interface */
6611       if (check_method_redefinition (interface, method))
6612         continue;
6613
6614       /* 3- Overriding is OK as far as we preserve the return type.  */
6615       found = lookup_java_interface_method2 (interface, method);
6616       if (found)
6617         {
6618           char *t;
6619           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6620           parse_error_context
6621             (DECL_FUNCTION_WFL (found),
6622              "Method `%s' was defined with return type `%s' in class `%s'",
6623              lang_printable_name (found, 0), t,
6624              IDENTIFIER_POINTER
6625                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6626           free (t);
6627           continue;
6628         }
6629     }
6630
6631   /* 4- Inherited methods can't differ by their returned types */
6632   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6633     return;
6634   n = TREE_VEC_LENGTH (basetype_vec);
6635   for (i = 0; i < n; i++)
6636     {
6637       tree sub_interface_method, sub_interface;
6638       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6639       if (!vec_elt)
6640         continue;
6641       sub_interface = BINFO_TYPE (vec_elt);
6642       for (sub_interface_method = TYPE_METHODS (sub_interface);
6643            sub_interface_method;
6644            sub_interface_method = TREE_CHAIN (sub_interface_method))
6645         {
6646           found = lookup_java_interface_method2 (interface,
6647                                                  sub_interface_method);
6648           if (found && (found != sub_interface_method))
6649             {
6650               parse_error_context
6651                 (lookup_cl (sub_interface_method),
6652                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6653                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6654                  lang_printable_name (found, 0),
6655                  IDENTIFIER_POINTER
6656                    (DECL_NAME (TYPE_NAME
6657                                (DECL_CONTEXT (sub_interface_method)))),
6658                  IDENTIFIER_POINTER
6659                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6660             }
6661         }
6662     }
6663 }
6664
6665 /* Lookup methods in interfaces using their name and partial
6666    signature. Return a matching method only if their types differ.  */
6667
6668 static tree
6669 lookup_java_interface_method2 (tree class, tree method_decl)
6670 {
6671   int i, n;
6672   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6673
6674   if (!basetype_vec)
6675     return NULL_TREE;
6676
6677   n = TREE_VEC_LENGTH (basetype_vec);
6678   for (i = 0; i < n; i++)
6679     {
6680       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6681       if ((BINFO_TYPE (vec_elt) != object_type_node)
6682           && (to_return =
6683               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6684         return to_return;
6685     }
6686   for (i = 0; i < n; i++)
6687     {
6688       to_return = lookup_java_interface_method2
6689         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6690       if (to_return)
6691         return to_return;
6692     }
6693
6694   return NULL_TREE;
6695 }
6696
6697 /* Lookup method using their name and partial signature. Return a
6698    matching method only if their types differ.  */
6699
6700 static tree
6701 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6702 {
6703   tree method, method_signature, method_name, method_type, name;
6704
6705   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6706   name = DECL_NAME (method_decl);
6707   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6708                  EXPR_WFL_NODE (name) : name);
6709   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6710
6711   while (clas != NULL_TREE)
6712     {
6713       for (method = TYPE_METHODS (clas);
6714            method != NULL_TREE;  method = TREE_CHAIN (method))
6715         {
6716           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6717           tree name = DECL_NAME (method);
6718           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6719                EXPR_WFL_NODE (name) : name) == method_name
6720               && method_sig == method_signature
6721               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6722             return method;
6723         }
6724       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6725     }
6726   return NULL_TREE;
6727 }
6728
6729 /* Return the line that matches DECL line number, and try its best to
6730    position the column number. Used during error reports.  */
6731
6732 static GTY(()) tree cl_v;
6733 static tree
6734 lookup_cl (tree decl)
6735 {
6736   char *line, *found;
6737
6738   if (!decl)
6739     return NULL_TREE;
6740
6741   if (cl_v == NULL_TREE)
6742     {
6743       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6744     }
6745
6746   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6747   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6748
6749   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6750                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6751
6752   found = strstr ((const char *)line,
6753                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6754   if (found)
6755     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6756
6757   return cl_v;
6758 }
6759
6760 /* Look for a simple name in the single-type import list */
6761
6762 static tree
6763 find_name_in_single_imports (tree name)
6764 {
6765   tree node;
6766
6767   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6768     if (TREE_VALUE (node) == name)
6769       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6770
6771   return NULL_TREE;
6772 }
6773
6774 /* Process all single-type import. */
6775
6776 static int
6777 process_imports (void)
6778 {
6779   tree import;
6780   int error_found;
6781
6782   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6783     {
6784       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6785       char *original_name;
6786
6787       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6788                                IDENTIFIER_LENGTH (to_be_found),
6789                                IDENTIFIER_LENGTH (to_be_found) + 1);
6790
6791       /* Don't load twice something already defined. */
6792       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6793         continue;
6794
6795       while (1)
6796         {
6797           tree left;
6798
6799           QUALIFIED_P (to_be_found) = 1;
6800           load_class (to_be_found, 0);
6801           error_found =
6802             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6803
6804           /* We found it, we can bail out */
6805           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6806             {
6807               check_deprecation (TREE_PURPOSE (import),
6808                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6809               break;
6810             }
6811
6812           /* We haven't found it. Maybe we're trying to access an
6813              inner class.  The only way for us to know is to try again
6814              after having dropped a qualifier. If we can't break it further,
6815              we have an error. */
6816           if (breakdown_qualified (&left, NULL, to_be_found))
6817             break;
6818
6819           to_be_found = left;
6820         }
6821       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6822         {
6823           parse_error_context (TREE_PURPOSE (import),
6824                                "Class or interface `%s' not found in import",
6825                                original_name);
6826           error_found = 1;
6827         }
6828
6829       free (original_name);
6830       if (error_found)
6831         return 1;
6832     }
6833   return 0;
6834 }
6835
6836 /* Possibly find and mark a class imported by a single-type import
6837    statement.  */
6838
6839 static void
6840 find_in_imports (tree enclosing_type, tree class_type)
6841 {
6842   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6843                  ctxp->import_list);
6844   while (import)
6845     {
6846       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6847         {
6848           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6849           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6850           return;
6851         }
6852       import = TREE_CHAIN (import);
6853     }
6854 }
6855
6856 static int
6857 note_possible_classname (const char *name, int len)
6858 {
6859   tree node;
6860   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6861     len = len - 5;
6862   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6863     len = len - 6;
6864   else
6865     return 0;
6866   node = ident_subst (name, len, "", '/', '.', "");
6867   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6868   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6869   return 1;
6870 }
6871
6872 /* Read a import directory, gathering potential match for further type
6873    references. Indifferently reads a filesystem or a ZIP archive
6874    directory.  */
6875
6876 static void
6877 read_import_dir (tree wfl)
6878 {
6879   tree package_id = EXPR_WFL_NODE (wfl);
6880   const char *package_name = IDENTIFIER_POINTER (package_id);
6881   int package_length = IDENTIFIER_LENGTH (package_id);
6882   DIR *dirp = NULL;
6883   JCF *saved_jcf = current_jcf;
6884
6885   int found = 0;
6886   int k;
6887   void *entry;
6888   struct buffer filename[1];
6889
6890   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6891     return;
6892   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6893
6894   BUFFER_INIT (filename);
6895   buffer_grow (filename, package_length + 100);
6896
6897   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6898     {
6899       const char *entry_name = jcf_path_name (entry);
6900       int entry_length = strlen (entry_name);
6901       if (jcf_path_is_zipfile (entry))
6902         {
6903           ZipFile *zipf;
6904           buffer_grow (filename, entry_length);
6905           memcpy (filename->data, entry_name, entry_length - 1);
6906           filename->data[entry_length-1] = '\0';
6907           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6908           if (zipf == NULL)
6909             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6910           else
6911             {
6912               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6913               BUFFER_RESET (filename);
6914               for (k = 0; k < package_length; k++)
6915                 {
6916                   char ch = package_name[k];
6917                   *filename->ptr++ = ch == '.' ? '/' : ch;
6918                 }
6919               *filename->ptr++ = '/';
6920
6921               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6922                 {
6923                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6924                   int current_entry_len = zipd->filename_length;
6925
6926                   if (current_entry_len >= BUFFER_LENGTH (filename)
6927                       && strncmp (filename->data, current_entry,
6928                                   BUFFER_LENGTH (filename)) != 0)
6929                     continue;
6930                   found |= note_possible_classname (current_entry,
6931                                                     current_entry_len);
6932                 }
6933             }
6934         }
6935       else
6936         {
6937           BUFFER_RESET (filename);
6938           buffer_grow (filename, entry_length + package_length + 4);
6939           strcpy (filename->data, entry_name);
6940           filename->ptr = filename->data + entry_length;
6941           for (k = 0; k < package_length; k++)
6942             {
6943               char ch = package_name[k];
6944               *filename->ptr++ = ch == '.' ? '/' : ch;
6945             }
6946           *filename->ptr = '\0';
6947
6948           dirp = opendir (filename->data);
6949           if (dirp == NULL)
6950             continue;
6951           *filename->ptr++ = '/';
6952           for (;;)
6953             {
6954               int len;
6955               const char *d_name;
6956               struct dirent *direntp = readdir (dirp);
6957               if (!direntp)
6958                 break;
6959               d_name = direntp->d_name;
6960               len = strlen (direntp->d_name);
6961               buffer_grow (filename, len+1);
6962               strcpy (filename->ptr, d_name);
6963               found |= note_possible_classname (filename->data + entry_length,
6964                                                 package_length+len+1);
6965             }
6966           if (dirp)
6967             closedir (dirp);
6968         }
6969     }
6970
6971   free (filename->data);
6972
6973   /* Here we should have a unified way of retrieving an entry, to be
6974      indexed. */
6975   if (!found)
6976     {
6977       static int first = 1;
6978       if (first)
6979         {
6980           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6981           java_error_count++;
6982           first = 0;
6983         }
6984       else
6985         parse_error_context (wfl, "Package `%s' not found in import",
6986                              package_name);
6987       current_jcf = saved_jcf;
6988       return;
6989     }
6990   current_jcf = saved_jcf;
6991 }
6992
6993 /* Possibly find a type in the import on demands specified
6994    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6995    entire list, to detected potential double definitions.  */
6996
6997 static int
6998 find_in_imports_on_demand (tree enclosing_type, tree class_type)
6999 {
7000   tree class_type_name = TYPE_NAME (class_type);
7001   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7002                   ctxp->import_demand_list);
7003   tree cl = NULL_TREE;
7004   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7005   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7006   tree node;
7007
7008   for (; import; import = TREE_CHAIN (import))
7009     {
7010       int saved_lineno = input_line;
7011       int access_check;
7012       const char *id_name;
7013       tree decl, type_name_copy;
7014
7015       obstack_grow (&temporary_obstack,
7016                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7017                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7018       obstack_1grow (&temporary_obstack, '.');
7019       obstack_grow0 (&temporary_obstack,
7020                      IDENTIFIER_POINTER (class_type_name),
7021                      IDENTIFIER_LENGTH (class_type_name));
7022       id_name = obstack_finish (&temporary_obstack);
7023
7024       if (! (node = maybe_get_identifier (id_name)))
7025         continue;
7026
7027       /* Setup lineno so that it refers to the line of the import (in
7028          case we parse a class file and encounter errors */
7029       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7030
7031       type_name_copy = TYPE_NAME (class_type);
7032       TYPE_NAME (class_type) = node;
7033       QUALIFIED_P (node) = 1;
7034       decl = IDENTIFIER_CLASS_VALUE (node);
7035       access_check = -1;
7036       /* If there is no DECL set for the class or if the class isn't
7037          loaded and not seen in source yet, then load */
7038       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7039                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7040         {
7041           load_class (node, 0);
7042           decl = IDENTIFIER_CLASS_VALUE (node);
7043         }
7044       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7045         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7046                                                false);
7047       else
7048         /* 6.6.1: Inner classes are subject to member access rules. */
7049         access_check = 0;
7050
7051       input_line = saved_lineno;
7052
7053       /* If the loaded class is not accessible or couldn't be loaded,
7054          we restore the original TYPE_NAME and process the next
7055          import. */
7056       if (access_check || !decl)
7057         {
7058           TYPE_NAME (class_type) = type_name_copy;
7059           continue;
7060         }
7061
7062       /* If the loaded class is accessible, we keep a tab on it to
7063          detect and report multiple inclusions. */
7064       if (IS_A_CLASSFILE_NAME (node))
7065         {
7066           if (seen_once < 0)
7067             {
7068               cl = TREE_PURPOSE (import);
7069               seen_once = 1;
7070             }
7071           else if (seen_once >= 0)
7072             {
7073               tree location = (cl ? cl : TREE_PURPOSE (import));
7074               tree package = (cl ? EXPR_WFL_NODE (cl) :
7075                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7076               seen_once++;
7077               parse_error_context
7078                 (location,
7079                  "Type `%s' also potentially defined in package `%s'",
7080                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7081                  IDENTIFIER_POINTER (package));
7082             }
7083         }
7084       to_return = access_check;
7085     }
7086
7087   if (seen_once == 1)
7088     return to_return;
7089   else
7090     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7091 }
7092
7093 /* Add package NAME to the list of packages encountered so far. To
7094    speed up class lookup in do_resolve_class, we make sure a
7095    particular package is added only once.  */
7096
7097 static void
7098 register_package (tree name)
7099 {
7100   static htab_t pht;
7101   void **e;
7102
7103   if (pht == NULL)
7104     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7105
7106   e = htab_find_slot (pht, name, INSERT);
7107   if (*e == NULL)
7108     {
7109       package_list = chainon (package_list, build_tree_list (name, NULL));
7110       *e = name;
7111     }
7112 }
7113
7114 static tree
7115 resolve_package (tree pkg, tree *next, tree *type_name)
7116 {
7117   tree current;
7118   tree decl = NULL_TREE;
7119   *type_name = NULL_TREE;
7120
7121   /* The trick is to determine when the package name stops and were
7122      the name of something contained in the package starts. Then we
7123      return a fully qualified name of what we want to get. */
7124
7125   *next = EXPR_WFL_QUALIFICATION (pkg);
7126
7127   /* Try to progressively construct a type name */
7128   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7129     for (current = EXPR_WFL_QUALIFICATION (pkg);
7130          current; current = TREE_CHAIN (current))
7131       {
7132         /* If we don't have what we're expecting, exit now. TYPE_NAME
7133            will be null and the error caught later. */
7134         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7135           break;
7136         *type_name =
7137           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7138         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7139           {
7140             /* resolve_package should be used in a loop, hence we
7141                point at this one to naturally process the next one at
7142                the next iteration. */
7143             *next = current;
7144             break;
7145           }
7146       }
7147   return decl;
7148 }
7149
7150
7151 /* Check accessibility of inner classes according to member access rules.
7152    DECL is the inner class, ENCLOSING_DECL is the class from which the
7153    access is being attempted. */
7154
7155 static void
7156 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7157 {
7158   const char *access;
7159   tree enclosing_decl_type;
7160
7161   /* We don't issue an error message when CL is null. CL can be null
7162      as a result of processing a JDEP crafted by source_start_java_method
7163      for the purpose of patching its parm decl. But the error would
7164      have been already trapped when fixing the method's signature.
7165      DECL can also be NULL in case of earlier errors. */
7166   if (!decl || !cl)
7167     return;
7168
7169   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7170
7171   if (CLASS_PRIVATE (decl))
7172     {
7173       /* Access is permitted only within the body of the top-level
7174          class in which DECL is declared. */
7175       tree top_level = decl;
7176       while (DECL_CONTEXT (top_level))
7177         top_level = DECL_CONTEXT (top_level);
7178       while (DECL_CONTEXT (enclosing_decl))
7179         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7180       if (top_level == enclosing_decl)
7181         return;
7182       access = "private";
7183     }
7184   else if (CLASS_PROTECTED (decl))
7185     {
7186       tree decl_context;
7187       /* Access is permitted from within the same package... */
7188       if (in_same_package (decl, enclosing_decl))
7189         return;
7190
7191       /* ... or from within the body of a subtype of the context in which
7192          DECL is declared. */
7193       decl_context = DECL_CONTEXT (decl);
7194       while (enclosing_decl)
7195         {
7196           if (CLASS_INTERFACE (decl))
7197             {
7198               if (interface_of_p (TREE_TYPE (decl_context),
7199                                   enclosing_decl_type))
7200                 return;
7201             }
7202           else
7203             {
7204               /* Eww. The order of the arguments is different!! */
7205               if (inherits_from_p (enclosing_decl_type,
7206                                    TREE_TYPE (decl_context)))
7207                 return;
7208             }
7209           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7210         }
7211       access = "protected";
7212     }
7213   else if (! CLASS_PUBLIC (decl))
7214     {
7215       /* Access is permitted only from within the same package as DECL. */
7216       if (in_same_package (decl, enclosing_decl))
7217         return;
7218       access = "non-public";
7219     }
7220   else
7221     /* Class is public. */
7222     return;
7223
7224   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7225                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7226                        lang_printable_name (decl, 0), access);
7227 }
7228
7229 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7230    foreign package, it must be PUBLIC. Return 0 if no access
7231    violations were found, 1 otherwise. If VERBOSE is true and an error
7232    was found, it is reported and accounted for.  */
7233
7234 static int
7235 check_pkg_class_access (tree class_name, tree cl, bool verbose)
7236 {
7237   tree type;
7238
7239   if (!IDENTIFIER_CLASS_VALUE (class_name))
7240     return 0;
7241
7242   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7243     return 0;
7244
7245   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7246     {
7247       /* Access to a private class within the same package is
7248          allowed. */
7249       tree l, r;
7250       breakdown_qualified (&l, &r, class_name);
7251       if (!QUALIFIED_P (class_name) && !ctxp->package)
7252         /* Both in the empty package. */
7253         return 0;
7254       if (l == ctxp->package)
7255         /* Both in the same package. */
7256         return 0;
7257
7258       if (verbose)
7259         parse_error_context
7260           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7261            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7262            IDENTIFIER_POINTER (class_name));
7263       return 1;
7264     }
7265   return 0;
7266 }
7267
7268 /* Local variable declaration. */
7269
7270 static void
7271 declare_local_variables (int modifier, tree type, tree vlist)
7272 {
7273   tree decl, current, saved_type;
7274   tree type_wfl = NULL_TREE;
7275   int must_chain = 0;
7276   int final_p = 0;
7277
7278   /* Push a new block if statements were seen between the last time we
7279      pushed a block and now. Keep a count of blocks to close */
7280   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7281     {
7282       tree b = enter_block ();
7283       BLOCK_IS_IMPLICIT (b) = 1;
7284     }
7285
7286   if (modifier)
7287     {
7288       size_t i;
7289       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7290         if (1 << i & modifier)
7291           break;
7292       if (modifier == ACC_FINAL)
7293         final_p = 1;
7294       else
7295         {
7296           parse_error_context
7297             (ctxp->modifier_ctx [i],
7298              "Only `final' is allowed as a local variables modifier");
7299           return;
7300         }
7301     }
7302
7303   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7304      hold the TYPE value if a new incomplete has to be created (as
7305      opposed to being found already existing and reused). */
7306   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7307
7308   /* If TYPE is fully resolved and we don't have a reference, make one */
7309   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7310
7311   /* Go through all the declared variables */
7312   for (current = vlist, saved_type = type; current;
7313        current = TREE_CHAIN (current), type = saved_type)
7314     {
7315       tree other, real_type;
7316       tree wfl  = TREE_PURPOSE (current);
7317       tree name = EXPR_WFL_NODE (wfl);
7318       tree init = TREE_VALUE (current);
7319
7320       /* Process NAME, as it may specify extra dimension(s) for it */
7321       type = build_array_from_name (type, type_wfl, name, &name);
7322
7323       /* Variable redefinition check */
7324       if ((other = lookup_name_in_blocks (name)))
7325         {
7326           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7327                                        DECL_SOURCE_LINE (other));
7328           continue;
7329         }
7330
7331       /* Type adjustment. We may have just readjusted TYPE because
7332          the variable specified more dimensions. Make sure we have
7333          a reference if we can and don't have one already. */
7334       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7335
7336       real_type = GET_REAL_TYPE (type);
7337       /* Never layout this decl. This will be done when its scope
7338          will be entered */
7339       decl = build_decl (VAR_DECL, name, real_type);
7340       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7341       DECL_FINAL (decl) = final_p;
7342       BLOCK_CHAIN_DECL (decl);
7343
7344       /* If doing xreferencing, replace the line number with the WFL
7345          compound value */
7346       if (flag_emit_xref)
7347         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7348
7349       /* Don't try to use an INIT statement when an error was found */
7350       if (init && java_error_count)
7351         init = NULL_TREE;
7352
7353       /* Add the initialization function to the current function's code */
7354       if (init)
7355         {
7356           /* Name might have been readjusted */
7357           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7358           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7359           java_method_add_stmt (current_function_decl,
7360                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7361                                                       init));
7362         }
7363
7364       /* Setup dependency the type of the decl */
7365       if (must_chain)
7366         {
7367           jdep *dep;
7368           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7369           dep = CLASSD_LAST (ctxp->classd_list);
7370           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7371         }
7372     }
7373   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7374 }
7375
7376 /* Called during parsing. Build decls from argument list.  */
7377
7378 static void
7379 source_start_java_method (tree fndecl)
7380 {
7381   tree tem;
7382   tree parm_decl;
7383   int i;
7384
7385   if (!fndecl)
7386     return;
7387
7388   current_function_decl = fndecl;
7389
7390   /* New scope for the function */
7391   enter_block ();
7392   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7393        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7394     {
7395       tree type = TREE_VALUE (tem);
7396       tree name = TREE_PURPOSE (tem);
7397
7398       /* If type is incomplete. Create an incomplete decl and ask for
7399          the decl to be patched later */
7400       if (INCOMPLETE_TYPE_P (type))
7401         {
7402           jdep *jdep;
7403           tree real_type = GET_REAL_TYPE (type);
7404           parm_decl = build_decl (PARM_DECL, name, real_type);
7405           type = obtain_incomplete_type (type);
7406           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7407           jdep = CLASSD_LAST (ctxp->classd_list);
7408           JDEP_MISC (jdep) = name;
7409           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7410         }
7411       else
7412         parm_decl = build_decl (PARM_DECL, name, type);
7413
7414       /* Remember if a local variable was declared final (via its
7415          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7416       if (ARG_FINAL_P (tem))
7417         {
7418           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7419           DECL_FINAL (parm_decl) = 1;
7420         }
7421
7422       BLOCK_CHAIN_DECL (parm_decl);
7423     }
7424   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7425   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7426     nreverse (tem);
7427   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7428   DECL_MAX_LOCALS (current_function_decl) = i;
7429 }
7430
7431 /* Called during parsing. Creates an artificial method declaration.  */
7432
7433 static tree
7434 create_artificial_method (tree class, int flags, tree type,
7435                           tree name, tree args)
7436 {
7437   tree mdecl;
7438
7439   java_parser_context_save_global ();
7440   input_line = 0;
7441   mdecl = make_node (FUNCTION_TYPE);
7442   TREE_TYPE (mdecl) = type;
7443   TYPE_ARG_TYPES (mdecl) = args;
7444   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7445   java_parser_context_restore_global ();
7446   DECL_ARTIFICIAL (mdecl) = 1;
7447   return mdecl;
7448 }
7449
7450 /* Starts the body if an artificial method.  */
7451
7452 static void
7453 start_artificial_method_body (tree mdecl)
7454 {
7455   DECL_SOURCE_LINE (mdecl) = 1;
7456   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7457   source_start_java_method (mdecl);
7458   enter_block ();
7459 }
7460
7461 static void
7462 end_artificial_method_body (tree mdecl)
7463 {
7464   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7465      It has to be evaluated first. (if mdecl is current_function_decl,
7466      we have an undefined behavior if no temporary variable is used.) */
7467   tree b = exit_block ();
7468   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7469   exit_block ();
7470 }
7471
7472 /* Dump a tree of some kind.  This is a convenience wrapper for the
7473    dump_* functions in tree-dump.c.  */
7474 static void
7475 dump_java_tree (enum tree_dump_index phase, tree t)
7476 {
7477   FILE *stream;
7478   int flags;
7479
7480   stream = dump_begin (phase, &flags);
7481   flags |= TDF_SLIM;
7482   if (stream)
7483     {
7484       dump_node (t, flags, stream);
7485       dump_end (phase, stream);
7486     }
7487 }
7488
7489 /* Terminate a function and expand its body.  */
7490
7491 static void
7492 source_end_java_method (void)
7493 {
7494   tree fndecl = current_function_decl;
7495
7496   if (!fndecl)
7497     return;
7498
7499   java_parser_context_save_global ();
7500   input_line = ctxp->last_ccb_indent1;
7501
7502   /* Turn function bodies with only a NOP expr null, so they don't get
7503      generated at all and we won't get warnings when using the -W
7504      -Wall flags. */
7505   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7506     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7507
7508   /* We've generated all the trees for this function, and it has been
7509      patched.  Dump it to a file if the user requested it.  */
7510   dump_java_tree (TDI_original, fndecl);
7511
7512   /* Defer expanding the method until cgraph analysis is complete.  */
7513   if (DECL_SAVED_TREE (fndecl))
7514     cgraph_finalize_function (fndecl, false);
7515
7516   current_function_decl = NULL_TREE;
7517   java_parser_context_restore_global ();
7518 }
7519
7520 /* Record EXPR in the current function block. Complements compound
7521    expression second operand if necessary.  */
7522
7523 tree
7524 java_method_add_stmt (tree fndecl, tree expr)
7525 {
7526   if (!GET_CURRENT_BLOCK (fndecl))
7527     return NULL_TREE;
7528   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7529 }
7530
7531 static tree
7532 add_stmt_to_block (tree b, tree type, tree stmt)
7533 {
7534   tree body = BLOCK_EXPR_BODY (b), c;
7535
7536   if (java_error_count)
7537     return body;
7538
7539   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7540     return body;
7541
7542   BLOCK_EXPR_BODY (b) = c;
7543   TREE_SIDE_EFFECTS (c) = 1;
7544   return c;
7545 }
7546
7547 /* Add STMT to EXISTING if possible, otherwise create a new
7548    COMPOUND_EXPR and add STMT to it. */
7549
7550 static tree
7551 add_stmt_to_compound (tree existing, tree type, tree stmt)
7552 {
7553   if (existing)
7554     return build (COMPOUND_EXPR, type, existing, stmt);
7555   else
7556     return stmt;
7557 }
7558
7559 void java_layout_seen_class_methods (void)
7560 {
7561   tree previous_list = all_class_list;
7562   tree end = NULL_TREE;
7563   tree current;
7564
7565   while (1)
7566     {
7567       for (current = previous_list;
7568            current != end; current = TREE_CHAIN (current))
7569         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7570
7571       if (previous_list != all_class_list)
7572         {
7573           end = previous_list;
7574           previous_list = all_class_list;
7575         }
7576       else
7577         break;
7578     }
7579 }
7580
7581 static GTY(()) tree stop_reordering;
7582 void
7583 java_reorder_fields (void)
7584 {
7585   tree current;
7586
7587   for (current = gclass_list; current; current = TREE_CHAIN (current))
7588     {
7589       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7590
7591       if (current_class == stop_reordering)
7592         break;
7593
7594       /* Reverse the fields, but leave the dummy field in front.
7595          Fields are already ordered for Object and Class */
7596       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7597           && current_class != class_type_node)
7598       {
7599         /* If the dummy field is there, reverse the right fields and
7600            just layout the type for proper fields offset */
7601         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7602           {
7603             tree fields = TYPE_FIELDS (current_class);
7604             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7605             TYPE_SIZE (current_class) = NULL_TREE;
7606           }
7607         /* We don't have a dummy field, we need to layout the class,
7608            after having reversed the fields */
7609         else
7610           {
7611             TYPE_FIELDS (current_class) =
7612               nreverse (TYPE_FIELDS (current_class));
7613             TYPE_SIZE (current_class) = NULL_TREE;
7614           }
7615       }
7616     }
7617   /* There are cases were gclass_list will be empty. */
7618   if (gclass_list)
7619     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7620 }
7621
7622 /* Layout the methods of all classes loaded in one way or another.
7623    Check methods of source parsed classes. Then reorder the
7624    fields and layout the classes or the type of all source parsed
7625    classes */
7626
7627 void
7628 java_layout_classes (void)
7629 {
7630   tree current;
7631   int save_error_count = java_error_count;
7632
7633   /* Layout the methods of all classes seen so far */
7634   java_layout_seen_class_methods ();
7635   java_parse_abort_on_error ();
7636   all_class_list = NULL_TREE;
7637
7638   /* Then check the methods of all parsed classes */
7639   for (current = gclass_list; current; current = TREE_CHAIN (current))
7640     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7641       java_check_methods (TREE_VALUE (current));
7642   java_parse_abort_on_error ();
7643
7644   for (current = gclass_list; current; current = TREE_CHAIN (current))
7645     {
7646       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7647       layout_class (current_class);
7648
7649       /* Error reported by the caller */
7650       if (java_error_count)
7651         return;
7652     }
7653
7654   /* We might have reloaded classes durign the process of laying out
7655      classes for code generation. We must layout the methods of those
7656      late additions, as constructor checks might use them */
7657   java_layout_seen_class_methods ();
7658   java_parse_abort_on_error ();
7659 }
7660
7661 /* Expand methods in the current set of classes remembered for
7662    generation.  */
7663
7664 static void
7665 java_complete_expand_classes (void)
7666 {
7667   tree current;
7668
7669   do_not_fold = flag_emit_xref;
7670
7671   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7672     if (!INNER_CLASS_DECL_P (current))
7673       java_complete_expand_class (current);
7674 }
7675
7676 /* Expand the methods found in OUTER, starting first by OUTER's inner
7677    classes, if any.  */
7678
7679 static void
7680 java_complete_expand_class (tree outer)
7681 {
7682   tree inner_list;
7683
7684   set_nested_class_simple_name_value (outer, 1); /* Set */
7685
7686   /* We need to go after all inner classes and start expanding them,
7687      starting with most nested ones. We have to do that because nested
7688      classes might add functions to outer classes */
7689
7690   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7691        inner_list; inner_list = TREE_CHAIN (inner_list))
7692     java_complete_expand_class (TREE_PURPOSE (inner_list));
7693
7694   java_complete_expand_methods (outer);
7695   set_nested_class_simple_name_value (outer, 0); /* Reset */
7696 }
7697
7698 /* Expand methods registered in CLASS_DECL. The general idea is that
7699    we expand regular methods first. This allows us get an estimate on
7700    how outer context local alias fields are really used so we can add
7701    to the constructor just enough code to initialize them properly (it
7702    also lets us generate finit$ correctly.) Then we expand the
7703    constructors and then <clinit>.  */
7704
7705 static void
7706 java_complete_expand_methods (tree class_decl)
7707 {
7708   tree clinit, decl, first_decl;
7709
7710   output_class = current_class = TREE_TYPE (class_decl);
7711
7712   /* Pre-expand <clinit> to figure whether we really need it or
7713      not. If we do need it, we pre-expand the static fields so they're
7714      ready to be used somewhere else. <clinit> will be fully expanded
7715      after we processed the constructors. */
7716   first_decl = TYPE_METHODS (current_class);
7717   clinit = maybe_generate_pre_expand_clinit (current_class);
7718
7719   /* Then generate finit$ (if we need to) because constructors will
7720    try to use it.*/
7721   if (TYPE_FINIT_STMT_LIST (current_class))
7722     java_complete_expand_method (generate_finit (current_class));
7723
7724   /* Then generate instinit$ (if we need to) because constructors will
7725      try to use it. */
7726   if (TYPE_II_STMT_LIST (current_class))
7727     java_complete_expand_method (generate_instinit (current_class));
7728
7729   /* Now do the constructors */
7730   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7731     {
7732       int no_body;
7733
7734       if (!DECL_CONSTRUCTOR_P (decl))
7735         continue;
7736
7737       no_body = !DECL_FUNCTION_BODY (decl);
7738       /* Don't generate debug info on line zero when expanding a
7739          generated constructor. */
7740       if (no_body)
7741         restore_line_number_status (1);
7742
7743       java_complete_expand_method (decl);
7744
7745       if (no_body)
7746         restore_line_number_status (0);
7747     }
7748
7749   /* First, do the ordinary methods. */
7750   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7751     {
7752       /* Ctors aren't part of this batch. */
7753       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7754         continue;
7755
7756       /* Skip abstract or native methods -- but do handle native
7757          methods when generating JNI stubs.  */
7758       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7759         {
7760           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7761           continue;
7762         }
7763
7764       if (METHOD_NATIVE (decl))
7765         {
7766           tree body;
7767           current_function_decl = decl;
7768           body = build_jni_stub (decl);
7769           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7770         }
7771
7772       java_complete_expand_method (decl);
7773     }
7774
7775   /* If there is indeed a <clinit>, fully expand it now */
7776   if (clinit)
7777     {
7778       /* Prevent the use of `this' inside <clinit> */
7779       ctxp->explicit_constructor_p = 1;
7780       java_complete_expand_method (clinit);
7781       ctxp->explicit_constructor_p = 0;
7782     }
7783
7784   /* We might have generated a class$ that we now want to expand */
7785   if (TYPE_DOT_CLASS (current_class))
7786     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7787
7788   /* Now verify constructor circularity (stop after the first one we
7789      prove wrong.) */
7790   if (!CLASS_INTERFACE (class_decl))
7791     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7792       if (DECL_CONSTRUCTOR_P (decl)
7793           && verify_constructor_circularity (decl, decl))
7794         break;
7795 }
7796
7797 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7798    safely used in some other methods/constructors.  */
7799
7800 static tree
7801 maybe_generate_pre_expand_clinit (tree class_type)
7802 {
7803   tree current, mdecl;
7804
7805   if (!TYPE_CLINIT_STMT_LIST (class_type))
7806     return NULL_TREE;
7807
7808   /* Go through all static fields and pre expand them */
7809   for (current = TYPE_FIELDS (class_type); current;
7810        current = TREE_CHAIN (current))
7811     if (FIELD_STATIC (current))
7812       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7813
7814   /* Then build the <clinit> method */
7815   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7816                                     clinit_identifier_node, end_params_node);
7817   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7818                        mdecl, NULL_TREE);
7819   start_artificial_method_body (mdecl);
7820
7821   /* We process the list of assignment we produced as the result of
7822      the declaration of initialized static field and add them as
7823      statement to the <clinit> method. */
7824   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7825        current = TREE_CHAIN (current))
7826     {
7827       tree stmt = current;
7828       /* We build the assignment expression that will initialize the
7829          field to its value. There are strict rules on static
7830          initializers (8.5). FIXME */
7831       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7832         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7833       java_method_add_stmt (mdecl, stmt);
7834     }
7835
7836   end_artificial_method_body (mdecl);
7837
7838   /* Now we want to place <clinit> as the last method (because we need
7839      it at least for interface so that it doesn't interfere with the
7840      dispatch table based lookup. */
7841   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7842     {
7843       current = TREE_CHAIN (TYPE_METHODS (class_type));
7844       TYPE_METHODS (class_type) = current;
7845
7846       while (TREE_CHAIN (current))
7847         current = TREE_CHAIN (current);
7848
7849       TREE_CHAIN (current) = mdecl;
7850       TREE_CHAIN (mdecl) = NULL_TREE;
7851     }
7852
7853   return mdecl;
7854 }
7855
7856 /* Analyzes a method body and look for something that isn't a
7857    MODIFY_EXPR with a constant value.  */
7858
7859 static int
7860 analyze_clinit_body (tree this_class, tree bbody)
7861 {
7862   while (bbody)
7863     switch (TREE_CODE (bbody))
7864       {
7865       case BLOCK:
7866         bbody = BLOCK_EXPR_BODY (bbody);
7867         break;
7868
7869       case EXPR_WITH_FILE_LOCATION:
7870         bbody = EXPR_WFL_NODE (bbody);
7871         break;
7872
7873       case COMPOUND_EXPR:
7874         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7875           return 1;
7876         bbody = TREE_OPERAND (bbody, 1);
7877         break;
7878
7879       case MODIFY_EXPR:
7880         /* If we're generating to class file and we're dealing with an
7881            array initialization, we return 1 to keep <clinit> */
7882         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7883             && flag_emit_class_files)
7884           return 1;
7885
7886         /* There are a few cases where we're required to keep
7887            <clinit>:
7888            - If this is an assignment whose operand is not constant,
7889            - If this is an assignment to a non-initialized field,
7890            - If this field is not a member of the current class.
7891         */
7892         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7893                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7894                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7895
7896       default:
7897         return 1;
7898       }
7899   return 0;
7900 }
7901
7902
7903 /* See whether we could get rid of <clinit>. Criteria are: all static
7904    final fields have constant initial values and the body of <clinit>
7905    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7906
7907 static int
7908 maybe_yank_clinit (tree mdecl)
7909 {
7910   tree type, current;
7911   tree fbody, bbody;
7912
7913   if (!DECL_CLINIT_P (mdecl))
7914     return 0;
7915
7916   /* If the body isn't empty, then we keep <clinit>. Note that if
7917      we're emitting classfiles, this isn't enough not to rule it
7918      out. */
7919   fbody = DECL_FUNCTION_BODY (mdecl);
7920   bbody = BLOCK_EXPR_BODY (fbody);
7921   if (bbody && bbody != error_mark_node)
7922     bbody = BLOCK_EXPR_BODY (bbody);
7923   else
7924     return 0;
7925   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7926     return 0;
7927
7928   type = DECL_CONTEXT (mdecl);
7929   current = TYPE_FIELDS (type);
7930
7931   for (current = (current ? TREE_CHAIN (current) : current);
7932        current; current = TREE_CHAIN (current))
7933     {
7934       tree f_init;
7935
7936       /* We're not interested in non-static fields.  */
7937       if (!FIELD_STATIC (current))
7938         continue;
7939
7940       /* Nor in fields without initializers. */
7941       f_init = DECL_INITIAL (current);
7942       if (f_init == NULL_TREE)
7943         continue;
7944
7945       /* Anything that isn't String or a basic type is ruled out -- or
7946          if we know how to deal with it (when doing things natively) we
7947          should generated an empty <clinit> so that SUID are computed
7948          correctly. */
7949       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7950           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7951         return 0;
7952
7953       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7954         return 0;
7955     }
7956
7957   /* Now we analyze the method body and look for something that
7958      isn't a MODIFY_EXPR */
7959   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7960     return 0;
7961
7962   /* Get rid of <clinit> in the class' list of methods */
7963   if (TYPE_METHODS (type) == mdecl)
7964     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7965   else
7966     for (current = TYPE_METHODS (type); current;
7967          current = TREE_CHAIN (current))
7968       if (TREE_CHAIN (current) == mdecl)
7969         {
7970           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7971           break;
7972         }
7973
7974   return 1;
7975 }
7976
7977 /* Install the argument from MDECL. Suitable to completion and
7978    expansion of mdecl's body.  */
7979
7980 void
7981 start_complete_expand_method (tree mdecl)
7982 {
7983   tree tem;
7984
7985   pushlevel (1);                /* Prepare for a parameter push */
7986   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7987   DECL_ARGUMENTS (mdecl) = tem;
7988
7989   for (; tem; tem = TREE_CHAIN (tem))
7990     {
7991       /* TREE_CHAIN (tem) will change after pushdecl. */
7992       tree next = TREE_CHAIN (tem);
7993       tree type = TREE_TYPE (tem);
7994       if (targetm.calls.promote_prototypes (type)
7995           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7996           && INTEGRAL_TYPE_P (type))
7997         type = integer_type_node;
7998       DECL_ARG_TYPE (tem) = type;
7999       layout_decl (tem, 0);
8000       pushdecl (tem);
8001       /* Re-install the next so that the list is kept and the loop
8002          advances. */
8003       TREE_CHAIN (tem) = next;
8004     }
8005   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8006   input_line = DECL_SOURCE_LINE (mdecl);
8007   build_result_decl (mdecl);
8008 }
8009
8010
8011 /* Complete and expand a method.  */
8012
8013 static void
8014 java_complete_expand_method (tree mdecl)
8015 {
8016   tree fbody, block_body, exception_copy;
8017
8018   current_function_decl = mdecl;
8019   /* Fix constructors before expanding them */
8020   if (DECL_CONSTRUCTOR_P (mdecl))
8021     fix_constructors (mdecl);
8022
8023   /* Expand functions that have a body */
8024   if (!DECL_FUNCTION_BODY (mdecl))
8025     return;
8026
8027   fbody = DECL_FUNCTION_BODY (mdecl);
8028   block_body = BLOCK_EXPR_BODY (fbody);
8029   exception_copy = NULL_TREE;
8030
8031   current_function_decl = mdecl;
8032
8033   if (! quiet_flag)
8034     fprintf (stderr, " [%s.",
8035              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8036   announce_function (mdecl);
8037   if (! quiet_flag)
8038     fprintf (stderr, "]");
8039
8040   /* Prepare the function for tree completion */
8041   start_complete_expand_method (mdecl);
8042
8043   /* Install the current this */
8044   current_this = (!METHOD_STATIC (mdecl) ?
8045                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8046
8047   /* Purge the `throws' list of unchecked exceptions (we save a copy
8048      of the list and re-install it later.) */
8049   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8050   purge_unchecked_exceptions (mdecl);
8051
8052   /* Install exceptions thrown with `throws' */
8053   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8054
8055   if (block_body != NULL_TREE)
8056     {
8057       block_body = java_complete_tree (block_body);
8058
8059       /* Before we check initialization, attached all class initialization
8060          variable to the block_body */
8061       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8062                      attach_init_test_initialization_flags, block_body);
8063
8064       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8065         {
8066           check_for_initialization (block_body, mdecl);
8067
8068           /* Go through all the flags marking the initialization of
8069              static variables and see whether they're definitively
8070              assigned, in which case the type is remembered as
8071              definitively initialized in MDECL. */
8072           if (STATIC_CLASS_INIT_OPT_P ())
8073             {
8074               /* Always register the context as properly initialized in
8075                  MDECL. This used with caution helps removing extra
8076                  initialization of self. */
8077               if (METHOD_STATIC (mdecl))
8078                 {
8079                   *(htab_find_slot
8080                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8081                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8082                 }
8083             }
8084         }
8085       ctxp->explicit_constructor_p = 0;
8086     }
8087
8088   BLOCK_EXPR_BODY (fbody) = block_body;
8089
8090   /* If we saw a return but couldn't evaluate it properly, we'll have
8091      an error_mark_node here. */
8092   if (block_body != error_mark_node
8093       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8094       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8095       && !flag_emit_xref)
8096     missing_return_error (current_function_decl);
8097
8098   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8099   maybe_yank_clinit (mdecl);
8100
8101   /* Pop the current level, with special measures if we found errors. */
8102   if (java_error_count)
8103     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8104   poplevel (1, 0, 1);
8105
8106   /* Pop the exceptions and sanity check */
8107   POP_EXCEPTIONS();
8108   if (currently_caught_type_list)
8109     abort ();
8110
8111   /* Restore the copy of the list of exceptions if emitting xrefs. */
8112   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8113 }
8114
8115 /* For with each class for which there's code to generate. */
8116
8117 static void
8118 java_expand_method_bodies (tree class)
8119 {
8120   tree decl;
8121   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8122     {
8123       tree block;
8124       tree body;
8125
8126       if (! DECL_FUNCTION_BODY (decl))
8127         continue;
8128
8129       current_function_decl = decl;
8130
8131       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8132
8133       if (TREE_CODE (block) != BLOCK)
8134         abort ();
8135
8136       /* Save the function body for inlining.  */
8137       DECL_SAVED_TREE (decl) = block;
8138
8139       body = BLOCK_EXPR_BODY (block);
8140
8141       if (TREE_TYPE (body) == NULL_TREE)
8142         abort ();
8143
8144       /* It's time to assign the variable flagging static class
8145          initialization based on which classes invoked static methods
8146          are definitely initializing. This should be flagged. */
8147       if (STATIC_CLASS_INIT_OPT_P ())
8148         {
8149           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8150           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8151             {
8152               /* Executed for each statement calling a static function.
8153                  LIST is a TREE_LIST whose PURPOSE is the called function
8154                  and VALUE is a compound whose second operand can be patched
8155                  with static class initialization flag assignments.  */
8156
8157               tree called_method = TREE_PURPOSE (list);
8158               tree compound = TREE_VALUE (list);
8159               tree assignment_compound_list
8160                 = build_tree_list (called_method, NULL);
8161
8162               /* For each class definitely initialized in
8163                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8164                  assignment to the class initialization flag. */
8165               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8166                              emit_test_initialization,
8167                              assignment_compound_list);
8168
8169               if (TREE_VALUE (assignment_compound_list))
8170                 TREE_OPERAND (compound, 1)
8171                   = TREE_VALUE (assignment_compound_list);
8172             }
8173         }
8174
8175       /* Prepend class initialization to static methods.  */
8176       if (METHOD_STATIC (decl) && ! METHOD_PRIVATE (decl)
8177           && ! flag_emit_class_files
8178           && ! DECL_CLINIT_P (decl)
8179           && ! CLASS_INTERFACE (TYPE_NAME (class)))
8180         {
8181           tree init = build (CALL_EXPR, void_type_node,
8182                              build_address_of (soft_initclass_node),
8183                              build_tree_list (NULL_TREE,
8184                                               build_class_ref (class)),
8185                              NULL_TREE);
8186           TREE_SIDE_EFFECTS (init) = 1;
8187           body = build (COMPOUND_EXPR, TREE_TYPE (body), init, body);
8188           BLOCK_EXPR_BODY (block) = body;
8189         }
8190
8191       /* Wrap synchronized method bodies in a monitorenter
8192          plus monitorexit cleanup.  */
8193       if (METHOD_SYNCHRONIZED (decl) && ! flag_emit_class_files)
8194         {
8195           tree enter, exit, lock;
8196           if (METHOD_STATIC (decl))
8197             lock = build_class_ref (class);
8198           else
8199             lock = DECL_ARGUMENTS (decl);
8200           BUILD_MONITOR_ENTER (enter, lock);
8201           BUILD_MONITOR_EXIT (exit, lock);
8202
8203           body = build (COMPOUND_EXPR, void_type_node,
8204                         enter,
8205                         build (TRY_FINALLY_EXPR, void_type_node, body, exit));
8206           BLOCK_EXPR_BODY (block) = body;
8207         }
8208
8209       /* Expand the the function body.  */
8210       source_end_java_method ();
8211     }
8212 }
8213
8214 \f
8215
8216 /* This section of the code deals with accessing enclosing context
8217    fields either directly by using the relevant access to this$<n> or
8218    by invoking an access method crafted for that purpose.  */
8219
8220 /* Build the necessary access from an inner class to an outer
8221    class. This routine could be optimized to cache previous result
8222    (decl, current_class and returned access).  When an access method
8223    needs to be generated, it always takes the form of a read. It might
8224    be later turned into a write by calling outer_field_access_fix.  */
8225
8226 static tree
8227 build_outer_field_access (tree id, tree decl)
8228 {
8229   tree access = NULL_TREE;
8230   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8231   tree decl_ctx = DECL_CONTEXT (decl);
8232
8233   /* If the immediate enclosing context of the current class is the
8234      field decl's class or inherits from it; build the access as
8235      `this$<n>.<field>'. Note that we will break the `private' barrier
8236      if we're not emitting bytecodes. */
8237   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8238       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8239     {
8240       tree thisn = build_current_thisn (current_class);
8241       access = make_qualified_primary (build_wfl_node (thisn),
8242                                        id, EXPR_WFL_LINECOL (id));
8243     }
8244   /* Otherwise, generate access methods to outer this and access the
8245      field (either using an access method or by direct access.) */
8246   else
8247     {
8248       int lc = EXPR_WFL_LINECOL (id);
8249
8250       /* Now we chain the required number of calls to the access$0 to
8251          get a hold to the enclosing instance we need, and then we
8252          build the field access. */
8253       access = build_access_to_thisn (current_class, decl_ctx, lc);
8254
8255       /* If the field is private and we're generating bytecode, then
8256          we generate an access method */
8257       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8258         {
8259           tree name = build_outer_field_access_methods (decl);
8260           access = build_outer_field_access_expr (lc, decl_ctx,
8261                                                   name, access, NULL_TREE);
8262         }
8263       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8264          Once again we break the `private' access rule from a foreign
8265          class. */
8266       else
8267         access = make_qualified_primary (access, id, lc);
8268     }
8269   return resolve_expression_name (access, NULL);
8270 }
8271
8272 /* Return a nonzero value if NODE describes an outer field inner
8273    access.  */
8274
8275 static int
8276 outer_field_access_p (tree type, tree decl)
8277 {
8278   if (!INNER_CLASS_TYPE_P (type)
8279       || TREE_CODE (decl) != FIELD_DECL
8280       || DECL_CONTEXT (decl) == type)
8281     return 0;
8282
8283   /* If the inner class extends the declaration context of the field
8284      we're trying to access, then this isn't an outer field access */
8285   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8286     return 0;
8287
8288   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8289        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8290     {
8291       if (type == DECL_CONTEXT (decl))
8292         return 1;
8293
8294       if (!DECL_CONTEXT (TYPE_NAME (type)))
8295         {
8296           /* Before we give up, see whether the field is inherited from
8297              the enclosing context we're considering. */
8298           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8299             return 1;
8300           break;
8301         }
8302     }
8303
8304   return 0;
8305 }
8306
8307 /* Return a nonzero value if NODE represents an outer field inner
8308    access that was been already expanded. As a side effect, it returns
8309    the name of the field being accessed and the argument passed to the
8310    access function, suitable for a regeneration of the access method
8311    call if necessary. */
8312
8313 static int
8314 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8315                                tree *arg)
8316 {
8317   int identified = 0;
8318
8319   if (TREE_CODE (node) != CALL_EXPR)
8320     return 0;
8321
8322   /* Well, gcj generates slightly different tree nodes when compiling
8323      to native or bytecodes. It's the case for function calls. */
8324
8325   if (flag_emit_class_files
8326       && TREE_CODE (node) == CALL_EXPR
8327       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8328     identified = 1;
8329   else if (!flag_emit_class_files)
8330     {
8331       node = TREE_OPERAND (node, 0);
8332
8333       if (node && TREE_OPERAND (node, 0)
8334           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8335         {
8336           node = TREE_OPERAND (node, 0);
8337           if (TREE_OPERAND (node, 0)
8338               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8339               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8340                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8341             identified = 1;
8342         }
8343     }
8344
8345   if (identified && name && arg_type && arg)
8346     {
8347       tree argument = TREE_OPERAND (node, 1);
8348       *name = DECL_NAME (TREE_OPERAND (node, 0));
8349       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8350       *arg = TREE_VALUE (argument);
8351     }
8352   return identified;
8353 }
8354
8355 /* Detect in NODE an outer field read access from an inner class and
8356    transform it into a write with RHS as an argument. This function is
8357    called from the java_complete_lhs when an assignment to a LHS can
8358    be identified. */
8359
8360 static tree
8361 outer_field_access_fix (tree wfl, tree node, tree rhs)
8362 {
8363   tree name, arg_type, arg;
8364
8365   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8366     {
8367       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8368                                             arg_type, name, arg, rhs);
8369       return java_complete_tree (node);
8370     }
8371   return NULL_TREE;
8372 }
8373
8374 /* Construct the expression that calls an access method:
8375      <type>.access$<n>(<arg1> [, <arg2>]);
8376
8377    ARG2 can be NULL and will be omitted in that case. It will denote a
8378    read access.  */
8379
8380 static tree
8381 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8382                                tree arg1, tree arg2)
8383 {
8384   tree args, cn, access;
8385
8386   args = arg1 ? arg1 :
8387     build_wfl_node (build_current_thisn (current_class));
8388   args = build_tree_list (NULL_TREE, args);
8389
8390   if (arg2)
8391     args = tree_cons (NULL_TREE, arg2, args);
8392
8393   access = build_method_invocation (build_wfl_node (access_method_name), args);
8394   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8395   return make_qualified_primary (cn, access, lc);
8396 }
8397
8398 static tree
8399 build_new_access_id (void)
8400 {
8401   static int access_n_counter = 1;
8402   char buffer [128];
8403
8404   sprintf (buffer, "access$%d", access_n_counter++);
8405   return get_identifier (buffer);
8406 }
8407
8408 /* Create the static access functions for the outer field DECL. We define a
8409    read:
8410      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8411        return inst$.field;
8412      }
8413    and a write access:
8414      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8415                                      TREE_TYPE (<field>) value$) {
8416        return inst$.field = value$;
8417      }
8418    We should have a usage flags on the DECL so we can lazily turn the ones
8419    we're using for code generation. FIXME.
8420 */
8421
8422 static tree
8423 build_outer_field_access_methods (tree decl)
8424 {
8425   tree id, args, stmt, mdecl;
8426
8427   if (FIELD_INNER_ACCESS_P (decl))
8428     return FIELD_INNER_ACCESS (decl);
8429
8430   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8431
8432   /* Create the identifier and a function named after it. */
8433   id = build_new_access_id ();
8434
8435   /* The identifier is marked as bearing the name of a generated write
8436      access function for outer field accessed from inner classes. */
8437   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8438
8439   /* Create the read access */
8440   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8441   TREE_CHAIN (args) = end_params_node;
8442   stmt = make_qualified_primary (build_wfl_node (inst_id),
8443                                  build_wfl_node (DECL_NAME (decl)), 0);
8444   stmt = build_return (0, stmt);
8445   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8446                                            TREE_TYPE (decl), id, args, stmt);
8447   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8448
8449   /* Create the write access method. No write access for final variable */
8450   if (!FIELD_FINAL (decl))
8451     {
8452       args = build_tree_list (inst_id,
8453                               build_pointer_type (DECL_CONTEXT (decl)));
8454       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8455       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8456       stmt = make_qualified_primary (build_wfl_node (inst_id),
8457                                      build_wfl_node (DECL_NAME (decl)), 0);
8458       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8459                                                 build_wfl_node (wpv_id)));
8460       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8461                                                TREE_TYPE (decl), id,
8462                                                args, stmt);
8463     }
8464   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8465
8466   /* Return the access name */
8467   return FIELD_INNER_ACCESS (decl) = id;
8468 }
8469
8470 /* Build an field access method NAME.  */
8471
8472 static tree
8473 build_outer_field_access_method (tree class, tree type, tree name,
8474                                  tree args, tree body)
8475 {
8476   tree saved_current_function_decl, mdecl;
8477
8478   /* Create the method */
8479   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8480   fix_method_argument_names (args, mdecl);
8481   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8482
8483   /* Attach the method body. */
8484   saved_current_function_decl = current_function_decl;
8485   start_artificial_method_body (mdecl);
8486   java_method_add_stmt (mdecl, body);
8487   end_artificial_method_body (mdecl);
8488   current_function_decl = saved_current_function_decl;
8489
8490   return mdecl;
8491 }
8492
8493 \f
8494 /* This section deals with building access function necessary for
8495    certain kinds of method invocation from inner classes.  */
8496
8497 static tree
8498 build_outer_method_access_method (tree decl)
8499 {
8500   tree saved_current_function_decl, mdecl;
8501   tree args = NULL_TREE, call_args = NULL_TREE;
8502   tree carg, id, body, class;
8503   char buffer [80];
8504   int parm_id_count = 0;
8505
8506   /* Test this abort with an access to a private field */
8507   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8508     abort ();
8509
8510   /* Check the cache first */
8511   if (DECL_FUNCTION_INNER_ACCESS (decl))
8512     return DECL_FUNCTION_INNER_ACCESS (decl);
8513
8514   class = DECL_CONTEXT (decl);
8515
8516   /* Obtain an access identifier and mark it */
8517   id = build_new_access_id ();
8518   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8519
8520   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8521   /* Create the arguments, as much as the original */
8522   for (; carg && carg != end_params_node;
8523        carg = TREE_CHAIN (carg))
8524     {
8525       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8526       args = chainon (args, build_tree_list (get_identifier (buffer),
8527                                              TREE_VALUE (carg)));
8528     }
8529   args = chainon (args, end_params_node);
8530
8531   /* Create the method */
8532   mdecl = create_artificial_method (class, ACC_STATIC,
8533                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8534   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8535   /* There is a potential bug here. We should be able to use
8536      fix_method_argument_names, but then arg names get mixed up and
8537      eventually a constructor will have its this$0 altered and the
8538      outer context won't be assignment properly. The testcase is
8539      stub.java FIXME */
8540   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8541
8542   /* Attach the method body. */
8543   saved_current_function_decl = current_function_decl;
8544   start_artificial_method_body (mdecl);
8545
8546   /* The actual method invocation uses the same args. When invoking a
8547      static methods that way, we don't want to skip the first
8548      argument. */
8549   carg = args;
8550   if (!METHOD_STATIC (decl))
8551     carg = TREE_CHAIN (carg);
8552   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8553     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8554                            call_args);
8555
8556   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8557                                   call_args);
8558   if (!METHOD_STATIC (decl))
8559     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8560                                    body, 0);
8561   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8562     body = build_return (0, body);
8563   java_method_add_stmt (mdecl,body);
8564   end_artificial_method_body (mdecl);
8565   current_function_decl = saved_current_function_decl;
8566
8567   /* Back tag the access function so it know what it accesses */
8568   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8569
8570   /* Tag the current method so it knows it has an access generated */
8571   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8572 }
8573
8574 \f
8575 /* This section of the code deals with building expressions to access
8576    the enclosing instance of an inner class. The enclosing instance is
8577    kept in a generated field called this$<n>, with <n> being the
8578    inner class nesting level (starting from 0.)  */
8579
8580 /* Build an access to a given this$<n>, always chaining access call to
8581    others. Access methods to this$<n> are build on the fly if
8582    necessary. This CAN'T be used to solely access this$<n-1> from
8583    this$<n> (which alway yield to special cases and optimization, see
8584    for example build_outer_field_access).  */
8585
8586 static tree
8587 build_access_to_thisn (tree from, tree to, int lc)
8588 {
8589   tree access = NULL_TREE;
8590
8591   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8592     {
8593       if (!access)
8594         {
8595           access = build_current_thisn (from);
8596           access = build_wfl_node (access);
8597         }
8598       else
8599         {
8600           tree access0_wfl, cn;
8601
8602           maybe_build_thisn_access_method (from);
8603           access0_wfl = build_wfl_node (access0_identifier_node);
8604           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8605           EXPR_WFL_LINECOL (access0_wfl) = lc;
8606           access = build_tree_list (NULL_TREE, access);
8607           access = build_method_invocation (access0_wfl, access);
8608           access = make_qualified_primary (cn, access, lc);
8609         }
8610
8611       /* If FROM isn't an inner class, that's fine, we've done enough.
8612          What we're looking for can be accessed from there.  */
8613       from = DECL_CONTEXT (TYPE_NAME (from));
8614       if (!from)
8615         break;
8616       from = TREE_TYPE (from);
8617     }
8618   return access;
8619 }
8620
8621 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8622    is returned if nothing needs to be generated. Otherwise, the method
8623    generated and a method decl is returned.
8624
8625    NOTE: These generated methods should be declared in a class file
8626    attribute so that they can't be referred to directly.  */
8627
8628 static tree
8629 maybe_build_thisn_access_method (tree type)
8630 {
8631   tree mdecl, args, stmt, rtype;
8632   tree saved_current_function_decl;
8633
8634   /* If TYPE is a top-level class, no access method is required.
8635      If there already is such an access method, bail out. */
8636   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8637     return NULL_TREE;
8638
8639   /* We generate the method. The method looks like:
8640      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8641   */
8642   args = build_tree_list (inst_id, build_pointer_type (type));
8643   TREE_CHAIN (args) = end_params_node;
8644   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8645   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8646                                     access0_identifier_node, args);
8647   fix_method_argument_names (args, mdecl);
8648   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8649   stmt = build_current_thisn (type);
8650   stmt = make_qualified_primary (build_wfl_node (inst_id),
8651                                  build_wfl_node (stmt), 0);
8652   stmt = build_return (0, stmt);
8653
8654   saved_current_function_decl = current_function_decl;
8655   start_artificial_method_body (mdecl);
8656   java_method_add_stmt (mdecl, stmt);
8657   end_artificial_method_body (mdecl);
8658   current_function_decl = saved_current_function_decl;
8659
8660   CLASS_ACCESS0_GENERATED_P (type) = 1;
8661
8662   return mdecl;
8663 }
8664
8665 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8666    the first level of innerclassing. this$1 for the next one, etc...
8667    This function can be invoked with TYPE to NULL, available and then
8668    has to count the parser context.  */
8669
8670 static GTY(()) tree saved_thisn;
8671 static GTY(()) tree saved_type;
8672
8673 static tree
8674 build_current_thisn (tree type)
8675 {
8676   static int saved_i = -1;
8677   static int saved_type_i = 0;
8678   tree decl;
8679   char buffer [24];
8680   int i = 0;
8681
8682   if (type)
8683     {
8684       if (type == saved_type)
8685         i = saved_type_i;
8686       else
8687         {
8688           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8689                decl; decl = DECL_CONTEXT (decl), i++)
8690             ;
8691
8692           saved_type = type;
8693           saved_type_i = i;
8694         }
8695     }
8696   else
8697     i = list_length (GET_CPC_LIST ())-2;
8698
8699   if (i == saved_i)
8700     return saved_thisn;
8701
8702   sprintf (buffer, "this$%d", i);
8703   saved_i = i;
8704   saved_thisn = get_identifier (buffer);
8705   return saved_thisn;
8706 }
8707
8708 /* Return the assignment to the hidden enclosing context `this$<n>'
8709    by the second incoming parameter to the innerclass constructor. The
8710    form used is `this.this$<n> = this$<n>;'.  */
8711
8712 static tree
8713 build_thisn_assign (void)
8714 {
8715   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8716     {
8717       tree thisn = build_current_thisn (current_class);
8718       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8719                                          build_wfl_node (thisn), 0);
8720       tree rhs = build_wfl_node (thisn);
8721       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8722       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8723     }
8724   return NULL_TREE;
8725 }
8726
8727 \f
8728 /* Building the synthetic `class$' used to implement the `.class' 1.1
8729    extension for non primitive types. This method looks like:
8730
8731     static Class class$(String type) throws NoClassDefFoundError
8732     {
8733       try {return (java.lang.Class.forName (String));}
8734       catch (ClassNotFoundException e) {
8735         throw new NoClassDefFoundError(e.getMessage());}
8736     } */
8737
8738 static GTY(()) tree get_message_wfl;
8739 static GTY(()) tree type_parm_wfl;
8740
8741 static tree
8742 build_dot_class_method (tree class)
8743 {
8744 #define BWF(S) build_wfl_node (get_identifier ((S)))
8745 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8746   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8747   tree stmt, throw_stmt;
8748
8749   if (!get_message_wfl)
8750     {
8751       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8752       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8753     }
8754
8755   /* Build the arguments */
8756   args = build_tree_list (get_identifier ("type$"),
8757                           build_pointer_type (string_type_node));
8758   TREE_CHAIN (args) = end_params_node;
8759
8760   /* Build the qualified name java.lang.Class.forName */
8761   tmp = MQN (MQN (MQN (BWF ("java"),
8762                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8763
8764   /* Create the "class$" function */
8765   mdecl = create_artificial_method (class, ACC_STATIC,
8766                                     build_pointer_type (class_type_node),
8767                                     classdollar_identifier_node, args);
8768   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8769                    BWF ("NoClassDefFoundError"));
8770   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8771   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8772   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8773     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8774
8775   /* We start by building the try block. We need to build:
8776        return (java.lang.Class.forName (type)); */
8777   stmt = build_method_invocation (tmp,
8778                                   build_tree_list (NULL_TREE, type_parm_wfl));
8779   stmt = build_return (0, stmt);
8780
8781   /* Now onto the catch block. We start by building the expression
8782      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8783   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8784                                     get_message_wfl, 0);
8785   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8786
8787   /* Build new NoClassDefFoundError (_.getMessage) */
8788   throw_stmt = build_new_invocation
8789     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8790      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8791
8792   /* Build the throw, (it's too early to use BUILD_THROW) */
8793   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8794
8795   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8796   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8797                    BWF ("ClassNotFoundException"));
8798   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8799
8800   fix_method_argument_names (args, mdecl);
8801   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8802   saved_current_function_decl = current_function_decl;
8803   start_artificial_method_body (mdecl);
8804   java_method_add_stmt (mdecl, stmt);
8805   end_artificial_method_body (mdecl);
8806   current_function_decl = saved_current_function_decl;
8807   TYPE_DOT_CLASS (class) = mdecl;
8808
8809   return mdecl;
8810 }
8811
8812 static tree
8813 build_dot_class_method_invocation (tree this_class, tree type)
8814 {
8815   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8816   tree sig_id, s, t;
8817
8818   if (TYPE_ARRAY_P (type))
8819     sig_id = build_java_signature (type);
8820   else
8821     sig_id = DECL_NAME (TYPE_NAME (type));
8822
8823   /* Ensure that the proper name separator is used */
8824   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8825                                IDENTIFIER_LENGTH (sig_id));
8826
8827   s = build_string (IDENTIFIER_LENGTH (sig_id),
8828                     IDENTIFIER_POINTER (sig_id));
8829   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8830                                build_tree_list (NULL_TREE, s));
8831   if (DECL_CONTEXT (dot_class_method) != this_class)
8832     {
8833       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8834       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8835     }
8836   return t;
8837 }
8838
8839 /* This section of the code deals with constructor.  */
8840
8841 /* Craft a body for default constructor. Patch existing constructor
8842    bodies with call to super() and field initialization statements if
8843    necessary.  */
8844
8845 static void
8846 fix_constructors (tree mdecl)
8847 {
8848   tree iii;                     /* Instance Initializer Invocation */
8849   tree body = DECL_FUNCTION_BODY (mdecl);
8850   tree thisn_assign, compound = NULL_TREE;
8851   tree class_type = DECL_CONTEXT (mdecl);
8852
8853   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8854     return;
8855   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8856
8857   if (!body)
8858     {
8859       /* It is an error for the compiler to generate a default
8860          constructor if the superclass doesn't have a constructor that
8861          takes no argument, or the same args for an anonymous class */
8862       if (verify_constructor_super (mdecl))
8863         {
8864           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8865           tree save = DECL_NAME (mdecl);
8866           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8867           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8868           parse_error_context
8869             (lookup_cl (TYPE_NAME (class_type)),
8870              "No constructor matching `%s' found in class `%s'",
8871              lang_printable_name (mdecl, 0), n);
8872           DECL_NAME (mdecl) = save;
8873         }
8874
8875       /* The constructor body must be crafted by hand. It's the
8876          constructor we defined when we realize we didn't have the
8877          CLASSNAME() constructor */
8878       start_artificial_method_body (mdecl);
8879
8880       /* Insert an assignment to the this$<n> hidden field, if
8881          necessary */
8882       if ((thisn_assign = build_thisn_assign ()))
8883         java_method_add_stmt (mdecl, thisn_assign);
8884
8885       /* We don't generate a super constructor invocation if we're
8886          compiling java.lang.Object. build_super_invocation takes care
8887          of that. */
8888       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8889
8890       /* FIXME */
8891       if ((iii = build_instinit_invocation (class_type)))
8892         java_method_add_stmt (mdecl, iii);
8893
8894       end_artificial_method_body (mdecl);
8895     }
8896   /* Search for an explicit constructor invocation */
8897   else
8898     {
8899       int found = 0;
8900       int invokes_this = 0;
8901       tree found_call = NULL_TREE;
8902       tree main_block = BLOCK_EXPR_BODY (body);
8903
8904       while (body)
8905         switch (TREE_CODE (body))
8906           {
8907           case CALL_EXPR:
8908             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8909             if (CALL_THIS_CONSTRUCTOR_P (body))
8910               invokes_this = 1;
8911             body = NULL_TREE;
8912             break;
8913           case COMPOUND_EXPR:
8914           case EXPR_WITH_FILE_LOCATION:
8915             found_call = body;
8916             body = TREE_OPERAND (body, 0);
8917             break;
8918           case BLOCK:
8919             found_call = body;
8920             body = BLOCK_EXPR_BODY (body);
8921             break;
8922           default:
8923             found = 0;
8924             body = NULL_TREE;
8925           }
8926
8927       /* Generate the assignment to this$<n>, if necessary */
8928       if ((thisn_assign = build_thisn_assign ()))
8929         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8930
8931       /* The constructor is missing an invocation of super() */
8932       if (!found)
8933         compound = add_stmt_to_compound (compound, NULL_TREE,
8934                                          build_super_invocation (mdecl));
8935       /* Explicit super() invocation should take place before the
8936          instance initializer blocks. */
8937       else
8938         {
8939           compound = add_stmt_to_compound (compound, NULL_TREE,
8940                                            TREE_OPERAND (found_call, 0));
8941           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8942         }
8943
8944       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8945
8946       /* Insert the instance initializer block right after. */
8947       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8948         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8949
8950       /* Fix the constructor main block if we're adding extra stmts */
8951       if (compound)
8952         {
8953           compound = add_stmt_to_compound (compound, NULL_TREE,
8954                                            BLOCK_EXPR_BODY (main_block));
8955           BLOCK_EXPR_BODY (main_block) = compound;
8956         }
8957     }
8958 }
8959
8960 /* Browse constructors in the super class, searching for a constructor
8961    that doesn't take any argument. Return 0 if one is found, 1
8962    otherwise.  If the current class is an anonymous inner class, look
8963    for something that has the same signature. */
8964
8965 static int
8966 verify_constructor_super (tree mdecl)
8967 {
8968   tree class = CLASSTYPE_SUPER (current_class);
8969   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8970   tree sdecl;
8971
8972   if (!class)
8973     return 0;
8974
8975   if (ANONYMOUS_CLASS_P (current_class))
8976     {
8977       tree mdecl_arg_type;
8978       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8979       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8980         if (DECL_CONSTRUCTOR_P (sdecl))
8981           {
8982             tree m_arg_type;
8983             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8984             if (super_inner)
8985               arg_type = TREE_CHAIN (arg_type);
8986             for (m_arg_type = mdecl_arg_type;
8987                  (arg_type != end_params_node
8988                   && m_arg_type != end_params_node);
8989                  arg_type = TREE_CHAIN (arg_type),
8990                    m_arg_type = TREE_CHAIN (m_arg_type))
8991               if (!valid_method_invocation_conversion_p
8992                      (TREE_VALUE (arg_type),
8993                       TREE_VALUE (m_arg_type)))
8994                 break;
8995
8996             if (arg_type == end_params_node && m_arg_type == end_params_node)
8997               return 0;
8998           }
8999     }
9000   else
9001     {
9002       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9003         {
9004           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9005           if (super_inner)
9006             arg = TREE_CHAIN (arg);
9007           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9008             return 0;
9009         }
9010     }
9011   return 1;
9012 }
9013
9014 /* Generate code for all context remembered for code generation.  */
9015
9016 static GTY(()) tree reversed_class_list;
9017 void
9018 java_expand_classes (void)
9019 {
9020   int save_error_count = 0;
9021   static struct parser_ctxt *cur_ctxp = NULL;
9022
9023   java_parse_abort_on_error ();
9024   if (!(ctxp = ctxp_for_generation))
9025     return;
9026   java_layout_classes ();
9027   java_parse_abort_on_error ();
9028
9029   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9030     {
9031       tree current;
9032       for (current = cur_ctxp->class_list;
9033            current;
9034            current = TREE_CHAIN (current))
9035         gen_indirect_dispatch_tables (TREE_TYPE (current));
9036     }
9037
9038   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9039     {
9040       ctxp = cur_ctxp;
9041       input_filename = ctxp->filename;
9042       lang_init_source (2);            /* Error msgs have method prototypes */
9043       java_complete_expand_classes (); /* Complete and expand classes */
9044       java_parse_abort_on_error ();
9045     }
9046   input_filename = main_input_filename;
9047
9048   /* Find anonymous classes and expand their constructor. This extra pass is
9049      necessary because the constructor itself is only generated when the
9050      method in which it is defined is expanded. */
9051   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9052     {
9053       tree current;
9054       ctxp = cur_ctxp;
9055       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9056         {
9057           output_class = current_class = TREE_TYPE (current);
9058           if (ANONYMOUS_CLASS_P (current_class))
9059             {
9060               tree d;
9061               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9062                 {
9063                   if (DECL_CONSTRUCTOR_P (d))
9064                     {
9065                       restore_line_number_status (1);
9066                       java_complete_expand_method (d);
9067                       restore_line_number_status (0);
9068                       break;    /* There is only one constructor. */
9069                     }
9070                 }
9071             }
9072         }
9073     }
9074
9075   /* Expanding the constructors of anonymous classes generates access
9076      methods.  Scan all the methods looking for null DECL_RESULTs --
9077      this will be the case if a method hasn't been expanded.  */
9078   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9079     {
9080       tree current;
9081       ctxp = cur_ctxp;
9082       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9083         {
9084           tree d;
9085           output_class = current_class = TREE_TYPE (current);
9086           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9087             {
9088               if (DECL_RESULT (d) == NULL_TREE)
9089                 {
9090                   restore_line_number_status (1);
9091                   java_complete_expand_method (d);
9092                   restore_line_number_status (0);
9093                 }
9094             }
9095         }
9096     }
9097
9098   /* ???  Instead of all this we could iterate around the list of
9099      classes until there were no more un-expanded methods.  It would
9100      take a little longer -- one pass over the whole list of methods
9101      -- but it would be simpler.  Like this:  */
9102 #if 0
9103     {
9104       int something_changed;
9105
9106       do
9107         {
9108           something_changed = 0;
9109           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9110             {
9111               tree current;
9112               ctxp = cur_ctxp;
9113               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9114                 {
9115                   tree d;
9116                   output_class = current_class = TREE_TYPE (current);
9117                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9118                     {
9119                       if (DECL_RESULT (d) == NULL_TREE)
9120                         {
9121                           something_changed = 1;
9122                           restore_line_number_status (1);
9123                           java_complete_expand_method (d);
9124                           restore_line_number_status (0);
9125                         }
9126                     }
9127                 }
9128             }
9129         }
9130       while (something_changed);
9131     }
9132 #endif
9133
9134   /* If we've found error at that stage, don't try to generate
9135      anything, unless we're emitting xrefs or checking the syntax only
9136      (but not using -fsyntax-only for the purpose of generating
9137      bytecode. */
9138   if (java_error_count && !flag_emit_xref
9139       && (!flag_syntax_only && !flag_emit_class_files))
9140     return;
9141
9142   /* Now things are stable, go for generation of the class data. */
9143
9144   /* We pessimistically marked all methods and fields external until
9145      we knew what set of classes we were planning to compile.  Now mark
9146      those that will be generated locally as not external.  */
9147   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9148     {
9149       tree current;
9150       ctxp = cur_ctxp;
9151       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9152         java_mark_class_local (TREE_TYPE (current));
9153     }
9154
9155   /* Compile the classes.  */
9156   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9157     {
9158       tree current;
9159       reversed_class_list = NULL;
9160
9161       ctxp = cur_ctxp;
9162
9163       /* We write out the classes in reverse order.  This ensures that
9164          inner classes are written before their containing classes,
9165          which is important for parallel builds.  Otherwise, the
9166          class file for the outer class may be found, but the class
9167          file for the inner class may not be present.  In that
9168          situation, the compiler cannot fall back to the original
9169          source, having already read the outer class, so we must
9170          prevent that situation.  */
9171       for (current = ctxp->class_list;
9172            current;
9173            current = TREE_CHAIN (current))
9174         reversed_class_list
9175           = tree_cons (NULL_TREE, current, reversed_class_list);
9176
9177       for (current = reversed_class_list;
9178            current;
9179            current = TREE_CHAIN (current))
9180         {
9181           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9182           if (flag_emit_class_files)
9183             write_classfile (current_class);
9184           if (flag_emit_xref)
9185             expand_xref (current_class);
9186           else if (! flag_syntax_only)
9187             java_expand_method_bodies (current_class);
9188         }
9189     }
9190 }
9191
9192 void
9193 java_finish_classes (void)
9194 {
9195   static struct parser_ctxt *cur_ctxp = NULL;
9196   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9197     {
9198       tree current;
9199       ctxp = cur_ctxp;
9200       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9201         {
9202           output_class = current_class = TREE_TYPE (current);
9203           finish_class ();
9204         }
9205     }
9206 }
9207
9208 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9209    a tree list node containing RIGHT. Fore coming RIGHTs will be
9210    chained to this hook. LOCATION contains the location of the
9211    separating `.' operator.  */
9212
9213 static tree
9214 make_qualified_primary (tree primary, tree right, int location)
9215 {
9216   tree wfl;
9217
9218   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9219     wfl = build_wfl_wrap (primary, location);
9220   else
9221     {
9222       wfl = primary;
9223       /* If wfl wasn't qualified, we build a first anchor */
9224       if (!EXPR_WFL_QUALIFICATION (wfl))
9225         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9226     }
9227
9228   /* And chain them */
9229   EXPR_WFL_LINECOL (right) = location;
9230   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9231   PRIMARY_P (wfl) =  1;
9232   return wfl;
9233 }
9234
9235 /* Simple merge of two name separated by a `.' */
9236
9237 static tree
9238 merge_qualified_name (tree left, tree right)
9239 {
9240   tree node;
9241   if (!left && !right)
9242     return NULL_TREE;
9243
9244   if (!left)
9245     return right;
9246
9247   if (!right)
9248     return left;
9249
9250   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9251                 IDENTIFIER_LENGTH (left));
9252   obstack_1grow (&temporary_obstack, '.');
9253   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9254                  IDENTIFIER_LENGTH (right));
9255   node =  get_identifier (obstack_base (&temporary_obstack));
9256   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9257   QUALIFIED_P (node) = 1;
9258   return node;
9259 }
9260
9261 /* Merge the two parts of a qualified name into LEFT.  Set the
9262    location information of the resulting node to LOCATION, usually
9263    inherited from the location information of the `.' operator. */
9264
9265 static tree
9266 make_qualified_name (tree left, tree right, int location)
9267 {
9268 #ifdef USE_COMPONENT_REF
9269   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9270   EXPR_WFL_LINECOL (node) = location;
9271   return node;
9272 #else
9273   tree left_id = EXPR_WFL_NODE (left);
9274   tree right_id = EXPR_WFL_NODE (right);
9275   tree wfl, merge;
9276
9277   merge = merge_qualified_name (left_id, right_id);
9278
9279   /* Left wasn't qualified and is now qualified */
9280   if (!QUALIFIED_P (left_id))
9281     {
9282       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9283       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9284       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9285     }
9286
9287   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9288   EXPR_WFL_LINECOL (wfl) = location;
9289   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9290
9291   EXPR_WFL_NODE (left) = merge;
9292   return left;
9293 #endif
9294 }
9295
9296 /* Extract the last identifier component of the qualified in WFL. The
9297    last identifier is removed from the linked list */
9298
9299 static tree
9300 cut_identifier_in_qualified (tree wfl)
9301 {
9302   tree q;
9303   tree previous = NULL_TREE;
9304   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9305     if (!TREE_CHAIN (q))
9306       {
9307         if (!previous)
9308           /* Operating on a non qualified qualified WFL.  */
9309           abort ();
9310
9311         TREE_CHAIN (previous) = NULL_TREE;
9312         return TREE_PURPOSE (q);
9313       }
9314 }
9315
9316 /* Resolve the expression name NAME. Return its decl.  */
9317
9318 static tree
9319 resolve_expression_name (tree id, tree *orig)
9320 {
9321   tree name = EXPR_WFL_NODE (id);
9322   tree decl;
9323
9324   /* 6.5.5.1: Simple expression names */
9325   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9326     {
9327       /* 15.13.1: NAME can appear within the scope of a local variable
9328          declaration */
9329       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9330         return decl;
9331
9332       /* 15.13.1: NAME can appear within a class declaration */
9333       else
9334         {
9335           decl = lookup_field_wrapper (current_class, name);
9336           if (decl)
9337             {
9338               tree access = NULL_TREE;
9339               int fs = FIELD_STATIC (decl);
9340
9341               /* If we're accessing an outer scope local alias, make
9342                  sure we change the name of the field we're going to
9343                  build access to. */
9344               if (FIELD_LOCAL_ALIAS_USED (decl))
9345                 name = DECL_NAME (decl);
9346
9347               check_deprecation (id, decl);
9348
9349               /* Instance variable (8.3.1.1) can't appear within
9350                  static method, static initializer or initializer for
9351                  a static variable. */
9352               if (!fs && METHOD_STATIC (current_function_decl))
9353                 {
9354                   static_ref_err (id, name, current_class);
9355                   return error_mark_node;
9356                 }
9357               /* Instance variables can't appear as an argument of
9358                  an explicit constructor invocation */
9359               if (!fs && ctxp->explicit_constructor_p
9360                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9361                 {
9362                   parse_error_context
9363                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9364                   return error_mark_node;
9365                 }
9366
9367               /* If we're processing an inner class and we're trying
9368                  to access a field belonging to an outer class, build
9369                  the access to the field */
9370               if (!fs && outer_field_access_p (current_class, decl))
9371                 {
9372                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9373                     {
9374                       static_ref_err (id, DECL_NAME (decl), current_class);
9375                       return error_mark_node;
9376                     }
9377                   access = build_outer_field_access (id, decl);
9378                   if (orig)
9379                     *orig = access;
9380                   return access;
9381                 }
9382
9383               /* Otherwise build what it takes to access the field */
9384               access = build_field_ref ((fs ? NULL_TREE : current_this),
9385                                         DECL_CONTEXT (decl), name);
9386               if (fs)
9387                 access = maybe_build_class_init_for_field (decl, access);
9388               /* We may be asked to save the real field access node */
9389               if (orig)
9390                 *orig = access;
9391               /* Last check: can we access the field? */
9392               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9393                 {
9394                   not_accessible_field_error (id, decl);
9395                   return error_mark_node;
9396                 }
9397               /* And we return what we got */
9398               return access;
9399             }
9400           /* Fall down to error report on undefined variable */
9401         }
9402     }
9403   /* 6.5.5.2 Qualified Expression Names */
9404   else
9405     {
9406       if (orig)
9407         *orig = NULL_TREE;
9408       qualify_ambiguous_name (id);
9409       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9410       /* 15.10.2: Accessing Superclass Members using super */
9411       return resolve_field_access (id, orig, NULL);
9412     }
9413
9414   /* We've got an error here */
9415   if (INNER_CLASS_TYPE_P (current_class))
9416     parse_error_context (id,
9417                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9418                          IDENTIFIER_POINTER (name),
9419                          IDENTIFIER_POINTER (DECL_NAME
9420                                              (TYPE_NAME (current_class))));
9421   else
9422     parse_error_context (id, "Undefined variable `%s'",
9423                          IDENTIFIER_POINTER (name));
9424
9425   return error_mark_node;
9426 }
9427
9428 static void
9429 static_ref_err (tree wfl, tree field_id, tree class_type)
9430 {
9431   parse_error_context
9432     (wfl,
9433      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9434      IDENTIFIER_POINTER (field_id),
9435      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9436 }
9437
9438 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9439    We return something suitable to generate the field access. We also
9440    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9441    recipient's address can be null. */
9442
9443 static tree
9444 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9445 {
9446   int is_static = 0;
9447   tree field_ref;
9448   tree decl, where_found, type_found;
9449
9450   if (resolve_qualified_expression_name (qual_wfl, &decl,
9451                                          &where_found, &type_found))
9452     return error_mark_node;
9453
9454   /* Resolve the LENGTH field of an array here */
9455   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9456       && type_found && TYPE_ARRAY_P (type_found)
9457       && ! flag_emit_class_files && ! flag_emit_xref)
9458     {
9459       tree length = build_java_array_length_access (where_found);
9460       field_ref = length;
9461
9462       /* In case we're dealing with a static array, we need to
9463          initialize its class before the array length can be fetched.
9464          It's also a good time to create a DECL_RTL for the field if
9465          none already exists, otherwise if the field was declared in a
9466          class found in an external file and hasn't been (and won't
9467          be) accessed for its value, none will be created. */
9468       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9469         {
9470           build_static_field_ref (where_found);
9471           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9472         }
9473     }
9474   /* We might have been trying to resolve field.method(). In which
9475      case, the resolution is over and decl is the answer */
9476   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9477     field_ref = decl;
9478   else if (JDECL_P (decl))
9479     {
9480       if (!type_found)
9481         type_found = DECL_CONTEXT (decl);
9482       is_static = FIELD_STATIC (decl);
9483       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9484                                     NULL_TREE : where_found),
9485                                    type_found, DECL_NAME (decl));
9486       if (field_ref == error_mark_node)
9487         return error_mark_node;
9488       if (is_static)
9489         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9490
9491       /* If we're looking at a static field, we may need to generate a
9492          class initialization for it.  This can happen when the access
9493          looks like `field.ref', where `field' is a static field in an
9494          interface we implement.  */
9495       if (!flag_emit_class_files
9496           && !flag_emit_xref
9497           && TREE_CODE (where_found) == VAR_DECL
9498           && FIELD_STATIC (where_found))
9499         {
9500           build_static_field_ref (where_found);
9501           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9502         }
9503     }
9504   else
9505     field_ref = decl;
9506
9507   if (field_decl)
9508     *field_decl = decl;
9509   if (field_type)
9510     *field_type = (QUAL_DECL_TYPE (decl) ?
9511                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9512   return field_ref;
9513 }
9514
9515 /* If NODE is an access to f static field, strip out the class
9516    initialization part and return the field decl, otherwise, return
9517    NODE. */
9518
9519 static tree
9520 strip_out_static_field_access_decl (tree node)
9521 {
9522   if (TREE_CODE (node) == COMPOUND_EXPR)
9523     {
9524       tree op1 = TREE_OPERAND (node, 1);
9525       if (TREE_CODE (op1) == COMPOUND_EXPR)
9526          {
9527            tree call = TREE_OPERAND (op1, 0);
9528            if (TREE_CODE (call) == CALL_EXPR
9529                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9530                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9531                == soft_initclass_node)
9532              return TREE_OPERAND (op1, 1);
9533          }
9534       else if (JDECL_P (op1))
9535         return op1;
9536     }
9537   return node;
9538 }
9539
9540 /* 6.5.5.2: Qualified Expression Names */
9541
9542 static int
9543 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9544                                    tree *where_found, tree *type_found)
9545 {
9546   int from_type = 0;            /* Field search initiated from a type */
9547   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9548   int previous_call_static = 0;
9549   int is_static;
9550   tree decl = NULL_TREE, type = NULL_TREE, q;
9551   /* For certain for of inner class instantiation */
9552   tree saved_current, saved_this;
9553 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9554   { current_class = saved_current; current_this = saved_this;}
9555
9556   *type_found = *where_found = NULL_TREE;
9557
9558   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9559     {
9560       tree qual_wfl = QUAL_WFL (q);
9561       tree ret_decl;            /* for EH checking */
9562       int location;             /* for EH checking */
9563
9564       /* 15.10.1 Field Access Using a Primary */
9565       switch (TREE_CODE (qual_wfl))
9566         {
9567         case CALL_EXPR:
9568         case NEW_CLASS_EXPR:
9569           /* If the access to the function call is a non static field,
9570              build the code to access it. */
9571           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9572             {
9573               decl = maybe_access_field (decl, *where_found,
9574                                          DECL_CONTEXT (decl));
9575               if (decl == error_mark_node)
9576                 return 1;
9577             }
9578
9579           /* And code for the function call */
9580           if (complete_function_arguments (qual_wfl))
9581             return 1;
9582
9583           /* We might have to setup a new current class and a new this
9584              for the search of an inner class, relative to the type of
9585              a expression resolved as `decl'. The current values are
9586              saved and restored shortly after */
9587           saved_current = current_class;
9588           saved_this = current_this;
9589           if (decl
9590               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9591                   || from_qualified_this))
9592             {
9593               /* If we still have `from_qualified_this', we have the form
9594                  <T>.this.f() and we need to build <T>.this */
9595               if (from_qualified_this)
9596                 {
9597                   decl = build_access_to_thisn (current_class, type, 0);
9598                   decl = java_complete_tree (decl);
9599                   type = TREE_TYPE (TREE_TYPE (decl));
9600                 }
9601               current_class = type;
9602               current_this = decl;
9603               from_qualified_this = 0;
9604             }
9605
9606           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9607             CALL_USING_SUPER (qual_wfl) = 1;
9608           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9609                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9610           *where_found = patch_method_invocation (qual_wfl, decl, type,
9611                                                   from_super,
9612                                                   &is_static, &ret_decl);
9613           from_super = 0;
9614           if (*where_found == error_mark_node)
9615             {
9616               RESTORE_THIS_AND_CURRENT_CLASS;
9617               return 1;
9618             }
9619           *type_found = type = QUAL_DECL_TYPE (*where_found);
9620
9621           *where_found = force_evaluation_order (*where_found);
9622
9623           /* If we're creating an inner class instance, check for that
9624              an enclosing instance is in scope */
9625           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9626               && INNER_ENCLOSING_SCOPE_CHECK (type))
9627             {
9628               parse_error_context
9629                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9630                  lang_printable_name (type, 0),
9631                  (!current_this ? "" :
9632                   "; an explicit one must be provided when creating this inner class"));
9633               RESTORE_THIS_AND_CURRENT_CLASS;
9634               return 1;
9635             }
9636
9637           /* In case we had to change then to resolve a inner class
9638              instantiation using a primary qualified by a `new' */
9639           RESTORE_THIS_AND_CURRENT_CLASS;
9640
9641           if (location)
9642             {
9643               tree arguments = NULL_TREE;
9644               if (TREE_CODE (qual_wfl) == CALL_EXPR
9645                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9646                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9647               check_thrown_exceptions (location, ret_decl, arguments);
9648             }
9649
9650           /* If the previous call was static and this one is too,
9651              build a compound expression to hold the two (because in
9652              that case, previous function calls aren't transported as
9653              forcoming function's argument. */
9654           if (previous_call_static && is_static)
9655             {
9656               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9657                             decl, *where_found);
9658               TREE_SIDE_EFFECTS (decl) = 1;
9659             }
9660           else
9661             {
9662               previous_call_static = is_static;
9663               decl = *where_found;
9664             }
9665           from_type = 0;
9666           continue;
9667
9668         case NEW_ARRAY_EXPR:
9669         case NEW_ANONYMOUS_ARRAY_EXPR:
9670           *where_found = decl = java_complete_tree (qual_wfl);
9671           if (decl == error_mark_node)
9672             return 1;
9673           *type_found = type = QUAL_DECL_TYPE (decl);
9674           continue;
9675
9676         case CONVERT_EXPR:
9677           *where_found = decl = java_complete_tree (qual_wfl);
9678           if (decl == error_mark_node)
9679             return 1;
9680           *type_found = type = QUAL_DECL_TYPE (decl);
9681           from_cast = 1;
9682           continue;
9683
9684         case CONDITIONAL_EXPR:
9685         case STRING_CST:
9686         case MODIFY_EXPR:
9687           *where_found = decl = java_complete_tree (qual_wfl);
9688           if (decl == error_mark_node)
9689             return 1;
9690           *type_found = type = QUAL_DECL_TYPE (decl);
9691           continue;
9692
9693         case ARRAY_REF:
9694           /* If the access to the function call is a non static field,
9695              build the code to access it. */
9696           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9697             {
9698               decl = maybe_access_field (decl, *where_found, type);
9699               if (decl == error_mark_node)
9700                 return 1;
9701             }
9702           /* And code for the array reference expression */
9703           decl = java_complete_tree (qual_wfl);
9704           if (decl == error_mark_node)
9705             return 1;
9706           type = QUAL_DECL_TYPE (decl);
9707           continue;
9708
9709         case PLUS_EXPR:
9710           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9711             return 1;
9712           if ((type = patch_string (decl)))
9713             decl = type;
9714           *where_found = QUAL_RESOLUTION (q) = decl;
9715           *type_found = type = TREE_TYPE (decl);
9716           break;
9717
9718         case CLASS_LITERAL:
9719           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9720             return 1;
9721           *where_found = QUAL_RESOLUTION (q) = decl;
9722           *type_found = type = TREE_TYPE (decl);
9723           break;
9724
9725         default:
9726           /* Fix for -Wall Just go to the next statement. Don't
9727              continue */
9728           break;
9729         }
9730
9731       /* If we fall here, we weren't processing a (static) function call. */
9732       previous_call_static = 0;
9733
9734       /* It can be the keyword THIS */
9735       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9736           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9737         {
9738           if (!current_this)
9739             {
9740               parse_error_context
9741                 (wfl, "Keyword `this' used outside allowed context");
9742               return 1;
9743             }
9744           if (ctxp->explicit_constructor_p
9745               && type == current_class)
9746             {
9747               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9748               return 1;
9749             }
9750           /* We have to generate code for intermediate access */
9751           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9752             {
9753               *where_found = decl = current_this;
9754               *type_found = type = QUAL_DECL_TYPE (decl);
9755             }
9756           /* We're trying to access the this from somewhere else. Make sure
9757              it's allowed before doing so. */
9758           else
9759             {
9760               if (!enclosing_context_p (type, current_class))
9761                 {
9762                   char *p  = xstrdup (lang_printable_name (type, 0));
9763                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9764                                        p, p,
9765                                        lang_printable_name (current_class, 0));
9766                   free (p);
9767                   return 1;
9768                 }
9769               from_qualified_this = 1;
9770               /* If there's nothing else after that, we need to
9771                  produce something now, otherwise, the section of the
9772                  code that needs to produce <T>.this will generate
9773                  what is necessary. */
9774               if (!TREE_CHAIN (q))
9775                 {
9776                   decl = build_access_to_thisn (current_class, type, 0);
9777                   *where_found = decl = java_complete_tree (decl);
9778                   *type_found = type = TREE_TYPE (decl);
9779                 }
9780             }
9781
9782           from_type = 0;
9783           continue;
9784         }
9785
9786       /* 15.10.2 Accessing Superclass Members using SUPER */
9787       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9788           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9789         {
9790           tree node;
9791           /* Check on the restricted use of SUPER */
9792           if (METHOD_STATIC (current_function_decl)
9793               || current_class == object_type_node)
9794             {
9795               parse_error_context
9796                 (wfl, "Keyword `super' used outside allowed context");
9797               return 1;
9798             }
9799           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9800           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9801                              CLASSTYPE_SUPER (current_class),
9802                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9803           *where_found = decl = java_complete_tree (node);
9804           if (decl == error_mark_node)
9805             return 1;
9806           *type_found = type = QUAL_DECL_TYPE (decl);
9807           from_super = from_type = 1;
9808           continue;
9809         }
9810
9811       /* 15.13.1: Can't search for field name in packages, so we
9812          assume a variable/class name was meant. */
9813       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9814         {
9815           tree name;
9816           if ((decl = resolve_package (wfl, &q, &name)))
9817             {
9818               tree list;
9819               *where_found = decl;
9820
9821               /* We want to be absolutely sure that the class is laid
9822                  out. We're going to search something inside it. */
9823               *type_found = type = TREE_TYPE (decl);
9824               layout_class (type);
9825               from_type = 1;
9826
9827               /* Fix them all the way down, if any are left. */
9828               if (q)
9829                 {
9830                   list = TREE_CHAIN (q);
9831                   while (list)
9832                     {
9833                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9834                       list = TREE_CHAIN (list);
9835                     }
9836                 }
9837             }
9838           else
9839             {
9840               if (from_super || from_cast)
9841                 parse_error_context
9842                   ((from_cast ? qual_wfl : wfl),
9843                    "No variable `%s' defined in class `%s'",
9844                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9845                    lang_printable_name (type, 0));
9846               else
9847                 parse_error_context
9848                   (qual_wfl, "Undefined variable or class name: `%s'",
9849                    IDENTIFIER_POINTER (name));
9850               return 1;
9851             }
9852         }
9853
9854       /* We have a type name. It's been already resolved when the
9855          expression was qualified. */
9856       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9857         {
9858           decl = QUAL_RESOLUTION (q);
9859
9860           /* Sneak preview. If next we see a `new', we're facing a
9861              qualification with resulted in a type being selected
9862              instead of a field.  Report the error */
9863           if(TREE_CHAIN (q)
9864              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9865             {
9866               parse_error_context (qual_wfl, "Undefined variable `%s'",
9867                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9868               return 1;
9869             }
9870
9871           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9872             {
9873               parse_error_context
9874                 (qual_wfl, "Can't access %s class '%s' from '%s'",
9875                  java_accstring_lookup (get_access_flags_from_decl (decl)),
9876                  IDENTIFIER_POINTER (DECL_NAME (decl)),
9877                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9878               return 1;
9879             }
9880           check_deprecation (qual_wfl, decl);
9881
9882           type = TREE_TYPE (decl);
9883           from_type = 1;
9884         }
9885       /* We resolve an expression name */
9886       else
9887         {
9888           tree field_decl = NULL_TREE;
9889
9890           /* If there exists an early resolution, use it. That occurs
9891              only once and we know that there are more things to
9892              come. Don't do that when processing something after SUPER
9893              (we need more thing to be put in place below */
9894           if (!from_super && QUAL_RESOLUTION (q))
9895             {
9896               decl = QUAL_RESOLUTION (q);
9897               if (!type)
9898                 {
9899                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9900                     {
9901                       if (current_this)
9902                         *where_found = current_this;
9903                       else
9904                         {
9905                           static_ref_err (qual_wfl, DECL_NAME (decl),
9906                                           current_class);
9907                           return 1;
9908                         }
9909                       if (outer_field_access_p (current_class, decl))
9910                         decl = build_outer_field_access (qual_wfl, decl);
9911                     }
9912                   else
9913                     {
9914                       *where_found = TREE_TYPE (decl);
9915                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9916                         *where_found = TREE_TYPE (*where_found);
9917                     }
9918                 }
9919             }
9920
9921           /* Report and error if we're using a numerical literal as a
9922              qualifier. It can only be an INTEGER_CST. */
9923           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9924             {
9925               parse_error_context
9926                 (wfl, "Can't use type `%s' as a qualifier",
9927                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9928               return 1;
9929             }
9930
9931           /* We have to search for a field, knowing the type of its
9932              container. The flag FROM_TYPE indicates that we resolved
9933              the last member of the expression as a type name, which
9934              means that for the resolution of this field, we'll look
9935              for other errors than if it was resolved as a member of
9936              an other field. */
9937           else
9938             {
9939               int is_static;
9940               tree field_decl_type; /* For layout */
9941
9942               if (!from_type && !JREFERENCE_TYPE_P (type))
9943                 {
9944                   parse_error_context
9945                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9946                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9947                      lang_printable_name (type, 0),
9948                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9949                   return 1;
9950                 }
9951
9952               field_decl = lookup_field_wrapper (type,
9953                                                  EXPR_WFL_NODE (qual_wfl));
9954
9955               /* Maybe what we're trying to access to is an inner
9956                  class, only if decl is a TYPE_DECL. */
9957               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9958                 {
9959                   tree ptr, inner_decl;
9960
9961                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9962                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9963                   if (inner_decl)
9964                     {
9965                       check_inner_class_access (inner_decl, decl, qual_wfl);
9966                       type = TREE_TYPE (inner_decl);
9967                       decl = inner_decl;
9968                       from_type = 1;
9969                       continue;
9970                     }
9971                 }
9972
9973               if (field_decl == NULL_TREE)
9974                 {
9975                   parse_error_context
9976                     (qual_wfl, "No variable `%s' defined in type `%s'",
9977                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9978                      GET_TYPE_NAME (type));
9979                   return 1;
9980                 }
9981               if (field_decl == error_mark_node)
9982                 return 1;
9983
9984               /* Layout the type of field_decl, since we may need
9985                  it. Don't do primitive types or loaded classes. The
9986                  situation of non primitive arrays may not handled
9987                  properly here. FIXME */
9988               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9989                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9990               else
9991                 field_decl_type = TREE_TYPE (field_decl);
9992               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9993                   && !CLASS_LOADED_P (field_decl_type)
9994                   && !TYPE_ARRAY_P (field_decl_type))
9995                 resolve_and_layout (field_decl_type, NULL_TREE);
9996
9997               /* Check on accessibility here */
9998               if (not_accessible_p (current_class, field_decl,
9999                                     DECL_CONTEXT (field_decl), from_super))
10000                 return not_accessible_field_error (qual_wfl,field_decl);
10001               check_deprecation (qual_wfl, field_decl);
10002
10003               /* There are things to check when fields are accessed
10004                  from type. There are no restrictions on a static
10005                  declaration of the field when it is accessed from an
10006                  interface */
10007               is_static = FIELD_STATIC (field_decl);
10008               if (!from_super && from_type
10009                   && !TYPE_INTERFACE_P (type)
10010                   && !is_static
10011                   && (current_function_decl
10012                       && METHOD_STATIC (current_function_decl)))
10013                 {
10014                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10015                   return 1;
10016                 }
10017               from_cast = from_super = 0;
10018
10019               /* It's an access from a type but it isn't static, we
10020                  make it relative to `this'. */
10021               if (!is_static && from_type)
10022                 decl = current_this;
10023
10024               /* If we need to generate something to get a proper
10025                  handle on what this field is accessed from, do it
10026                  now. */
10027               if (!is_static)
10028                 {
10029                   decl = maybe_access_field (decl, *where_found, *type_found);
10030                   if (decl == error_mark_node)
10031                     return 1;
10032                 }
10033
10034               /* We want to keep the location were found it, and the type
10035                  we found. */
10036               *where_found = decl;
10037               *type_found = type;
10038
10039               /* Generate the correct expression for field access from
10040                  qualified this */
10041               if (from_qualified_this)
10042                 {
10043                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10044                   from_qualified_this = 0;
10045                 }
10046
10047               /* This is the decl found and eventually the next one to
10048                  search from */
10049               decl = field_decl;
10050             }
10051           from_type = 0;
10052           type = QUAL_DECL_TYPE (decl);
10053
10054           /* Sneak preview. If decl is qualified by a `new', report
10055              the error here to be accurate on the peculiar construct */
10056           if (TREE_CHAIN (q)
10057               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10058               && !JREFERENCE_TYPE_P (type))
10059             {
10060               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10061                                    lang_printable_name (type, 0));
10062               return 1;
10063             }
10064         }
10065       /* `q' might have changed due to a after package resolution
10066          re-qualification */
10067       if (!q)
10068         break;
10069     }
10070   *found_decl = decl;
10071   return 0;
10072 }
10073
10074 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10075    can't be accessed from REFERENCE (a record type). If MEMBER
10076    features a protected access, we then use WHERE which, if non null,
10077    holds the type of MEMBER's access that is checked against
10078    6.6.2.1. This function should be used when decl is a field or a
10079    method.  */
10080
10081 static int
10082 not_accessible_p (tree reference, tree member, tree where, int from_super)
10083 {
10084   int access_flag = get_access_flags_from_decl (member);
10085
10086   /* Inner classes are processed by check_inner_class_access */
10087   if (INNER_CLASS_TYPE_P (reference))
10088     return 0;
10089
10090   /* Access always granted for members declared public */
10091   if (access_flag & ACC_PUBLIC)
10092     return 0;
10093
10094   /* Check access on protected members */
10095   if (access_flag & ACC_PROTECTED)
10096     {
10097       /* Access granted if it occurs from within the package
10098          containing the class in which the protected member is
10099          declared */
10100       if (class_in_current_package (DECL_CONTEXT (member)))
10101         return 0;
10102
10103       /* If accessed with the form `super.member', then access is granted */
10104       if (from_super)
10105         return 0;
10106
10107       /* If where is active, access was made through a
10108          qualifier. Access is granted if the type of the qualifier is
10109          or is a sublass of the type the access made from (6.6.2.1.)  */
10110       if (where && !inherits_from_p (reference, where))
10111         return 1;
10112
10113       /* Otherwise, access is granted if occurring from the class where
10114          member is declared or a subclass of it. Find the right
10115          context to perform the check */
10116       if (PURE_INNER_CLASS_TYPE_P (reference))
10117         {
10118           while (INNER_CLASS_TYPE_P (reference))
10119             {
10120               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10121                 return 0;
10122               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10123             }
10124         }
10125       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10126         return 0;
10127       return 1;
10128     }
10129
10130   /* Check access on private members. Access is granted only if it
10131      occurs from within the class in which it is declared -- that does
10132      it for innerclasses too. */
10133   if (access_flag & ACC_PRIVATE)
10134     {
10135       if (reference == DECL_CONTEXT (member))
10136         return 0;
10137       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10138         return 0;
10139       return 1;
10140     }
10141
10142   /* Default access are permitted only when occurring within the
10143      package in which the type (REFERENCE) is declared. In other words,
10144      REFERENCE is defined in the current package */
10145   if (ctxp->package)
10146     return !class_in_current_package (reference);
10147
10148   /* Otherwise, access is granted */
10149   return 0;
10150 }
10151
10152 /* Test deprecated decl access.  */
10153 static void
10154 check_deprecation (tree wfl, tree decl)
10155 {
10156   const char *file;
10157   tree elt;
10158
10159   if (! flag_deprecated)
10160     return;
10161
10162   /* We want to look at the element type of arrays here, so we strip
10163      all surrounding array types.  */
10164   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10165     {
10166       elt = TREE_TYPE (decl);
10167       while (TYPE_ARRAY_P (elt))
10168         elt = TYPE_ARRAY_ELEMENT (elt);
10169       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10170          to the record.  */
10171       decl = TYPE_NAME (TREE_TYPE (elt));
10172     }
10173   file = DECL_SOURCE_FILE (decl);
10174
10175   /* Complain if the field is deprecated and the file it was defined
10176      in isn't compiled at the same time the file which contains its
10177      use is */
10178   if (DECL_DEPRECATED (decl)
10179       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10180     {
10181       const char *the;
10182       switch (TREE_CODE (decl))
10183         {
10184         case FUNCTION_DECL:
10185           the = "method";
10186           break;
10187         case FIELD_DECL:
10188         case VAR_DECL:
10189           the = "field";
10190           break;
10191         case TYPE_DECL:
10192           parse_warning_context (wfl, "The class `%s' has been deprecated",
10193                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10194           return;
10195         default:
10196           abort ();
10197         }
10198       /* Don't issue a message if the context as been deprecated as a
10199          whole. */
10200       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10201         parse_warning_context
10202           (wfl, "The %s `%s' in class `%s' has been deprecated",
10203            the, lang_printable_name (decl, 0),
10204            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10205     }
10206 }
10207
10208 /* Returns 1 if class was declared in the current package, 0 otherwise */
10209
10210 static GTY(()) tree cicp_cache;
10211 static int
10212 class_in_current_package (tree class)
10213 {
10214   int qualified_flag;
10215   tree left;
10216
10217   if (cicp_cache == class)
10218     return 1;
10219
10220   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10221
10222   /* If the current package is empty and the name of CLASS is
10223      qualified, class isn't in the current package.  If there is a
10224      current package and the name of the CLASS is not qualified, class
10225      isn't in the current package */
10226   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10227     return 0;
10228
10229   /* If there is not package and the name of CLASS isn't qualified,
10230      they belong to the same unnamed package */
10231   if (!ctxp->package && !qualified_flag)
10232     return 1;
10233
10234   /* Compare the left part of the name of CLASS with the package name */
10235   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10236   if (ctxp->package == left)
10237     {
10238       cicp_cache = class;
10239       return 1;
10240     }
10241   return 0;
10242 }
10243
10244 /* This function may generate code to access DECL from WHERE. This is
10245    done only if certain conditions meet.  */
10246
10247 static tree
10248 maybe_access_field (tree decl, tree where, tree type)
10249 {
10250   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10251       && !FIELD_STATIC (decl))
10252     decl = build_field_ref (where ? where : current_this,
10253                             (type ? type : DECL_CONTEXT (decl)),
10254                             DECL_NAME (decl));
10255   return decl;
10256 }
10257
10258 /* Build a method invocation, by patching PATCH. If non NULL
10259    and according to the situation, PRIMARY and WHERE may be
10260    used. IS_STATIC is set to 1 if the invoked function is static. */
10261
10262 static tree
10263 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10264                          int *is_static, tree *ret_decl)
10265 {
10266   tree wfl = TREE_OPERAND (patch, 0);
10267   tree args = TREE_OPERAND (patch, 1);
10268   tree name = EXPR_WFL_NODE (wfl);
10269   tree list;
10270   int is_static_flag = 0;
10271   int is_super_init = 0;
10272   tree this_arg = NULL_TREE;
10273   int is_array_clone_call = 0;
10274
10275   /* Should be overridden if everything goes well. Otherwise, if
10276      something fails, it should keep this value. It stop the
10277      evaluation of a bogus assignment. See java_complete_tree,
10278      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10279      evaluating an assignment */
10280   TREE_TYPE (patch) = error_mark_node;
10281
10282   /* Since lookup functions are messing with line numbers, save the
10283      context now.  */
10284   java_parser_context_save_global ();
10285
10286   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10287
10288   /* Resolution of qualified name, excluding constructors */
10289   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10290     {
10291       tree identifier, identifier_wfl, type, resolved;
10292       /* Extract the last IDENTIFIER of the qualified
10293          expression. This is a wfl and we will use it's location
10294          data during error report. */
10295       identifier_wfl = cut_identifier_in_qualified (wfl);
10296       identifier = EXPR_WFL_NODE (identifier_wfl);
10297
10298       /* Given the context, IDENTIFIER is syntactically qualified
10299          as a MethodName. We need to qualify what's before */
10300       qualify_ambiguous_name (wfl);
10301       resolved = resolve_field_access (wfl, NULL, NULL);
10302
10303       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10304          && FIELD_FINAL (resolved)
10305          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10306          && !flag_emit_class_files && !flag_emit_xref)
10307        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10308
10309       if (resolved == error_mark_node)
10310         PATCH_METHOD_RETURN_ERROR ();
10311
10312       type = GET_SKIP_TYPE (resolved);
10313       resolve_and_layout (type, NULL_TREE);
10314
10315       if (JPRIMITIVE_TYPE_P (type))
10316         {
10317           parse_error_context
10318             (identifier_wfl,
10319              "Can't invoke a method on primitive type `%s'",
10320              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10321           PATCH_METHOD_RETURN_ERROR ();
10322         }
10323
10324       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10325       args = nreverse (args);
10326
10327       /* We're resolving a call from a type */
10328       if (TREE_CODE (resolved) == TYPE_DECL)
10329         {
10330           if (CLASS_INTERFACE (resolved))
10331             {
10332               parse_error_context
10333                 (identifier_wfl,
10334                 "Can't make static reference to method `%s' in interface `%s'",
10335                  IDENTIFIER_POINTER (identifier),
10336                  IDENTIFIER_POINTER (name));
10337               PATCH_METHOD_RETURN_ERROR ();
10338             }
10339           if (list && !METHOD_STATIC (list))
10340             {
10341               char *fct_name = xstrdup (lang_printable_name (list, 0));
10342               parse_error_context
10343                 (identifier_wfl,
10344                  "Can't make static reference to method `%s %s' in class `%s'",
10345                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10346                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10347               free (fct_name);
10348               PATCH_METHOD_RETURN_ERROR ();
10349             }
10350         }
10351       else
10352         this_arg = primary = resolved;
10353
10354       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10355         is_array_clone_call = 1;
10356
10357       /* IDENTIFIER_WFL will be used to report any problem further */
10358       wfl = identifier_wfl;
10359     }
10360   /* Resolution of simple names, names generated after a primary: or
10361      constructors */
10362   else
10363     {
10364       tree class_to_search = NULL_TREE;
10365       int lc;                   /* Looking for Constructor */
10366
10367       /* We search constructor in their target class */
10368       if (CALL_CONSTRUCTOR_P (patch))
10369         {
10370           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10371             class_to_search = EXPR_WFL_NODE (wfl);
10372           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10373                    this_identifier_node)
10374             class_to_search = NULL_TREE;
10375           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10376                    super_identifier_node)
10377             {
10378               is_super_init = 1;
10379               if (CLASSTYPE_SUPER (current_class))
10380                 class_to_search =
10381                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10382               else
10383                 {
10384                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10385                   PATCH_METHOD_RETURN_ERROR ();
10386                 }
10387             }
10388
10389           /* Class to search is NULL if we're searching the current one */
10390           if (class_to_search)
10391             {
10392               class_to_search = resolve_and_layout (class_to_search, wfl);
10393
10394               if (!class_to_search)
10395                 {
10396                   parse_error_context
10397                     (wfl, "Class `%s' not found in type declaration",
10398                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10399                   PATCH_METHOD_RETURN_ERROR ();
10400                 }
10401
10402               /* Can't instantiate an abstract class, but we can
10403                  invoke it's constructor. It's use within the `new'
10404                  context is denied here. */
10405               if (CLASS_ABSTRACT (class_to_search)
10406                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10407                 {
10408                   parse_error_context
10409                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10410                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10411                   PATCH_METHOD_RETURN_ERROR ();
10412                 }
10413
10414               class_to_search = TREE_TYPE (class_to_search);
10415             }
10416           else
10417             class_to_search = current_class;
10418           lc = 1;
10419         }
10420       /* This is a regular search in the local class, unless an
10421          alternate class is specified. */
10422       else
10423         {
10424           if (where != NULL_TREE)
10425             class_to_search = where;
10426           else if (QUALIFIED_P (name))
10427             class_to_search = current_class;
10428           else
10429             {
10430               class_to_search = current_class;
10431
10432               for (;;)
10433                 {
10434                   if (has_method (class_to_search, name))
10435                     break;
10436                   if (! INNER_CLASS_TYPE_P (class_to_search))
10437                     {
10438                       parse_error_context (wfl,
10439                                            "No method named `%s' in scope",
10440                                            IDENTIFIER_POINTER (name));
10441                       PATCH_METHOD_RETURN_ERROR ();
10442                     }
10443                   class_to_search
10444                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10445                 }
10446             }
10447           lc = 0;
10448         }
10449
10450       /* NAME is a simple identifier or comes from a primary. Search
10451          in the class whose declaration contain the method being
10452          invoked. */
10453       resolve_and_layout (class_to_search, NULL_TREE);
10454
10455       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10456       /* Don't continue if no method were found, as the next statement
10457          can't be executed then. */
10458       if (!list)
10459         PATCH_METHOD_RETURN_ERROR ();
10460
10461       if (TYPE_ARRAY_P (class_to_search)
10462           && DECL_NAME (list) == get_identifier ("clone"))
10463         is_array_clone_call = 1;
10464
10465       /* Check for static reference if non static methods */
10466       if (check_for_static_method_reference (wfl, patch, list,
10467                                              class_to_search, primary))
10468         PATCH_METHOD_RETURN_ERROR ();
10469
10470       /* Check for inner classes creation from illegal contexts */
10471       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10472                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10473           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10474           && !DECL_INIT_P (current_function_decl))
10475         {
10476           parse_error_context
10477             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10478              lang_printable_name (class_to_search, 0),
10479              (!current_this ? "" :
10480               "; an explicit one must be provided when creating this inner class"));
10481           PATCH_METHOD_RETURN_ERROR ();
10482         }
10483
10484       /* Non static methods are called with the current object extra
10485          argument. If patch a `new TYPE()', the argument is the value
10486          returned by the object allocator. If method is resolved as a
10487          primary, use the primary otherwise use the current THIS. */
10488       args = nreverse (args);
10489       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10490         {
10491           this_arg = primary ? primary : current_this;
10492
10493           /* If we're using an access method, things are different.
10494              There are two family of cases:
10495
10496              1) We're not generating bytecodes:
10497
10498              - LIST is non static. It's invocation is transformed from
10499                x(a1,...,an) into this$<n>.x(a1,....an).
10500              - LIST is static. It's invocation is transformed from
10501                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10502
10503              2) We're generating bytecodes:
10504
10505              - LIST is non static. It's invocation is transformed from
10506                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10507              - LIST is static. It's invocation is transformed from
10508                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10509
10510              Of course, this$<n> can be arbitrarily complex, ranging from
10511              this$0 (the immediate outer context) to
10512              access$0(access$0(...(this$0))).
10513
10514              maybe_use_access_method returns a nonzero value if the
10515              this_arg has to be moved into the (then generated) stub
10516              argument list. In the meantime, the selected function
10517              might have be replaced by a generated stub. */
10518           if (!primary &&
10519               maybe_use_access_method (is_super_init, &list, &this_arg))
10520             {
10521               args = tree_cons (NULL_TREE, this_arg, args);
10522               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10523             }
10524         }
10525     }
10526
10527   /* Merge point of all resolution schemes. If we have nothing, this
10528      is an error, already signaled */
10529   if (!list)
10530     PATCH_METHOD_RETURN_ERROR ();
10531
10532   /* Check accessibility, position the is_static flag, build and
10533      return the call */
10534   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10535                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10536                          NULL_TREE), from_super)
10537       /* Calls to clone() on array types are permitted as a special-case. */
10538       && !is_array_clone_call)
10539     {
10540       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10541       const char *const access =
10542         java_accstring_lookup (get_access_flags_from_decl (list));
10543       const char *const klass =
10544         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10545       const char *const refklass =
10546         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10547       const char *const what = (DECL_CONSTRUCTOR_P (list)
10548                                 ? "constructor" : "method");
10549       /* FIXME: WFL yields the wrong message here but I don't know
10550          what else to use.  */
10551       parse_error_context (wfl,
10552                            "Can't access %s %s `%s.%s' from `%s'",
10553                            access, what, klass, fct_name, refklass);
10554       PATCH_METHOD_RETURN_ERROR ();
10555     }
10556
10557   /* Deprecation check: check whether the method being invoked or the
10558      instance-being-created's type are deprecated.  */
10559   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10560     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10561   check_deprecation (wfl, list);
10562
10563   /* If invoking a innerclass constructor, there are hidden parameters
10564      to pass */
10565   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10566       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10567     {
10568       /* And make sure we add the accessed local variables to be saved
10569          in field aliases. */
10570       args = build_alias_initializer_parameter_list
10571         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10572
10573       /* Secretly pass the current_this/primary as a second argument */
10574       if (primary || current_this)
10575         {
10576           tree extra_arg;
10577           tree this_type = (current_this ?
10578                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10579           /* Method's (list) enclosing context */
10580           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10581           /* If we have a primary, use it. */
10582           if (primary)
10583             extra_arg = primary;
10584           /* The current `this' is an inner class but isn't a direct
10585              enclosing context for the inner class we're trying to
10586              create. Build an access to the proper enclosing context
10587              and use it. */
10588           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10589                    && this_type != TREE_TYPE (mec))
10590             {
10591
10592               extra_arg = build_access_to_thisn (current_class,
10593                                                  TREE_TYPE (mec), 0);
10594               extra_arg = java_complete_tree (extra_arg);
10595             }
10596           /* Otherwise, just use the current `this' as an enclosing
10597              context. */
10598           else
10599             extra_arg = current_this;
10600           args = tree_cons (NULL_TREE, extra_arg, args);
10601         }
10602       else
10603         args = tree_cons (NULL_TREE, integer_zero_node, args);
10604     }
10605
10606   /* This handles the situation where a constructor invocation needs
10607      to have an enclosing context passed as a second parameter (the
10608      constructor is one of an inner class). */
10609   if ((is_super_init ||
10610        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10611       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10612     {
10613       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10614       tree extra_arg =
10615         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10616       extra_arg = java_complete_tree (extra_arg);
10617       args = tree_cons (NULL_TREE, extra_arg, args);
10618     }
10619
10620   is_static_flag = METHOD_STATIC (list);
10621   if (! is_static_flag && this_arg != NULL_TREE)
10622     args = tree_cons (NULL_TREE, this_arg, args);
10623
10624   /* In the context of an explicit constructor invocation, we can't
10625      invoke any method relying on `this'. Exceptions are: we're
10626      invoking a static function, primary exists and is not the current
10627      this, we're creating a new object. */
10628   if (ctxp->explicit_constructor_p
10629       && !is_static_flag
10630       && (!primary || primary == current_this)
10631       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10632     {
10633       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10634       PATCH_METHOD_RETURN_ERROR ();
10635     }
10636   java_parser_context_restore_global ();
10637   if (is_static)
10638     *is_static = is_static_flag;
10639   /* Sometimes, we want the decl of the selected method. Such as for
10640      EH checking */
10641   if (ret_decl)
10642     *ret_decl = list;
10643   patch = patch_invoke (patch, list, args);
10644
10645   /* Now is a good time to insert the call to finit$ */
10646   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10647     {
10648       tree finit_parms, finit_call;
10649
10650       /* Prepare to pass hidden parameters to finit$, if any. */
10651       finit_parms = build_alias_initializer_parameter_list
10652         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10653
10654       finit_call =
10655         build_method_invocation (build_wfl_node (finit_identifier_node),
10656                                  finit_parms);
10657
10658       /* Generate the code used to initialize fields declared with an
10659          initialization statement and build a compound statement along
10660          with the super constructor invocation. */
10661       CAN_COMPLETE_NORMALLY (patch) = 1;
10662       patch = build (COMPOUND_EXPR, void_type_node, patch,
10663                      java_complete_tree (finit_call));
10664     }
10665   return patch;
10666 }
10667
10668 /* Check that we're not trying to do a static reference to a method in
10669    non static method. Return 1 if it's the case, 0 otherwise. */
10670
10671 static int
10672 check_for_static_method_reference (tree wfl, tree node, tree method,
10673                                    tree where, tree primary)
10674 {
10675   if (METHOD_STATIC (current_function_decl)
10676       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10677     {
10678       char *fct_name = xstrdup (lang_printable_name (method, 0));
10679       parse_error_context
10680         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10681          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10682          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10683       free (fct_name);
10684       return 1;
10685     }
10686   return 0;
10687 }
10688
10689 /* Fix the invocation of *MDECL if necessary in the case of a
10690    invocation from an inner class. *THIS_ARG might be modified
10691    appropriately and an alternative access to *MDECL might be
10692    returned.  */
10693
10694 static int
10695 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10696 {
10697   tree ctx;
10698   tree md = *mdecl, ta = *this_arg;
10699   int to_return = 0;
10700   int non_static_context = !METHOD_STATIC (md);
10701
10702   if (is_super_init
10703       || DECL_CONTEXT (md) == current_class
10704       || !PURE_INNER_CLASS_TYPE_P (current_class)
10705       || DECL_FINIT_P (md)
10706       || DECL_INSTINIT_P (md))
10707     return 0;
10708
10709   /* If we're calling a method found in an enclosing class, generate
10710      what it takes to retrieve the right this. Don't do that if we're
10711      invoking a static method. Note that if MD's type is unrelated to
10712      CURRENT_CLASS, then the current this can be used. */
10713
10714   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10715     {
10716       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10717       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10718         {
10719           ta = build_current_thisn (current_class);
10720           ta = build_wfl_node (ta);
10721         }
10722       else
10723         {
10724           tree type = ctx;
10725           while (type)
10726             {
10727               maybe_build_thisn_access_method (type);
10728               if (inherits_from_p (type, DECL_CONTEXT (md)))
10729                 {
10730                   ta = build_access_to_thisn (ctx, type, 0);
10731                   break;
10732                 }
10733               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10734                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10735             }
10736         }
10737       ta = java_complete_tree (ta);
10738     }
10739
10740   /* We might have to use an access method to get to MD. We can
10741      break the method access rule as far as we're not generating
10742      bytecode */
10743   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10744     {
10745       md = build_outer_method_access_method (md);
10746       to_return = 1;
10747     }
10748
10749   *mdecl = md;
10750   *this_arg = ta;
10751
10752   /* Returning a nonzero value indicates we were doing a non static
10753      method invocation that is now a static invocation. It will have
10754      callee displace `this' to insert it in the regular argument
10755      list. */
10756   return (non_static_context && to_return);
10757 }
10758
10759 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10760    mode.  */
10761
10762 static tree
10763 patch_invoke (tree patch, tree method, tree args)
10764 {
10765   tree dtable, func;
10766   tree original_call, t, ta;
10767   tree check = NULL_TREE;
10768
10769   /* Last step for args: convert build-in types. If we're dealing with
10770      a new TYPE() type call, the first argument to the constructor
10771      isn't found in the incoming argument list, but delivered by
10772      `new' */
10773   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10774   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10775     t = TREE_CHAIN (t);
10776   for (ta = args; t != end_params_node && ta;
10777        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10778     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10779         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10780       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10781
10782   /* Resolve unresolved returned type issues */
10783   t = TREE_TYPE (TREE_TYPE (method));
10784   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10785     resolve_and_layout (TREE_TYPE (t), NULL);
10786
10787   if (flag_emit_class_files || flag_emit_xref)
10788     func = method;
10789   else
10790     {
10791       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10792         {
10793         case INVOKE_VIRTUAL:
10794           dtable = invoke_build_dtable (0, args);
10795           func = build_invokevirtual (dtable, method);
10796           break;
10797
10798         case INVOKE_NONVIRTUAL:
10799           /* If the object for the method call is null, we throw an
10800              exception.  We don't do this if the object is the current
10801              method's `this'.  In other cases we just rely on an
10802              optimization pass to eliminate redundant checks.  */
10803           if (TREE_VALUE (args) != current_this)
10804             {
10805               /* We use a save_expr here to make sure we only evaluate
10806                  the new `self' expression once.  */
10807               tree save_arg = save_expr (TREE_VALUE (args));
10808               TREE_VALUE (args) = save_arg;
10809               check = java_check_reference (save_arg, 1);
10810             }
10811           /* Fall through.  */
10812
10813         case INVOKE_SUPER:
10814         case INVOKE_STATIC:
10815           {
10816             tree signature = build_java_signature (TREE_TYPE (method));
10817             func = build_known_method_ref (method, TREE_TYPE (method),
10818                                            DECL_CONTEXT (method),
10819                                            signature, args);
10820           }
10821           break;
10822
10823         case INVOKE_INTERFACE:
10824           dtable = invoke_build_dtable (1, args);
10825           func = build_invokeinterface (dtable, method);
10826           break;
10827
10828         default:
10829           abort ();
10830         }
10831
10832       /* Ensure self_type is initialized, (invokestatic). FIXME */
10833       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10834     }
10835
10836   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10837   TREE_OPERAND (patch, 0) = func;
10838   TREE_OPERAND (patch, 1) = args;
10839   patch = check_for_builtin (method, patch);
10840   original_call = patch;
10841
10842   /* We're processing a `new TYPE ()' form. New is called and its
10843      returned value is the first argument to the constructor. We build
10844      a COMPOUND_EXPR and use saved expression so that the overall NEW
10845      expression value is a pointer to a newly created and initialized
10846      class. */
10847   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10848     {
10849       tree class = DECL_CONTEXT (method);
10850       tree c1, saved_new, size, new;
10851       tree alloc_node;
10852
10853       if (flag_emit_class_files || flag_emit_xref)
10854         {
10855           TREE_TYPE (patch) = build_pointer_type (class);
10856           return patch;
10857         }
10858       if (!TYPE_SIZE (class))
10859         safe_layout_class (class);
10860       size = size_in_bytes (class);
10861       alloc_node =
10862         (class_has_finalize_method (class) ? alloc_object_node
10863                                            : alloc_no_finalizer_node);
10864       new = build (CALL_EXPR, promote_type (class),
10865                    build_address_of (alloc_node),
10866                    tree_cons (NULL_TREE, build_class_ref (class),
10867                               build_tree_list (NULL_TREE,
10868                                                size_in_bytes (class))),
10869                    NULL_TREE);
10870       saved_new = save_expr (new);
10871       c1 = build_tree_list (NULL_TREE, saved_new);
10872       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10873       TREE_OPERAND (original_call, 1) = c1;
10874       TREE_SET_CODE (original_call, CALL_EXPR);
10875       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10876     }
10877
10878   /* If CHECK is set, then we are building a check to see if the object
10879      is NULL.  */
10880   if (check != NULL_TREE)
10881     {
10882       /* We have to call force_evaluation_order now because creating a
10883          COMPOUND_EXPR wraps the arg list in a way that makes it
10884          unrecognizable by force_evaluation_order later.  Yuk.  */
10885       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10886                      force_evaluation_order (patch));
10887       TREE_SIDE_EFFECTS (patch) = 1;
10888     }
10889
10890   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10891      put it as the first expression of a COMPOUND_EXPR. The second
10892      expression being an empty statement to be later patched if
10893      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10894      the VALUE is the compound) in a hashtable and return a
10895      COMPOUND_EXPR built so that the result of the evaluation of the
10896      original PATCH node is returned. */
10897   if (STATIC_CLASS_INIT_OPT_P ()
10898       && current_function_decl && METHOD_STATIC (method))
10899     {
10900       tree list;
10901       tree fndecl = current_function_decl;
10902       /* We have to call force_evaluation_order now because creating a
10903          COMPOUND_EXPR wraps the arg list in a way that makes it
10904          unrecognizable by force_evaluation_order later.  Yuk.  */
10905       tree save = save_expr (force_evaluation_order (patch));
10906       tree type = TREE_TYPE (patch);
10907
10908       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10909       list = tree_cons (method, patch,
10910                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10911
10912       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10913
10914       patch = build (COMPOUND_EXPR, type, patch, save);
10915     }
10916
10917   return patch;
10918 }
10919
10920 static int
10921 invocation_mode (tree method, int super)
10922 {
10923   int access = get_access_flags_from_decl (method);
10924
10925   if (super)
10926     return INVOKE_SUPER;
10927
10928   if (access & ACC_STATIC)
10929     return INVOKE_STATIC;
10930
10931   /* We have to look for a constructor before we handle nonvirtual
10932      calls; otherwise the constructor will look nonvirtual.  */
10933   if (DECL_CONSTRUCTOR_P (method))
10934     return INVOKE_STATIC;
10935
10936   if (access & ACC_FINAL || access & ACC_PRIVATE)
10937     return INVOKE_NONVIRTUAL;
10938
10939   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10940     return INVOKE_NONVIRTUAL;
10941
10942   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10943     return INVOKE_INTERFACE;
10944
10945   return INVOKE_VIRTUAL;
10946 }
10947
10948 /* Retrieve a refined list of matching methods. It covers the step
10949    15.11.2 (Compile-Time Step 2) */
10950
10951 static tree
10952 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10953 {
10954   tree atl = end_params_node;           /* Arg Type List */
10955   tree method, signature, list, node;
10956   const char *candidates;               /* Used for error report */
10957   char *dup;
10958
10959   /* Fix the arguments */
10960   for (node = arg_list; node; node = TREE_CHAIN (node))
10961     {
10962       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10963       /* Non primitive type may have to be resolved */
10964       if (!JPRIMITIVE_TYPE_P (current_arg))
10965         resolve_and_layout (current_arg, NULL_TREE);
10966       /* And promoted */
10967       if (TREE_CODE (current_arg) == RECORD_TYPE)
10968         current_arg = promote_type (current_arg);
10969       atl = tree_cons (NULL_TREE, current_arg, atl);
10970     }
10971
10972   /* Presto. If we're dealing with an anonymous class and a
10973      constructor call, generate the right constructor now, since we
10974      know the arguments' types. */
10975
10976   if (lc && ANONYMOUS_CLASS_P (class))
10977     {
10978       tree saved_current_class;
10979       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10980       saved_current_class = current_class;
10981       current_class = class;
10982       fix_constructors (mdecl);
10983       current_class = saved_current_class;
10984     }
10985
10986   /* Find all candidates and then refine the list, searching for the
10987      most specific method. */
10988   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10989   list = find_most_specific_methods_list (list);
10990   if (list && !TREE_CHAIN (list))
10991     return TREE_VALUE (list);
10992
10993   /* Issue an error. List candidates if any. Candidates are listed
10994      only if accessible (non accessible methods may end-up here for
10995      the sake of a better error report). */
10996   candidates = NULL;
10997   if (list)
10998     {
10999       tree current;
11000       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
11001       for (current = list; current; current = TREE_CHAIN (current))
11002         {
11003           tree cm = TREE_VALUE (current);
11004           char string [4096];
11005           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
11006             continue;
11007           sprintf
11008             (string, "  `%s' in `%s'%s",
11009              get_printable_method_name (cm),
11010              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11011              (TREE_CHAIN (current) ? "\n" : ""));
11012           obstack_grow (&temporary_obstack, string, strlen (string));
11013         }
11014       obstack_1grow (&temporary_obstack, '\0');
11015       candidates = obstack_finish (&temporary_obstack);
11016     }
11017   /* Issue the error message */
11018   method = make_node (FUNCTION_TYPE);
11019   TYPE_ARG_TYPES (method) = atl;
11020   signature = build_java_argument_signature (method);
11021   dup = xstrdup (lang_printable_name (class, 0));
11022   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
11023                        (lc ? "constructor" : "method"),
11024                        (lc ? dup : IDENTIFIER_POINTER (name)),
11025                        IDENTIFIER_POINTER (signature), dup,
11026                        (candidates ? candidates : ""));
11027   free (dup);
11028   return NULL_TREE;
11029 }
11030
11031 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11032    when we're looking for a constructor. */
11033
11034 static tree
11035 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11036                                          tree arglist)
11037 {
11038   static htab_t searched_classes;
11039   static int search_not_done = 0;
11040   tree list = NULL_TREE, all_list = NULL_TREE;
11041
11042   /* Check the hash table to determine if this class has been searched
11043      already. */
11044   if (searched_classes)
11045     {
11046       if (htab_find (searched_classes, class) != NULL)
11047         return NULL;
11048     }
11049   else
11050     {
11051       searched_classes = htab_create (10, htab_hash_pointer,
11052                                       htab_eq_pointer, NULL);
11053     }
11054
11055   search_not_done++;
11056   *htab_find_slot (searched_classes, class, INSERT) = class;
11057
11058   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11059     {
11060       load_class (class, 1);
11061       safe_layout_class (class);
11062     }
11063
11064   /* Search interfaces */
11065   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11066       && CLASS_INTERFACE (TYPE_NAME (class)))
11067     {
11068       int i, n;
11069       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11070       search_applicable_methods_list (lc, TYPE_METHODS (class),
11071                                       name, arglist, &list, &all_list);
11072       n = TREE_VEC_LENGTH (basetype_vec);
11073       for (i = 1; i < n; i++)
11074         {
11075           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11076           tree rlist;
11077
11078           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11079                                                            arglist);
11080           list = chainon (rlist, list);
11081         }
11082     }
11083   /* Search classes */
11084   else
11085     {
11086       search_applicable_methods_list (lc, TYPE_METHODS (class),
11087                                       name, arglist, &list, &all_list);
11088
11089       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11090          that we only search in class. Note that we should have found
11091          something at this point. */
11092       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11093         {
11094           lc = 1;
11095           if (!list)
11096             abort ();
11097         }
11098
11099       /* We must search all interfaces of this class */
11100       if (!lc)
11101       {
11102         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11103         int n = TREE_VEC_LENGTH (basetype_vec), i;
11104         for (i = 1; i < n; i++)
11105           {
11106             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11107             if (t != object_type_node)
11108               {
11109                 tree rlist
11110                   = find_applicable_accessible_methods_list (lc, t,
11111                                                              name, arglist);
11112                 list = chainon (rlist, list);
11113               }
11114           }
11115       }
11116
11117       /* Search superclass */
11118       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11119         {
11120           tree rlist;
11121           class = CLASSTYPE_SUPER (class);
11122           rlist = find_applicable_accessible_methods_list (lc, class,
11123                                                            name, arglist);
11124           list = chainon (rlist, list);
11125         }
11126     }
11127
11128   search_not_done--;
11129
11130   /* We're done. Reset the searched classes list and finally search
11131      java.lang.Object if it wasn't searched already. */
11132   if (!search_not_done)
11133     {
11134       if (!lc
11135           && TYPE_METHODS (object_type_node)
11136           && htab_find (searched_classes, object_type_node) == NULL)
11137         {
11138           search_applicable_methods_list (lc,
11139                                           TYPE_METHODS (object_type_node),
11140                                           name, arglist, &list, &all_list);
11141         }
11142       htab_delete (searched_classes);
11143       searched_classes = NULL;
11144     }
11145
11146   /* Either return the list obtained or all selected (but
11147      inaccessible) methods for better error report. */
11148   return (!list ? all_list : list);
11149 }
11150
11151 /* Effectively search for the appropriate method in method */
11152
11153 static void
11154 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11155                                 tree *list, tree *all_list)
11156 {
11157   for (; method; method = TREE_CHAIN (method))
11158     {
11159       /* When dealing with constructor, stop here, otherwise search
11160          other classes */
11161       if (lc && !DECL_CONSTRUCTOR_P (method))
11162         continue;
11163       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11164                        || (DECL_NAME (method) != name)))
11165         continue;
11166
11167       if (argument_types_convertible (method, arglist))
11168         {
11169           /* Retain accessible methods only */
11170           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11171                                  method, NULL_TREE, 0))
11172             *list = tree_cons (NULL_TREE, method, *list);
11173           else
11174             /* Also retain all selected method here */
11175             *all_list = tree_cons (NULL_TREE, method, *list);
11176         }
11177     }
11178 }
11179
11180 /* 15.11.2.2 Choose the Most Specific Method */
11181
11182 static tree
11183 find_most_specific_methods_list (tree list)
11184 {
11185   int max = 0;
11186   int abstract, candidates;
11187   tree current, new_list = NULL_TREE;
11188   for (current = list; current; current = TREE_CHAIN (current))
11189     {
11190       tree method;
11191       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11192
11193       for (method = list; method; method = TREE_CHAIN (method))
11194         {
11195           tree method_v, current_v;
11196           /* Don't test a method against itself */
11197           if (method == current)
11198             continue;
11199
11200           method_v = TREE_VALUE (method);
11201           current_v = TREE_VALUE (current);
11202
11203           /* Compare arguments and location where methods where declared */
11204           if (argument_types_convertible (method_v, current_v))
11205             {
11206               if (valid_method_invocation_conversion_p
11207                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11208                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11209                       && enclosing_context_p (DECL_CONTEXT (method_v),
11210                                               DECL_CONTEXT (current_v))))
11211                 {
11212                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11213                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11214                   max = (v > max ? v : max);
11215                 }
11216             }
11217         }
11218     }
11219
11220   /* Review the list and select the maximally specific methods */
11221   for (current = list, abstract = -1, candidates = -1;
11222        current; current = TREE_CHAIN (current))
11223     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11224       {
11225         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11226         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11227         candidates++;
11228       }
11229
11230   /* If we have several and they're all abstract, just pick the
11231      closest one. */
11232   if (candidates > 0 && candidates == abstract)
11233     {
11234       /* FIXME: merge the throws clauses.  There is no convenient way
11235          to do this in gcj right now, since ideally we'd like to
11236          introduce a new METHOD_DECL here, but that is really not
11237          possible.  */
11238       new_list = nreverse (new_list);
11239       TREE_CHAIN (new_list) = NULL_TREE;
11240       return new_list;
11241     }
11242
11243   /* We have several (we couldn't find a most specific), all but one
11244      are abstract, we pick the only non abstract one. */
11245   if (candidates > 0 && (candidates == abstract+1))
11246     {
11247       for (current = new_list; current; current = TREE_CHAIN (current))
11248         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11249           {
11250             TREE_CHAIN (current) = NULL_TREE;
11251             new_list = current;
11252           }
11253     }
11254
11255   /* If we can't find one, lower expectations and try to gather multiple
11256      maximally specific methods */
11257   while (!new_list && max)
11258     {
11259       while (--max > 0)
11260         {
11261           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11262             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11263         }
11264     }
11265
11266   return new_list;
11267 }
11268
11269 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11270    converted by method invocation conversion (5.3) to the type of the
11271    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11272    to change less often than M1. */
11273
11274 static GTY(()) tree m2_arg_value;
11275 static GTY(()) tree m2_arg_cache;
11276
11277 static int
11278 argument_types_convertible (tree m1, tree m2_or_arglist)
11279 {
11280   tree m1_arg, m2_arg;
11281
11282   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11283
11284   if (m2_arg_value == m2_or_arglist)
11285     m2_arg = m2_arg_cache;
11286   else
11287     {
11288       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11289          argument types */
11290       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11291         {
11292           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11293           if (!METHOD_STATIC (m2_or_arglist))
11294             m2_arg = TREE_CHAIN (m2_arg);
11295         }
11296       else
11297         m2_arg = m2_or_arglist;
11298
11299       m2_arg_value = m2_or_arglist;
11300       m2_arg_cache = m2_arg;
11301     }
11302
11303   while (m1_arg != end_params_node && m2_arg != end_params_node)
11304     {
11305       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11306       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11307                                                  TREE_VALUE (m2_arg)))
11308         break;
11309       m1_arg = TREE_CHAIN (m1_arg);
11310       m2_arg = TREE_CHAIN (m2_arg);
11311     }
11312   return m1_arg == end_params_node && m2_arg == end_params_node;
11313 }
11314
11315 /* Qualification routines */
11316
11317 /* Given a name x.y.z, look up x locally.  If it's found, save the
11318    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11319    so that we later try and load the appropriate classes.  */
11320 static void
11321 qualify_ambiguous_name (tree id)
11322 {
11323   tree name, decl;
11324
11325   /* We inspect the first item of the qualification list.  As a sanity
11326      check, make sure that it is an identfier node.  */
11327   tree qual = EXPR_WFL_QUALIFICATION (id);
11328   tree qual_wfl = QUAL_WFL (qual);
11329
11330   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11331     return;
11332
11333   name = EXPR_WFL_NODE (qual_wfl);
11334
11335   /* If we don't have an identifier, or we have a 'this' or 'super',
11336      then field access processing is all we need : there is nothing
11337      for us to do.  */
11338   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11339       name == this_identifier_node ||
11340       name == super_identifier_node)
11341     return;
11342
11343   /* If name appears within the scope of a local variable declaration
11344      or parameter declaration, or is a field within an enclosing
11345      class, then it is an expression name.  Save the decl and let
11346      resolve_field_access do it's work.  */
11347   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11348       (decl = lookup_field_wrapper (current_class, name)))
11349     {
11350       QUAL_RESOLUTION (qual) = decl;
11351       return;
11352     }
11353
11354   /* If name is a known class name (either declared or imported), mark
11355      us as a type name.  */
11356   if ((decl = resolve_and_layout (name, NULL_TREE)))
11357     {
11358       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11359       QUAL_RESOLUTION (qual) = decl;
11360     }
11361
11362   /* Check here that NAME isn't declared by more than one
11363      type-import-on-demand declaration of the compilation unit
11364      containing NAME. FIXME */
11365
11366   /* We couldn't find a declaration for the name.  Assume for now that
11367      we have a qualified class name that needs to be loaded from an
11368      external class file.  */
11369   else
11370     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11371
11372   /* Propagate the qualification across other components of the
11373      qualified name */
11374   for (qual = TREE_CHAIN (qual); qual;
11375        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11376     {
11377       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11378         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11379     }
11380
11381   /* Store the global qualification for the ambiguous part of ID back
11382      into ID fields */
11383   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11384     RESOLVE_TYPE_NAME_P (id) = 1;
11385   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11386     RESOLVE_PACKAGE_NAME_P (id) = 1;
11387 }
11388
11389 static int
11390 breakdown_qualified (tree *left, tree *right, tree source)
11391 {
11392   char *p, *base;
11393   int l = IDENTIFIER_LENGTH (source);
11394
11395   base = alloca (l + 1);
11396   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11397
11398   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11399   p = base + l - 1;
11400   while (*p != '.' && p != base)
11401     p--;
11402
11403   /* We didn't find a '.'. Return an error.  */
11404   if (p == base)
11405     return 1;
11406
11407   *p = '\0';
11408   if (right)
11409     *right = get_identifier (p+1);
11410   *left = get_identifier (base);
11411
11412   return 0;
11413 }
11414
11415 /* Return TRUE if two classes are from the same package. */
11416
11417 static int
11418 in_same_package (tree name1, tree name2)
11419 {
11420   tree tmp;
11421   tree pkg1;
11422   tree pkg2;
11423
11424   if (TREE_CODE (name1) == TYPE_DECL)
11425     name1 = DECL_NAME (name1);
11426   if (TREE_CODE (name2) == TYPE_DECL)
11427     name2 = DECL_NAME (name2);
11428
11429   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11430     /* One in empty package. */
11431     return 0;
11432
11433   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11434     /* Both in empty package. */
11435     return 1;
11436
11437   breakdown_qualified (&pkg1, &tmp, name1);
11438   breakdown_qualified (&pkg2, &tmp, name2);
11439
11440   return (pkg1 == pkg2);
11441 }
11442
11443 /* Patch tree nodes in a function body. When a BLOCK is found, push
11444    local variable decls if present.
11445    Same as java_complete_lhs, but does resolve static finals to values. */
11446
11447 static tree
11448 java_complete_tree (tree node)
11449 {
11450   node = java_complete_lhs (node);
11451   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11452       && DECL_INITIAL (node) != NULL_TREE
11453       && !flag_emit_xref)
11454     {
11455       tree value = fold_constant_for_init (node, node);
11456       if (value != NULL_TREE)
11457         return value;
11458     }
11459   return node;
11460 }
11461
11462 static tree
11463 java_stabilize_reference (tree node)
11464 {
11465   if (TREE_CODE (node) == COMPOUND_EXPR)
11466     {
11467       tree op0 = TREE_OPERAND (node, 0);
11468       tree op1 = TREE_OPERAND (node, 1);
11469       TREE_OPERAND (node, 0) = save_expr (op0);
11470       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11471       return node;
11472     }
11473   return stabilize_reference (node);
11474 }
11475
11476 /* Patch tree nodes in a function body. When a BLOCK is found, push
11477    local variable decls if present.
11478    Same as java_complete_tree, but does not resolve static finals to values. */
11479
11480 static tree
11481 java_complete_lhs (tree node)
11482 {
11483   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11484   int flag;
11485
11486   /* CONVERT_EXPR always has its type set, even though it needs to be
11487      worked out. */
11488   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11489     return node;
11490
11491   /* The switch block implements cases processing container nodes
11492      first.  Contained nodes are always written back. Leaves come
11493      next and return a value. */
11494   switch (TREE_CODE (node))
11495     {
11496     case BLOCK:
11497
11498       /* 1- Block section.
11499          Set the local values on decl names so we can identify them
11500          faster when they're referenced. At that stage, identifiers
11501          are legal so we don't check for declaration errors. */
11502       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11503         {
11504           DECL_CONTEXT (cn) = current_function_decl;
11505           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11506         }
11507       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11508           CAN_COMPLETE_NORMALLY (node) = 1;
11509       else
11510         {
11511           tree stmt = BLOCK_EXPR_BODY (node);
11512           tree *ptr;
11513           int error_seen = 0;
11514           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11515             {
11516               /* Re-order from (((A; B); C); ...; Z) to
11517                  (A; (B; (C ; (...; Z)))).
11518                  This makes it easier to scan the statements left-to-right
11519                  without using recursion (which might overflow the stack
11520                  if the block has many statements. */
11521               for (;;)
11522                 {
11523                   tree left = TREE_OPERAND (stmt, 0);
11524                   if (TREE_CODE (left) != COMPOUND_EXPR)
11525                     break;
11526                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11527                   TREE_OPERAND (left, 1) = stmt;
11528                   stmt = left;
11529                 }
11530               BLOCK_EXPR_BODY (node) = stmt;
11531             }
11532
11533           /* Now do the actual complete, without deep recursion for
11534              long blocks. */
11535           ptr = &BLOCK_EXPR_BODY (node);
11536           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11537                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11538             {
11539               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11540               tree *next = &TREE_OPERAND (*ptr, 1);
11541               TREE_OPERAND (*ptr, 0) = cur;
11542               if (cur == empty_stmt_node)
11543                 {
11544                   /* Optimization;  makes it easier to detect empty bodies.
11545                      Most useful for <clinit> with all-constant initializer. */
11546                   *ptr = *next;
11547                   continue;
11548                 }
11549               if (TREE_CODE (cur) == ERROR_MARK)
11550                 error_seen++;
11551               else if (! CAN_COMPLETE_NORMALLY (cur))
11552                 {
11553                   wfl_op2 = *next;
11554                   for (;;)
11555                     {
11556                       if (TREE_CODE (wfl_op2) == BLOCK)
11557                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11558                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11559                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11560                       else
11561                         break;
11562                     }
11563                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11564                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11565                     unreachable_stmt_error (*ptr);
11566                 }
11567               if (TREE_TYPE (*ptr) == NULL_TREE)
11568                 TREE_TYPE (*ptr) = void_type_node;
11569               ptr = next;
11570             }
11571           *ptr = java_complete_tree (*ptr);
11572
11573           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11574             return error_mark_node;
11575           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11576         }
11577       /* Turn local bindings to null */
11578       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11579         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11580
11581       TREE_TYPE (node) = void_type_node;
11582       break;
11583
11584       /* 2- They are expressions but ultimately deal with statements */
11585
11586     case THROW_EXPR:
11587       wfl_op1 = TREE_OPERAND (node, 0);
11588       COMPLETE_CHECK_OP_0 (node);
11589       /* 14.19 A throw statement cannot complete normally. */
11590       CAN_COMPLETE_NORMALLY (node) = 0;
11591       return patch_throw_statement (node, wfl_op1);
11592
11593     case SYNCHRONIZED_EXPR:
11594       wfl_op1 = TREE_OPERAND (node, 0);
11595       return patch_synchronized_statement (node, wfl_op1);
11596
11597     case TRY_EXPR:
11598       return patch_try_statement (node);
11599
11600     case TRY_FINALLY_EXPR:
11601       COMPLETE_CHECK_OP_0 (node);
11602       COMPLETE_CHECK_OP_1 (node);
11603       /* Reduce try/finally nodes with an empty try block.  */
11604       if (TREE_OPERAND (node, 0) == empty_stmt_node
11605           || BLOCK_EMPTY_P (TREE_OPERAND (node, 0)))
11606         return TREE_OPERAND (node, 1);
11607       /* Likewise for an empty finally block.  */
11608       if (TREE_OPERAND (node, 1) == empty_stmt_node
11609           || BLOCK_EMPTY_P (TREE_OPERAND (node, 1)))
11610         return TREE_OPERAND (node, 0);
11611       CAN_COMPLETE_NORMALLY (node)
11612         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11613            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11614       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11615       return node;
11616
11617     case LABELED_BLOCK_EXPR:
11618       PUSH_LABELED_BLOCK (node);
11619       if (LABELED_BLOCK_BODY (node))
11620         COMPLETE_CHECK_OP_1 (node);
11621       TREE_TYPE (node) = void_type_node;
11622       POP_LABELED_BLOCK ();
11623
11624       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11625         {
11626           LABELED_BLOCK_BODY (node) = NULL_TREE;
11627           CAN_COMPLETE_NORMALLY (node) = 1;
11628         }
11629       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11630         CAN_COMPLETE_NORMALLY (node) = 1;
11631       return node;
11632
11633     case EXIT_BLOCK_EXPR:
11634       /* We don't complete operand 1, because it's the return value of
11635          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11636       return patch_bc_statement (node);
11637
11638     case CASE_EXPR:
11639       cn = java_complete_tree (TREE_OPERAND (node, 0));
11640       if (cn == error_mark_node)
11641         return cn;
11642
11643       /* First, the case expression must be constant. Values of final
11644          fields are accepted. */
11645       cn = fold (cn);
11646       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11647           && JDECL_P (TREE_OPERAND (cn, 1))
11648           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11649           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11650         {
11651           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11652                                        TREE_OPERAND (cn, 1));
11653         }
11654       /* Accept final locals too. */
11655       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11656         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11657
11658       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11659         {
11660           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11661           parse_error_context (node, "Constant expression required");
11662           return error_mark_node;
11663         }
11664
11665       nn = ctxp->current_loop;
11666
11667       /* It must be assignable to the type of the switch expression. */
11668       if (!try_builtin_assignconv (NULL_TREE,
11669                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11670         {
11671           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11672           parse_error_context
11673             (wfl_operator,
11674              "Incompatible type for case. Can't convert `%s' to `int'",
11675              lang_printable_name (TREE_TYPE (cn), 0));
11676           return error_mark_node;
11677         }
11678
11679       cn = fold (convert (int_type_node, cn));
11680       TREE_CONSTANT_OVERFLOW (cn) = 0;
11681       CAN_COMPLETE_NORMALLY (cn) = 1;
11682
11683       /* Save the label on a list so that we can later check for
11684          duplicates.  */
11685       case_label_list = tree_cons (node, cn, case_label_list);
11686
11687       /* Multiple instance of a case label bearing the same value is
11688          checked later. The case expression is all right so far. */
11689       if (TREE_CODE (cn) == VAR_DECL)
11690         cn = DECL_INITIAL (cn);
11691       TREE_OPERAND (node, 0) = cn;
11692       TREE_TYPE (node) = void_type_node;
11693       CAN_COMPLETE_NORMALLY (node) = 1;
11694       TREE_SIDE_EFFECTS (node) = 1;
11695       break;
11696
11697     case DEFAULT_EXPR:
11698       nn = ctxp->current_loop;
11699       /* Only one default label is allowed per switch statement */
11700       if (SWITCH_HAS_DEFAULT (nn))
11701         {
11702           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11703           parse_error_context (wfl_operator,
11704                                "Duplicate case label: `default'");
11705           return error_mark_node;
11706         }
11707       else
11708         SWITCH_HAS_DEFAULT (nn) = 1;
11709       TREE_TYPE (node) = void_type_node;
11710       TREE_SIDE_EFFECTS (node) = 1;
11711       CAN_COMPLETE_NORMALLY (node) = 1;
11712       break;
11713
11714     case SWITCH_EXPR:
11715     case LOOP_EXPR:
11716       PUSH_LOOP (node);
11717       /* Check whether the loop was enclosed in a labeled
11718          statement. If not, create one, insert the loop in it and
11719          return the node */
11720       nn = patch_loop_statement (node);
11721
11722       /* Anyways, walk the body of the loop */
11723       if (TREE_CODE (node) == LOOP_EXPR)
11724         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11725       /* Switch statement: walk the switch expression and the cases */
11726       else
11727         node = patch_switch_statement (node);
11728
11729       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11730         nn = error_mark_node;
11731       else
11732         {
11733           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11734           /* If we returned something different, that's because we
11735              inserted a label. Pop the label too. */
11736           if (nn != node)
11737             {
11738               if (CAN_COMPLETE_NORMALLY (node))
11739                 CAN_COMPLETE_NORMALLY (nn) = 1;
11740               POP_LABELED_BLOCK ();
11741             }
11742         }
11743       POP_LOOP ();
11744       return nn;
11745
11746     case EXIT_EXPR:
11747       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11748       return patch_exit_expr (node);
11749
11750     case COND_EXPR:
11751       /* Condition */
11752       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11753       if (TREE_OPERAND (node, 0) == error_mark_node)
11754         return error_mark_node;
11755       /* then-else branches */
11756       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11757       if (TREE_OPERAND (node, 1) == error_mark_node)
11758         return error_mark_node;
11759       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11760       if (TREE_OPERAND (node, 2) == error_mark_node)
11761         return error_mark_node;
11762       return patch_if_else_statement (node);
11763       break;
11764
11765     case CONDITIONAL_EXPR:
11766       /* Condition */
11767       wfl_op1 = TREE_OPERAND (node, 0);
11768       COMPLETE_CHECK_OP_0 (node);
11769       wfl_op2 = TREE_OPERAND (node, 1);
11770       COMPLETE_CHECK_OP_1 (node);
11771       wfl_op3 = TREE_OPERAND (node, 2);
11772       COMPLETE_CHECK_OP_2 (node);
11773       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11774
11775       /* 3- Expression section */
11776     case COMPOUND_EXPR:
11777       wfl_op2 = TREE_OPERAND (node, 1);
11778       TREE_OPERAND (node, 0) = nn =
11779         java_complete_tree (TREE_OPERAND (node, 0));
11780       if (wfl_op2 == empty_stmt_node)
11781         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11782       else
11783         {
11784           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11785             {
11786               /* An unreachable condition in a do-while statement
11787                  is *not* (technically) an unreachable statement. */
11788               nn = wfl_op2;
11789               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11790                 nn = EXPR_WFL_NODE (nn);
11791               /* NN can be NULL_TREE exactly when UPDATE is, in
11792                  finish_for_loop.  */
11793               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11794                 {
11795                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11796                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11797                     {
11798                       /* Perhaps this warning should have an
11799                          associated flag.  The code being compiled is
11800                          pedantically correct, but useless.  */
11801                       parse_warning_context (wfl_operator,
11802                                              "Unreachable statement");
11803                     }
11804                   else
11805                     parse_error_context (wfl_operator,
11806                                          "Unreachable statement");
11807                 }
11808             }
11809           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11810           if (TREE_OPERAND (node, 1) == error_mark_node)
11811             return error_mark_node;
11812           /* Even though we might allow the case where the first
11813              operand doesn't return normally, we still should compute
11814              CAN_COMPLETE_NORMALLY correctly.  */
11815           CAN_COMPLETE_NORMALLY (node)
11816             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11817                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11818         }
11819       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11820       break;
11821
11822     case RETURN_EXPR:
11823       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11824       return patch_return (node);
11825
11826     case EXPR_WITH_FILE_LOCATION:
11827       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11828           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11829         {
11830           tree wfl = node;
11831           node = resolve_expression_name (node, NULL);
11832           if (node == error_mark_node)
11833             return node;
11834           /* Keep line number information somewhere were it doesn't
11835              disrupt the completion process. */
11836           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11837             {
11838               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11839               TREE_OPERAND (node, 1) = wfl;
11840             }
11841           CAN_COMPLETE_NORMALLY (node) = 1;
11842         }
11843       else
11844         {
11845           tree body;
11846           int save_lineno = input_line;
11847           input_line = EXPR_WFL_LINENO (node);
11848           body = java_complete_tree (EXPR_WFL_NODE (node));
11849           input_line = save_lineno;
11850           EXPR_WFL_NODE (node) = body;
11851           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11852           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11853           if (body == empty_stmt_node || TREE_CONSTANT (body))
11854             {
11855               /* Makes it easier to constant fold, detect empty bodies. */
11856               return body;
11857             }
11858           if (body == error_mark_node)
11859             {
11860               /* Its important for the evaluation of assignment that
11861                  this mark on the TREE_TYPE is propagated. */
11862               TREE_TYPE (node) = error_mark_node;
11863               return error_mark_node;
11864             }
11865           else
11866             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11867
11868         }
11869       break;
11870
11871     case NEW_ARRAY_EXPR:
11872       /* Patch all the dimensions */
11873       flag = 0;
11874       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11875         {
11876           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11877           tree dim = convert (int_type_node,
11878                               java_complete_tree (TREE_VALUE (cn)));
11879           if (dim == error_mark_node)
11880             {
11881               flag = 1;
11882               continue;
11883             }
11884           else
11885             {
11886               TREE_VALUE (cn) = dim;
11887               /* Setup the location of the current dimension, for
11888                  later error report. */
11889               TREE_PURPOSE (cn) =
11890                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11891               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11892             }
11893         }
11894       /* They complete the array creation expression, if no errors
11895          were found. */
11896       CAN_COMPLETE_NORMALLY (node) = 1;
11897       return (flag ? error_mark_node
11898               : force_evaluation_order (patch_newarray (node)));
11899
11900     case NEW_ANONYMOUS_ARRAY_EXPR:
11901       /* Create the array type if necessary. */
11902       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11903         {
11904           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11905           if (!(type = resolve_type_during_patch (type)))
11906             return error_mark_node;
11907           type = build_array_from_name (type, NULL_TREE,
11908                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11909           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11910         }
11911       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11912                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11913       if (node == error_mark_node)
11914         return error_mark_node;
11915       CAN_COMPLETE_NORMALLY (node) = 1;
11916       return node;
11917
11918     case NEW_CLASS_EXPR:
11919     case CALL_EXPR:
11920       /* Complete function's argument(s) first */
11921       if (complete_function_arguments (node))
11922         return error_mark_node;
11923       else
11924         {
11925           tree decl, wfl = TREE_OPERAND (node, 0);
11926           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11927           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11928                            super_identifier_node);
11929           tree arguments;
11930           int location = EXPR_WFL_LINECOL (node);
11931
11932           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11933                                           from_super, 0, &decl);
11934           if (node == error_mark_node)
11935             return error_mark_node;
11936
11937           if (TREE_CODE (node) == CALL_EXPR
11938               && TREE_OPERAND (node, 1) != NULL_TREE)
11939             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11940           else
11941             arguments = NULL_TREE;
11942           check_thrown_exceptions (location, decl, arguments);
11943           /* If we call this(...), register signature and positions */
11944           if (in_this)
11945             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11946               tree_cons (wfl, decl,
11947                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11948           CAN_COMPLETE_NORMALLY (node) = 1;
11949           return force_evaluation_order (node);
11950         }
11951
11952     case MODIFY_EXPR:
11953       /* Save potential wfls */
11954       wfl_op1 = TREE_OPERAND (node, 0);
11955       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11956
11957       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11958           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11959           && DECL_INITIAL (nn) != NULL_TREE)
11960         {
11961           tree value;
11962
11963           value = fold_constant_for_init (nn, nn);
11964
11965           /* When we have a primitype type, or a string and we're not
11966              emitting a class file, we actually don't want to generate
11967              anything for the assignment. */
11968           if (value != NULL_TREE &&
11969               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11970                (TREE_TYPE (value) == string_ptr_type_node &&
11971                 ! flag_emit_class_files)))
11972             {
11973               /* Prepare node for patch_assignment */
11974               TREE_OPERAND (node, 1) = value;
11975               /* Call patch assignment to verify the assignment */
11976               if (patch_assignment (node, wfl_op1) == error_mark_node)
11977                 return error_mark_node;
11978               /* Set DECL_INITIAL properly (a conversion might have
11979                  been decided by patch_assignment) and return the
11980                  empty statement. */
11981               else
11982                 {
11983                   tree patched = patch_string (TREE_OPERAND (node, 1));
11984                   if (patched)
11985                     DECL_INITIAL (nn) = patched;
11986                   else
11987                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11988                   DECL_FIELD_FINAL_IUD (nn) = 1;
11989                   return empty_stmt_node;
11990                 }
11991             }
11992           if (! flag_emit_class_files)
11993             DECL_INITIAL (nn) = NULL_TREE;
11994         }
11995       wfl_op2 = TREE_OPERAND (node, 1);
11996
11997       if (TREE_OPERAND (node, 0) == error_mark_node)
11998         return error_mark_node;
11999
12000       flag = COMPOUND_ASSIGN_P (wfl_op2);
12001       if (flag)
12002         {
12003           /* This might break when accessing outer field from inner
12004              class. TESTME, FIXME */
12005           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12006
12007           /* Hand stabilize the lhs on both places */
12008           TREE_OPERAND (node, 0) = lvalue;
12009           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12010             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12011
12012           /* 15.25.2.a: Left hand is not an array access. FIXME */
12013           /* Now complete the RHS. We write it back later on. */
12014           nn = java_complete_tree (TREE_OPERAND (node, 1));
12015
12016           if ((cn = patch_string (nn)))
12017             nn = cn;
12018
12019           /* The last part of the rewrite for E1 op= E2 is to have
12020              E1 = (T)(E1 op E2), with T being the type of E1. */
12021           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12022                                                TREE_TYPE (lvalue), nn));
12023
12024           /* If the assignment is compound and has reference type,
12025              then ensure the LHS has type String and nothing else.  */
12026           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12027               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12028             parse_error_context (wfl_op2,
12029                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12030                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12031
12032           /* 15.25.2.b: Left hand is an array access. FIXME */
12033         }
12034
12035       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12036          function to complete this RHS. Note that a NEW_ARRAY_INIT
12037          might have been already fully expanded if created as a result
12038          of processing an anonymous array initializer. We avoid doing
12039          the operation twice by testing whether the node already bears
12040          a type. */
12041       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12042         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12043                                    TREE_OPERAND (node, 1));
12044       /* Otherwise we simply complete the RHS */
12045       else
12046         nn = java_complete_tree (TREE_OPERAND (node, 1));
12047
12048       if (nn == error_mark_node)
12049         return error_mark_node;
12050
12051       /* Write back the RHS as we evaluated it. */
12052       TREE_OPERAND (node, 1) = nn;
12053
12054       /* In case we're handling = with a String as a RHS, we need to
12055          produce a String out of the RHS (it might still be a
12056          STRING_CST or a StringBuffer at this stage */
12057       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12058         TREE_OPERAND (node, 1) = nn;
12059
12060       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12061                                         TREE_OPERAND (node, 1))))
12062         {
12063           /* We return error_mark_node if outer_field_access_fix
12064              detects we write into a final. */
12065           if (nn == error_mark_node)
12066             return error_mark_node;
12067           node = nn;
12068         }
12069       else
12070         {
12071           node = patch_assignment (node, wfl_op1);
12072           if (node == error_mark_node)
12073             return error_mark_node;
12074           /* Reorganize the tree if necessary. */
12075           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12076                        || JSTRING_P (TREE_TYPE (node))))
12077             node = java_refold (node);
12078         }
12079
12080       /* Seek to set DECL_INITIAL to a proper value, since it might have
12081          undergone a conversion in patch_assignment. We do that only when
12082          it's necessary to have DECL_INITIAL properly set. */
12083       nn = TREE_OPERAND (node, 0);
12084       if (TREE_CODE (nn) == VAR_DECL
12085           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12086           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12087           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12088               || TREE_TYPE (nn) == string_ptr_type_node))
12089         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12090
12091       CAN_COMPLETE_NORMALLY (node) = 1;
12092       return node;
12093
12094     case MULT_EXPR:
12095     case PLUS_EXPR:
12096     case MINUS_EXPR:
12097     case LSHIFT_EXPR:
12098     case RSHIFT_EXPR:
12099     case URSHIFT_EXPR:
12100     case BIT_AND_EXPR:
12101     case BIT_XOR_EXPR:
12102     case BIT_IOR_EXPR:
12103     case TRUNC_MOD_EXPR:
12104     case TRUNC_DIV_EXPR:
12105     case RDIV_EXPR:
12106     case TRUTH_ANDIF_EXPR:
12107     case TRUTH_ORIF_EXPR:
12108     case EQ_EXPR:
12109     case NE_EXPR:
12110     case GT_EXPR:
12111     case GE_EXPR:
12112     case LT_EXPR:
12113     case LE_EXPR:
12114       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12115          knows how to handle those cases. */
12116       wfl_op1 = TREE_OPERAND (node, 0);
12117       wfl_op2 = TREE_OPERAND (node, 1);
12118
12119       CAN_COMPLETE_NORMALLY (node) = 1;
12120       /* Don't complete string nodes if dealing with the PLUS operand. */
12121       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12122         {
12123           nn = java_complete_tree (wfl_op1);
12124           if (nn == error_mark_node)
12125             return error_mark_node;
12126
12127           TREE_OPERAND (node, 0) = nn;
12128         }
12129       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12130         {
12131           nn = java_complete_tree (wfl_op2);
12132           if (nn == error_mark_node)
12133             return error_mark_node;
12134
12135           TREE_OPERAND (node, 1) = nn;
12136         }
12137       return patch_binop (node, wfl_op1, wfl_op2);
12138
12139     case INSTANCEOF_EXPR:
12140       wfl_op1 = TREE_OPERAND (node, 0);
12141       COMPLETE_CHECK_OP_0 (node);
12142       if (flag_emit_xref)
12143         {
12144           TREE_TYPE (node) = boolean_type_node;
12145           return node;
12146         }
12147       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12148
12149     case UNARY_PLUS_EXPR:
12150     case NEGATE_EXPR:
12151     case TRUTH_NOT_EXPR:
12152     case BIT_NOT_EXPR:
12153     case PREDECREMENT_EXPR:
12154     case PREINCREMENT_EXPR:
12155     case POSTDECREMENT_EXPR:
12156     case POSTINCREMENT_EXPR:
12157     case CONVERT_EXPR:
12158       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12159          how to handle those cases. */
12160       wfl_op1 = TREE_OPERAND (node, 0);
12161       CAN_COMPLETE_NORMALLY (node) = 1;
12162       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12163       if (TREE_OPERAND (node, 0) == error_mark_node)
12164         return error_mark_node;
12165       node = patch_unaryop (node, wfl_op1);
12166       CAN_COMPLETE_NORMALLY (node) = 1;
12167       break;
12168
12169     case ARRAY_REF:
12170       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12171          how to handle those cases. */
12172       wfl_op1 = TREE_OPERAND (node, 0);
12173       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12174       if (TREE_OPERAND (node, 0) == error_mark_node)
12175         return error_mark_node;
12176       if (!flag_emit_class_files && !flag_emit_xref)
12177         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12178       /* The same applies to wfl_op2 */
12179       wfl_op2 = TREE_OPERAND (node, 1);
12180       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12181       if (TREE_OPERAND (node, 1) == error_mark_node)
12182         return error_mark_node;
12183       if (!flag_emit_class_files && !flag_emit_xref)
12184         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12185       return patch_array_ref (node);
12186
12187     case RECORD_TYPE:
12188       return node;;
12189
12190     case COMPONENT_REF:
12191       /* The first step in the re-write of qualified name handling.  FIXME.
12192          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12193       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12194       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12195         {
12196           tree name = TREE_OPERAND (node, 1);
12197           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12198           if (field == NULL_TREE)
12199             {
12200               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12201               return error_mark_node;
12202             }
12203           if (! FIELD_STATIC (field))
12204             {
12205               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12206               return error_mark_node;
12207             }
12208           return field;
12209         }
12210       else
12211         abort ();
12212       break;
12213
12214     case THIS_EXPR:
12215       /* Can't use THIS in a static environment */
12216       if (!current_this)
12217         {
12218           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12219           parse_error_context (wfl_operator,
12220                                "Keyword `this' used outside allowed context");
12221           TREE_TYPE (node) = error_mark_node;
12222           return error_mark_node;
12223         }
12224       if (ctxp->explicit_constructor_p)
12225         {
12226           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12227           parse_error_context
12228             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12229           TREE_TYPE (node) = error_mark_node;
12230           return error_mark_node;
12231         }
12232       return current_this;
12233
12234     case CLASS_LITERAL:
12235       CAN_COMPLETE_NORMALLY (node) = 1;
12236       node = patch_incomplete_class_ref (node);
12237       if (node == error_mark_node)
12238         return error_mark_node;
12239       break;
12240
12241     default:
12242       CAN_COMPLETE_NORMALLY (node) = 1;
12243       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12244          and it's time to turn it into the appropriate String object */
12245       if ((nn = patch_string (node)))
12246         node = nn;
12247       else
12248         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12249     }
12250   return node;
12251 }
12252
12253 /* Complete function call's argument. Return a nonzero value is an
12254    error was found.  */
12255
12256 static int
12257 complete_function_arguments (tree node)
12258 {
12259   int flag = 0;
12260   tree cn;
12261
12262   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12263   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12264     {
12265       tree wfl = TREE_VALUE (cn), parm, temp;
12266       parm = java_complete_tree (wfl);
12267
12268       if (parm == error_mark_node)
12269         {
12270           flag = 1;
12271           continue;
12272         }
12273       /* If have a string literal that we haven't transformed yet or a
12274          crafted string buffer, as a result of use of the the String
12275          `+' operator. Build `parm.toString()' and expand it. */
12276       if ((temp = patch_string (parm)))
12277         parm = temp;
12278
12279       TREE_VALUE (cn) = parm;
12280     }
12281   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12282   return flag;
12283 }
12284
12285 /* Sometimes (for loops and variable initialized during their
12286    declaration), we want to wrap a statement around a WFL and turn it
12287    debugable.  */
12288
12289 static tree
12290 build_debugable_stmt (int location, tree stmt)
12291 {
12292   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12293     {
12294       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12295       EXPR_WFL_LINECOL (stmt) = location;
12296     }
12297   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12298   return stmt;
12299 }
12300
12301 static tree
12302 build_expr_block (tree body, tree decls)
12303
12304 {
12305   tree node = make_node (BLOCK);
12306   BLOCK_EXPR_DECLS (node) = decls;
12307   BLOCK_EXPR_BODY (node) = body;
12308   if (body)
12309     TREE_TYPE (node) = TREE_TYPE (body);
12310   TREE_SIDE_EFFECTS (node) = 1;
12311   return node;
12312 }
12313
12314 /* Create a new function block and link it appropriately to current
12315    function block chain */
12316
12317 static tree
12318 enter_block (void)
12319 {
12320   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12321
12322   /* Link block B supercontext to the previous block. The current
12323      function DECL is used as supercontext when enter_a_block is called
12324      for the first time for a given function. The current function body
12325      (DECL_FUNCTION_BODY) is set to be block B.  */
12326
12327   tree fndecl = current_function_decl;
12328
12329   if (!fndecl) {
12330     BLOCK_SUPERCONTEXT (b) = current_static_block;
12331     current_static_block = b;
12332   }
12333
12334   else if (!DECL_FUNCTION_BODY (fndecl))
12335     {
12336       BLOCK_SUPERCONTEXT (b) = fndecl;
12337       DECL_FUNCTION_BODY (fndecl) = b;
12338     }
12339   else
12340     {
12341       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12342       DECL_FUNCTION_BODY (fndecl) = b;
12343     }
12344   return b;
12345 }
12346
12347 /* Exit a block by changing the current function body
12348    (DECL_FUNCTION_BODY) to the current block super context, only if
12349    the block being exited isn't the method's top level one.  */
12350
12351 static tree
12352 exit_block (void)
12353 {
12354   tree b;
12355   if (current_function_decl)
12356     {
12357       b = DECL_FUNCTION_BODY (current_function_decl);
12358       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12359         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12360     }
12361   else
12362     {
12363       b = current_static_block;
12364
12365       if (BLOCK_SUPERCONTEXT (b))
12366         current_static_block = BLOCK_SUPERCONTEXT (b);
12367     }
12368   return b;
12369 }
12370
12371 /* Lookup for NAME in the nested function's blocks, all the way up to
12372    the current toplevel one. It complies with Java's local variable
12373    scoping rules.  */
12374
12375 static tree
12376 lookup_name_in_blocks (tree name)
12377 {
12378   tree b = GET_CURRENT_BLOCK (current_function_decl);
12379
12380   while (b != current_function_decl)
12381     {
12382       tree current;
12383
12384       /* Paranoid sanity check. To be removed */
12385       if (TREE_CODE (b) != BLOCK)
12386         abort ();
12387
12388       for (current = BLOCK_EXPR_DECLS (b); current;
12389            current = TREE_CHAIN (current))
12390         if (DECL_NAME (current) == name)
12391           return current;
12392       b = BLOCK_SUPERCONTEXT (b);
12393     }
12394   return NULL_TREE;
12395 }
12396
12397 static void
12398 maybe_absorb_scoping_blocks (void)
12399 {
12400   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12401     {
12402       tree b = exit_block ();
12403       java_method_add_stmt (current_function_decl, b);
12404       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12405     }
12406 }
12407
12408 \f
12409 /* This section of the source is reserved to build_* functions that
12410    are building incomplete tree nodes and the patch_* functions that
12411    are completing them.  */
12412
12413 /* Wrap a non WFL node around a WFL.  */
12414
12415 static tree
12416 build_wfl_wrap (tree node, int location)
12417 {
12418   tree wfl, node_to_insert = node;
12419
12420   /* We want to process THIS . xxx symbolically, to keep it consistent
12421      with the way we're processing SUPER. A THIS from a primary as a
12422      different form than a SUPER. Turn THIS into something symbolic */
12423   if (TREE_CODE (node) == THIS_EXPR)
12424     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12425   else
12426     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12427
12428   EXPR_WFL_LINECOL (wfl) = location;
12429   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12430   return wfl;
12431 }
12432
12433 /* Build a super() constructor invocation. Returns empty_stmt_node if
12434    we're currently dealing with the class java.lang.Object. */
12435
12436 static tree
12437 build_super_invocation (tree mdecl)
12438 {
12439   if (DECL_CONTEXT (mdecl) == object_type_node)
12440     return empty_stmt_node;
12441   else
12442     {
12443       tree super_wfl = build_wfl_node (super_identifier_node);
12444       tree a = NULL_TREE, t;
12445       /* If we're dealing with an anonymous class, pass the arguments
12446          of the crafted constructor along. */
12447       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12448         {
12449           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12450           for (; t != end_params_node; t = TREE_CHAIN (t))
12451             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12452         }
12453       return build_method_invocation (super_wfl, a);
12454     }
12455 }
12456
12457 /* Build a SUPER/THIS qualified method invocation.  */
12458
12459 static tree
12460 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12461                                        int lloc, int rloc)
12462 {
12463   tree invok;
12464   tree wfl =
12465     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12466   EXPR_WFL_LINECOL (wfl) = lloc;
12467   invok = build_method_invocation (name, args);
12468   return make_qualified_primary (wfl, invok, rloc);
12469 }
12470
12471 /* Build an incomplete CALL_EXPR node. */
12472
12473 static tree
12474 build_method_invocation (tree name, tree args)
12475 {
12476   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12477   TREE_SIDE_EFFECTS (call) = 1;
12478   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12479   return call;
12480 }
12481
12482 /* Build an incomplete new xxx(...) node. */
12483
12484 static tree
12485 build_new_invocation (tree name, tree args)
12486 {
12487   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12488   TREE_SIDE_EFFECTS (call) = 1;
12489   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12490   return call;
12491 }
12492
12493 /* Build an incomplete assignment expression. */
12494
12495 static tree
12496 build_assignment (int op, int op_location, tree lhs, tree rhs)
12497 {
12498   tree assignment;
12499   /* Build the corresponding binop if we deal with a Compound
12500      Assignment operator. Mark the binop sub-tree as part of a
12501      Compound Assignment expression */
12502   if (op != ASSIGN_TK)
12503     {
12504       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12505       COMPOUND_ASSIGN_P (rhs) = 1;
12506     }
12507   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12508   TREE_SIDE_EFFECTS (assignment) = 1;
12509   EXPR_WFL_LINECOL (assignment) = op_location;
12510   return assignment;
12511 }
12512
12513 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12514    the buffer.  This is used only for string conversion.  */
12515 static char *
12516 string_convert_int_cst (tree node)
12517 {
12518   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12519   static char buffer[21];
12520
12521   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12522   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12523   char *p = buffer + sizeof (buffer);
12524   int neg = 0;
12525
12526   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12527                                   << (HOST_BITS_PER_WIDE_INT - 1));
12528
12529   *--p = '\0';
12530
12531   /* If negative, note the fact and negate the value.  */
12532   if ((hi & hibit))
12533     {
12534       lo = ~lo;
12535       hi = ~hi;
12536       if (++lo == 0)
12537         ++hi;
12538       neg = 1;
12539     }
12540
12541   /* Divide by 10 until there are no bits left.  */
12542   do
12543     {
12544       unsigned HOST_WIDE_INT acc = 0;
12545       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12546       unsigned int i;
12547
12548       /* Use long division to compute the result and the remainder.  */
12549       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12550         {
12551           /* Shift a bit into accumulator.  */
12552           acc <<= 1;
12553           if ((hi & hibit))
12554             acc |= 1;
12555
12556           /* Shift the value.  */
12557           hi <<= 1;
12558           if ((lo & hibit))
12559             hi |= 1;
12560           lo <<= 1;
12561
12562           /* Shift the correct bit into the result.  */
12563           outhi <<= 1;
12564           if ((outlo & hibit))
12565             outhi |= 1;
12566           outlo <<= 1;
12567           if (acc >= 10)
12568             {
12569               acc -= 10;
12570               outlo |= 1;
12571             }
12572         }
12573
12574       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12575       *--p = '\060' + acc;
12576
12577       hi = outhi;
12578       lo = outlo;
12579     }
12580   while (hi || lo);
12581
12582   if (neg)
12583     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12584
12585   return p;
12586 }
12587
12588 /* Print an INTEGER_CST node in a static buffer, and return the
12589    buffer.  This is used only for error handling.  */
12590 char *
12591 print_int_node (tree node)
12592 {
12593   static char buffer [80];
12594   if (TREE_CONSTANT_OVERFLOW (node))
12595     sprintf (buffer, "<overflow>");
12596
12597   if (TREE_INT_CST_HIGH (node) == 0)
12598     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12599              TREE_INT_CST_LOW (node));
12600   else if (TREE_INT_CST_HIGH (node) == -1
12601            && TREE_INT_CST_LOW (node) != 0)
12602     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12603              -TREE_INT_CST_LOW (node));
12604   else
12605     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12606              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12607
12608   return buffer;
12609 }
12610
12611 \f
12612 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12613    context.  */
12614
12615 /* 15.25 Assignment operators. */
12616
12617 static tree
12618 patch_assignment (tree node, tree wfl_op1)
12619 {
12620   tree rhs = TREE_OPERAND (node, 1);
12621   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12622   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12623   int error_found = 0;
12624   int lvalue_from_array = 0;
12625   int is_return = 0;
12626
12627   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12628
12629   /* Lhs can be a named variable */
12630   if (JDECL_P (lvalue))
12631     {
12632       lhs_type = TREE_TYPE (lvalue);
12633     }
12634   /* Or Lhs can be an array access. */
12635   else if (TREE_CODE (lvalue) == ARRAY_REF)
12636     {
12637       lhs_type = TREE_TYPE (lvalue);
12638       lvalue_from_array = 1;
12639     }
12640   /* Or a field access */
12641   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12642     lhs_type = TREE_TYPE (lvalue);
12643   /* Or a function return slot */
12644   else if (TREE_CODE (lvalue) == RESULT_DECL)
12645     {
12646       /* If the return type is an integral type, then we create the
12647          RESULT_DECL with a promoted type, but we need to do these
12648          checks against the unpromoted type to ensure type safety.  So
12649          here we look at the real type, not the type of the decl we
12650          are modifying.  */
12651       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12652       is_return = 1;
12653     }
12654   /* Otherwise, we might want to try to write into an optimized static
12655      final, this is an of a different nature, reported further on. */
12656   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12657            && resolve_expression_name (wfl_op1, &llvalue))
12658     {
12659       lhs_type = TREE_TYPE (lvalue);
12660     }
12661   else
12662     {
12663       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12664       error_found = 1;
12665     }
12666
12667   rhs_type = TREE_TYPE (rhs);
12668
12669   /* 5.1 Try the assignment conversion for builtin type. */
12670   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12671
12672   /* 5.2 If it failed, try a reference conversion */
12673   if (!new_rhs)
12674     new_rhs = try_reference_assignconv (lhs_type, rhs);
12675
12676   /* 15.25.2 If we have a compound assignment, convert RHS into the
12677      type of the LHS */
12678   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12679     new_rhs = convert (lhs_type, rhs);
12680
12681   /* Explicit cast required. This is an error */
12682   if (!new_rhs)
12683     {
12684       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12685       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12686       tree wfl;
12687       char operation [32];      /* Max size known */
12688
12689       /* If the assignment is part of a declaration, we use the WFL of
12690          the declared variable to point out the error and call it a
12691          declaration problem. If the assignment is a genuine =
12692          operator, we call is a operator `=' problem, otherwise we
12693          call it an assignment problem. In both of these last cases,
12694          we use the WFL of the operator to indicate the error. */
12695
12696       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12697         {
12698           wfl = wfl_op1;
12699           strcpy (operation, "declaration");
12700         }
12701       else
12702         {
12703           wfl = wfl_operator;
12704           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12705             strcpy (operation, "assignment");
12706           else if (is_return)
12707             strcpy (operation, "`return'");
12708           else
12709             strcpy (operation, "`='");
12710         }
12711
12712       if (!valid_cast_to_p (rhs_type, lhs_type))
12713         parse_error_context
12714           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12715            operation, t1, t2);
12716       else
12717         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12718                              operation, t1, t2);
12719       free (t1); free (t2);
12720       error_found = 1;
12721     }
12722
12723   if (error_found)
12724     return error_mark_node;
12725
12726   /* If we're processing a `return' statement, promote the actual type
12727      to the promoted type.  */
12728   if (is_return)
12729     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12730
12731   /* 10.10: Array Store Exception runtime check */
12732   if (!flag_emit_class_files
12733       && !flag_emit_xref
12734       && lvalue_from_array
12735       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12736     {
12737       tree array, store_check, base, index_expr;
12738
12739       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12740       new_rhs = save_expr (new_rhs);
12741
12742       /* Get the INDIRECT_REF. */
12743       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12744       /* Get the array pointer expr. */
12745       array = TREE_OPERAND (array, 0);
12746       store_check = build_java_arraystore_check (array, new_rhs);
12747
12748       index_expr = TREE_OPERAND (lvalue, 1);
12749
12750       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12751         {
12752           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12753              happen before the store check, so prepare to insert the store
12754              check within the second operand of the existing COMPOUND_EXPR. */
12755           base = index_expr;
12756         }
12757       else
12758         base = lvalue;
12759
12760       index_expr = TREE_OPERAND (base, 1);
12761       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12762                                       store_check, index_expr);
12763     }
12764
12765   /* Final locals can be used as case values in switch
12766      statement. Prepare them for this eventuality. */
12767   if (TREE_CODE (lvalue) == VAR_DECL
12768       && DECL_FINAL (lvalue)
12769       && TREE_CONSTANT (new_rhs)
12770       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12771       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12772       )
12773     {
12774       TREE_CONSTANT (lvalue) = 1;
12775       DECL_INITIAL (lvalue) = new_rhs;
12776     }
12777
12778   /* Copy the rhs if it's a reference.  */
12779   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12780     {
12781       switch (TREE_CODE (new_rhs))
12782         {
12783         case ARRAY_REF:
12784         case INDIRECT_REF:
12785         case COMPONENT_REF:
12786           /* Transform a = foo.bar
12787              into a = { int tmp; tmp = foo.bar; tmp; ).
12788              We need to ensure that if a read from memory fails
12789              because of a NullPointerException, a destination variable
12790              will remain unchanged.  An explicit temporary does what
12791              we need.
12792
12793              If flag_check_references is set, this is unnecessary
12794              because we'll check each reference before doing any
12795              reads.  If optimize is not set the result will never be
12796              written to a stack slot that contains the LHS.  */
12797           {
12798             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12799                                    TREE_TYPE (new_rhs));
12800             tree block = make_node (BLOCK);
12801             tree assignment
12802               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12803             DECL_CONTEXT (tmp) = current_function_decl;
12804             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12805             BLOCK_VARS (block) = tmp;
12806             BLOCK_EXPR_BODY (block)
12807               = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12808             TREE_SIDE_EFFECTS (block) = 1;
12809             new_rhs = block;
12810           }
12811           break;
12812         default:
12813           break;
12814         }
12815     }
12816
12817   TREE_OPERAND (node, 0) = lvalue;
12818   TREE_OPERAND (node, 1) = new_rhs;
12819   TREE_TYPE (node) = lhs_type;
12820   return node;
12821 }
12822
12823 /* Check that type SOURCE can be cast into type DEST. If the cast
12824    can't occur at all, return NULL; otherwise, return a possibly
12825    modified rhs.  */
12826
12827 static tree
12828 try_reference_assignconv (tree lhs_type, tree rhs)
12829 {
12830   tree new_rhs = NULL_TREE;
12831   tree rhs_type = TREE_TYPE (rhs);
12832
12833   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12834     {
12835       /* `null' may be assigned to any reference type */
12836       if (rhs == null_pointer_node)
12837         new_rhs = null_pointer_node;
12838       /* Try the reference assignment conversion */
12839       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12840         new_rhs = rhs;
12841       /* This is a magic assignment that we process differently */
12842       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12843         new_rhs = rhs;
12844     }
12845   return new_rhs;
12846 }
12847
12848 /* Check that RHS can be converted into LHS_TYPE by the assignment
12849    conversion (5.2), for the cases of RHS being a builtin type. Return
12850    NULL_TREE if the conversion fails or if because RHS isn't of a
12851    builtin type. Return a converted RHS if the conversion is possible.  */
12852
12853 static tree
12854 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12855 {
12856   tree new_rhs = NULL_TREE;
12857   tree rhs_type = TREE_TYPE (rhs);
12858
12859   /* Handle boolean specially.  */
12860   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12861       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12862     {
12863       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12864           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12865         new_rhs = rhs;
12866     }
12867
12868   /* 5.1.1 Try Identity Conversion,
12869      5.1.2 Try Widening Primitive Conversion */
12870   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12871     new_rhs = convert (lhs_type, rhs);
12872
12873   /* Try a narrowing primitive conversion (5.1.3):
12874        - expression is a constant expression of type byte, short, char,
12875          or int, AND
12876        - variable is byte, short or char AND
12877        - The value of the expression is representable in the type of the
12878          variable */
12879   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12880             || rhs_type == char_type_node || rhs_type == int_type_node)
12881             && TREE_CONSTANT (rhs)
12882            && (lhs_type == byte_type_node || lhs_type == char_type_node
12883                || lhs_type == short_type_node))
12884     {
12885       if (int_fits_type_p (rhs, lhs_type))
12886         new_rhs = convert (lhs_type, rhs);
12887       else if (wfl_op1)         /* Might be called with a NULL */
12888         parse_warning_context
12889           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12890            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12891       /* Reported a warning that will turn into an error further
12892          down, so we don't return */
12893     }
12894
12895   return new_rhs;
12896 }
12897
12898 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12899    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12900    0 is the conversion test fails.  This implements parts the method
12901    invocation conversion (5.3).  */
12902
12903 static int
12904 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12905 {
12906   /* 5.1.1: This is the identity conversion part. */
12907   if (lhs_type == rhs_type)
12908     return 1;
12909
12910   /* Reject non primitive types and boolean conversions.  */
12911   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12912     return 0;
12913
12914   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12915      than a char can't be converted into a char. Short can't too, but
12916      the < test below takes care of that */
12917   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12918     return 0;
12919
12920   /* Accept all promoted type here. Note, we can't use <= in the test
12921      below, because we still need to bounce out assignments of short
12922      to char and the likes */
12923   if (lhs_type == int_type_node
12924       && (rhs_type == promoted_byte_type_node
12925           || rhs_type == promoted_short_type_node
12926           || rhs_type == promoted_char_type_node
12927           || rhs_type == promoted_boolean_type_node))
12928     return 1;
12929
12930   /* From here, an integral is widened if its precision is smaller
12931      than the precision of the LHS or if the LHS is a floating point
12932      type, or the RHS is a float and the RHS a double. */
12933   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12934        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12935       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12936       || (rhs_type == float_type_node && lhs_type == double_type_node))
12937     return 1;
12938
12939   return 0;
12940 }
12941
12942 /* Check that something of SOURCE type can be assigned or cast to
12943    something of DEST type at runtime. Return 1 if the operation is
12944    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12945    were SOURCE is cast into DEST, which borrows a lot of the
12946    assignment check. */
12947
12948 static int
12949 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12950 {
12951   /* SOURCE or DEST might be null if not from a declared entity. */
12952   if (!source || !dest)
12953     return 0;
12954   if (JNULLP_TYPE_P (source))
12955     return 1;
12956   if (TREE_CODE (source) == POINTER_TYPE)
12957     source = TREE_TYPE (source);
12958   if (TREE_CODE (dest) == POINTER_TYPE)
12959     dest = TREE_TYPE (dest);
12960
12961   /* If source and dest are being compiled from bytecode, they may need to
12962      be loaded. */
12963   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12964     {
12965       load_class (source, 1);
12966       safe_layout_class (source);
12967     }
12968   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12969     {
12970       load_class (dest, 1);
12971       safe_layout_class (dest);
12972     }
12973
12974   /* Case where SOURCE is a class type */
12975   if (TYPE_CLASS_P (source))
12976     {
12977       if (TYPE_CLASS_P (dest))
12978         return  (source == dest
12979                  || inherits_from_p (source, dest)
12980                  || (cast && inherits_from_p (dest, source)));
12981       if (TYPE_INTERFACE_P (dest))
12982         {
12983           /* If doing a cast and SOURCE is final, the operation is
12984              always correct a compile time (because even if SOURCE
12985              does not implement DEST, a subclass of SOURCE might). */
12986           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12987             return 1;
12988           /* Otherwise, SOURCE must implement DEST */
12989           return interface_of_p (dest, source);
12990         }
12991       /* DEST is an array, cast permitted if SOURCE is of Object type */
12992       return (cast && source == object_type_node ? 1 : 0);
12993     }
12994   if (TYPE_INTERFACE_P (source))
12995     {
12996       if (TYPE_CLASS_P (dest))
12997         {
12998           /* If not casting, DEST must be the Object type */
12999           if (!cast)
13000             return dest == object_type_node;
13001           /* We're doing a cast. The cast is always valid is class
13002              DEST is not final, otherwise, DEST must implement SOURCE */
13003           else if (!CLASS_FINAL (TYPE_NAME (dest)))
13004             return 1;
13005           else
13006             return interface_of_p (source, dest);
13007         }
13008       if (TYPE_INTERFACE_P (dest))
13009         {
13010           /* If doing a cast, then if SOURCE and DEST contain method
13011              with the same signature but different return type, then
13012              this is a (compile time) error */
13013           if (cast)
13014             {
13015               tree method_source, method_dest;
13016               tree source_type;
13017               tree source_sig;
13018               tree source_name;
13019               for (method_source = TYPE_METHODS (source); method_source;
13020                    method_source = TREE_CHAIN (method_source))
13021                 {
13022                   source_sig =
13023                     build_java_argument_signature (TREE_TYPE (method_source));
13024                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13025                   source_name = DECL_NAME (method_source);
13026                   for (method_dest = TYPE_METHODS (dest);
13027                        method_dest; method_dest = TREE_CHAIN (method_dest))
13028                     if (source_sig ==
13029                         build_java_argument_signature (TREE_TYPE (method_dest))
13030                         && source_name == DECL_NAME (method_dest)
13031                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13032                       return 0;
13033                 }
13034               return 1;
13035             }
13036           else
13037             return source == dest || interface_of_p (dest, source);
13038         }
13039       else
13040         {
13041           /* Array */
13042           return (cast
13043                   && (DECL_NAME (TYPE_NAME (source))
13044                       == java_lang_cloneable_identifier_node
13045                       || (DECL_NAME (TYPE_NAME (source))
13046                           == java_io_serializable_identifier_node)));
13047         }
13048     }
13049   if (TYPE_ARRAY_P (source))
13050     {
13051       if (TYPE_CLASS_P (dest))
13052         return dest == object_type_node;
13053       /* Can't cast an array to an interface unless the interface is
13054          java.lang.Cloneable or java.io.Serializable.  */
13055       if (TYPE_INTERFACE_P (dest))
13056         return (DECL_NAME (TYPE_NAME (dest))
13057                 == java_lang_cloneable_identifier_node
13058                 || (DECL_NAME (TYPE_NAME (dest))
13059                     == java_io_serializable_identifier_node));
13060       else                      /* Arrays */
13061         {
13062           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13063           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13064
13065           /* In case of severe errors, they turn out null */
13066           if (!dest_element_type || !source_element_type)
13067             return 0;
13068           if (source_element_type == dest_element_type)
13069             return 1;
13070           return valid_ref_assignconv_cast_p (source_element_type,
13071                                               dest_element_type, cast);
13072         }
13073       return 0;
13074     }
13075   return 0;
13076 }
13077
13078 static int
13079 valid_cast_to_p (tree source, tree dest)
13080 {
13081   if (TREE_CODE (source) == POINTER_TYPE)
13082     source = TREE_TYPE (source);
13083   if (TREE_CODE (dest) == POINTER_TYPE)
13084     dest = TREE_TYPE (dest);
13085
13086   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13087     return valid_ref_assignconv_cast_p (source, dest, 1);
13088
13089   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13090     return 1;
13091
13092   else if (TREE_CODE (source) == BOOLEAN_TYPE
13093            && TREE_CODE (dest) == BOOLEAN_TYPE)
13094     return 1;
13095
13096   return 0;
13097 }
13098
13099 static tree
13100 do_unary_numeric_promotion (tree arg)
13101 {
13102   tree type = TREE_TYPE (arg);
13103   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13104       || TREE_CODE (type) == CHAR_TYPE)
13105     arg = convert (int_type_node, arg);
13106   return arg;
13107 }
13108
13109 /* Return a nonzero value if SOURCE can be converted into DEST using
13110    the method invocation conversion rule (5.3).  */
13111 static int
13112 valid_method_invocation_conversion_p (tree dest, tree source)
13113 {
13114   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13115            && valid_builtin_assignconv_identity_widening_p (dest, source))
13116           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13117               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13118               && valid_ref_assignconv_cast_p (source, dest, 0)));
13119 }
13120
13121 /* Build an incomplete binop expression. */
13122
13123 static tree
13124 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13125 {
13126   tree binop = build (op, NULL_TREE, op1, op2);
13127   TREE_SIDE_EFFECTS (binop) = 1;
13128   /* Store the location of the operator, for better error report. The
13129      string of the operator will be rebuild based on the OP value. */
13130   EXPR_WFL_LINECOL (binop) = op_location;
13131   return binop;
13132 }
13133
13134 /* Build the string of the operator retained by NODE. If NODE is part
13135    of a compound expression, add an '=' at the end of the string. This
13136    function is called when an error needs to be reported on an
13137    operator. The string is returned as a pointer to a static character
13138    buffer. */
13139
13140 static char *
13141 operator_string (tree node)
13142 {
13143 #define BUILD_OPERATOR_STRING(S)                                        \
13144   {                                                                     \
13145     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13146     return buffer;                                                      \
13147   }
13148
13149   static char buffer [10];
13150   switch (TREE_CODE (node))
13151     {
13152     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13153     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13154     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13155     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13156     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13157     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13158     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13159     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13160     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13161     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13162     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13163     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13164     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13165     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13166     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13167     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13168     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13169     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13170     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13171     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13172     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13173     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13174     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13175     case PREINCREMENT_EXPR:     /* Fall through */
13176     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13177     case PREDECREMENT_EXPR:     /* Fall through */
13178     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13179     default:
13180       internal_error ("unregistered operator %s",
13181                       tree_code_name [TREE_CODE (node)]);
13182     }
13183   return NULL;
13184 #undef BUILD_OPERATOR_STRING
13185 }
13186
13187 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13188
13189 static int
13190 java_decl_equiv (tree var_acc1, tree var_acc2)
13191 {
13192   if (JDECL_P (var_acc1))
13193     return (var_acc1 == var_acc2);
13194
13195   return (TREE_CODE (var_acc1) == COMPONENT_REF
13196           && TREE_CODE (var_acc2) == COMPONENT_REF
13197           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13198              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13199           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13200 }
13201
13202 /* Return a nonzero value if CODE is one of the operators that can be
13203    used in conjunction with the `=' operator in a compound assignment.  */
13204
13205 static int
13206 binop_compound_p (enum tree_code code)
13207 {
13208   int i;
13209   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13210     if (binop_lookup [i] == code)
13211       break;
13212
13213   return i < BINOP_COMPOUND_CANDIDATES;
13214 }
13215
13216 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13217
13218 static tree
13219 java_refold (tree t)
13220 {
13221   tree c, b, ns, decl;
13222
13223   if (TREE_CODE (t) != MODIFY_EXPR)
13224     return t;
13225
13226   c = TREE_OPERAND (t, 1);
13227   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13228          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13229          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13230     return t;
13231
13232   /* Now the left branch of the binary operator. */
13233   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13234   if (! (b && TREE_CODE (b) == NOP_EXPR
13235          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13236     return t;
13237
13238   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13239   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13240          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13241     return t;
13242
13243   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13244   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13245       /* It's got to be the an equivalent decl */
13246       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13247     {
13248       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13249       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13250       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13251       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13252       /* Change the right part of the BINOP_EXPR */
13253       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13254     }
13255
13256   return t;
13257 }
13258
13259 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13260    errors but we modify NODE so that it contains the type computed
13261    according to the expression, when it's fixed. Otherwise, we write
13262    error_mark_node as the type. It allows us to further the analysis
13263    of remaining nodes and detects more errors in certain cases.  */
13264
13265 static tree
13266 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13267 {
13268   tree op1 = TREE_OPERAND (node, 0);
13269   tree op2 = TREE_OPERAND (node, 1);
13270   tree op1_type = TREE_TYPE (op1);
13271   tree op2_type = TREE_TYPE (op2);
13272   tree prom_type = NULL_TREE, cn;
13273   enum tree_code code = TREE_CODE (node);
13274
13275   /* If 1, tell the routine that we have to return error_mark_node
13276      after checking for the initialization of the RHS */
13277   int error_found = 0;
13278
13279   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13280
13281   /* If either op<n>_type are NULL, this might be early signs of an
13282      error situation, unless it's too early to tell (in case we're
13283      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13284      correctly so the error can be later on reported accurately. */
13285   if (! (code == PLUS_EXPR || code == NE_EXPR
13286          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13287     {
13288       tree n;
13289       if (! op1_type)
13290         {
13291           n = java_complete_tree (op1);
13292           op1_type = TREE_TYPE (n);
13293         }
13294       if (! op2_type)
13295         {
13296           n = java_complete_tree (op2);
13297           op2_type = TREE_TYPE (n);
13298         }
13299     }
13300
13301   switch (code)
13302     {
13303     /* 15.16 Multiplicative operators */
13304     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13305     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13306     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13307     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13308       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13309         {
13310           if (!JNUMERIC_TYPE_P (op1_type))
13311             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13312           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13313             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13314           TREE_TYPE (node) = error_mark_node;
13315           error_found = 1;
13316           break;
13317         }
13318       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13319
13320       /* Detect integral division by zero */
13321       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13322           && TREE_CODE (prom_type) == INTEGER_TYPE
13323           && (op2 == integer_zero_node || op2 == long_zero_node ||
13324               (TREE_CODE (op2) == INTEGER_CST &&
13325                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13326         {
13327           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13328           TREE_CONSTANT (node) = 0;
13329         }
13330
13331       /* Change the division operator if necessary */
13332       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13333         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13334
13335       /* Before divisions as is disappear, try to simplify and bail if
13336          applicable, otherwise we won't perform even simple
13337          simplifications like (1-1)/3. We can't do that with floating
13338          point number, folds can't handle them at this stage. */
13339       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13340           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13341         {
13342           TREE_TYPE (node) = prom_type;
13343           node = fold (node);
13344           if (TREE_CODE (node) != code)
13345             return node;
13346         }
13347
13348       if (TREE_CODE (prom_type) == INTEGER_TYPE
13349           && flag_use_divide_subroutine
13350           && ! flag_emit_class_files
13351           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13352         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13353
13354       /* This one is more complicated. FLOATs are processed by a
13355          function call to soft_fmod. Duplicate the value of the
13356          COMPOUND_ASSIGN_P flag. */
13357       if (code == TRUNC_MOD_EXPR)
13358         {
13359           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13360           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13361           TREE_SIDE_EFFECTS (mod)
13362             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13363           return mod;
13364         }
13365       break;
13366
13367     /* 15.17 Additive Operators */
13368     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13369
13370       /* Operation is valid if either one argument is a string
13371          constant, a String object or a StringBuffer crafted for the
13372          purpose of the a previous usage of the String concatenation
13373          operator */
13374
13375       if (TREE_CODE (op1) == STRING_CST
13376           || TREE_CODE (op2) == STRING_CST
13377           || JSTRING_TYPE_P (op1_type)
13378           || JSTRING_TYPE_P (op2_type)
13379           || IS_CRAFTED_STRING_BUFFER_P (op1)
13380           || IS_CRAFTED_STRING_BUFFER_P (op2))
13381         return build_string_concatenation (op1, op2);
13382
13383     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13384                                    Numeric Types */
13385       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13386         {
13387           if (!JNUMERIC_TYPE_P (op1_type))
13388             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13389           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13390             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13391           TREE_TYPE (node) = error_mark_node;
13392           error_found = 1;
13393           break;
13394         }
13395       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13396       break;
13397
13398     /* 15.18 Shift Operators */
13399     case LSHIFT_EXPR:
13400     case RSHIFT_EXPR:
13401     case URSHIFT_EXPR:
13402       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13403         {
13404           if (!JINTEGRAL_TYPE_P (op1_type))
13405             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13406           else
13407             {
13408               if (JNUMERIC_TYPE_P (op2_type))
13409                 parse_error_context (wfl_operator,
13410                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13411                                      operator_string (node),
13412                                      lang_printable_name (op2_type, 0));
13413               else
13414                 parse_error_context (wfl_operator,
13415                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13416                                      operator_string (node),
13417                                      lang_printable_name (op2_type, 0));
13418             }
13419           TREE_TYPE (node) = error_mark_node;
13420           error_found = 1;
13421           break;
13422         }
13423
13424       /* Unary numeric promotion (5.6.1) is performed on each operand
13425          separately */
13426       op1 = do_unary_numeric_promotion (op1);
13427       op2 = do_unary_numeric_promotion (op2);
13428
13429       /* If the right hand side is of type `long', first cast it to
13430          `int'.  */
13431       if (TREE_TYPE (op2) == long_type_node)
13432         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13433
13434       /* The type of the shift expression is the type of the promoted
13435          type of the left-hand operand */
13436       prom_type = TREE_TYPE (op1);
13437
13438       /* Shift int only up to 0x1f and long up to 0x3f */
13439       if (prom_type == int_type_node)
13440         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13441                            build_int_2 (0x1f, 0)));
13442       else
13443         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13444                            build_int_2 (0x3f, 0)));
13445
13446       /* The >>> operator is a >> operating on unsigned quantities */
13447       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13448         {
13449           tree to_return;
13450           tree utype = java_unsigned_type (prom_type);
13451           op1 = convert (utype, op1);
13452           TREE_SET_CODE (node, RSHIFT_EXPR);
13453           TREE_OPERAND (node, 0) = op1;
13454           TREE_OPERAND (node, 1) = op2;
13455           TREE_TYPE (node) = utype;
13456           to_return = convert (prom_type, node);
13457           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13458           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13459           TREE_SIDE_EFFECTS (to_return)
13460             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13461           return to_return;
13462         }
13463       break;
13464
13465       /* 15.19.1 Type Comparison Operator instanceof */
13466     case INSTANCEOF_EXPR:
13467
13468       TREE_TYPE (node) = boolean_type_node;
13469
13470       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13471       if ((cn = patch_string (op1)))
13472         {
13473           op1 = cn;
13474           op1_type = TREE_TYPE (op1);
13475         }
13476       if (op1_type == NULL_TREE)
13477         abort ();
13478
13479       if (!(op2_type = resolve_type_during_patch (op2)))
13480         return error_mark_node;
13481
13482       /* The first operand must be a reference type or the null type */
13483       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13484         error_found = 1;        /* Error reported further below */
13485
13486       /* The second operand must be a reference type */
13487       if (!JREFERENCE_TYPE_P (op2_type))
13488         {
13489           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13490           parse_error_context
13491             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13492              lang_printable_name (op2_type, 0));
13493           error_found = 1;
13494         }
13495
13496       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13497         {
13498           /* If the first operand is null, the result is always false */
13499           if (op1 == null_pointer_node)
13500             return boolean_false_node;
13501           else if (flag_emit_class_files)
13502             {
13503               TREE_OPERAND (node, 1) = op2_type;
13504               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13505               return node;
13506             }
13507           /* Otherwise we have to invoke instance of to figure it out */
13508           else
13509             return build_instanceof (op1, op2_type);
13510         }
13511       /* There is no way the expression operand can be an instance of
13512          the type operand. This is a compile time error. */
13513       else
13514         {
13515           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13516           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13517           parse_error_context
13518             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13519              t1, lang_printable_name (op2_type, 0));
13520           free (t1);
13521           error_found = 1;
13522         }
13523
13524       break;
13525
13526       /* 15.21 Bitwise and Logical Operators */
13527     case BIT_AND_EXPR:
13528     case BIT_XOR_EXPR:
13529     case BIT_IOR_EXPR:
13530       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13531         /* Binary numeric promotion is performed on both operand and the
13532            expression retain that type */
13533         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13534
13535       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13536                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13537         /* The type of the bitwise operator expression is BOOLEAN */
13538         prom_type = boolean_type_node;
13539       else
13540         {
13541           if (!JINTEGRAL_TYPE_P (op1_type))
13542             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13543           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13544             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13545           TREE_TYPE (node) = error_mark_node;
13546           error_found = 1;
13547           /* Insert a break here if adding thing before the switch's
13548              break for this case */
13549         }
13550       break;
13551
13552       /* 15.22 Conditional-And Operator */
13553     case TRUTH_ANDIF_EXPR:
13554       /* 15.23 Conditional-Or Operator */
13555     case TRUTH_ORIF_EXPR:
13556       /* Operands must be of BOOLEAN type */
13557       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13558           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13559         {
13560           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13561             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13562           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13563             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13564           TREE_TYPE (node) = boolean_type_node;
13565           error_found = 1;
13566           break;
13567         }
13568       else if (integer_zerop (op1))
13569         {
13570           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13571         }
13572       else if (integer_onep (op1))
13573         {
13574           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13575         }
13576       /* The type of the conditional operators is BOOLEAN */
13577       prom_type = boolean_type_node;
13578       break;
13579
13580       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13581     case LT_EXPR:
13582     case GT_EXPR:
13583     case LE_EXPR:
13584     case GE_EXPR:
13585       /* The type of each of the operands must be a primitive numeric
13586          type */
13587       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13588         {
13589           if (!JNUMERIC_TYPE_P (op1_type))
13590             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13591           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13592             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13593           TREE_TYPE (node) = boolean_type_node;
13594           error_found = 1;
13595           break;
13596         }
13597       /* Binary numeric promotion is performed on the operands */
13598       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13599       /* The type of the relation expression is always BOOLEAN */
13600       prom_type = boolean_type_node;
13601       break;
13602
13603       /* 15.20 Equality Operator */
13604     case EQ_EXPR:
13605     case NE_EXPR:
13606       /* It's time for us to patch the strings. */
13607       if ((cn = patch_string (op1)))
13608        {
13609          op1 = cn;
13610          op1_type = TREE_TYPE (op1);
13611        }
13612       if ((cn = patch_string (op2)))
13613        {
13614          op2 = cn;
13615          op2_type = TREE_TYPE (op2);
13616        }
13617
13618       /* 15.20.1 Numerical Equality Operators == and != */
13619       /* Binary numeric promotion is performed on the operands */
13620       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13621         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13622
13623       /* 15.20.2 Boolean Equality Operators == and != */
13624       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13625           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13626         ;                       /* Nothing to do here */
13627
13628       /* 15.20.3 Reference Equality Operators == and != */
13629       /* Types have to be either references or the null type. If
13630          they're references, it must be possible to convert either
13631          type to the other by casting conversion. */
13632       else if (op1 == null_pointer_node || op2 == null_pointer_node
13633                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13634                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13635                        || valid_ref_assignconv_cast_p (op2_type,
13636                                                        op1_type, 1))))
13637         ;                       /* Nothing to do here */
13638
13639       /* Else we have an error figure what can't be converted into
13640          what and report the error */
13641       else
13642         {
13643           char *t1;
13644           t1 = xstrdup (lang_printable_name (op1_type, 0));
13645           parse_error_context
13646             (wfl_operator,
13647              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13648              operator_string (node), t1,
13649              lang_printable_name (op2_type, 0));
13650           free (t1);
13651           TREE_TYPE (node) = boolean_type_node;
13652           error_found = 1;
13653           break;
13654         }
13655       prom_type = boolean_type_node;
13656       break;
13657     default:
13658       abort ();
13659     }
13660
13661   if (error_found)
13662     return error_mark_node;
13663
13664   TREE_OPERAND (node, 0) = op1;
13665   TREE_OPERAND (node, 1) = op2;
13666   TREE_TYPE (node) = prom_type;
13667   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13668
13669   if (flag_emit_xref)
13670     return node;
13671
13672   /* fold does not respect side-effect order as required for Java but not C.
13673    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13674    * bytecode.
13675    */
13676   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13677       : ! TREE_SIDE_EFFECTS (node))
13678     node = fold (node);
13679   return node;
13680 }
13681
13682 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13683    zero value, the value of CSTE comes after the valude of STRING */
13684
13685 static tree
13686 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13687 {
13688   const char *old = TREE_STRING_POINTER (cste);
13689   int old_len = TREE_STRING_LENGTH (cste);
13690   int len = old_len + string_len;
13691   char *new = alloca (len+1);
13692
13693   if (after)
13694     {
13695       memcpy (new, string, string_len);
13696       memcpy (&new [string_len], old, old_len);
13697     }
13698   else
13699     {
13700       memcpy (new, old, old_len);
13701       memcpy (&new [old_len], string, string_len);
13702     }
13703   new [len] = '\0';
13704   return build_string (len, new);
13705 }
13706
13707 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13708    new STRING_CST on success, NULL_TREE on failure.  */
13709
13710 static tree
13711 merge_string_cste (tree op1, tree op2, int after)
13712 {
13713   /* Handle two string constants right away.  */
13714   if (TREE_CODE (op2) == STRING_CST)
13715     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13716                                  TREE_STRING_LENGTH (op2), after);
13717
13718   /* Reasonable integer constant can be treated right away.  */
13719   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13720     {
13721       static const char *const boolean_true = "true";
13722       static const char *const boolean_false = "false";
13723       static const char *const null_pointer = "null";
13724       char ch[4];
13725       const char *string;
13726
13727       if (op2 == boolean_true_node)
13728         string = boolean_true;
13729       else if (op2 == boolean_false_node)
13730         string = boolean_false;
13731       else if (op2 == null_pointer_node
13732                || (integer_zerop (op2)
13733                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13734         /* FIXME: null is not a compile-time constant, so it is only safe to
13735            merge if the overall expression is non-constant. However, this
13736            code always merges without checking the overall expression.  */
13737         string = null_pointer;
13738       else if (TREE_TYPE (op2) == char_type_node)
13739         {
13740           /* Convert the character into UTF-8.  */
13741           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13742           unsigned char *p = (unsigned char *) ch;
13743           if (0x01 <= c && c <= 0x7f)
13744             *p++ = (unsigned char) c;
13745           else if (c < 0x7ff)
13746             {
13747               *p++ = (unsigned char) (c >> 6 | 0xc0);
13748               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13749             }
13750           else
13751             {
13752               *p++ = (unsigned char) (c >> 12 | 0xe0);
13753               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13754               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13755             }
13756           *p = '\0';
13757
13758           string = ch;
13759         }
13760       else
13761         string = string_convert_int_cst (op2);
13762
13763       return do_merge_string_cste (op1, string, strlen (string), after);
13764     }
13765   return NULL_TREE;
13766 }
13767
13768 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13769    has to be a STRING_CST and the other part must be a STRING_CST or a
13770    INTEGRAL constant. Return a new STRING_CST if the operation
13771    succeed, NULL_TREE otherwise.
13772
13773    If the case we want to optimize for space, we might want to return
13774    NULL_TREE for each invocation of this routine. FIXME */
13775
13776 static tree
13777 string_constant_concatenation (tree op1, tree op2)
13778 {
13779   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13780     {
13781       tree string, rest;
13782       int invert;
13783
13784       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13785       rest   = (string == op1 ? op2 : op1);
13786       invert = (string == op1 ? 0 : 1 );
13787
13788       /* Walk REST, only if it looks reasonable */
13789       if (TREE_CODE (rest) != STRING_CST
13790           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13791           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13792           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13793         {
13794           rest = java_complete_tree (rest);
13795           if (rest == error_mark_node)
13796             return error_mark_node;
13797           rest = fold (rest);
13798         }
13799       return merge_string_cste (string, rest, invert);
13800     }
13801   return NULL_TREE;
13802 }
13803
13804 /* Implement the `+' operator. Does static optimization if possible,
13805    otherwise create (if necessary) and append elements to a
13806    StringBuffer. The StringBuffer will be carried around until it is
13807    used for a function call or an assignment. Then toString() will be
13808    called on it to turn it into a String object. */
13809
13810 static tree
13811 build_string_concatenation (tree op1, tree op2)
13812 {
13813   tree result;
13814   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13815
13816   if (flag_emit_xref)
13817     return build (PLUS_EXPR, string_type_node, op1, op2);
13818
13819   /* Try to do some static optimization */
13820   if ((result = string_constant_concatenation (op1, op2)))
13821     return result;
13822
13823   /* Discard empty strings on either side of the expression */
13824   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13825     {
13826       op1 = op2;
13827       op2 = NULL_TREE;
13828     }
13829   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13830     op2 = NULL_TREE;
13831
13832   /* If operands are string constant, turn then into object references */
13833   if (TREE_CODE (op1) == STRING_CST)
13834     op1 = patch_string_cst (op1);
13835   if (op2 && TREE_CODE (op2) == STRING_CST)
13836     op2 = patch_string_cst (op2);
13837
13838   /* If either one of the constant is null and the other non null
13839      operand is a String constant, return it. */
13840   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13841     return op1;
13842
13843   /* If OP1 isn't already a StringBuffer, create and
13844      initialize a new one */
13845   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13846     {
13847       /* Two solutions here:
13848          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13849          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13850       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13851         op1 = BUILD_STRING_BUFFER (op1);
13852       else
13853         {
13854           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13855           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13856         }
13857     }
13858
13859   if (op2)
13860     {
13861       /* OP1 is no longer the last node holding a crafted StringBuffer */
13862       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13863       /* Create a node for `{new...,xxx}.append (op2)' */
13864       if (op2)
13865         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13866     }
13867
13868   /* Mark the last node holding a crafted StringBuffer */
13869   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13870
13871   TREE_SIDE_EFFECTS (op1) = side_effects;
13872   return op1;
13873 }
13874
13875 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13876    StringBuffer. If no string were found to be patched, return
13877    NULL. */
13878
13879 static tree
13880 patch_string (tree node)
13881 {
13882   if (node == error_mark_node)
13883     return error_mark_node;
13884   if (TREE_CODE (node) == STRING_CST)
13885     return patch_string_cst (node);
13886   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13887     {
13888       int saved = ctxp->explicit_constructor_p;
13889       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13890       tree ret;
13891       /* Temporary disable forbid the use of `this'. */
13892       ctxp->explicit_constructor_p = 0;
13893       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13894       /* String concatenation arguments must be evaluated in order too. */
13895       ret = force_evaluation_order (ret);
13896       /* Restore it at its previous value */
13897       ctxp->explicit_constructor_p = saved;
13898       return ret;
13899     }
13900   return NULL_TREE;
13901 }
13902
13903 /* Build the internal representation of a string constant.  */
13904
13905 static tree
13906 patch_string_cst (tree node)
13907 {
13908   int location;
13909   if (! flag_emit_class_files)
13910     {
13911       node = get_identifier (TREE_STRING_POINTER (node));
13912       location = alloc_name_constant (CONSTANT_String, node);
13913       node = build_ref_from_constant_pool (location);
13914     }
13915   TREE_TYPE (node) = string_ptr_type_node;
13916   TREE_CONSTANT (node) = 1;
13917   return node;
13918 }
13919
13920 /* Build an incomplete unary operator expression. */
13921
13922 static tree
13923 build_unaryop (int op_token, int op_location, tree op1)
13924 {
13925   enum tree_code op;
13926   tree unaryop;
13927   switch (op_token)
13928     {
13929     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13930     case MINUS_TK: op = NEGATE_EXPR; break;
13931     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13932     case NOT_TK: op = BIT_NOT_EXPR; break;
13933     default: abort ();
13934     }
13935
13936   unaryop = build1 (op, NULL_TREE, op1);
13937   TREE_SIDE_EFFECTS (unaryop) = 1;
13938   /* Store the location of the operator, for better error report. The
13939      string of the operator will be rebuild based on the OP value. */
13940   EXPR_WFL_LINECOL (unaryop) = op_location;
13941   return unaryop;
13942 }
13943
13944 /* Special case for the ++/-- operators, since they require an extra
13945    argument to build, which is set to NULL and patched
13946    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13947
13948 static tree
13949 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13950 {
13951   static const enum tree_code lookup [2][2] =
13952     {
13953       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13954       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13955     };
13956   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13957                      NULL_TREE, op1, NULL_TREE);
13958   TREE_SIDE_EFFECTS (node) = 1;
13959   /* Store the location of the operator, for better error report. The
13960      string of the operator will be rebuild based on the OP value. */
13961   EXPR_WFL_LINECOL (node) = op_location;
13962   return node;
13963 }
13964
13965 /* Build an incomplete cast operator, based on the use of the
13966    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13967    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13968    though its type is already set.  */
13969
13970 static tree
13971 build_cast (int location, tree type, tree exp)
13972 {
13973   tree node = build1 (CONVERT_EXPR, type, exp);
13974   EXPR_WFL_LINECOL (node) = location;
13975   return node;
13976 }
13977
13978 /* Build an incomplete class reference operator.  */
13979 static tree
13980 build_incomplete_class_ref (int location, tree class_name)
13981 {
13982   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13983   tree class_decl = GET_CPC ();
13984   tree this_class = TREE_TYPE (class_decl);
13985
13986   /* Generate the synthetic static method `class$'.  (Previously we
13987      deferred this, causing different method tables to be emitted
13988      for native code and bytecode.)  */
13989   if (!TYPE_DOT_CLASS (this_class)
13990       && !JPRIMITIVE_TYPE_P (class_name)
13991       && !(TREE_CODE (class_name) == VOID_TYPE))
13992     {
13993       tree target_class;
13994
13995       if (CLASS_INTERFACE (TYPE_NAME (this_class)))
13996         {
13997           /* For interfaces, adding a static 'class$' method directly
13998              is illegal.  So create an inner class to contain the new
13999              method.  Empirically this matches the behavior of javac.  */
14000           tree t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
14001           tree inner = create_anonymous_class (0, t);
14002           target_class = TREE_TYPE (inner);
14003           end_class_declaration (1);
14004         }
14005       else
14006         {
14007           /* For inner classes, add a 'class$' method to their outermost
14008              context, creating it if necessary.  */
14009           while (INNER_CLASS_DECL_P (class_decl))
14010             class_decl = DECL_CONTEXT (class_decl);
14011           target_class = TREE_TYPE (class_decl);
14012         }
14013
14014       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14015         build_dot_class_method (target_class);
14016
14017       if (this_class != target_class)
14018         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14019     }
14020
14021   EXPR_WFL_LINECOL (node) = location;
14022   return node;
14023 }
14024
14025 /* Complete an incomplete class reference operator.  */
14026 static tree
14027 patch_incomplete_class_ref (tree node)
14028 {
14029   tree type = TREE_OPERAND (node, 0);
14030   tree ref_type;
14031
14032   if (!(ref_type = resolve_type_during_patch (type)))
14033     return error_mark_node;
14034
14035   /* If we're not emitting class files and we know ref_type is a
14036      compiled class, build a direct reference.  */
14037   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14038       || JPRIMITIVE_TYPE_P (ref_type)
14039       || TREE_CODE (ref_type) == VOID_TYPE)
14040     {
14041       tree dot = build_class_ref (ref_type);
14042       /* A class referenced by `foo.class' is initialized.  */
14043       if (!flag_emit_class_files)
14044        dot = build_class_init (ref_type, dot);
14045       return java_complete_tree (dot);
14046     }
14047
14048   /* If we're emitting class files and we have to deal with non
14049      primitive types, we invoke the synthetic static method `class$'.  */
14050   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14051   return java_complete_tree (ref_type);
14052 }
14053
14054 /* 15.14 Unary operators. We return error_mark_node in case of error,
14055    but preserve the type of NODE if the type is fixed.  */
14056
14057 static tree
14058 patch_unaryop (tree node, tree wfl_op)
14059 {
14060   tree op = TREE_OPERAND (node, 0);
14061   tree op_type = TREE_TYPE (op);
14062   tree prom_type = NULL_TREE, value, decl;
14063   int outer_field_flag = 0;
14064   int code = TREE_CODE (node);
14065   int error_found = 0;
14066
14067   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14068
14069   switch (code)
14070     {
14071       /* 15.13.2 Postfix Increment Operator ++ */
14072     case POSTINCREMENT_EXPR:
14073       /* 15.13.3 Postfix Increment Operator -- */
14074     case POSTDECREMENT_EXPR:
14075       /* 15.14.1 Prefix Increment Operator ++ */
14076     case PREINCREMENT_EXPR:
14077       /* 15.14.2 Prefix Decrement Operator -- */
14078     case PREDECREMENT_EXPR:
14079       op = decl = strip_out_static_field_access_decl (op);
14080       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14081       /* We might be trying to change an outer field accessed using
14082          access method. */
14083       if (outer_field_flag)
14084         {
14085           /* Retrieve the decl of the field we're trying to access. We
14086              do that by first retrieving the function we would call to
14087              access the field. It has been already verified that this
14088              field isn't final */
14089           if (flag_emit_class_files)
14090             decl = TREE_OPERAND (op, 0);
14091           else
14092             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14093           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14094         }
14095       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14096       else if (!JDECL_P (decl)
14097           && TREE_CODE (decl) != COMPONENT_REF
14098           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14099           && TREE_CODE (decl) != INDIRECT_REF
14100           && !(TREE_CODE (decl) == COMPOUND_EXPR
14101                && TREE_OPERAND (decl, 1)
14102                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14103         {
14104           TREE_TYPE (node) = error_mark_node;
14105           error_found = 1;
14106         }
14107
14108       /* From now on, we know that op if a variable and that it has a
14109          valid wfl. We use wfl_op to locate errors related to the
14110          ++/-- operand. */
14111       if (!JNUMERIC_TYPE_P (op_type))
14112         {
14113           parse_error_context
14114             (wfl_op, "Invalid argument type `%s' to `%s'",
14115              lang_printable_name (op_type, 0), operator_string (node));
14116           TREE_TYPE (node) = error_mark_node;
14117           error_found = 1;
14118         }
14119       else
14120         {
14121           /* Before the addition, binary numeric promotion is performed on
14122              both operands, if really necessary */
14123           if (JINTEGRAL_TYPE_P (op_type))
14124             {
14125               value = build_int_2 (1, 0);
14126               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14127             }
14128           else
14129             {
14130               value = build_int_2 (1, 0);
14131               TREE_TYPE (node) =
14132                 binary_numeric_promotion (op_type,
14133                                           TREE_TYPE (value), &op, &value);
14134             }
14135
14136           /* We remember we might be accessing an outer field */
14137           if (outer_field_flag)
14138             {
14139               /* We re-generate an access to the field */
14140               value = build (PLUS_EXPR, TREE_TYPE (op),
14141                              build_outer_field_access (wfl_op, decl), value);
14142
14143               /* And we patch the original access$() into a write
14144                  with plus_op as a rhs */
14145               return outer_field_access_fix (node, op, value);
14146             }
14147
14148           /* And write back into the node. */
14149           TREE_OPERAND (node, 0) = op;
14150           TREE_OPERAND (node, 1) = value;
14151           /* Convert the overall back into its original type, if
14152              necessary, and return */
14153           if (JINTEGRAL_TYPE_P (op_type))
14154             return fold (node);
14155           else
14156             return fold (convert (op_type, node));
14157         }
14158       break;
14159
14160       /* 15.14.3 Unary Plus Operator + */
14161     case UNARY_PLUS_EXPR:
14162       /* 15.14.4 Unary Minus Operator - */
14163     case NEGATE_EXPR:
14164       if (!JNUMERIC_TYPE_P (op_type))
14165         {
14166           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14167           TREE_TYPE (node) = error_mark_node;
14168           error_found = 1;
14169         }
14170       /* Unary numeric promotion is performed on operand */
14171       else
14172         {
14173           op = do_unary_numeric_promotion (op);
14174           prom_type = TREE_TYPE (op);
14175           if (code == UNARY_PLUS_EXPR)
14176             return fold (op);
14177         }
14178       break;
14179
14180       /* 15.14.5 Bitwise Complement Operator ~ */
14181     case BIT_NOT_EXPR:
14182       if (!JINTEGRAL_TYPE_P (op_type))
14183         {
14184           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14185           TREE_TYPE (node) = error_mark_node;
14186           error_found = 1;
14187         }
14188       else
14189         {
14190           op = do_unary_numeric_promotion (op);
14191           prom_type = TREE_TYPE (op);
14192         }
14193       break;
14194
14195       /* 15.14.6 Logical Complement Operator ! */
14196     case TRUTH_NOT_EXPR:
14197       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14198         {
14199           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14200           /* But the type is known. We will report an error if further
14201              attempt of a assignment is made with this rhs */
14202           TREE_TYPE (node) = boolean_type_node;
14203           error_found = 1;
14204         }
14205       else
14206         prom_type = boolean_type_node;
14207       break;
14208
14209       /* 15.15 Cast Expression */
14210     case CONVERT_EXPR:
14211       value = patch_cast (node, wfl_operator);
14212       if (value == error_mark_node)
14213         {
14214           /* If this cast is part of an assignment, we tell the code
14215              that deals with it not to complain about a mismatch,
14216              because things have been cast, anyways */
14217           TREE_TYPE (node) = error_mark_node;
14218           error_found = 1;
14219         }
14220       else
14221         {
14222           value = fold (value);
14223           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14224           return value;
14225         }
14226       break;
14227     }
14228
14229   if (error_found)
14230     return error_mark_node;
14231
14232   /* There are cases where node has been replaced by something else
14233      and we don't end up returning here: UNARY_PLUS_EXPR,
14234      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14235   TREE_OPERAND (node, 0) = fold (op);
14236   TREE_TYPE (node) = prom_type;
14237   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14238   return fold (node);
14239 }
14240
14241 /* Generic type resolution that sometimes takes place during node
14242    patching. Returned the resolved type or generate an error
14243    message. Return the resolved type or NULL_TREE.  */
14244
14245 static tree
14246 resolve_type_during_patch (tree type)
14247 {
14248   if (unresolved_type_p (type, NULL))
14249     {
14250       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14251       if (!type_decl)
14252         {
14253           parse_error_context (type,
14254                                "Class `%s' not found in type declaration",
14255                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14256           return NULL_TREE;
14257         }
14258
14259       check_deprecation (type, type_decl);
14260
14261       return TREE_TYPE (type_decl);
14262     }
14263   return type;
14264 }
14265
14266 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14267    found. Otherwise NODE or something meant to replace it is returned.  */
14268
14269 static tree
14270 patch_cast (tree node, tree wfl_op)
14271 {
14272   tree op = TREE_OPERAND (node, 0);
14273   tree cast_type = TREE_TYPE (node);
14274   tree patched, op_type;
14275   char *t1;
14276
14277   /* Some string patching might be necessary at this stage */
14278   if ((patched = patch_string (op)))
14279     TREE_OPERAND (node, 0) = op = patched;
14280   op_type = TREE_TYPE (op);
14281
14282   /* First resolve OP_TYPE if unresolved */
14283   if (!(cast_type = resolve_type_during_patch (cast_type)))
14284     return error_mark_node;
14285
14286   /* Check on cast that are proven correct at compile time */
14287   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14288     {
14289       /* Same type */
14290       if (cast_type == op_type)
14291         return node;
14292
14293       /* A narrowing conversion from a floating-point number to an
14294          integral type requires special handling (5.1.3).  */
14295       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14296         if (cast_type != long_type_node)
14297           op = convert (integer_type_node, op);
14298
14299       /* Try widening/narrowing conversion.  Potentially, things need
14300          to be worked out in gcc so we implement the extreme cases
14301          correctly.  fold_convert() needs to be fixed.  */
14302       return convert (cast_type, op);
14303     }
14304
14305   /* It's also valid to cast a boolean into a boolean */
14306   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14307     return node;
14308
14309   /* null can be casted to references */
14310   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14311     return build_null_of_type (cast_type);
14312
14313   /* The remaining legal casts involve conversion between reference
14314      types. Check for their compile time correctness. */
14315   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14316       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14317     {
14318       TREE_TYPE (node) = promote_type (cast_type);
14319       /* Now, the case can be determined correct at compile time if
14320          OP_TYPE can be converted into CAST_TYPE by assignment
14321          conversion (5.2) */
14322
14323       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14324         {
14325           TREE_SET_CODE (node, NOP_EXPR);
14326           return node;
14327         }
14328
14329       if (flag_emit_class_files)
14330         {
14331           TREE_SET_CODE (node, CONVERT_EXPR);
14332           return node;
14333         }
14334
14335       /* The cast requires a run-time check */
14336       return build (CALL_EXPR, promote_type (cast_type),
14337                     build_address_of (soft_checkcast_node),
14338                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14339                                build_tree_list (NULL_TREE, op)),
14340                     NULL_TREE);
14341     }
14342
14343   /* Any other casts are proven incorrect at compile time */
14344   t1 = xstrdup (lang_printable_name (op_type, 0));
14345   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14346                        t1, lang_printable_name (cast_type, 0));
14347   free (t1);
14348   return error_mark_node;
14349 }
14350
14351 /* Build a null constant and give it the type TYPE.  */
14352
14353 static tree
14354 build_null_of_type (tree type)
14355 {
14356   tree node = build_int_2 (0, 0);
14357   TREE_TYPE (node) = promote_type (type);
14358   return node;
14359 }
14360
14361 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14362    a list of indices. */
14363 static tree
14364 build_array_ref (int location, tree array, tree index)
14365 {
14366   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14367   EXPR_WFL_LINECOL (node) = location;
14368   return node;
14369 }
14370
14371 /* 15.12 Array Access Expression */
14372
14373 static tree
14374 patch_array_ref (tree node)
14375 {
14376   tree array = TREE_OPERAND (node, 0);
14377   tree array_type  = TREE_TYPE (array);
14378   tree index = TREE_OPERAND (node, 1);
14379   tree index_type = TREE_TYPE (index);
14380   int error_found = 0;
14381
14382   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14383
14384   if (TREE_CODE (array_type) == POINTER_TYPE)
14385     array_type = TREE_TYPE (array_type);
14386
14387   /* The array reference must be an array */
14388   if (!TYPE_ARRAY_P (array_type))
14389     {
14390       parse_error_context
14391         (wfl_operator,
14392          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14393          lang_printable_name (array_type, 0));
14394       TREE_TYPE (node) = error_mark_node;
14395       error_found = 1;
14396     }
14397
14398   /* The array index undergoes unary numeric promotion. The promoted
14399      type must be int */
14400   index = do_unary_numeric_promotion (index);
14401   if (TREE_TYPE (index) != int_type_node)
14402     {
14403       if (valid_cast_to_p (index_type, int_type_node))
14404         parse_error_context (wfl_operator,
14405    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14406                              lang_printable_name (index_type, 0));
14407       else
14408         parse_error_context (wfl_operator,
14409           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14410                              lang_printable_name (index_type, 0));
14411       TREE_TYPE (node) = error_mark_node;
14412       error_found = 1;
14413     }
14414
14415   if (error_found)
14416     return error_mark_node;
14417
14418   array_type = TYPE_ARRAY_ELEMENT (array_type);
14419
14420   if (flag_emit_class_files || flag_emit_xref)
14421     {
14422       TREE_OPERAND (node, 0) = array;
14423       TREE_OPERAND (node, 1) = index;
14424     }
14425   else
14426     node = build_java_arrayaccess (array, array_type, index);
14427   TREE_TYPE (node) = array_type;
14428   return node;
14429 }
14430
14431 /* 15.9 Array Creation Expressions */
14432
14433 static tree
14434 build_newarray_node (tree type, tree dims, int extra_dims)
14435 {
14436   tree node =
14437     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14438            build_int_2 (extra_dims, 0));
14439   return node;
14440 }
14441
14442 static tree
14443 patch_newarray (tree node)
14444 {
14445   tree type = TREE_OPERAND (node, 0);
14446   tree dims = TREE_OPERAND (node, 1);
14447   tree cdim, array_type;
14448   int error_found = 0;
14449   int ndims = 0;
14450   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14451
14452   /* Dimension types are verified. It's better for the types to be
14453      verified in order. */
14454   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14455     {
14456       int dim_error = 0;
14457       tree dim = TREE_VALUE (cdim);
14458
14459       /* Dim might have been saved during its evaluation */
14460       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14461
14462       /* The type of each specified dimension must be an integral type. */
14463       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14464         dim_error = 1;
14465
14466       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14467          promoted type must be int. */
14468       else
14469         {
14470           dim = do_unary_numeric_promotion (dim);
14471           if (TREE_TYPE (dim) != int_type_node)
14472             dim_error = 1;
14473         }
14474
14475       /* Report errors on types here */
14476       if (dim_error)
14477         {
14478           parse_error_context
14479             (TREE_PURPOSE (cdim),
14480              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14481              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14482               "Explicit cast needed to" : "Can't"),
14483              lang_printable_name (TREE_TYPE (dim), 0));
14484           error_found = 1;
14485         }
14486
14487       TREE_PURPOSE (cdim) = NULL_TREE;
14488     }
14489
14490   /* Resolve array base type if unresolved */
14491   if (!(type = resolve_type_during_patch (type)))
14492     error_found = 1;
14493
14494   if (error_found)
14495     {
14496       /* We don't want further evaluation of this bogus array creation
14497          operation */
14498       TREE_TYPE (node) = error_mark_node;
14499       return error_mark_node;
14500     }
14501
14502   /* Set array_type to the actual (promoted) array type of the result. */
14503   if (TREE_CODE (type) == RECORD_TYPE)
14504     type = build_pointer_type (type);
14505   while (--xdims >= 0)
14506     {
14507       type = promote_type (build_java_array_type (type, -1));
14508     }
14509   dims = nreverse (dims);
14510   array_type = type;
14511   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14512     {
14513       type = array_type;
14514       array_type
14515         = build_java_array_type (type,
14516                                  TREE_CODE (cdim) == INTEGER_CST
14517                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14518                                  : -1);
14519       array_type = promote_type (array_type);
14520     }
14521   dims = nreverse (dims);
14522
14523   /* The node is transformed into a function call. Things are done
14524      differently according to the number of dimensions. If the number
14525      of dimension is equal to 1, then the nature of the base type
14526      (primitive or not) matters. */
14527   if (ndims == 1)
14528     return build_new_array (type, TREE_VALUE (dims));
14529
14530   /* Can't reuse what's already written in expr.c because it uses the
14531      JVM stack representation. Provide a build_multianewarray. FIXME */
14532   return build (CALL_EXPR, array_type,
14533                 build_address_of (soft_multianewarray_node),
14534                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14535                            tree_cons (NULL_TREE,
14536                                       build_int_2 (ndims, 0), dims )),
14537                 NULL_TREE);
14538 }
14539
14540 /* 10.6 Array initializer.  */
14541
14542 /* Build a wfl for array element that don't have one, so we can
14543    pin-point errors.  */
14544
14545 static tree
14546 maybe_build_array_element_wfl (tree node)
14547 {
14548   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14549     return build_expr_wfl (NULL_TREE, ctxp->filename,
14550                            ctxp->elc.line, ctxp->elc.prev_col);
14551   else
14552     return NULL_TREE;
14553 }
14554
14555 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14556    identification of initialized arrays easier to detect during walk
14557    and expansion.  */
14558
14559 static tree
14560 build_new_array_init (int location, tree values)
14561 {
14562   tree constructor = build_constructor (NULL_TREE, values);
14563   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14564   EXPR_WFL_LINECOL (to_return) = location;
14565   return to_return;
14566 }
14567
14568 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14569    occurred.  Otherwise return NODE after having set its type
14570    appropriately.  */
14571
14572 static tree
14573 patch_new_array_init (tree type, tree node)
14574 {
14575   int error_seen = 0;
14576   tree current, element_type;
14577   HOST_WIDE_INT length;
14578   int all_constant = 1;
14579   tree init = TREE_OPERAND (node, 0);
14580
14581   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14582     {
14583       parse_error_context (node,
14584                            "Invalid array initializer for non-array type `%s'",
14585                            lang_printable_name (type, 1));
14586       return error_mark_node;
14587     }
14588   type = TREE_TYPE (type);
14589   element_type = TYPE_ARRAY_ELEMENT (type);
14590
14591   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14592
14593   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14594        current;  length++, current = TREE_CHAIN (current))
14595     {
14596       tree elt = TREE_VALUE (current);
14597       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14598         {
14599           error_seen |= array_constructor_check_entry (element_type, current);
14600           elt = TREE_VALUE (current);
14601           /* When compiling to native code, STRING_CST is converted to
14602              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14603           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14604             all_constant = 0;
14605         }
14606       else
14607         {
14608           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14609           TREE_PURPOSE (current) = NULL_TREE;
14610           all_constant = 0;
14611         }
14612       if (elt && TREE_CODE (elt) == TREE_LIST
14613           && TREE_VALUE (elt) == error_mark_node)
14614         error_seen = 1;
14615     }
14616
14617   if (error_seen)
14618     return error_mark_node;
14619
14620   /* Create a new type. We can't reuse the one we have here by
14621      patching its dimension because it originally is of dimension -1
14622      hence reused by gcc. This would prevent triangular arrays. */
14623   type = build_java_array_type (element_type, length);
14624   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14625   TREE_TYPE (node) = promote_type (type);
14626   TREE_CONSTANT (init) = all_constant;
14627   TREE_CONSTANT (node) = all_constant;
14628   return node;
14629 }
14630
14631 /* Verify that one entry of the initializer element list can be
14632    assigned to the array base type. Report 1 if an error occurred, 0
14633    otherwise.  */
14634
14635 static int
14636 array_constructor_check_entry (tree type, tree entry)
14637 {
14638   char *array_type_string = NULL;       /* For error reports */
14639   tree value, type_value, new_value, wfl_value, patched;
14640   int error_seen = 0;
14641
14642   new_value = NULL_TREE;
14643   wfl_value = TREE_VALUE (entry);
14644
14645   value = java_complete_tree (TREE_VALUE (entry));
14646   /* patch_string return error_mark_node if arg is error_mark_node */
14647   if ((patched = patch_string (value)))
14648     value = patched;
14649   if (value == error_mark_node)
14650     return 1;
14651
14652   type_value = TREE_TYPE (value);
14653
14654   /* At anytime, try_builtin_assignconv can report a warning on
14655      constant overflow during narrowing. */
14656   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14657   new_value = try_builtin_assignconv (wfl_operator, type, value);
14658   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14659     type_value = promote_type (type);
14660
14661   /* Check and report errors */
14662   if (!new_value)
14663     {
14664       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14665                    "Can't" : "Explicit cast needed to");
14666       if (!array_type_string)
14667         array_type_string = xstrdup (lang_printable_name (type, 1));
14668       parse_error_context
14669         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14670          msg, lang_printable_name (type_value, 1), array_type_string);
14671       error_seen = 1;
14672     }
14673
14674   if (new_value)
14675     TREE_VALUE (entry) = new_value;
14676
14677   if (array_type_string)
14678     free (array_type_string);
14679
14680   TREE_PURPOSE (entry) = NULL_TREE;
14681   return error_seen;
14682 }
14683
14684 static tree
14685 build_this (int location)
14686 {
14687   tree node = build_wfl_node (this_identifier_node);
14688   TREE_SET_CODE (node, THIS_EXPR);
14689   EXPR_WFL_LINECOL (node) = location;
14690   return node;
14691 }
14692
14693 /* 14.15 The return statement. It builds a modify expression that
14694    assigns the returned value to the RESULT_DECL that hold the value
14695    to be returned. */
14696
14697 static tree
14698 build_return (int location, tree op)
14699 {
14700   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14701   EXPR_WFL_LINECOL (node) = location;
14702   node = build_debugable_stmt (location, node);
14703   return node;
14704 }
14705
14706 static tree
14707 patch_return (tree node)
14708 {
14709   tree return_exp = TREE_OPERAND (node, 0);
14710   tree meth = current_function_decl;
14711   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14712   int error_found = 0;
14713
14714   TREE_TYPE (node) = error_mark_node;
14715   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14716
14717   /* It's invalid to have a return value within a function that is
14718      declared with the keyword void or that is a constructor */
14719   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14720     error_found = 1;
14721
14722   /* It's invalid to use a return statement in a static block */
14723   if (DECL_CLINIT_P (current_function_decl))
14724     error_found = 1;
14725
14726   /* It's invalid to have a no return value within a function that
14727      isn't declared with the keyword `void' */
14728   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14729     error_found = 2;
14730
14731   if (DECL_INSTINIT_P (current_function_decl))
14732     error_found = 1;
14733
14734   if (error_found)
14735     {
14736       if (DECL_INSTINIT_P (current_function_decl))
14737         parse_error_context (wfl_operator,
14738                              "`return' inside instance initializer");
14739
14740       else if (DECL_CLINIT_P (current_function_decl))
14741         parse_error_context (wfl_operator,
14742                              "`return' inside static initializer");
14743
14744       else if (!DECL_CONSTRUCTOR_P (meth))
14745         {
14746           char *t = xstrdup (lang_printable_name (mtype, 0));
14747           parse_error_context (wfl_operator,
14748                                "`return' with%s value from `%s %s'",
14749                                (error_found == 1 ? "" : "out"),
14750                                t, lang_printable_name (meth, 0));
14751           free (t);
14752         }
14753       else
14754         parse_error_context (wfl_operator,
14755                              "`return' with value from constructor `%s'",
14756                              lang_printable_name (meth, 0));
14757       return error_mark_node;
14758     }
14759
14760   /* If we have a return_exp, build a modify expression and expand
14761      it. Note: at that point, the assignment is declared valid, but we
14762      may want to carry some more hacks */
14763   if (return_exp)
14764     {
14765       tree exp = java_complete_tree (return_exp);
14766       tree modify, patched;
14767
14768       if ((patched = patch_string (exp)))
14769         exp = patched;
14770
14771       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14772       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14773       modify = java_complete_tree (modify);
14774
14775       if (modify != error_mark_node)
14776         {
14777           TREE_SIDE_EFFECTS (modify) = 1;
14778           TREE_OPERAND (node, 0) = modify;
14779         }
14780       else
14781         return error_mark_node;
14782     }
14783   TREE_TYPE (node) = void_type_node;
14784   TREE_SIDE_EFFECTS (node) = 1;
14785   return node;
14786 }
14787
14788 /* 14.8 The if Statement */
14789
14790 static tree
14791 build_if_else_statement (int location, tree expression, tree if_body,
14792                          tree else_body)
14793 {
14794   tree node;
14795   if (!else_body)
14796     else_body = empty_stmt_node;
14797   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14798   EXPR_WFL_LINECOL (node) = location;
14799   node = build_debugable_stmt (location, node);
14800   return node;
14801 }
14802
14803 static tree
14804 patch_if_else_statement (tree node)
14805 {
14806   tree expression = TREE_OPERAND (node, 0);
14807   int can_complete_normally
14808     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14809        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14810
14811   TREE_TYPE (node) = error_mark_node;
14812   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14813
14814   /* The type of expression must be boolean */
14815   if (TREE_TYPE (expression) != boolean_type_node
14816       && TREE_TYPE (expression) != promoted_boolean_type_node)
14817     {
14818       parse_error_context
14819         (wfl_operator,
14820          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14821          lang_printable_name (TREE_TYPE (expression), 0));
14822       return error_mark_node;
14823     }
14824
14825   if (TREE_CODE (expression) == INTEGER_CST)
14826     {
14827       if (integer_zerop (expression))
14828         node = TREE_OPERAND (node, 2);
14829       else
14830         node = TREE_OPERAND (node, 1);
14831       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14832         {
14833           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14834           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14835         }
14836       return node;
14837     }
14838   TREE_TYPE (node) = void_type_node;
14839   TREE_SIDE_EFFECTS (node) = 1;
14840   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14841   return node;
14842 }
14843
14844 /* 14.6 Labeled Statements */
14845
14846 /* Action taken when a labeled statement is parsed. a new
14847    LABELED_BLOCK_EXPR is created. No statement is attached to the
14848    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14849
14850 static tree
14851 build_labeled_block (int location, tree label)
14852 {
14853   tree label_name ;
14854   tree label_decl, node;
14855   if (label == NULL_TREE || label == continue_identifier_node)
14856     label_name = label;
14857   else
14858     {
14859       label_name = merge_qualified_name (label_id, label);
14860       /* Issue an error if we try to reuse a label that was previously
14861          declared */
14862       if (IDENTIFIER_LOCAL_VALUE (label_name))
14863         {
14864           EXPR_WFL_LINECOL (wfl_operator) = location;
14865           parse_error_context (wfl_operator,
14866             "Declaration of `%s' shadows a previous label declaration",
14867                                IDENTIFIER_POINTER (label));
14868           EXPR_WFL_LINECOL (wfl_operator) =
14869             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14870           parse_error_context (wfl_operator,
14871             "This is the location of the previous declaration of label `%s'",
14872                                IDENTIFIER_POINTER (label));
14873           java_error_count--;
14874         }
14875     }
14876
14877   label_decl = create_label_decl (label_name);
14878   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14879   EXPR_WFL_LINECOL (node) = location;
14880   TREE_SIDE_EFFECTS (node) = 1;
14881   return node;
14882 }
14883
14884 /* A labeled statement LBE is attached a statement.  */
14885
14886 static tree
14887 finish_labeled_statement (tree lbe, /* Labeled block expr */
14888                           tree statement)
14889 {
14890   /* In anyways, tie the loop to its statement */
14891   LABELED_BLOCK_BODY (lbe) = statement;
14892   pop_labeled_block ();
14893   POP_LABELED_BLOCK ();
14894   return lbe;
14895 }
14896
14897 /* 14.10, 14.11, 14.12 Loop Statements */
14898
14899 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14900    list. */
14901
14902 static tree
14903 build_new_loop (tree loop_body)
14904 {
14905   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14906   TREE_SIDE_EFFECTS (loop) = 1;
14907   PUSH_LOOP (loop);
14908   return loop;
14909 }
14910
14911 /* Create a loop body according to the following structure:
14912      COMPOUND_EXPR
14913        COMPOUND_EXPR            (loop main body)
14914          EXIT_EXPR              (this order is for while/for loops.
14915          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14916            LABEL_DECL           (a continue occurring here branches at the
14917            BODY                  end of this labeled block)
14918        INCREMENT                (if any)
14919
14920   REVERSED, if nonzero, tells that the loop condition expr comes
14921   after the body, like in the do-while loop.
14922
14923   To obtain a loop, the loop body structure described above is
14924   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14925
14926    LABELED_BLOCK_EXPR
14927      LABEL_DECL                   (use this label to exit the loop)
14928      LOOP_EXPR
14929        <structure described above> */
14930
14931 static tree
14932 build_loop_body (int location, tree condition, int reversed)
14933 {
14934   tree first, second, body;
14935
14936   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14937   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14938   condition = build_debugable_stmt (location, condition);
14939   TREE_SIDE_EFFECTS (condition) = 1;
14940
14941   body = build_labeled_block (0, continue_identifier_node);
14942   first = (reversed ? body : condition);
14943   second = (reversed ? condition : body);
14944   return
14945     build (COMPOUND_EXPR, NULL_TREE,
14946            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14947 }
14948
14949 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14950    their order) on the current loop. Unlink the current loop from the
14951    loop list.  */
14952
14953 static tree
14954 finish_loop_body (int location, tree condition, tree body, int reversed)
14955 {
14956   tree to_return = ctxp->current_loop;
14957   tree loop_body = LOOP_EXPR_BODY (to_return);
14958   if (condition)
14959     {
14960       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14961       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14962          The real EXIT_EXPR is one operand further. */
14963       EXPR_WFL_LINECOL (cnode) = location;
14964       /* This one is for accurate error reports */
14965       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14966       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14967     }
14968   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14969   POP_LOOP ();
14970   return to_return;
14971 }
14972
14973 /* Tailored version of finish_loop_body for FOR loops, when FOR
14974    loops feature the condition part */
14975
14976 static tree
14977 finish_for_loop (int location, tree condition, tree update, tree body)
14978 {
14979   /* Put the condition and the loop body in place */
14980   tree loop = finish_loop_body (location, condition, body, 0);
14981   /* LOOP is the current loop which has been now popped of the loop
14982      stack.  Mark the update block as reachable and install it.  We do
14983      this because the (current interpretation of the) JLS requires
14984      that the update expression be considered reachable even if the
14985      for loop's body doesn't complete normally.  */
14986   if (update != NULL_TREE && update != empty_stmt_node)
14987     {
14988       tree up2 = update;
14989       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14990         up2 = EXPR_WFL_NODE (up2);
14991       /* It is possible for the update expression to be an
14992          EXPR_WFL_NODE wrapping nothing.  */
14993       if (up2 != NULL_TREE && up2 != empty_stmt_node)
14994         {
14995           /* Try to detect constraint violations.  These would be
14996              programming errors somewhere.  */
14997           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14998               || TREE_CODE (up2) == LOOP_EXPR)
14999             abort ();
15000           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15001         }
15002     }
15003   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15004   return loop;
15005 }
15006
15007 /* Try to find the loop a block might be related to. This comprises
15008    the case where the LOOP_EXPR is found as the second operand of a
15009    COMPOUND_EXPR, because the loop happens to have an initialization
15010    part, then expressed as the first operand of the COMPOUND_EXPR. If
15011    the search finds something, 1 is returned. Otherwise, 0 is
15012    returned. The search is assumed to start from a
15013    LABELED_BLOCK_EXPR's block.  */
15014
15015 static tree
15016 search_loop (tree statement)
15017 {
15018   if (TREE_CODE (statement) == LOOP_EXPR)
15019     return statement;
15020
15021   if (TREE_CODE (statement) == BLOCK)
15022     statement = BLOCK_SUBBLOCKS (statement);
15023   else
15024     return NULL_TREE;
15025
15026   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15027     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15028       statement = TREE_OPERAND (statement, 1);
15029
15030   return (TREE_CODE (statement) == LOOP_EXPR
15031           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15032 }
15033
15034 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15035    returned otherwise.  */
15036
15037 static int
15038 labeled_block_contains_loop_p (tree block, tree loop)
15039 {
15040   if (!block)
15041     return 0;
15042
15043   if (LABELED_BLOCK_BODY (block) == loop)
15044     return 1;
15045
15046   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15047     return 1;
15048
15049   return 0;
15050 }
15051
15052 /* If the loop isn't surrounded by a labeled statement, create one and
15053    insert LOOP as its body.  */
15054
15055 static tree
15056 patch_loop_statement (tree loop)
15057 {
15058   tree loop_label;
15059
15060   TREE_TYPE (loop) = void_type_node;
15061   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15062     return loop;
15063
15064   loop_label = build_labeled_block (0, NULL_TREE);
15065   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15066      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15067   LABELED_BLOCK_BODY (loop_label) = loop;
15068   PUSH_LABELED_BLOCK (loop_label);
15069   return loop_label;
15070 }
15071
15072 /* 14.13, 14.14: break and continue Statements */
15073
15074 /* Build a break or a continue statement. a null NAME indicates an
15075    unlabeled break/continue statement.  */
15076
15077 static tree
15078 build_bc_statement (int location, int is_break, tree name)
15079 {
15080   tree break_continue, label_block_expr = NULL_TREE;
15081
15082   if (name)
15083     {
15084       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15085             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15086         /* Null means that we don't have a target for this named
15087            break/continue. In this case, we make the target to be the
15088            label name, so that the error can be reported accurately in
15089            patch_bc_statement. */
15090         label_block_expr = EXPR_WFL_NODE (name);
15091     }
15092   /* Unlabeled break/continue will be handled during the
15093      break/continue patch operation */
15094   break_continue
15095     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15096
15097   IS_BREAK_STMT_P (break_continue) = is_break;
15098   TREE_SIDE_EFFECTS (break_continue) = 1;
15099   EXPR_WFL_LINECOL (break_continue) = location;
15100   break_continue = build_debugable_stmt (location, break_continue);
15101   return break_continue;
15102 }
15103
15104 /* Verification of a break/continue statement. */
15105
15106 static tree
15107 patch_bc_statement (tree node)
15108 {
15109   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15110   tree labeled_block = ctxp->current_labeled_block;
15111   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15112
15113   /* Having an identifier here means that the target is unknown. */
15114   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15115     {
15116       parse_error_context (wfl_operator, "No label definition found for `%s'",
15117                            IDENTIFIER_POINTER (bc_label));
15118       return error_mark_node;
15119     }
15120   if (! IS_BREAK_STMT_P (node))
15121     {
15122       /* It's a continue statement. */
15123       for (;; labeled_block = TREE_CHAIN (labeled_block))
15124         {
15125           if (labeled_block == NULL_TREE)
15126             {
15127               if (bc_label == NULL_TREE)
15128                 parse_error_context (wfl_operator,
15129                                      "`continue' must be in loop");
15130               else
15131                 parse_error_context
15132                   (wfl_operator, "continue label `%s' does not name a loop",
15133                    IDENTIFIER_POINTER (bc_label));
15134               return error_mark_node;
15135             }
15136           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15137                == continue_identifier_node)
15138               && (bc_label == NULL_TREE
15139                   || TREE_CHAIN (labeled_block) == bc_label))
15140             {
15141               bc_label = labeled_block;
15142               break;
15143             }
15144         }
15145     }
15146   else if (!bc_label)
15147     {
15148       for (;; labeled_block = TREE_CHAIN (labeled_block))
15149         {
15150           if (labeled_block == NULL_TREE)
15151             {
15152               parse_error_context (wfl_operator,
15153                                      "`break' must be in loop or switch");
15154               return error_mark_node;
15155             }
15156           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15157           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15158               || search_loop (target_stmt))
15159             {
15160               bc_label = labeled_block;
15161               break;
15162             }
15163         }
15164     }
15165
15166   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15167   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15168
15169   /* Our break/continue don't return values. */
15170   TREE_TYPE (node) = void_type_node;
15171   /* Encapsulate the break within a compound statement so that it's
15172      expanded all the times by expand_expr (and not clobbered
15173      sometimes, like after a if statement) */
15174   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15175   TREE_SIDE_EFFECTS (node) = 1;
15176   return node;
15177 }
15178
15179 /* Process the exit expression belonging to a loop. Its type must be
15180    boolean.  */
15181
15182 static tree
15183 patch_exit_expr (tree node)
15184 {
15185   tree expression = TREE_OPERAND (node, 0);
15186   TREE_TYPE (node) = error_mark_node;
15187   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15188
15189   /* The type of expression must be boolean */
15190   if (TREE_TYPE (expression) != boolean_type_node)
15191     {
15192       parse_error_context
15193         (wfl_operator,
15194     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15195          lang_printable_name (TREE_TYPE (expression), 0));
15196       return error_mark_node;
15197     }
15198   /* Now we know things are allright, invert the condition, fold and
15199      return */
15200   TREE_OPERAND (node, 0) =
15201     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15202
15203   if (! integer_zerop (TREE_OPERAND (node, 0))
15204       && ctxp->current_loop != NULL_TREE
15205       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15206     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15207   if (! integer_onep (TREE_OPERAND (node, 0)))
15208     CAN_COMPLETE_NORMALLY (node) = 1;
15209
15210
15211   TREE_TYPE (node) = void_type_node;
15212   return node;
15213 }
15214
15215 /* 14.9 Switch statement */
15216
15217 static tree
15218 patch_switch_statement (tree node)
15219 {
15220   tree se = TREE_OPERAND (node, 0), se_type;
15221   tree save, iter;
15222
15223   /* Complete the switch expression */
15224   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15225   se_type = TREE_TYPE (se);
15226   /* The type of the switch expression must be char, byte, short or
15227      int */
15228   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15229     {
15230       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15231       parse_error_context (wfl_operator,
15232           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15233                            lang_printable_name (se_type, 0));
15234       /* This is what java_complete_tree will check */
15235       TREE_OPERAND (node, 0) = error_mark_node;
15236       return error_mark_node;
15237     }
15238
15239   /* Save and restore the outer case label list.  */
15240   save = case_label_list;
15241   case_label_list = NULL_TREE;
15242
15243   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15244
15245   /* See if we've found a duplicate label.  We can't leave this until
15246      code generation, because in `--syntax-only' and `-C' modes we
15247      don't do ordinary code generation.  */
15248   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15249     {
15250       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15251       tree subiter;
15252       for (subiter = TREE_CHAIN (iter);
15253            subiter != NULL_TREE;
15254            subiter = TREE_CHAIN (subiter))
15255         {
15256           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15257           if (val == subval)
15258             {
15259               EXPR_WFL_LINECOL (wfl_operator)
15260                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15261               /* The case_label_list is in reverse order, so print the
15262                  outer label first.  */
15263               parse_error_context (wfl_operator, "duplicate case label: `"
15264                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15265               EXPR_WFL_LINECOL (wfl_operator)
15266                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15267               parse_error_context (wfl_operator, "original label is here");
15268
15269               break;
15270             }
15271         }
15272     }
15273
15274   case_label_list = save;
15275
15276   /* Ready to return */
15277   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15278     {
15279       TREE_TYPE (node) = error_mark_node;
15280       return error_mark_node;
15281     }
15282   TREE_TYPE (node) = void_type_node;
15283   TREE_SIDE_EFFECTS (node) = 1;
15284   CAN_COMPLETE_NORMALLY (node)
15285     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15286       || ! SWITCH_HAS_DEFAULT (node);
15287   return node;
15288 }
15289
15290 /* Assertions.  */
15291
15292 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15293    might be NULL_TREE.  */
15294 static tree
15295 build_assertion (int location, tree condition, tree value)
15296 {
15297   tree node;
15298   tree klass = GET_CPC ();
15299
15300   if (! CLASS_USES_ASSERTIONS (klass))
15301     {
15302       tree field, classdollar, id, call;
15303       tree class_type = TREE_TYPE (klass);
15304
15305       field = add_field (class_type,
15306                          get_identifier ("$assertionsDisabled"),
15307                          boolean_type_node,
15308                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15309       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15310       FIELD_SYNTHETIC (field) = 1;
15311
15312       if (!TYPE_DOT_CLASS (class_type))
15313         build_dot_class_method (class_type);
15314       classdollar = build_dot_class_method_invocation (class_type, class_type);
15315
15316       /* Call CLASS.desiredAssertionStatus().  */
15317       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15318       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15319       call = make_qualified_primary (classdollar, call, location);
15320       TREE_SIDE_EFFECTS (call) = 1;
15321
15322       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15323          seem odd, but we do it to generate code identical to that of
15324          the JDK.  */
15325       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15326       TREE_SIDE_EFFECTS (call) = 1;
15327       DECL_INITIAL (field) = call;
15328
15329       /* Record the initializer in the initializer statement list.  */
15330       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15331       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15332       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15333       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15334
15335       CLASS_USES_ASSERTIONS (klass) = 1;
15336     }
15337
15338   if (value != NULL_TREE)
15339     value = tree_cons (NULL_TREE, value, NULL_TREE);
15340
15341   node = build_wfl_node (get_identifier ("java"));
15342   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15343                               location);
15344   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15345                               location);
15346
15347   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15348   TREE_SIDE_EFFECTS (node) = 1;
15349   /* It is too early to use BUILD_THROW.  */
15350   node = build1 (THROW_EXPR, NULL_TREE, node);
15351   TREE_SIDE_EFFECTS (node) = 1;
15352
15353   /* We invert the condition; if we just put NODE as the `else' part
15354      then we generate weird-looking bytecode.  */
15355   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15356   /* Check $assertionsDisabled.  */
15357   condition
15358     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15359              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15360                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15361              condition);
15362   node = build_if_else_statement (location, condition, node, NULL_TREE);
15363   return node;
15364 }
15365
15366 /* 14.18 The try/catch statements */
15367
15368 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15369    catches TYPE and executes CATCH_STMTS.  */
15370
15371 static tree
15372 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15373                             tree catch_stmts)
15374 {
15375   tree try_block, catch_clause_param, catch_block, catch;
15376
15377   /* First build a try block */
15378   try_block = build_expr_block (try_stmts, NULL_TREE);
15379
15380   /* Build a catch block: we need a catch clause parameter */
15381   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15382     {
15383       tree catch_type = obtain_incomplete_type (type_or_name);
15384       jdep *dep;
15385       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15386       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15387                                 catch_clause_param, catch_type);
15388       dep = CLASSD_LAST (ctxp->classd_list);
15389       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15390     }
15391   else
15392     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15393                                      build_pointer_type (type_or_name));
15394
15395   /* And a block */
15396   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15397
15398   /* Initialize the variable and store in the block */
15399   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15400                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15401   add_stmt_to_block (catch_block, NULL_TREE, catch);
15402
15403   /* Add the catch statements */
15404   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15405
15406   /* Now we can build a CATCH_EXPR */
15407   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15408
15409   return build_try_statement (location, try_block, catch_block);
15410 }
15411
15412 static tree
15413 build_try_statement (int location, tree try_block, tree catches)
15414 {
15415   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15416   EXPR_WFL_LINECOL (node) = location;
15417   return node;
15418 }
15419
15420 static tree
15421 build_try_finally_statement (int location, tree try_block, tree finally)
15422 {
15423   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15424   EXPR_WFL_LINECOL (node) = location;
15425   return node;
15426 }
15427
15428 static tree
15429 patch_try_statement (tree node)
15430 {
15431   int error_found = 0;
15432   tree try = TREE_OPERAND (node, 0);
15433   /* Exception handlers are considered in left to right order */
15434   tree catch = nreverse (TREE_OPERAND (node, 1));
15435   tree current, caught_type_list = NULL_TREE;
15436
15437   /* Check catch clauses, if any. Every time we find an error, we try
15438      to process the next catch clause. We process the catch clause before
15439      the try block so that when processing the try block we can check thrown
15440      exceptions againts the caught type list. */
15441   for (current = catch; current; current = TREE_CHAIN (current))
15442     {
15443       tree carg_decl, carg_type;
15444       tree sub_current, catch_block, catch_clause;
15445       int unreachable;
15446
15447       /* At this point, the structure of the catch clause is
15448            CATCH_EXPR           (catch node)
15449              BLOCK              (with the decl of the parameter)
15450                COMPOUND_EXPR
15451                  MODIFY_EXPR   (assignment of the catch parameter)
15452                  BLOCK          (catch clause block)
15453        */
15454       catch_clause = TREE_OPERAND (current, 0);
15455       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15456       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15457
15458       /* Catch clauses can't have more than one parameter declared,
15459          but it's already enforced by the grammar. Make sure that the
15460          only parameter of the clause statement in of class Throwable
15461          or a subclass of Throwable, but that was done earlier. The
15462          catch clause parameter type has also been resolved. */
15463
15464       /* Just make sure that the catch clause parameter type inherits
15465          from java.lang.Throwable */
15466       if (!inherits_from_p (carg_type, throwable_type_node))
15467         {
15468           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15469           parse_error_context (wfl_operator,
15470                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15471                                lang_printable_name (carg_type, 0));
15472           error_found = 1;
15473           continue;
15474         }
15475
15476       /* Partial check for unreachable catch statement: The catch
15477          clause is reachable iff is no earlier catch block A in
15478          the try statement such that the type of the catch
15479          clause's parameter is the same as or a subclass of the
15480          type of A's parameter */
15481       unreachable = 0;
15482       for (sub_current = catch;
15483            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15484         {
15485           tree sub_catch_clause, decl;
15486           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15487           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15488
15489           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15490             {
15491               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15492               parse_error_context
15493                 (wfl_operator,
15494                  "`catch' not reached because of the catch clause at line %d",
15495                  EXPR_WFL_LINENO (sub_current));
15496               unreachable = error_found = 1;
15497               break;
15498             }
15499         }
15500       /* Complete the catch clause block */
15501       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15502       if (catch_block == error_mark_node)
15503         {
15504           error_found = 1;
15505           continue;
15506         }
15507       if (CAN_COMPLETE_NORMALLY (catch_block))
15508         CAN_COMPLETE_NORMALLY (node) = 1;
15509       TREE_OPERAND (current, 0) = catch_block;
15510
15511       if (unreachable)
15512         continue;
15513
15514       /* Things to do here: the exception must be thrown */
15515
15516       /* Link this type to the caught type list */
15517       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15518     }
15519
15520   PUSH_EXCEPTIONS (caught_type_list);
15521   if ((try = java_complete_tree (try)) == error_mark_node)
15522     error_found = 1;
15523   if (CAN_COMPLETE_NORMALLY (try))
15524     CAN_COMPLETE_NORMALLY (node) = 1;
15525   POP_EXCEPTIONS ();
15526
15527   /* Verification ends here */
15528   if (error_found)
15529     return error_mark_node;
15530
15531   TREE_OPERAND (node, 0) = try;
15532   TREE_OPERAND (node, 1) = catch;
15533   TREE_TYPE (node) = void_type_node;
15534   return node;
15535 }
15536
15537 /* 14.17 The synchronized Statement */
15538
15539 static tree
15540 patch_synchronized_statement (tree node, tree wfl_op1)
15541 {
15542   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15543   tree block = TREE_OPERAND (node, 1);
15544
15545   tree tmp, enter, exit, expr_decl, assignment;
15546
15547   if (expr == error_mark_node)
15548     {
15549       block = java_complete_tree (block);
15550       return expr;
15551     }
15552
15553   /* We might be trying to synchronize on a STRING_CST */
15554   if ((tmp = patch_string (expr)))
15555     expr = tmp;
15556
15557   /* The TYPE of expr must be a reference type */
15558   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15559     {
15560       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15561       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15562                            lang_printable_name (TREE_TYPE (expr), 0));
15563       return error_mark_node;
15564     }
15565
15566   if (flag_emit_xref)
15567     {
15568       TREE_OPERAND (node, 0) = expr;
15569       TREE_OPERAND (node, 1) = java_complete_tree (block);
15570       CAN_COMPLETE_NORMALLY (node) = 1;
15571       return node;
15572     }
15573
15574   /* Generate a try-finally for the synchronized statement, except
15575      that the handler that catches all throw exception calls
15576      _Jv_MonitorExit and then rethrow the exception.
15577      The synchronized statement is then implemented as:
15578      TRY
15579        {
15580          _Jv_MonitorEnter (expression)
15581          synchronized_block
15582          _Jv_MonitorExit (expression)
15583        }
15584      CATCH_ALL
15585        {
15586          e = _Jv_exception_info ();
15587          _Jv_MonitorExit (expression)
15588          Throw (e);
15589        } */
15590
15591   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15592   BUILD_MONITOR_ENTER (enter, expr_decl);
15593   BUILD_MONITOR_EXIT (exit, expr_decl);
15594   CAN_COMPLETE_NORMALLY (enter) = 1;
15595   CAN_COMPLETE_NORMALLY (exit) = 1;
15596   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15597   TREE_SIDE_EFFECTS (assignment) = 1;
15598   node = build (COMPOUND_EXPR, NULL_TREE,
15599                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15600                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15601   node = build_expr_block (node, expr_decl);
15602
15603   return java_complete_tree (node);
15604 }
15605
15606 /* 14.16 The throw Statement */
15607
15608 static tree
15609 patch_throw_statement (tree node, tree wfl_op1)
15610 {
15611   tree expr = TREE_OPERAND (node, 0);
15612   tree type = TREE_TYPE (expr);
15613   int unchecked_ok = 0, tryblock_throws_ok = 0;
15614
15615   /* Thrown expression must be assignable to java.lang.Throwable */
15616   if (!try_reference_assignconv (throwable_type_node, expr))
15617     {
15618       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15619       parse_error_context (wfl_operator,
15620     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15621                            lang_printable_name (type, 0));
15622       /* If the thrown expression was a reference, we further the
15623          compile-time check. */
15624       if (!JREFERENCE_TYPE_P (type))
15625         return error_mark_node;
15626     }
15627
15628   /* At least one of the following must be true */
15629
15630   /* The type of the throw expression is a not checked exception,
15631      i.e. is a unchecked expression. */
15632   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15633
15634   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15635   /* An instance can't throw a checked exception unless that exception
15636      is explicitly declared in the `throws' clause of each
15637      constructor. This doesn't apply to anonymous classes, since they
15638      don't have declared constructors. */
15639   if (!unchecked_ok
15640       && DECL_INSTINIT_P (current_function_decl)
15641       && !ANONYMOUS_CLASS_P (current_class))
15642     {
15643       tree current;
15644       for (current = TYPE_METHODS (current_class); current;
15645            current = TREE_CHAIN (current))
15646         if (DECL_CONSTRUCTOR_P (current)
15647             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15648           {
15649             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)",
15650                                  lang_printable_name (TREE_TYPE (expr), 0));
15651             return error_mark_node;
15652           }
15653     }
15654
15655   /* Throw is contained in a try statement and at least one catch
15656      clause can receive the thrown expression or the current method is
15657      declared to throw such an exception. Or, the throw statement is
15658      contained in a method or constructor declaration and the type of
15659      the Expression is assignable to at least one type listed in the
15660      throws clause the declaration. */
15661   if (!unchecked_ok)
15662     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15663   if (!(unchecked_ok || tryblock_throws_ok))
15664     {
15665       /* If there is a surrounding try block that has no matching
15666          clatch clause, report it first. A surrounding try block exits
15667          only if there is something after the list of checked
15668          exception thrown by the current function (if any). */
15669       if (IN_TRY_BLOCK_P ())
15670         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15671                              lang_printable_name (type, 0));
15672       /* If we have no surrounding try statement and the method doesn't have
15673          any throws, report it now. FIXME */
15674
15675       /* We report that the exception can't be throw from a try block
15676          in all circumstances but when the `throw' is inside a static
15677          block. */
15678       else if (!EXCEPTIONS_P (currently_caught_type_list)
15679                && !tryblock_throws_ok)
15680         {
15681           if (DECL_CLINIT_P (current_function_decl))
15682             parse_error_context (wfl_operator,
15683                    "Checked exception `%s' can't be thrown in initializer",
15684                                  lang_printable_name (type, 0));
15685           else
15686             parse_error_context (wfl_operator,
15687                    "Checked exception `%s' isn't thrown from a `try' block",
15688                                  lang_printable_name (type, 0));
15689         }
15690       /* Otherwise, the current method doesn't have the appropriate
15691          throws declaration */
15692       else
15693         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15694                              lang_printable_name (type, 0));
15695       return error_mark_node;
15696     }
15697
15698   if (! flag_emit_class_files && ! flag_emit_xref)
15699     BUILD_THROW (node, expr);
15700
15701   /* If doing xrefs, keep the location where the `throw' was seen. */
15702   if (flag_emit_xref)
15703     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15704   return node;
15705 }
15706
15707 /* Check that exception said to be thrown by method DECL can be
15708    effectively caught from where DECL is invoked.  THIS_EXPR is the
15709    expression that computes `this' for the method call.  */
15710 static void
15711 check_thrown_exceptions (int location, tree decl, tree this_expr)
15712 {
15713   tree throws;
15714   int is_array_call = 0;
15715
15716   /* Skip check within generated methods, such as access$<n>.  */
15717   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15718     return;
15719
15720   if (this_expr != NULL_TREE
15721       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15722       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15723     is_array_call = 1;
15724
15725   /* For all the unchecked exceptions thrown by DECL.  */
15726   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15727        throws = TREE_CHAIN (throws))
15728     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15729       {
15730         /* Suppress errors about cloning arrays.  */
15731         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15732           continue;
15733
15734         EXPR_WFL_LINECOL (wfl_operator) = location;
15735         if (DECL_FINIT_P (current_function_decl))
15736           parse_error_context
15737             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15738              lang_printable_name (TREE_VALUE (throws), 0));
15739         else
15740           {
15741             parse_error_context
15742               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15743                lang_printable_name (TREE_VALUE (throws), 0),
15744                (DECL_INIT_P (current_function_decl) ?
15745                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15746                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15747           }
15748       }
15749 }
15750
15751 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15752    try-catch blocks, OR is listed in the `throws' clause of the
15753    current method.  */
15754
15755 static int
15756 check_thrown_exceptions_do (tree exception)
15757 {
15758   tree list = currently_caught_type_list;
15759   resolve_and_layout (exception, NULL_TREE);
15760   /* First, all the nested try-catch-finally at that stage. The
15761      last element contains `throws' clause exceptions, if any. */
15762   if (IS_UNCHECKED_EXCEPTION_P (exception))
15763     return 1;
15764   while (list)
15765     {
15766       tree caught;
15767       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15768         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15769           return 1;
15770       list = TREE_CHAIN (list);
15771     }
15772   return 0;
15773 }
15774
15775 static void
15776 purge_unchecked_exceptions (tree mdecl)
15777 {
15778   tree throws = DECL_FUNCTION_THROWS (mdecl);
15779   tree new = NULL_TREE;
15780
15781   while (throws)
15782     {
15783       tree next = TREE_CHAIN (throws);
15784       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15785         {
15786           TREE_CHAIN (throws) = new;
15787           new = throws;
15788         }
15789       throws = next;
15790     }
15791   /* List is inverted here, but it doesn't matter */
15792   DECL_FUNCTION_THROWS (mdecl) = new;
15793 }
15794
15795 /* This function goes over all of CLASS_TYPE ctors and checks whether
15796    each of them features at least one unchecked exception in its
15797    `throws' clause. If it's the case, it returns `true', `false'
15798    otherwise.  */
15799
15800 static bool
15801 ctors_unchecked_throws_clause_p (tree class_type)
15802 {
15803   tree current;
15804
15805   for (current = TYPE_METHODS (class_type); current;
15806        current = TREE_CHAIN (current))
15807     {
15808       bool ctu = false; /* Ctor Throws Unchecked */
15809       if (DECL_CONSTRUCTOR_P (current))
15810         {
15811           tree throws;
15812           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15813                throws = TREE_CHAIN (throws))
15814             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15815               ctu = true;
15816         }
15817       /* We return false as we found one ctor that is unfit. */
15818       if (!ctu && DECL_CONSTRUCTOR_P (current))
15819         return false;
15820     }
15821   /* All ctors feature at least one unchecked exception in their
15822      `throws' clause. */
15823   return true;
15824 }
15825
15826 /* 15.24 Conditional Operator ?: */
15827
15828 static tree
15829 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15830 {
15831   tree cond = TREE_OPERAND (node, 0);
15832   tree op1 = TREE_OPERAND (node, 1);
15833   tree op2 = TREE_OPERAND (node, 2);
15834   tree resulting_type = NULL_TREE;
15835   tree t1, t2, patched;
15836   int error_found = 0;
15837
15838   /* Operands of ?: might be StringBuffers crafted as a result of a
15839      string concatenation. Obtain a descent operand here.  */
15840   if ((patched = patch_string (op1)))
15841     TREE_OPERAND (node, 1) = op1 = patched;
15842   if ((patched = patch_string (op2)))
15843     TREE_OPERAND (node, 2) = op2 = patched;
15844
15845   t1 = TREE_TYPE (op1);
15846   t2 = TREE_TYPE (op2);
15847
15848   /* The first expression must be a boolean */
15849   if (TREE_TYPE (cond) != boolean_type_node)
15850     {
15851       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15852       parse_error_context (wfl_operator,
15853                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15854                            lang_printable_name (TREE_TYPE (cond), 0));
15855       error_found = 1;
15856     }
15857
15858   /* Second and third can be numeric, boolean (i.e. primitive),
15859      references or null. Anything else results in an error */
15860   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15861         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15862             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15863         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15864     error_found = 1;
15865
15866   /* Determine the type of the conditional expression. Same types are
15867      easy to deal with */
15868   else if (t1 == t2)
15869     resulting_type = t1;
15870
15871   /* There are different rules for numeric types */
15872   else if (JNUMERIC_TYPE_P (t1))
15873     {
15874       /* if byte/short found, the resulting type is short */
15875       if ((t1 == byte_type_node && t2 == short_type_node)
15876           || (t1 == short_type_node && t2 == byte_type_node))
15877         resulting_type = short_type_node;
15878
15879       /* If t1 is a constant int and t2 is of type byte, short or char
15880          and t1's value fits in t2, then the resulting type is t2 */
15881       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15882           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15883         resulting_type = t2;
15884
15885       /* If t2 is a constant int and t1 is of type byte, short or char
15886          and t2's value fits in t1, then the resulting type is t1 */
15887       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15888           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15889         resulting_type = t1;
15890
15891       /* Otherwise, binary numeric promotion is applied and the
15892          resulting type is the promoted type of operand 1 and 2 */
15893       else
15894         resulting_type = binary_numeric_promotion (t1, t2,
15895                                                    &TREE_OPERAND (node, 1),
15896                                                    &TREE_OPERAND (node, 2));
15897     }
15898
15899   /* Cases of a reference and a null type */
15900   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15901     resulting_type = t1;
15902
15903   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15904     resulting_type = t2;
15905
15906   /* Last case: different reference types. If a type can be converted
15907      into the other one by assignment conversion, the latter
15908      determines the type of the expression */
15909   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15910     resulting_type = promote_type (t1);
15911
15912   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15913     resulting_type = promote_type (t2);
15914
15915   /* If we don't have any resulting type, we're in trouble */
15916   if (!resulting_type)
15917     {
15918       char *t = xstrdup (lang_printable_name (t1, 0));
15919       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15920       parse_error_context (wfl_operator,
15921                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15922                            t, lang_printable_name (t2, 0));
15923       free (t);
15924       error_found = 1;
15925     }
15926
15927   if (error_found)
15928     {
15929       TREE_TYPE (node) = error_mark_node;
15930       return error_mark_node;
15931     }
15932
15933   TREE_TYPE (node) = resulting_type;
15934   TREE_SET_CODE (node, COND_EXPR);
15935   CAN_COMPLETE_NORMALLY (node) = 1;
15936   return node;
15937 }
15938
15939 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15940
15941 static tree
15942 maybe_build_class_init_for_field (tree decl, tree expr)
15943 {
15944   tree clas = DECL_CONTEXT (decl);
15945   if (flag_emit_class_files || flag_emit_xref)
15946     return expr;
15947
15948   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15949       && FIELD_FINAL (decl))
15950     {
15951       tree init = DECL_INITIAL (decl);
15952       if (init != NULL_TREE)
15953         init = fold_constant_for_init (init, decl);
15954       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15955         return expr;
15956     }
15957
15958   return build_class_init (clas, expr);
15959 }
15960
15961 /* Try to constant fold NODE.
15962    If NODE is not a constant expression, return NULL_EXPR.
15963    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15964
15965 static tree
15966 fold_constant_for_init (tree node, tree context)
15967 {
15968   tree op0, op1, val;
15969   enum tree_code code = TREE_CODE (node);
15970
15971   switch (code)
15972     {
15973     case INTEGER_CST:
15974       if (node == null_pointer_node)
15975         return NULL_TREE;
15976     case STRING_CST:
15977     case REAL_CST:
15978       return node;
15979
15980     case PLUS_EXPR:
15981     case MINUS_EXPR:
15982     case MULT_EXPR:
15983     case TRUNC_MOD_EXPR:
15984     case RDIV_EXPR:
15985     case LSHIFT_EXPR:
15986     case RSHIFT_EXPR:
15987     case URSHIFT_EXPR:
15988     case BIT_AND_EXPR:
15989     case BIT_XOR_EXPR:
15990     case BIT_IOR_EXPR:
15991     case TRUTH_ANDIF_EXPR:
15992     case TRUTH_ORIF_EXPR:
15993     case EQ_EXPR:
15994     case NE_EXPR:
15995     case GT_EXPR:
15996     case GE_EXPR:
15997     case LT_EXPR:
15998     case LE_EXPR:
15999       op0 = TREE_OPERAND (node, 0);
16000       op1 = TREE_OPERAND (node, 1);
16001       val = fold_constant_for_init (op0, context);
16002       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16003         return NULL_TREE;
16004       TREE_OPERAND (node, 0) = val;
16005       val = fold_constant_for_init (op1, context);
16006       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16007         return NULL_TREE;
16008       TREE_OPERAND (node, 1) = val;
16009       return patch_binop (node, op0, op1);
16010
16011     case UNARY_PLUS_EXPR:
16012     case NEGATE_EXPR:
16013     case TRUTH_NOT_EXPR:
16014     case BIT_NOT_EXPR:
16015     case CONVERT_EXPR:
16016       op0 = TREE_OPERAND (node, 0);
16017       val = fold_constant_for_init (op0, context);
16018       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16019         return NULL_TREE;
16020       TREE_OPERAND (node, 0) = val;
16021       val = patch_unaryop (node, op0);
16022       if (! TREE_CONSTANT (val))
16023         return NULL_TREE;
16024       return val;
16025
16026       break;
16027
16028     case COND_EXPR:
16029       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16030       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16031         return NULL_TREE;
16032       TREE_OPERAND (node, 0) = val;
16033       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16034       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16035         return NULL_TREE;
16036       TREE_OPERAND (node, 1) = val;
16037       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16038       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16039         return NULL_TREE;
16040       TREE_OPERAND (node, 2) = val;
16041       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16042         : TREE_OPERAND (node, 2);
16043
16044     case VAR_DECL:
16045     case FIELD_DECL:
16046       if (! FIELD_FINAL (node)
16047           || DECL_INITIAL (node) == NULL_TREE)
16048         return NULL_TREE;
16049       val = DECL_INITIAL (node);
16050       /* Guard against infinite recursion. */
16051       DECL_INITIAL (node) = NULL_TREE;
16052       val = fold_constant_for_init (val, node);
16053       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16054         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16055       DECL_INITIAL (node) = val;
16056       return val;
16057
16058     case EXPR_WITH_FILE_LOCATION:
16059       /* Compare java_complete_tree and resolve_expression_name. */
16060       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16061           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16062         {
16063           tree name = EXPR_WFL_NODE (node);
16064           tree decl;
16065           if (PRIMARY_P (node))
16066             return NULL_TREE;
16067           else if (! QUALIFIED_P (name))
16068             {
16069               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16070               if (decl == NULL_TREE
16071                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16072                 return NULL_TREE;
16073               return fold_constant_for_init (decl, decl);
16074             }
16075           else
16076             {
16077               /* Install the proper context for the field resolution.
16078                  The prior context is restored once the name is
16079                  properly qualified. */
16080               tree saved_current_class = current_class;
16081               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16082               current_class = DECL_CONTEXT (context);
16083               qualify_ambiguous_name (node);
16084               current_class = saved_current_class;
16085               if (resolve_field_access (node, &decl, NULL)
16086                   && decl != NULL_TREE)
16087                 return fold_constant_for_init (decl, decl);
16088               return NULL_TREE;
16089             }
16090         }
16091       else
16092         {
16093           op0 = TREE_OPERAND (node, 0);
16094           val = fold_constant_for_init (op0, context);
16095           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16096             return NULL_TREE;
16097           TREE_OPERAND (node, 0) = val;
16098           return val;
16099         }
16100
16101 #ifdef USE_COMPONENT_REF
16102     case IDENTIFIER:
16103     case COMPONENT_REF:
16104       ?;
16105 #endif
16106
16107     default:
16108       return NULL_TREE;
16109     }
16110 }
16111
16112 #ifdef USE_COMPONENT_REF
16113 /* Context is 'T' for TypeName, 'P' for PackageName,
16114    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16115
16116 tree
16117 resolve_simple_name (tree name, int context)
16118 {
16119 }
16120
16121 tree
16122 resolve_qualified_name (tree name, int context)
16123 {
16124 }
16125 #endif
16126
16127 void
16128 init_src_parse (void)
16129 {
16130   /* Sanity check; we've been bit by this before.  */
16131   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16132     abort ();
16133 }
16134
16135 \f
16136
16137 /* This section deals with the functions that are called when tables
16138    recording class initialization information are traversed.  */
16139
16140 /* Attach to PTR (a block) the declaration found in ENTRY. */
16141
16142 static int
16143 attach_init_test_initialization_flags (void **entry, void *ptr)
16144 {
16145   tree block = (tree)ptr;
16146   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16147
16148   if (block != error_mark_node)
16149     {
16150       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16151       BLOCK_EXPR_DECLS (block) = ite->value;
16152     }
16153   return true;
16154 }
16155
16156 /* This function is called for each class that is known definitely
16157    initialized when a given static method was called. This function
16158    augments a compound expression (INFO) storing all assignment to
16159    initialized static class flags if a flag already existed, otherwise
16160    a new one is created.  */
16161
16162 static int
16163 emit_test_initialization (void **entry_p, void *info)
16164 {
16165   tree l = (tree) info;
16166   tree decl, init;
16167   tree key = (tree) *entry_p;
16168   tree *ite;
16169   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16170
16171   /* If we haven't found a flag and we're dealing with self registered
16172      with current_function_decl, then don't do anything. Self is
16173      always added as definitely initialized but this information is
16174      valid only if used outside the current function. */
16175   if (current_function_decl == TREE_PURPOSE (l)
16176       && java_treetreehash_find (cf_ht, key) == NULL)
16177     return true;
16178
16179   ite = java_treetreehash_new (cf_ht, key);
16180
16181   /* If we don't have a variable, create one and install it. */
16182   if (*ite == NULL)
16183     {
16184       tree block;
16185
16186       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16187       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16188       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16189       DECL_CONTEXT (decl) = current_function_decl;
16190       DECL_INITIAL (decl) = boolean_true_node;
16191       /* Don't emit any symbolic debugging info for this decl.  */
16192       DECL_IGNORED_P (decl) = 1;
16193
16194       /* The trick is to find the right context for it. */
16195       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16196       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16197       BLOCK_EXPR_DECLS (block) = decl;
16198       *ite = decl;
16199     }
16200   else
16201     decl = *ite;
16202
16203   /* Now simply augment the compound that holds all the assignments
16204      pertaining to this method invocation. */
16205   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16206   TREE_SIDE_EFFECTS (init) = 1;
16207   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16208   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16209
16210   return true;
16211 }
16212
16213 #include "gt-java-parse.h"
16214 #include "gtype-java.h"