gcc/java/parse.y

   1 /* Source code parsing and tree node generation for the GNU compiler
   2    for the Java(TM) language.
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   4    Free Software Foundation, Inc.
   5    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.
  23
  24 Java and all Java-based marks are trademarks or registered trademarks
  25 of Sun Microsystems, Inc. in the United States and other countries.
  26 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  27
  28 /* This file parses java source code and issues a tree node image
  29 suitable for code generation (byte code and targeted CPU assembly
  30 language).
  31
  32 The grammar conforms to the Java grammar described in "The Java(TM)
  33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  34 1996, ISBN 0-201-63451-1"
  35
  36 The following modifications were brought to the original grammar:
  37
  38 method_body: added the rule '| block SC_TK'
  39 static_initializer: added the rule 'static block SC_TK'.
  40
  41 Note: All the extra rules described above should go away when the
  42       empty_statement rule will work.
  43
  44 statement_nsi: 'nsi' should be read no_short_if.
  45
  46 Some rules have been modified to support JDK1.1 inner classes
  47 definitions and other extensions.  */
  48
  49 %{
  50 #include "config.h"
  51 #include "system.h"
  52 #include "coretypes.h"
  53 #include "tm.h"
  54 #include <dirent.h>
  55 #include "tree.h"
  56 #include "rtl.h"
  57 #include "real.h"
  58 #include "obstack.h"
  59 #include "toplev.h"
  60 #include "flags.h"
  61 #include "java-tree.h"
  62 #include "jcf.h"
  63 #include "lex.h"
  64 #include "parse.h"
  65 #include "zipfile.h"
  66 #include "convert.h"
  67 #include "buffer.h"
  68 #include "xref.h"
  69 #include "function.h"
  70 #include "except.h"
  71 #include "ggc.h"
  72 #include "debug.h"
  73 #include "tree-inline.h"
  74 #include "cgraph.h"
  75 #include "target.h"
  76
  77 /* Local function prototypes */
  78 static char *java_accstring_lookup (int);
  79 static const char *accessibility_string (int);
  80 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  81 static void  variable_redefinition_error (tree, tree, tree, int);
  82 static tree  create_class (int, tree, tree, tree);
  83 static tree  create_interface (int, tree, tree);
  84 static void  end_class_declaration (int);
  85 static tree  find_field (tree, tree);
  86 static tree lookup_field_wrapper (tree, tree);
  87 static int   duplicate_declaration_error_p (tree, tree, tree);
  88 static void  register_fields (int, tree, tree);
  89 static tree parser_qualified_classname (tree);
  90 static int  parser_check_super (tree, tree, tree);
  91 static int  parser_check_super_interface (tree, tree, tree);
  92 static void check_modifiers_consistency (int);
  93 static tree lookup_cl (tree);
  94 static tree lookup_java_method2 (tree, tree, int);
  95 static tree method_header (int, tree, tree, tree);
  96 static void fix_method_argument_names (tree ,tree);
  97 static tree method_declarator (tree, tree);
  98 static void parse_warning_context (tree cl, const char *msg, ...)
  99   ATTRIBUTE_PRINTF_2;
 100 static void issue_warning_error_from_context (tree, const char *msg, va_list)
 101   ATTRIBUTE_PRINTF (2, 0);
 102 static void parse_ctor_invocation_error (void);
 103 static tree parse_jdk1_1_error (const char *);
 104 static void complete_class_report_errors (jdep *);
 105 static int process_imports (void);
 106 static void read_import_dir (tree);
 107 static int find_in_imports_on_demand (tree, tree);
 108 static void find_in_imports (tree, tree);
 109 static void check_inner_class_access (tree, tree, tree);
 110 static int check_pkg_class_access (tree, tree, bool, tree);
 111 static void register_package (tree);
 112 static tree resolve_package (tree, tree *, tree *);
 113 static tree resolve_class (tree, tree, tree, tree);
 114 static void declare_local_variables (int, tree, tree);
 115 static void dump_java_tree (enum tree_dump_index, tree);
 116 static void source_start_java_method (tree);
 117 static void source_end_java_method (void);
 118 static tree find_name_in_single_imports (tree);
 119 static void check_abstract_method_header (tree);
 120 static tree lookup_java_interface_method2 (tree, tree);
 121 static tree resolve_expression_name (tree, tree *);
 122 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 123 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 124 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 125 static int breakdown_qualified (tree *, tree *, tree);
 126 static int in_same_package (tree, tree);
 127 static tree resolve_and_layout (tree, tree);
 128 static tree qualify_and_find (tree, tree, tree);
 129 static tree resolve_no_layout (tree, tree);
 130 static int invocation_mode (tree, int);
 131 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 132 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 133 static tree find_most_specific_methods_list (tree);
 134 static int argument_types_convertible (tree, tree);
 135 static tree patch_invoke (tree, tree, tree);
 136 static int maybe_use_access_method (int, tree *, tree *);
 137 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 138 static tree register_incomplete_type (int, tree, tree, tree);
 139 static tree check_inner_circular_reference (tree, tree);
 140 static tree check_circular_reference (tree);
 141 static tree obtain_incomplete_type (tree);
 142 static tree java_complete_lhs (tree);
 143 static tree java_complete_tree (tree);
 144 static tree maybe_generate_pre_expand_clinit (tree);
 145 static int analyze_clinit_body (tree, tree);
 146 static int maybe_yank_clinit (tree);
 147 static void start_complete_expand_method (tree);
 148 static void java_complete_expand_method (tree);
 149 static void java_expand_method_bodies (tree);
 150 static int  unresolved_type_p (tree, tree *);
 151 static void create_jdep_list (struct parser_ctxt *);
 152 static tree build_expr_block (tree, tree);
 153 static tree enter_block (void);
 154 static tree exit_block (void);
 155 static tree lookup_name_in_blocks (tree);
 156 static void maybe_absorb_scoping_blocks (void);
 157 static tree build_method_invocation (tree, tree);
 158 static tree build_new_invocation (tree, tree);
 159 static tree build_assignment (int, int, tree, tree);
 160 static tree build_binop (enum tree_code, int, tree, tree);
 161 static tree patch_assignment (tree, tree);
 162 static tree patch_binop (tree, tree, tree);
 163 static tree build_unaryop (int, int, tree);
 164 static tree build_incdec (int, int, tree, int);
 165 static tree patch_unaryop (tree, tree);
 166 static tree build_cast (int, tree, tree);
 167 static tree build_null_of_type (tree);
 168 static tree patch_cast (tree, tree);
 169 static int valid_ref_assignconv_cast_p (tree, tree, int);
 170 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 171 static int valid_cast_to_p (tree, tree);
 172 static int valid_method_invocation_conversion_p (tree, tree);
 173 static tree try_builtin_assignconv (tree, tree, tree);
 174 static tree try_reference_assignconv (tree, tree);
 175 static tree build_unresolved_array_type (tree);
 176 static int build_type_name_from_array_name (tree, tree *);
 177 static tree build_array_from_name (tree, tree, tree, tree *);
 178 static tree build_array_ref (int, tree, tree);
 179 static tree patch_array_ref (tree);
 180 static tree make_qualified_name (tree, tree, int);
 181 static tree merge_qualified_name (tree, tree);
 182 static tree make_qualified_primary (tree, tree, int);
 183 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 184 static void qualify_ambiguous_name (tree);
 185 static tree resolve_field_access (tree, tree *, tree *);
 186 static tree build_newarray_node (tree, tree, int);
 187 static tree patch_newarray (tree);
 188 static tree resolve_type_during_patch (tree);
 189 static tree build_this (int);
 190 static tree build_wfl_wrap (tree, int);
 191 static tree build_return (int, tree);
 192 static tree patch_return (tree);
 193 static tree maybe_access_field (tree, tree, tree);
 194 static int complete_function_arguments (tree);
 195 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 196 static int not_accessible_p (tree, tree, tree, int);
 197 static void check_deprecation (tree, tree);
 198 static int class_in_current_package (tree);
 199 static tree build_if_else_statement (int, tree, tree, tree);
 200 static tree patch_if_else_statement (tree);
 201 static tree add_stmt_to_block (tree, tree, tree);
 202 static tree patch_exit_expr (tree);
 203 static tree build_labeled_block (int, tree);
 204 static tree finish_labeled_statement (tree, tree);
 205 static tree build_bc_statement (int, int, tree);
 206 static tree patch_bc_statement (tree);
 207 static tree patch_loop_statement (tree);
 208 static tree build_new_loop (tree);
 209 static tree build_loop_body (int, tree, int);
 210 static tree finish_loop_body (int, tree, tree, int);
 211 static tree build_debugable_stmt (int, tree);
 212 static tree finish_for_loop (int, tree, tree, tree);
 213 static tree patch_switch_statement (tree);
 214 static tree string_constant_concatenation (tree, tree);
 215 static tree build_string_concatenation (tree, tree);
 216 static tree patch_string_cst (tree);
 217 static tree patch_string (tree);
 218 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 219 static tree build_assertion (int, tree, tree);
 220 static tree build_try_statement (int, tree, tree);
 221 static tree build_try_finally_statement (int, tree, tree);
 222 static tree patch_try_statement (tree);
 223 static tree patch_synchronized_statement (tree, tree);
 224 static tree patch_throw_statement (tree, tree);
 225 static void check_thrown_exceptions (int, tree, tree);
 226 static int check_thrown_exceptions_do (tree);
 227 static void purge_unchecked_exceptions (tree);
 228 static bool ctors_unchecked_throws_clause_p (tree);
 229 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 230 static void check_throws_clauses (tree, tree, tree);
 231 static void finish_method_declaration (tree);
 232 static tree build_super_invocation (tree);
 233 static int verify_constructor_circularity (tree, tree);
 234 static char *constructor_circularity_msg (tree, tree);
 235 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 236 static const char *get_printable_method_name (tree);
 237 static tree patch_conditional_expr (tree, tree, tree);
 238 static tree generate_finit (tree);
 239 static tree generate_instinit (tree);
 240 static tree build_instinit_invocation (tree);
 241 static void fix_constructors (tree);
 242 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 243 static tree craft_constructor (tree, tree);
 244 static int verify_constructor_super (tree);
 245 static tree create_artificial_method (tree, int, tree, tree, tree);
 246 static void start_artificial_method_body (tree);
 247 static void end_artificial_method_body (tree);
 248 static int check_method_redefinition (tree, tree);
 249 static int check_method_types_complete (tree);
 250 static bool hack_is_accessible_p (tree, tree);
 251 static void java_check_regular_methods (tree);
 252 static void check_interface_throws_clauses (tree, tree);
 253 static void java_check_abstract_methods (tree);
 254 static void unreachable_stmt_error (tree);
 255 static int not_accessible_field_error (tree, tree);
 256 static tree find_expr_with_wfl (tree);
 257 static void missing_return_error (tree);
 258 static tree build_new_array_init (int, tree);
 259 static tree patch_new_array_init (tree, tree);
 260 static tree maybe_build_array_element_wfl (tree);
 261 static int array_constructor_check_entry (tree, tree);
 262 static const char *purify_type_name (const char *);
 263 static tree fold_constant_for_init (tree, tree);
 264 static tree strip_out_static_field_access_decl (tree);
 265 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 266 static void static_ref_err (tree, tree, tree);
 267 static void parser_add_interface (tree, tree, tree);
 268 static void add_superinterfaces (tree, tree);
 269 static tree jdep_resolve_class (jdep *);
 270 static int note_possible_classname (const char *, int);
 271 static void java_complete_expand_classes (void);
 272 static void java_complete_expand_class (tree);
 273 static void java_complete_expand_methods (tree);
 274 static tree cut_identifier_in_qualified (tree);
 275 static tree java_stabilize_reference (tree);
 276 static tree do_unary_numeric_promotion (tree);
 277 static char * operator_string (tree);
 278 static tree do_merge_string_cste (tree, const char *, int, int);
 279 static tree merge_string_cste (tree, tree, int);
 280 static tree java_refold (tree);
 281 static int java_decl_equiv (tree, tree);
 282 static int binop_compound_p (enum tree_code);
 283 static tree search_loop (tree);
 284 static int labeled_block_contains_loop_p (tree, tree);
 285 static int check_abstract_method_definitions (int, tree, tree);
 286 static void java_check_abstract_method_definitions (tree);
 287 static void java_debug_context_do (int);
 288 static void java_parser_context_push_initialized_field (void);
 289 static void java_parser_context_pop_initialized_field (void);
 290 static tree reorder_static_initialized (tree);
 291 static void java_parser_context_suspend (void);
 292 static void java_parser_context_resume (void);
 293 static int pop_current_osb (struct parser_ctxt *);
 294
 295 /* JDK 1.1 work. FIXME */
 296
 297 static tree maybe_make_nested_class_name (tree);
 298 static int make_nested_class_name (tree);
 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 (!IS_EMPTY_STMT ($1))
 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) = build_java_empty_stmt ();
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 ($$) = build_java_empty_stmt ();
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                   $$ = build_java_empty_stmt ();
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, 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 = make_node (DEFAULT_EXPR);
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                     build_java_empty_stmt ();
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                     build_java_empty_stmt ();
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                 { $$ = build_java_empty_stmt (); }
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                 {$$ = build_java_empty_stmt ();}
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 (JAVA_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 build_java_empty_stmt ();
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      accessibility_string (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 /* Returns a string denoting the accessibility of a class or a member as
3232    indicated by FLAGS.  We need a separate function from
3233    java_accstring_lookup, as the latter can return spurious "static", etc.
3234    if package-private access is defined (in which case none of the
3235    relevant access control bits in FLAGS is set).  */
3236
3237 static const char *
3238 accessibility_string (int flags)
3239 {
3240   if (flags & ACC_PRIVATE) return "private";
3241   if (flags & ACC_PROTECTED) return "protected";
3242   if (flags & ACC_PUBLIC) return "public";
3243
3244   return "package-private";
3245 }
3246
3247 /* Issuing error messages upon redefinition of classes, interfaces or
3248    variables. */
3249
3250 static void
3251 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3252 {
3253   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3254                        context, IDENTIFIER_POINTER (id),
3255                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3256   /* Here we should point out where its redefined. It's a unicode. FIXME */
3257 }
3258
3259 static void
3260 variable_redefinition_error (tree context, tree name, tree type, int line)
3261 {
3262   const char *type_name;
3263
3264   /* Figure a proper name for type. We might haven't resolved it */
3265   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3266     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3267   else
3268     type_name = lang_printable_name (type, 0);
3269
3270   parse_error_context (context,
3271                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3272                        IDENTIFIER_POINTER (name),
3273                        type_name, IDENTIFIER_POINTER (name), line);
3274 }
3275
3276 /* If ANAME is terminated with `[]', it indicates an array. This
3277    function returns the number of `[]' found and if this number is
3278    greater than zero, it extracts the array type name and places it in
3279    the node pointed to by TRIMMED unless TRIMMED is null.  */
3280
3281 static int
3282 build_type_name_from_array_name (tree aname, tree *trimmed)
3283 {
3284   const char *name = IDENTIFIER_POINTER (aname);
3285   int len = IDENTIFIER_LENGTH (aname);
3286   int array_dims;
3287
3288   STRING_STRIP_BRACKETS (name, len, array_dims);
3289
3290   if (array_dims && trimmed)
3291     *trimmed = get_identifier_with_length (name, len);
3292
3293   return array_dims;
3294 }
3295
3296 static tree
3297 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3298 {
3299   int more_dims = 0;
3300
3301   /* Eventually get more dims */
3302   more_dims = build_type_name_from_array_name (name, &name);
3303
3304   /* If we have, then craft a new type for this variable */
3305   if (more_dims)
3306     {
3307       tree save = type;
3308
3309       /* If we have a pointer, use its type */
3310       if (TREE_CODE (type) == POINTER_TYPE)
3311         type = TREE_TYPE (type);
3312
3313       /* Building the first dimension of a primitive type uses this
3314          function */
3315       if (JPRIMITIVE_TYPE_P (type))
3316         {
3317           type = build_java_array_type (type, -1);
3318           more_dims--;
3319         }
3320       /* Otherwise, if we have a WFL for this type, use it (the type
3321          is already an array on an unresolved type, and we just keep
3322          on adding dimensions) */
3323       else if (type_wfl)
3324         {
3325           type = type_wfl;
3326           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3327                                                         NULL);
3328         }
3329
3330       /* Add all the dimensions */
3331       while (more_dims--)
3332         type = build_unresolved_array_type (type);
3333
3334       /* The type may have been incomplete in the first place */
3335       if (type_wfl)
3336         type = obtain_incomplete_type (type);
3337     }
3338
3339   if (ret_name)
3340     *ret_name = name;
3341   return type;
3342 }
3343
3344 /* Build something that the type identifier resolver will identify as
3345    being an array to an unresolved type. TYPE_WFL is a WFL on a
3346    identifier. */
3347
3348 static tree
3349 build_unresolved_array_type (tree type_or_wfl)
3350 {
3351   const char *ptr;
3352   tree wfl;
3353
3354   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3355      just create a array type */
3356   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3357     return build_java_array_type (type_or_wfl, -1);
3358
3359   obstack_grow (&temporary_obstack,
3360                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3361                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3362   obstack_grow0 (&temporary_obstack, "[]", 2);
3363   ptr = obstack_finish (&temporary_obstack);
3364   wfl = build_expr_wfl (get_identifier (ptr),
3365                         EXPR_WFL_FILENAME (type_or_wfl),
3366                         EXPR_WFL_LINENO (type_or_wfl),
3367                         EXPR_WFL_COLNO (type_or_wfl));
3368   /* Re-install the existing qualifications so that the type can be
3369      resolved properly. */
3370   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3371   return wfl;
3372 }
3373
3374 static void
3375 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3376 {
3377   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3378     parse_error_context (wfl, "Interface `%s' repeated",
3379                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3380 }
3381
3382 /* Bulk of common class/interface checks. Return 1 if an error was
3383    encountered. TAG is 0 for a class, 1 for an interface.  */
3384
3385 static int
3386 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3387                                 tree qualified_name, tree decl, tree cl)
3388 {
3389   tree node;
3390   int sca = 0;                  /* Static class allowed */
3391   int icaf = 0;                 /* Inner class allowed flags */
3392   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3393
3394   if (!quiet_flag)
3395     fprintf (stderr, " %s%s %s",
3396              (CPC_INNER_P () ? "inner" : ""),
3397              (is_interface ? "interface" : "class"),
3398              IDENTIFIER_POINTER (qualified_name));
3399
3400   /* Scope of an interface/class type name:
3401        - Can't be imported by a single type import
3402        - Can't already exists in the package */
3403   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3404       && (node = find_name_in_single_imports (raw_name))
3405       && !CPC_INNER_P ())
3406     {
3407       parse_error_context
3408         (cl, "%s name `%s' clashes with imported type `%s'",
3409          (is_interface ? "Interface" : "Class"),
3410          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3411       return 1;
3412     }
3413   if (decl && CLASS_COMPLETE_P (decl))
3414     {
3415       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3416                                    qualified_name, decl, cl);
3417       return 1;
3418     }
3419
3420   if (check_inner_class_redefinition (raw_name, cl))
3421     return 1;
3422
3423   /* If public, file name should match class/interface name, except
3424      when dealing with an inner class */
3425   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3426     {
3427       const char *f;
3428
3429       for (f = &input_filename [strlen (input_filename)];
3430            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3431            f--)
3432         ;
3433       if (IS_DIR_SEPARATOR (f[0]))
3434         f++;
3435       if (strncmp (IDENTIFIER_POINTER (raw_name),
3436                    f , IDENTIFIER_LENGTH (raw_name)) ||
3437           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3438         parse_error_context
3439           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3440                              (is_interface ? "interface" : "class"),
3441                              IDENTIFIER_POINTER (qualified_name),
3442                              IDENTIFIER_POINTER (raw_name));
3443     }
3444
3445   /* Static classes can be declared only in top level classes. Note:
3446      once static, a inner class is a top level class. */
3447   if (flags & ACC_STATIC)
3448     {
3449       /* Catch the specific error of declaring an class inner class
3450          with no toplevel enclosing class. Prevent check_modifiers from
3451          complaining a second time */
3452       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3453         {
3454           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3455                                IDENTIFIER_POINTER (qualified_name));
3456           sca = ACC_STATIC;
3457         }
3458       /* Else, in the context of a top-level class declaration, let
3459          `check_modifiers' do its job, otherwise, give it a go */
3460       else
3461         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3462     }
3463
3464   /* Inner classes can be declared private or protected
3465      within their enclosing classes. */
3466   if (CPC_INNER_P ())
3467     {
3468       /* A class which is local to a block can't be public, private,
3469          protected or static. But it is created final, so allow this
3470          one. */
3471       if (current_function_decl)
3472         icaf = sca = uaaf = ACC_FINAL;
3473       else
3474         {
3475           check_modifiers_consistency (flags);
3476           icaf = ACC_PROTECTED;
3477           if (! CLASS_INTERFACE (GET_CPC ()))
3478             icaf |= ACC_PRIVATE;
3479         }
3480     }
3481
3482   if (is_interface)
3483     {
3484       if (CPC_INNER_P ())
3485         uaaf = INTERFACE_INNER_MODIFIERS;
3486       else
3487         uaaf = INTERFACE_MODIFIERS;
3488
3489       check_modifiers ("Illegal modifier `%s' for interface declaration",
3490                        flags, uaaf);
3491     }
3492   else
3493     check_modifiers ((current_function_decl ?
3494                       "Illegal modifier `%s' for local class declaration" :
3495                       "Illegal modifier `%s' for class declaration"),
3496                      flags, uaaf|sca|icaf);
3497   return 0;
3498 }
3499
3500 /* Construct a nested class name.  If the final component starts with
3501    a digit, return true.  Otherwise return false.  */
3502 static int
3503 make_nested_class_name (tree cpc_list)
3504 {
3505   tree name;
3506
3507   if (!cpc_list)
3508     return 0;
3509
3510   make_nested_class_name (TREE_CHAIN (cpc_list));
3511
3512   /* Pick the qualified name when dealing with the first upmost
3513      enclosing class */
3514   name = (TREE_CHAIN (cpc_list)
3515           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3516   obstack_grow (&temporary_obstack,
3517                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3518   obstack_1grow (&temporary_obstack, '$');
3519
3520   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3521 }
3522
3523 /* Can't redefine a class already defined in an earlier scope. */
3524
3525 static int
3526 check_inner_class_redefinition (tree raw_name, tree cl)
3527 {
3528   tree scope_list;
3529
3530   for (scope_list = GET_CPC_LIST (); scope_list;
3531        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3532     if (raw_name == GET_CPC_UN_NODE (scope_list))
3533       {
3534         parse_error_context
3535           (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",
3536            IDENTIFIER_POINTER (raw_name));
3537         return 1;
3538       }
3539   return 0;
3540 }
3541
3542 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3543    we remember ENCLOSING and SUPER.  */
3544
3545 static tree
3546 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3547                      tree *super, tree class_type)
3548 {
3549   tree local_enclosing = *enclosing;
3550   tree local_super = NULL_TREE;
3551
3552   while (local_enclosing)
3553     {
3554       tree intermediate, decl;
3555
3556       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3557         local_enclosing;
3558
3559       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3560         return decl;
3561
3562       intermediate = local_enclosing;
3563       /* Explore enclosing contexts. */
3564       while (INNER_CLASS_DECL_P (intermediate))
3565         {
3566           intermediate = DECL_CONTEXT (intermediate);
3567           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3568             return decl;
3569         }
3570
3571       /* Now go to the upper classes, bail out if necessary.  We will
3572          analyze the returned SUPER and act accordingly (see
3573          do_resolve_class).  */
3574       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3575           || TREE_TYPE (local_enclosing) == void_type_node)
3576         {
3577           parse_error_context (cl, "Qualifier must be a reference");
3578           local_enclosing = NULL_TREE;
3579           break;
3580         }
3581       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3582       if (!local_super || local_super == object_type_node)
3583         break;
3584
3585       if (TREE_CODE (local_super) == POINTER_TYPE)
3586         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3587       else
3588         local_super = TYPE_NAME (local_super);
3589
3590       /* We may not have checked for circular inheritance yet, so do so
3591          here to prevent an infinite loop. */
3592       if (htab_find (circularity_hash, local_super) != NULL)
3593         {
3594           if (!cl)
3595             cl = lookup_cl (local_enclosing);
3596
3597           parse_error_context
3598             (cl, "Cyclic inheritance involving %s",
3599              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3600           local_enclosing = NULL_TREE;
3601         }
3602       else
3603         local_enclosing = local_super;
3604     }
3605
3606   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3607   *super = local_super;
3608   *enclosing = local_enclosing;
3609
3610   return NULL_TREE;
3611 }
3612
3613 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3614    qualified. */
3615
3616 static tree
3617 find_as_inner_class (tree enclosing, tree name, tree cl)
3618 {
3619   tree qual, to_return;
3620   if (!enclosing)
3621     return NULL_TREE;
3622
3623   name = TYPE_NAME (name);
3624
3625   /* First search: within the scope of `enclosing', search for name */
3626   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3627     qual = EXPR_WFL_QUALIFICATION (cl);
3628   else if (cl)
3629     qual = build_tree_list (cl, NULL_TREE);
3630   else
3631     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3632
3633   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3634     return to_return;
3635
3636   /* We're dealing with a qualified name. Try to resolve thing until
3637      we get something that is an enclosing class. */
3638   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3639     {
3640       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3641
3642       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3643            qual = TREE_CHAIN (qual))
3644         {
3645           acc = merge_qualified_name (acc,
3646                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3647           BUILD_PTR_FROM_NAME (ptr, acc);
3648           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3649         }
3650
3651       /* A NULL qual and a decl means that the search ended
3652          successfully?!? We have to do something then. FIXME */
3653
3654       if (decl)
3655         enclosing = decl;
3656       else
3657         qual = EXPR_WFL_QUALIFICATION (cl);
3658     }
3659   /* Otherwise, create a qual for the other part of the resolution. */
3660   else
3661     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3662
3663   return find_as_inner_class_do (qual, enclosing);
3664 }
3665
3666 /* We go inside the list of sub classes and try to find a way
3667    through. */
3668
3669 static tree
3670 find_as_inner_class_do (tree qual, tree enclosing)
3671 {
3672   if (!qual)
3673     return NULL_TREE;
3674
3675   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3676     {
3677       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3678       tree next_enclosing = NULL_TREE;
3679       tree inner_list;
3680
3681       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3682            inner_list; inner_list = TREE_CHAIN (inner_list))
3683         {
3684           if (TREE_VALUE (inner_list) == name_to_match)
3685             {
3686               next_enclosing = TREE_PURPOSE (inner_list);
3687               break;
3688             }
3689         }
3690       enclosing = next_enclosing;
3691     }
3692
3693   return (!qual && enclosing ? enclosing : NULL_TREE);
3694 }
3695
3696 static void
3697 link_nested_class_to_enclosing (void)
3698 {
3699   if (GET_ENCLOSING_CPC ())
3700     {
3701       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3702       DECL_INNER_CLASS_LIST (enclosing) =
3703         tree_cons (GET_CPC (), GET_CPC_UN (),
3704                    DECL_INNER_CLASS_LIST (enclosing));
3705     }
3706 }
3707
3708 static tree
3709 maybe_make_nested_class_name (tree name)
3710 {
3711   tree id = NULL_TREE;
3712
3713   if (CPC_INNER_P ())
3714     {
3715       /* If we're in a function, we must append a number to create the
3716          nested class name.  However, we don't do this if the class we
3717          are constructing is anonymous, because in that case we'll
3718          already have a number as the class name.  */
3719       if (! make_nested_class_name (GET_CPC_LIST ())
3720           && current_function_decl != NULL_TREE
3721           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3722         {
3723           char buf[10];
3724           sprintf (buf, "%d", anonymous_class_counter);
3725           ++anonymous_class_counter;
3726           obstack_grow (&temporary_obstack, buf, strlen (buf));
3727           obstack_1grow (&temporary_obstack, '$');
3728         }
3729       obstack_grow0 (&temporary_obstack,
3730                      IDENTIFIER_POINTER (name),
3731                      IDENTIFIER_LENGTH (name));
3732       id = get_identifier (obstack_finish (&temporary_obstack));
3733       if (ctxp->package)
3734         QUALIFIED_P (id) = 1;
3735     }
3736   return id;
3737 }
3738
3739 /* If DECL is NULL, create and push a new DECL, record the current
3740    line CL and do other maintenance things.  */
3741
3742 static tree
3743 maybe_create_class_interface_decl (tree decl, tree raw_name,
3744                                    tree qualified_name, tree cl)
3745 {
3746   if (!decl)
3747     decl = push_class (make_class (), qualified_name);
3748
3749   /* Take care of the file and line business */
3750   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3751   /* If we're emitting xrefs, store the line/col number information */
3752   if (flag_emit_xref)
3753     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3754   else
3755     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3756   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3757   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3758   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3759     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3760
3761   PUSH_CPC (decl, raw_name);
3762   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3763
3764   /* Link the declaration to the already seen ones */
3765   TREE_CHAIN (decl) = ctxp->class_list;
3766   ctxp->class_list = decl;
3767
3768   /* Create a new nodes in the global lists */
3769   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3770   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3771
3772   /* Install a new dependency list element */
3773   create_jdep_list (ctxp);
3774
3775   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3776                           IDENTIFIER_POINTER (qualified_name)));
3777   return decl;
3778 }
3779
3780 static void
3781 add_superinterfaces (tree decl, tree interface_list)
3782 {
3783   tree node;
3784   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3785      takes care of ensuring that:
3786        - This is an accessible interface type,
3787        - Circularity detection.
3788    parser_add_interface is then called. If present but not defined,
3789    the check operation is delayed until the super interface gets
3790    defined.  */
3791   for (node = interface_list; node; node = TREE_CHAIN (node))
3792     {
3793       tree current = TREE_PURPOSE (node);
3794       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3795       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3796         {
3797           if (!parser_check_super_interface (idecl, decl, current))
3798             parser_add_interface (decl, idecl, current);
3799         }
3800       else
3801         register_incomplete_type (JDEP_INTERFACE,
3802                                   current, decl, NULL_TREE);
3803     }
3804 }
3805
3806 /* Create an interface in pass1 and return its decl. Return the
3807    interface's decl in pass 2.  */
3808
3809 static tree
3810 create_interface (int flags, tree id, tree super)
3811 {
3812   tree raw_name = EXPR_WFL_NODE (id);
3813   tree q_name = parser_qualified_classname (raw_name);
3814   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3815
3816   /* Certain syntax errors are making SUPER be like ID. Avoid this
3817      case. */
3818   if (ctxp->class_err && id == super)
3819     super = NULL;
3820
3821   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3822
3823   /* Basic checks: scope, redefinition, modifiers */
3824   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3825     {
3826       PUSH_ERROR ();
3827       return NULL_TREE;
3828     }
3829
3830   /* Suspend the current parsing context if we're parsing an inner
3831      interface */
3832   if (CPC_INNER_P ())
3833     {
3834       java_parser_context_suspend ();
3835       /* Interface members are public. */
3836       if (CLASS_INTERFACE (GET_CPC ()))
3837         flags |= ACC_PUBLIC;
3838     }
3839
3840   /* Push a new context for (static) initialized upon declaration fields */
3841   java_parser_context_push_initialized_field ();
3842
3843   /* Interface modifiers check
3844        - public/abstract allowed (already done at that point)
3845        - abstract is obsolete (comes first, it's a warning, or should be)
3846        - Can't use twice the same (checked in the modifier rule) */
3847   if ((flags & ACC_ABSTRACT) && flag_redundant)
3848     parse_warning_context
3849       (MODIFIER_WFL (ABSTRACT_TK),
3850        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3851
3852   /* Create a new decl if DECL is NULL, otherwise fix it */
3853   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3854
3855   /* Interfaces are always abstract. */
3856   flags |= ACC_ABSTRACT;
3857
3858   /* Inner interfaces are always static.  */
3859   if (INNER_CLASS_DECL_P (decl))
3860     flags |= ACC_STATIC;
3861
3862   /* Set super info and mark the class a complete */
3863   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3864                   object_type_node, ctxp->interface_number);
3865   ctxp->interface_number = 0;
3866   CLASS_COMPLETE_P (decl) = 1;
3867   add_superinterfaces (decl, super);
3868
3869   /* Eventually sets the @deprecated tag flag */
3870   CHECK_DEPRECATED (decl);
3871
3872   return decl;
3873 }
3874
3875 /* Patch anonymous class CLASS, by either extending or implementing
3876    DEP.  */
3877
3878 static void
3879 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3880 {
3881   tree class = TREE_TYPE (class_decl);
3882   tree type =  TREE_TYPE (type_decl);
3883   tree binfo = TYPE_BINFO (class);
3884
3885   /* If it's an interface, implement it */
3886   if (CLASS_INTERFACE (type_decl))
3887     {
3888       tree s_binfo;
3889       int length;
3890
3891       if (parser_check_super_interface (type_decl, class_decl, wfl))
3892         return;
3893
3894       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3895       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3896       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3897       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3898       /* And add the interface */
3899       parser_add_interface (class_decl, type_decl, wfl);
3900     }
3901   /* Otherwise, it's a type we want to extend */
3902   else
3903     {
3904       if (parser_check_super (type_decl, class_decl, wfl))
3905         return;
3906       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3907     }
3908 }
3909
3910 static tree
3911 create_anonymous_class (int location, tree type_name)
3912 {
3913   char buffer [80];
3914   tree super = NULL_TREE, itf = NULL_TREE;
3915   tree id, type_decl, class;
3916
3917   /* The unqualified name of the anonymous class. It's just a number. */
3918   sprintf (buffer, "%d", anonymous_class_counter++);
3919   id = build_wfl_node (get_identifier (buffer));
3920   EXPR_WFL_LINECOL (id) = location;
3921
3922   /* We know about the type to extend/implement. We go ahead */
3923   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3924     {
3925       /* Create a class which either implements on extends the designated
3926          class. The class bears an inaccessible name. */
3927       if (CLASS_INTERFACE (type_decl))
3928         {
3929           /* It's OK to modify it here. It's been already used and
3930              shouldn't be reused */
3931           ctxp->interface_number = 1;
3932           /* Interfaces should presented as a list of WFLs */
3933           itf = build_tree_list (type_name, NULL_TREE);
3934         }
3935       else
3936         super = type_name;
3937     }
3938
3939   class = create_class (ACC_FINAL, id, super, itf);
3940
3941   /* We didn't know anything about the stuff. We register a dependence. */
3942   if (!type_decl)
3943     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3944
3945   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3946   return class;
3947 }
3948
3949 /* Create a class in pass1 and return its decl. Return class
3950    interface's decl in pass 2.  */
3951
3952 static tree
3953 create_class (int flags, tree id, tree super, tree interfaces)
3954 {
3955   tree raw_name = EXPR_WFL_NODE (id);
3956   tree class_id, decl;
3957   tree super_decl_type;
3958
3959   /* Certain syntax errors are making SUPER be like ID. Avoid this
3960      case. */
3961   if (ctxp->class_err && id == super)
3962     super = NULL;
3963
3964   class_id = parser_qualified_classname (raw_name);
3965   decl = IDENTIFIER_CLASS_VALUE (class_id);
3966   EXPR_WFL_NODE (id) = class_id;
3967
3968   /* Basic check: scope, redefinition, modifiers */
3969   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3970     {
3971       PUSH_ERROR ();
3972       return NULL_TREE;
3973     }
3974
3975   /* Suspend the current parsing context if we're parsing an inner
3976      class or an anonymous class. */
3977   if (CPC_INNER_P ())
3978     {
3979       java_parser_context_suspend ();
3980       /* Interface members are public. */
3981       if (CLASS_INTERFACE (GET_CPC ()))
3982         flags |= ACC_PUBLIC;
3983     }
3984
3985   /* Push a new context for (static) initialized upon declaration fields */
3986   java_parser_context_push_initialized_field ();
3987
3988   /* Class modifier check:
3989        - Allowed modifier (already done at that point)
3990        - abstract AND final forbidden
3991        - Public classes defined in the correct file */
3992   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3993     parse_error_context
3994       (id, "Class `%s' can't be declared both abstract and final",
3995        IDENTIFIER_POINTER (raw_name));
3996
3997   /* Create a new decl if DECL is NULL, otherwise fix it */
3998   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3999
4000   /* If SUPER exists, use it, otherwise use Object */
4001   if (super)
4002     {
4003       /* java.lang.Object can't extend anything.  */
4004       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4005         {
4006           parse_error_context (id, "`java.lang.Object' can't extend anything");
4007           return NULL_TREE;
4008         }
4009
4010       super_decl_type =
4011         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4012     }
4013   else if (TREE_TYPE (decl) != object_type_node)
4014     super_decl_type = object_type_node;
4015   /* We're defining java.lang.Object */
4016   else
4017     super_decl_type = NULL_TREE;
4018
4019   /* A class nested in an interface is implicitly static. */
4020   if (INNER_CLASS_DECL_P (decl)
4021       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4022     {
4023       flags |= ACC_STATIC;
4024     }
4025
4026   /* Set super info and mark the class as complete. */
4027   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4028                   ctxp->interface_number);
4029   ctxp->interface_number = 0;
4030   CLASS_COMPLETE_P (decl) = 1;
4031   add_superinterfaces (decl, interfaces);
4032
4033   /* TYPE_VFIELD' is a compiler-generated field used to point to
4034      virtual function tables.  In gcj, every class has a common base
4035      virtual function table in java.lang.object.  */
4036   TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4037
4038   /* Add the private this$<n> field, Replicate final locals still in
4039      scope as private final fields mangled like val$<local_name>.
4040      This doesn't not occur for top level (static) inner classes. */
4041   if (PURE_INNER_CLASS_DECL_P (decl))
4042     add_inner_class_fields (decl, current_function_decl);
4043
4044   /* If doing xref, store the location at which the inherited class
4045      (if any) was seen. */
4046   if (flag_emit_xref && super)
4047     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4048
4049   /* Eventually sets the @deprecated tag flag */
4050   CHECK_DEPRECATED (decl);
4051
4052   /* Reset the anonymous class counter when declaring non inner classes */
4053   if (!INNER_CLASS_DECL_P (decl))
4054     anonymous_class_counter = 1;
4055
4056   return decl;
4057 }
4058
4059 /* End a class declaration: register the statements used to create
4060    finit$ and <clinit>, pop the current class and resume the prior
4061    parser context if necessary.  */
4062
4063 static void
4064 end_class_declaration (int resume)
4065 {
4066   /* If an error occurred, context weren't pushed and won't need to be
4067      popped by a resume. */
4068   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4069
4070   if (GET_CPC () != error_mark_node)
4071     dump_java_tree (TDI_class, GET_CPC ());
4072
4073   java_parser_context_pop_initialized_field ();
4074   POP_CPC ();
4075   if (resume && no_error_occurred)
4076     java_parser_context_resume ();
4077
4078   /* We're ending a class declaration, this is a good time to reset
4079      the interface cout. Note that might have been already done in
4080      create_interface, but if at that time an inner class was being
4081      dealt with, the interface count was reset in a context created
4082      for the sake of handling inner classes declaration. */
4083   ctxp->interface_number = 0;
4084 }
4085
4086 static void
4087 add_inner_class_fields (tree class_decl, tree fct_decl)
4088 {
4089   tree block, marker, f;
4090
4091   f = add_field (TREE_TYPE (class_decl),
4092                  build_current_thisn (TREE_TYPE (class_decl)),
4093                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4094                  ACC_PRIVATE);
4095   FIELD_THISN (f) = 1;
4096
4097   if (!fct_decl)
4098     return;
4099
4100   for (block = GET_CURRENT_BLOCK (fct_decl);
4101        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4102     {
4103       tree decl;
4104       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4105         {
4106           tree name, pname;
4107           tree wfl, init, list;
4108
4109           /* Avoid non final arguments. */
4110           if (!LOCAL_FINAL_P (decl))
4111             continue;
4112
4113           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4114           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4115           wfl = build_wfl_node (name);
4116           init = build_wfl_node (pname);
4117           /* Build an initialization for the field: it will be
4118              initialized by a parameter added to finit$, bearing a
4119              mangled name of the field itself (param$<n>.) The
4120              parameter is provided to finit$ by the constructor
4121              invoking it (hence the constructor will also feature a
4122              hidden parameter, set to the value of the outer context
4123              local at the time the inner class is created.)
4124
4125              Note: we take into account all possible locals that can
4126              be accessed by the inner class. It's actually not trivial
4127              to minimize these aliases down to the ones really
4128              used. One way to do that would be to expand all regular
4129              methods first, then finit$ to get a picture of what's
4130              used.  It works with the exception that we would have to
4131              go back on all constructor invoked in regular methods to
4132              have their invocation reworked (to include the right amount
4133              of alias initializer parameters.)
4134
4135              The only real way around, I think, is a first pass to
4136              identify locals really used in the inner class. We leave
4137              the flag FIELD_LOCAL_ALIAS_USED around for that future
4138              use.
4139
4140              On the other hand, it only affect local inner classes,
4141              whose constructors (and finit$ call) will be featuring
4142              unnecessary arguments. It's easy for a developer to keep
4143              this number of parameter down by using the `final'
4144              keyword only when necessary. For the time being, we can
4145              issue a warning on unnecessary finals. FIXME */
4146           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4147                                    wfl, init);
4148
4149           /* Register the field. The TREE_LIST holding the part
4150              initialized/initializer will be marked ARG_FINAL_P so
4151              that the created field can be marked
4152              FIELD_LOCAL_ALIAS. */
4153           list = build_tree_list (wfl, init);
4154           ARG_FINAL_P (list) = 1;
4155           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4156         }
4157     }
4158
4159   if (!CPC_INITIALIZER_STMT (ctxp))
4160     return;
4161
4162   /* If we ever registered an alias field, insert and marker to
4163      remember where the list ends. The second part of the list (the one
4164      featuring initialized fields) so it can be later reversed to
4165      enforce 8.5. The marker will be removed during that operation. */
4166   marker = build_tree_list (NULL_TREE, NULL_TREE);
4167   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4168   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4169 }
4170
4171 /* Can't use lookup_field () since we don't want to load the class and
4172    can't set the CLASS_LOADED_P flag */
4173
4174 static tree
4175 find_field (tree class, tree name)
4176 {
4177   tree decl;
4178   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4179     {
4180       if (DECL_NAME (decl) == name)
4181         return decl;
4182     }
4183   return NULL_TREE;
4184 }
4185
4186 /* Wrap around lookup_field that doesn't potentially upset the value
4187    of CLASS */
4188
4189 static tree
4190 lookup_field_wrapper (tree class, tree name)
4191 {
4192   tree type = class;
4193   tree decl = NULL_TREE;
4194   java_parser_context_save_global ();
4195
4196   /* Last chance: if we're within the context of an inner class, we
4197      might be trying to access a local variable defined in an outer
4198      context. We try to look for it now. */
4199   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4200     {
4201       tree new_name;
4202       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4203       decl = lookup_field (&type, new_name);
4204       if (decl && decl != error_mark_node)
4205         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4206     }
4207   if (!decl || decl == error_mark_node)
4208     {
4209       type = class;
4210       decl = lookup_field (&type, name);
4211     }
4212
4213   /* If the field still hasn't been found, try the next enclosing context. */
4214   if (!decl && INNER_CLASS_TYPE_P (class))
4215     {
4216       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4217       decl = lookup_field_wrapper (outer_type, name);
4218     }
4219
4220   java_parser_context_restore_global ();
4221   return decl == error_mark_node ? NULL : decl;
4222 }
4223
4224 /* Find duplicate field within the same class declarations and report
4225    the error. Returns 1 if a duplicated field was found, 0
4226    otherwise.  */
4227
4228 static int
4229 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4230 {
4231   /* This might be modified to work with method decl as well */
4232   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4233   if (decl)
4234     {
4235       char *t1 = xstrdup (purify_type_name
4236                          ((TREE_CODE (new_type) == POINTER_TYPE
4237                            && TREE_TYPE (new_type) == NULL_TREE) ?
4238                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4239                           lang_printable_name (new_type, 1)));
4240       /* The type may not have been completed by the time we report
4241          the error */
4242       char *t2 = xstrdup (purify_type_name
4243                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4244                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4245                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4246                           lang_printable_name (TREE_TYPE (decl), 1)));
4247       parse_error_context
4248         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4249          t1, IDENTIFIER_POINTER (new_field_name),
4250          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4251          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4252       free (t1);
4253       free (t2);
4254       return 1;
4255     }
4256   return 0;
4257 }
4258
4259 /* Field registration routine. If TYPE doesn't exist, field
4260    declarations are linked to the undefined TYPE dependency list, to
4261    be later resolved in java_complete_class () */
4262
4263 static void
4264 register_fields (int flags, tree type, tree variable_list)
4265 {
4266   tree current, saved_type;
4267   tree class_type = NULL_TREE;
4268   int saved_lineno = input_line;
4269   int must_chain = 0;
4270   tree wfl = NULL_TREE;
4271
4272   if (GET_CPC ())
4273     class_type = TREE_TYPE (GET_CPC ());
4274
4275   if (!class_type || class_type == error_mark_node)
4276     return;
4277
4278   /* If we're adding fields to interfaces, those fields are public,
4279      static, final */
4280   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4281     {
4282       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4283                                  flags, ACC_PUBLIC, "interface field(s)");
4284       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4285                                  flags, ACC_STATIC, "interface field(s)");
4286       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4287                                  flags, ACC_FINAL, "interface field(s)");
4288       check_modifiers ("Illegal interface member modifier `%s'", flags,
4289                        INTERFACE_FIELD_MODIFIERS);
4290       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4291     }
4292
4293   /* Obtain a suitable type for resolution, if necessary */
4294   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4295
4296   /* If TYPE is fully resolved and we don't have a reference, make one */
4297   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4298
4299   for (current = variable_list, saved_type = type; current;
4300        current = TREE_CHAIN (current), type = saved_type)
4301     {
4302       tree real_type;
4303       tree field_decl;
4304       tree cl = TREE_PURPOSE (current);
4305       tree init = TREE_VALUE (current);
4306       tree current_name = EXPR_WFL_NODE (cl);
4307
4308       /* Can't declare non-final static fields in inner classes */
4309       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4310           && !(flags & ACC_FINAL))
4311         parse_error_context
4312           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4313            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4314            lang_printable_name (class_type, 0));
4315
4316       /* Process NAME, as it may specify extra dimension(s) for it */
4317       type = build_array_from_name (type, wfl, current_name, &current_name);
4318
4319       /* Type adjustment. We may have just readjusted TYPE because
4320          the variable specified more dimensions. Make sure we have
4321          a reference if we can and don't have one already. Also
4322          change the name if we have an init. */
4323       if (type != saved_type)
4324         {
4325           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4326           if (init)
4327             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4328         }
4329
4330       real_type = GET_REAL_TYPE (type);
4331       /* Check for redeclarations */
4332       if (duplicate_declaration_error_p (current_name, real_type, cl))
4333         continue;
4334
4335       /* Set input_line to the line the field was found and create a
4336          declaration for it. Eventually sets the @deprecated tag flag. */
4337       if (flag_emit_xref)
4338         input_line = EXPR_WFL_LINECOL (cl);
4339       else
4340         input_line = EXPR_WFL_LINENO (cl);
4341       field_decl = add_field (class_type, current_name, real_type, flags);
4342       CHECK_DEPRECATED_NO_RESET (field_decl);
4343
4344       /* If the field denotes a final instance variable, then we
4345          allocate a LANG_DECL_SPECIFIC part to keep track of its
4346          initialization. We also mark whether the field was
4347          initialized upon its declaration. We don't do that if the
4348          created field is an alias to a final local. */
4349       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4350         {
4351           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4352           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4353         }
4354
4355       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4356          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4357          hide parameters to this inner class finit$ and
4358          constructors. It also means that the field isn't final per
4359          say. */
4360       if (ARG_FINAL_P (current))
4361         {
4362           FIELD_LOCAL_ALIAS (field_decl) = 1;
4363           FIELD_FINAL (field_decl) = 0;
4364         }
4365
4366       /* Check if we must chain. */
4367       if (must_chain)
4368         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4369
4370       /* If we have an initialization value tied to the field */
4371       if (init)
4372         {
4373           /* The field is declared static */
4374           if (flags & ACC_STATIC)
4375             {
4376               /* We include the field and its initialization part into
4377                  a list used to generate <clinit>. After <clinit> is
4378                  walked, field initializations will be processed and
4379                  fields initialized with known constants will be taken
4380                  out of <clinit> and have their DECL_INITIAL set
4381                  appropriately. */
4382               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4383               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4384               if (TREE_OPERAND (init, 1)
4385                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4386                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4387             }
4388           /* A non-static field declared with an immediate initialization is
4389              to be initialized in <init>, if any.  This field is remembered
4390              to be processed at the time of the generation of <init>. */
4391           else
4392             {
4393               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4394               SET_CPC_INITIALIZER_STMT (ctxp, init);
4395             }
4396           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4397           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4398         }
4399     }
4400
4401   CLEAR_DEPRECATED;
4402   input_line = saved_lineno;
4403 }
4404
4405 /* Generate finit$, using the list of initialized fields to populate
4406    its body. finit$'s parameter(s) list is adjusted to include the
4407    one(s) used to initialized the field(s) caching outer context
4408    local(s).  */
4409
4410 static tree
4411 generate_finit (tree class_type)
4412 {
4413   int count = 0;
4414   tree list = TYPE_FINIT_STMT_LIST (class_type);
4415   tree mdecl, current, parms;
4416
4417   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4418                                                   class_type, NULL_TREE,
4419                                                   &count);
4420   CRAFTED_PARAM_LIST_FIXUP (parms);
4421   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4422                                     finit_identifier_node, parms);
4423   fix_method_argument_names (parms, mdecl);
4424   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4425                        mdecl, NULL_TREE);
4426   DECL_FUNCTION_NAP (mdecl) = count;
4427   start_artificial_method_body (mdecl);
4428
4429   for (current = list; current; current = TREE_CHAIN (current))
4430     java_method_add_stmt (mdecl,
4431                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4432                                                 current));
4433   end_artificial_method_body (mdecl);
4434   return mdecl;
4435 }
4436
4437 /* Generate a function to run the instance initialization code. The
4438    private method is called `instinit$'. Unless we're dealing with an
4439    anonymous class, we determine whether all ctors of CLASS_TYPE
4440    declare a checked exception in their `throws' clause in order to
4441    see whether it's necessary to encapsulate the instance initializer
4442    statements in a try/catch/rethrow sequence.  */
4443
4444 static tree
4445 generate_instinit (tree class_type)
4446 {
4447   tree current;
4448   tree compound = NULL_TREE;
4449   tree parms = tree_cons (this_identifier_node,
4450                           build_pointer_type (class_type), end_params_node);
4451   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4452                                          void_type_node,
4453                                          instinit_identifier_node, parms);
4454
4455   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4456                        mdecl, NULL_TREE);
4457
4458   /* Gather all the statements in a compound */
4459   for (current = TYPE_II_STMT_LIST (class_type);
4460        current; current = TREE_CHAIN (current))
4461     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4462
4463   /* We need to encapsulate COMPOUND by a try/catch statement to
4464      rethrow exceptions that might occur in the instance initializer.
4465      We do that only if all ctors of CLASS_TYPE are set to catch a
4466      checked exception. This doesn't apply to anonymous classes (since
4467      they don't have declared ctors.) */
4468   if (!ANONYMOUS_CLASS_P (class_type) &&
4469       ctors_unchecked_throws_clause_p (class_type))
4470     {
4471       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4472                                              build1 (THROW_EXPR, NULL_TREE,
4473                                                      build_wfl_node (wpv_id)));
4474       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4475                                                       exception_type_node);
4476     }
4477
4478   start_artificial_method_body (mdecl);
4479   java_method_add_stmt (mdecl, compound);
4480   end_artificial_method_body (mdecl);
4481
4482   return mdecl;
4483 }
4484
4485 /* FIXME */
4486 static tree
4487 build_instinit_invocation (tree class_type)
4488 {
4489   tree to_return = NULL_TREE;
4490
4491   if (TYPE_II_STMT_LIST (class_type))
4492     {
4493       tree parm = build_tree_list (NULL_TREE,
4494                                    build_wfl_node (this_identifier_node));
4495       to_return =
4496         build_method_invocation (build_wfl_node (instinit_identifier_node),
4497                                  parm);
4498     }
4499   return to_return;
4500 }
4501
4502 /* Shared across method_declarator and method_header to remember the
4503    patch stage that was reached during the declaration of the method.
4504    A method DECL is built differently is there is no patch
4505    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4506    pending on the currently defined method.  */
4507
4508 static int patch_stage;
4509
4510 /* Check the method declaration and add the method to its current
4511    class.  If the argument list is known to contain incomplete types,
4512    the method is partially added and the registration will be resume
4513    once the method arguments resolved. If TYPE is NULL, we're dealing
4514    with a constructor.  */
4515
4516 static tree
4517 method_header (int flags, tree type, tree mdecl, tree throws)
4518 {
4519   tree type_wfl = NULL_TREE;
4520   tree meth_name = NULL_TREE;
4521   tree current, orig_arg, this_class = NULL;
4522   tree id, meth;
4523   int saved_lineno;
4524   int constructor_ok = 0, must_chain;
4525   int count;
4526
4527   if (mdecl == error_mark_node)
4528     return error_mark_node;
4529   meth = TREE_VALUE (mdecl);
4530   id = TREE_PURPOSE (mdecl);
4531
4532   check_modifiers_consistency (flags);
4533
4534   if (GET_CPC ())
4535     this_class = TREE_TYPE (GET_CPC ());
4536
4537   if (!this_class || this_class == error_mark_node)
4538     return NULL_TREE;
4539
4540   /* There are some forbidden modifiers for an abstract method and its
4541      class must be abstract as well.  */
4542   if (type && (flags & ACC_ABSTRACT))
4543     {
4544       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4545       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4546       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4547       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4548       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4549       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4550       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4551           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4552         parse_error_context
4553           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4554            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4555            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4556     }
4557
4558   /* A native method can't be strictfp.  */
4559   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4560     parse_error_context (id, "native method `%s' can't be strictfp",
4561                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4562   /* No such thing as a transient or volatile method.  */
4563   if ((flags & ACC_TRANSIENT))
4564     parse_error_context (id, "method `%s' can't be transient",
4565                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4566   if ((flags & ACC_VOLATILE))
4567     parse_error_context (id, "method `%s' can't be volatile",
4568                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4569
4570   /* Things to be checked when declaring a constructor */
4571   if (!type)
4572     {
4573       int ec = java_error_count;
4574       /* 8.6: Constructor declarations: we might be trying to define a
4575          method without specifying a return type. */
4576       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4577         parse_error_context
4578           (id, "Invalid method declaration, return type required");
4579       /* 8.6.3: Constructor modifiers */
4580       else
4581         {
4582           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4583           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4584           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4585           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4586           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4587           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4588         }
4589       /* If we found error here, we don't consider it's OK to tread
4590          the method definition as a constructor, for the rest of this
4591          function */
4592       if (ec == java_error_count)
4593         constructor_ok = 1;
4594     }
4595
4596   /* Method declared within the scope of an interface are implicitly
4597      abstract and public. Conflicts with other erroneously provided
4598      modifiers are checked right after. */
4599
4600   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4601     {
4602       /* If FLAGS isn't set because of a modifier, turn the
4603          corresponding modifier WFL to NULL so we issue a warning on
4604          the obsolete use of the modifier */
4605       if (!(flags & ACC_PUBLIC))
4606         MODIFIER_WFL (PUBLIC_TK) = NULL;
4607       if (!(flags & ACC_ABSTRACT))
4608         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4609       flags |= ACC_PUBLIC;
4610       flags |= ACC_ABSTRACT;
4611     }
4612
4613   /* Inner class can't declare static methods */
4614   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4615     {
4616       parse_error_context
4617         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4618          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4619          lang_printable_name (this_class, 0));
4620     }
4621
4622   /* Modifiers context reset moved up, so abstract method declaration
4623      modifiers can be later checked.  */
4624
4625   /* Set constructor returned type to void and method name to <init>,
4626      unless we found an error identifier the constructor (in which
4627      case we retain the original name) */
4628   if (!type)
4629     {
4630       type = void_type_node;
4631       if (constructor_ok)
4632         meth_name = init_identifier_node;
4633     }
4634   else
4635     meth_name = EXPR_WFL_NODE (id);
4636
4637   /* Do the returned type resolution and registration if necessary */
4638   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4639
4640   if (meth_name)
4641     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4642   EXPR_WFL_NODE (id) = meth_name;
4643   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4644
4645   if (must_chain)
4646     {
4647       patch_stage = JDEP_METHOD_RETURN;
4648       register_incomplete_type (patch_stage, type_wfl, id, type);
4649       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4650     }
4651   else
4652     TREE_TYPE (meth) = type;
4653
4654   saved_lineno = input_line;
4655   /* When defining an abstract or interface method, the curly
4656      bracket at level 1 doesn't exist because there is no function
4657      body */
4658   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4659             EXPR_WFL_LINENO (id));
4660
4661   /* Remember the original argument list */
4662   orig_arg = TYPE_ARG_TYPES (meth);
4663
4664   if (patch_stage)              /* includes ret type and/or all args */
4665     {
4666       jdep *jdep;
4667       meth = add_method_1 (this_class, flags, meth_name, meth);
4668       /* Patch for the return type */
4669       if (patch_stage == JDEP_METHOD_RETURN)
4670         {
4671           jdep = CLASSD_LAST (ctxp->classd_list);
4672           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4673         }
4674       /* This is the stop JDEP. METH allows the function's signature
4675          to be computed. */
4676       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4677     }
4678   else
4679     meth = add_method (this_class, flags, meth_name,
4680                        build_java_signature (meth));
4681
4682   /* Remember final parameters */
4683   MARK_FINAL_PARMS (meth, orig_arg);
4684
4685   /* Fix the method argument list so we have the argument name
4686      information */
4687   fix_method_argument_names (orig_arg, meth);
4688
4689   /* Register the parameter number and re-install the current line
4690      number */
4691   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4692   input_line = saved_lineno;
4693
4694   /* Register exception specified by the `throws' keyword for
4695      resolution and set the method decl appropriate field to the list.
4696      Note: the grammar ensures that what we get here are class
4697      types. */
4698   if (throws)
4699     {
4700       throws = nreverse (throws);
4701       for (current = throws; current; current = TREE_CHAIN (current))
4702         {
4703           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4704                                     NULL_TREE, NULL_TREE);
4705           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4706             &TREE_VALUE (current);
4707         }
4708       DECL_FUNCTION_THROWS (meth) = throws;
4709     }
4710
4711   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4712     DECL_FUNCTION_WFL (meth) = id;
4713
4714   /* Set the flag if we correctly processed a constructor */
4715   if (constructor_ok)
4716     {
4717       DECL_CONSTRUCTOR_P (meth) = 1;
4718       /* Compute and store the number of artificial parameters declared
4719          for this constructor */
4720       for (count = 0, current = TYPE_FIELDS (this_class); current;
4721            current = TREE_CHAIN (current))
4722         if (FIELD_LOCAL_ALIAS (current))
4723           count++;
4724       DECL_FUNCTION_NAP (meth) = count;
4725     }
4726
4727   /* Eventually set the @deprecated tag flag */
4728   CHECK_DEPRECATED (meth);
4729
4730   /* If doing xref, store column and line number information instead
4731      of the line number only. */
4732   if (flag_emit_xref)
4733     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4734
4735   return meth;
4736 }
4737
4738 static void
4739 fix_method_argument_names (tree orig_arg, tree meth)
4740 {
4741   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4742   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4743     {
4744       TREE_PURPOSE (arg) = this_identifier_node;
4745       arg = TREE_CHAIN (arg);
4746     }
4747   while (orig_arg != end_params_node)
4748     {
4749       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4750       orig_arg = TREE_CHAIN (orig_arg);
4751       arg = TREE_CHAIN (arg);
4752     }
4753 }
4754
4755 /* Complete the method declaration with METHOD_BODY.  */
4756
4757 static void
4758 finish_method_declaration (tree method_body)
4759 {
4760   int flags;
4761
4762   if (!current_function_decl)
4763     return;
4764
4765   flags = get_access_flags_from_decl (current_function_decl);
4766
4767   /* 8.4.5 Method Body */
4768   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4769     {
4770       tree name = DECL_NAME (current_function_decl);
4771       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4772                            "%s method `%s' can't have a body defined",
4773                            (METHOD_NATIVE (current_function_decl) ?
4774                             "Native" : "Abstract"),
4775                            IDENTIFIER_POINTER (name));
4776       method_body = NULL_TREE;
4777     }
4778   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4779     {
4780       tree name = DECL_NAME (current_function_decl);
4781       parse_error_context
4782         (DECL_FUNCTION_WFL (current_function_decl),
4783          "Non native and non abstract method `%s' must have a body defined",
4784          IDENTIFIER_POINTER (name));
4785       method_body = NULL_TREE;
4786     }
4787
4788   if (flag_emit_class_files && method_body
4789       && TREE_CODE (method_body) == NOP_EXPR
4790       && TREE_TYPE (current_function_decl)
4791       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4792     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4793
4794   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4795   maybe_absorb_scoping_blocks ();
4796   /* Exit function's body */
4797   exit_block ();
4798   /* Merge last line of the function with first line, directly in the
4799      function decl. It will be used to emit correct debug info. */
4800   if (!flag_emit_xref)
4801     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4802
4803   /* Since function's argument's list are shared, reset the
4804      ARG_FINAL_P parameter that might have been set on some of this
4805      function parameters. */
4806   UNMARK_FINAL_PARMS (current_function_decl);
4807
4808   /* So we don't have an irrelevant function declaration context for
4809      the next static block we'll see. */
4810   current_function_decl = NULL_TREE;
4811 }
4812
4813 /* Build a an error message for constructor circularity errors.  */
4814
4815 static char *
4816 constructor_circularity_msg (tree from, tree to)
4817 {
4818   static char string [4096];
4819   char *t = xstrdup (lang_printable_name (from, 0));
4820   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4821   free (t);
4822   return string;
4823 }
4824
4825 /* Verify a circular call to METH. Return 1 if an error is found, 0
4826    otherwise.  */
4827
4828 static GTY(()) tree vcc_list;
4829 static int
4830 verify_constructor_circularity (tree meth, tree current)
4831 {
4832   tree c;
4833
4834   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4835     {
4836       if (TREE_VALUE (c) == meth)
4837         {
4838           char *t;
4839           if (vcc_list)
4840             {
4841               tree liste;
4842               vcc_list = nreverse (vcc_list);
4843               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4844                 {
4845                   parse_error_context
4846                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4847                      constructor_circularity_msg
4848                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4849                   java_error_count--;
4850                 }
4851             }
4852           t = xstrdup (lang_printable_name (meth, 0));
4853           parse_error_context (TREE_PURPOSE (c),
4854                                "%s: recursive invocation of constructor `%s'",
4855                                constructor_circularity_msg (current, meth), t);
4856           free (t);
4857           vcc_list = NULL_TREE;
4858           return 1;
4859         }
4860     }
4861   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4862     {
4863       vcc_list = tree_cons (c, current, vcc_list);
4864       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4865         return 1;
4866       vcc_list = TREE_CHAIN (vcc_list);
4867     }
4868   return 0;
4869 }
4870
4871 /* Check modifiers that can be declared but exclusively */
4872
4873 static void
4874 check_modifiers_consistency (int flags)
4875 {
4876   int acc_count = 0;
4877   tree cl = NULL_TREE;
4878
4879   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4880   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4881   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4882   if (acc_count > 1)
4883     parse_error_context
4884       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4885
4886   acc_count = 0;
4887   cl = NULL_TREE;
4888   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4889   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4890   if (acc_count > 1)
4891     parse_error_context (cl,
4892                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4893 }
4894
4895 /* Check the methode header METH for abstract specifics features */
4896
4897 static void
4898 check_abstract_method_header (tree meth)
4899 {
4900   int flags = get_access_flags_from_decl (meth);
4901
4902   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4903                               ACC_ABSTRACT, "abstract method",
4904                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4905   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4906                               ACC_PUBLIC, "abstract method",
4907                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4908
4909   check_modifiers ("Illegal modifier `%s' for interface method",
4910                   flags, INTERFACE_METHOD_MODIFIERS);
4911 }
4912
4913 /* Create a FUNCTION_TYPE node and start augmenting it with the
4914    declared function arguments. Arguments type that can't be resolved
4915    are left as they are, but the returned node is marked as containing
4916    incomplete types.  */
4917
4918 static tree
4919 method_declarator (tree id, tree list)
4920 {
4921   tree arg_types = NULL_TREE, current, node;
4922   tree meth = make_node (FUNCTION_TYPE);
4923   jdep *jdep;
4924
4925   patch_stage = JDEP_NO_PATCH;
4926
4927   if (GET_CPC () == error_mark_node)
4928     return error_mark_node;
4929
4930   /* If we're dealing with an inner class constructor, we hide the
4931      this$<n> decl in the name field of its parameter declaration.  We
4932      also might have to hide the outer context local alias
4933      initializers. Not done when the class is a toplevel class. */
4934   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4935       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4936     {
4937       tree aliases_list, type, thisn;
4938       /* First the aliases, linked to the regular parameters */
4939       aliases_list =
4940         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4941                                                 TREE_TYPE (GET_CPC ()),
4942                                                 NULL_TREE, NULL);
4943       list = chainon (nreverse (aliases_list), list);
4944
4945       /* Then this$<n> */
4946       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4947       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4948       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4949                         list);
4950     }
4951
4952   for (current = list; current; current = TREE_CHAIN (current))
4953     {
4954       int must_chain = 0;
4955       tree wfl_name = TREE_PURPOSE (current);
4956       tree type = TREE_VALUE (current);
4957       tree name = EXPR_WFL_NODE (wfl_name);
4958       tree already, arg_node;
4959       tree type_wfl = NULL_TREE;
4960       tree real_type;
4961
4962       /* Obtain a suitable type for resolution, if necessary */
4963       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4964
4965       /* Process NAME, as it may specify extra dimension(s) for it */
4966       type = build_array_from_name (type, type_wfl, name, &name);
4967       EXPR_WFL_NODE (wfl_name) = name;
4968
4969       real_type = GET_REAL_TYPE (type);
4970       if (TREE_CODE (real_type) == RECORD_TYPE)
4971         {
4972           real_type = promote_type (real_type);
4973           if (TREE_CODE (type) == TREE_LIST)
4974             TREE_PURPOSE (type) = real_type;
4975         }
4976
4977       /* Check redefinition */
4978       for (already = arg_types; already; already = TREE_CHAIN (already))
4979         if (TREE_PURPOSE (already) == name)
4980           {
4981             parse_error_context
4982               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4983                IDENTIFIER_POINTER (name),
4984                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4985             break;
4986           }
4987
4988       /* If we've an incomplete argument type, we know there is a location
4989          to patch when the type get resolved, later.  */
4990       jdep = NULL;
4991       if (must_chain)
4992         {
4993           patch_stage = JDEP_METHOD;
4994           type = register_incomplete_type (patch_stage,
4995                                            type_wfl, wfl_name, type);
4996           jdep = CLASSD_LAST (ctxp->classd_list);
4997           JDEP_MISC (jdep) = id;
4998         }
4999
5000       /* The argument node: a name and a (possibly) incomplete type.  */
5001       arg_node = build_tree_list (name, real_type);
5002       /* Remember arguments declared final. */
5003       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5004
5005       if (jdep)
5006         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5007       TREE_CHAIN (arg_node) = arg_types;
5008       arg_types = arg_node;
5009     }
5010   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5011   node = build_tree_list (id, meth);
5012   return node;
5013 }
5014
5015 static int
5016 unresolved_type_p (tree wfl, tree *returned)
5017
5018 {
5019   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5020     {
5021       if (returned)
5022         {
5023           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5024           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5025             *returned = TREE_TYPE (decl);
5026           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5027             *returned = TREE_TYPE (GET_CPC ());
5028           else
5029             *returned = NULL_TREE;
5030         }
5031       return 1;
5032     }
5033   if (returned)
5034     *returned = wfl;
5035   return 0;
5036 }
5037
5038 /* From NAME, build a qualified identifier node using the
5039    qualification from the current package definition. */
5040
5041 static tree
5042 parser_qualified_classname (tree name)
5043 {
5044   tree nested_class_name;
5045
5046   if ((nested_class_name = maybe_make_nested_class_name (name)))
5047     return nested_class_name;
5048
5049   if (ctxp->package)
5050     return merge_qualified_name (ctxp->package, name);
5051   else
5052     return name;
5053 }
5054
5055 /* Called once the type a interface extends is resolved. Returns 0 if
5056    everything is OK.  */
5057
5058 static int
5059 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5060 {
5061   tree super_type = TREE_TYPE (super_decl);
5062
5063   /* Has to be an interface */
5064   if (!CLASS_INTERFACE (super_decl))
5065     {
5066       parse_error_context
5067         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5068          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5069           "Interface" : "Class"),
5070          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5071          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5072          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5073       return 1;
5074     }
5075
5076   /* Check top-level interface access. Inner classes are subject to member
5077      access rules (6.6.1). */
5078   if (! INNER_CLASS_P (super_type)
5079       && check_pkg_class_access (DECL_NAME (super_decl),
5080                                  NULL_TREE, true, this_decl))
5081     return 1;
5082
5083   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5084                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5085                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5086   return 0;
5087 }
5088
5089 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5090    0 if everything is OK.  */
5091
5092 static int
5093 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5094 {
5095   tree super_type = TREE_TYPE (super_decl);
5096
5097   /* SUPER should be a CLASS (neither an array nor an interface) */
5098   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5099     {
5100       parse_error_context
5101         (wfl, "Class `%s' can't subclass %s `%s'",
5102          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5103          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5104          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5105       return 1;
5106     }
5107
5108   if (CLASS_FINAL (TYPE_NAME (super_type)))
5109     {
5110       parse_error_context (wfl, "Can't subclass final classes: %s",
5111                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5112       return 1;
5113     }
5114
5115   /* Check top-level class scope. Inner classes are subject to member access
5116      rules (6.6.1). */
5117   if (! INNER_CLASS_P (super_type)
5118       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5119     return 1;
5120
5121   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5122                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5123                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5124   return 0;
5125 }
5126
5127 /* Create a new dependency list and link it (in a LIFO manner) to the
5128    CTXP list of type dependency list.  */
5129
5130 static void
5131 create_jdep_list (struct parser_ctxt *ctxp)
5132 {
5133   jdeplist *new = xmalloc (sizeof (jdeplist));
5134   new->first = new->last = NULL;
5135   new->next = ctxp->classd_list;
5136   ctxp->classd_list = new;
5137 }
5138
5139 static jdeplist *
5140 reverse_jdep_list (struct parser_ctxt *ctxp)
5141 {
5142   jdeplist *prev = NULL, *current, *next;
5143   for (current = ctxp->classd_list; current; current = next)
5144     {
5145       next = current->next;
5146       current->next = prev;
5147       prev = current;
5148     }
5149   return prev;
5150 }
5151
5152 /* Create a fake pointer based on the ID stored in
5153    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5154    registered again. */
5155
5156 static tree
5157 obtain_incomplete_type (tree type_name)
5158 {
5159   tree ptr = NULL_TREE, name;
5160
5161   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5162     name = EXPR_WFL_NODE (type_name);
5163   else if (INCOMPLETE_TYPE_P (type_name))
5164     name = TYPE_NAME (type_name);
5165   else
5166     abort ();
5167
5168   /* Workaround from build_pointer_type for incomplete types.  */
5169   BUILD_PTR_FROM_NAME (ptr, name);
5170   TYPE_MODE (ptr) = ptr_mode;
5171   layout_type (ptr);
5172
5173   return ptr;
5174 }
5175
5176 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5177    non NULL instead of computing a new fake type based on WFL. The new
5178    dependency is inserted in the current type dependency list, in FIFO
5179    manner.  */
5180
5181 static tree
5182 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5183 {
5184   jdep *new = xmalloc (sizeof (jdep));
5185
5186   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5187     ptr = obtain_incomplete_type (wfl);
5188
5189   JDEP_KIND (new) = kind;
5190   JDEP_DECL (new) = decl;
5191   JDEP_TO_RESOLVE (new) = ptr;
5192   JDEP_WFL (new) = wfl;
5193   JDEP_CHAIN (new) = NULL;
5194   JDEP_MISC (new) = NULL_TREE;
5195   /* For some dependencies, set the enclosing class of the current
5196      class to be the enclosing context */
5197   if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
5198       && GET_ENCLOSING_CPC ())
5199     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5200   else
5201     JDEP_ENCLOSING (new) = GET_CPC ();
5202   JDEP_GET_PATCH (new) = (tree *)NULL;
5203
5204   JDEP_INSERT (ctxp->classd_list, new);
5205
5206   return ptr;
5207 }
5208
5209 /* This checks for circular references with innerclasses. We start
5210    from SOURCE and should never reach TARGET. Extended/implemented
5211    types in SOURCE have their enclosing context checked not to reach
5212    TARGET. When the last enclosing context of SOURCE is reached, its
5213    extended/implemented types are also checked not to reach TARGET.
5214    In case of error, WFL of the offending type is returned; NULL_TREE
5215    otherwise.  */
5216
5217 static tree
5218 check_inner_circular_reference (tree source, tree target)
5219 {
5220   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5221   tree ctx, cl;
5222   int i;
5223
5224   if (!basetype_vec)
5225     return NULL_TREE;
5226
5227   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5228     {
5229       tree su;
5230
5231       /* We can end up with a NULL_TREE or an incomplete type here if
5232          we encountered previous type resolution errors. It's safe to
5233          simply ignore these cases.  */
5234       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5235         continue;
5236       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5237       if (INCOMPLETE_TYPE_P (su))
5238         continue;
5239
5240       if (inherits_from_p (su, target))
5241         return lookup_cl (TYPE_NAME (su));
5242
5243       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5244         {
5245           /* An enclosing context shouldn't be TARGET */
5246           if (ctx == TYPE_NAME (target))
5247             return lookup_cl (TYPE_NAME (su));
5248
5249           /* When we reach the enclosing last context, start a check
5250              on it, with the same target */
5251           if (! DECL_CONTEXT (ctx) &&
5252               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5253             return cl;
5254         }
5255     }
5256   return NULL_TREE;
5257 }
5258
5259 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5260    offending type if a circularity is detected. NULL_TREE is returned
5261    otherwise. TYPE can be an interface or a class.   */
5262
5263 static tree
5264 check_circular_reference (tree type)
5265 {
5266   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5267   int i;
5268
5269   if (!basetype_vec)
5270     return NULL_TREE;
5271
5272   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5273     {
5274       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5275         return lookup_cl (TYPE_NAME (type));
5276       return NULL_TREE;
5277     }
5278
5279   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5280     {
5281       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5282       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5283           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5284         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5285     }
5286   return NULL_TREE;
5287 }
5288
5289 void
5290 java_check_circular_reference (void)
5291 {
5292   tree current;
5293   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5294     {
5295       tree type = TREE_TYPE (current);
5296       tree cl;
5297
5298       cl = check_circular_reference (type);
5299       if (! cl)
5300         cl = check_inner_circular_reference (type, type);
5301       if (cl)
5302         parse_error_context (cl, "Cyclic class inheritance%s",
5303                              (cyclic_inheritance_report ?
5304                               cyclic_inheritance_report : ""));
5305     }
5306 }
5307
5308 /* Augment the parameter list PARM with parameters crafted to
5309    initialize outer context locals aliases. Through ARTIFICIAL, a
5310    count is kept of the number of crafted parameters. MODE governs
5311    what eventually gets created: something suitable for a function
5312    creation or a function invocation, either the constructor or
5313    finit$.  */
5314
5315 static tree
5316 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5317                                         int *artificial)
5318 {
5319   tree field;
5320   tree additional_parms = NULL_TREE;
5321
5322   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5323     if (FIELD_LOCAL_ALIAS (field))
5324       {
5325         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5326         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5327         tree mangled_id;
5328
5329         switch (mode)
5330           {
5331           case AIPL_FUNCTION_DECLARATION:
5332             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5333                                                          &buffer [4]);
5334             purpose = build_wfl_node (mangled_id);
5335             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5336               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5337             else
5338               value = TREE_TYPE (field);
5339             break;
5340
5341           case AIPL_FUNCTION_CREATION:
5342             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5343                                                          &buffer [4]);
5344             value = TREE_TYPE (field);
5345             break;
5346
5347           case AIPL_FUNCTION_FINIT_INVOCATION:
5348             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5349                                                          &buffer [4]);
5350             /* Now, this is wrong. purpose should always be the NAME
5351                of something and value its matching value (decl, type,
5352                etc...) FIXME -- but there is a lot to fix. */
5353
5354             /* When invoked for this kind of operation, we already
5355                know whether a field is used or not. */
5356             purpose = TREE_TYPE (field);
5357             value = build_wfl_node (mangled_id);
5358             break;
5359
5360           case AIPL_FUNCTION_CTOR_INVOCATION:
5361             /* There are two case: the constructor invocation happens
5362                outside the local inner, in which case, locales from the outer
5363                context are directly used.
5364
5365                Otherwise, we fold to using the alias directly. */
5366             if (class_type == current_class)
5367               value = field;
5368             else
5369               {
5370                 name = get_identifier (&buffer[4]);
5371                 value = IDENTIFIER_LOCAL_VALUE (name);
5372               }
5373             break;
5374           }
5375         additional_parms = tree_cons (purpose, value, additional_parms);
5376         if (artificial)
5377           *artificial +=1;
5378       }
5379   if (additional_parms)
5380     {
5381       if (ANONYMOUS_CLASS_P (class_type)
5382           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5383         additional_parms = nreverse (additional_parms);
5384       parm = chainon (additional_parms, parm);
5385     }
5386
5387    return parm;
5388 }
5389
5390 /* Craft a constructor for CLASS_DECL -- what we should do when none
5391    where found. ARGS is non NULL when a special signature must be
5392    enforced. This is the case for anonymous classes.  */
5393
5394 static tree
5395 craft_constructor (tree class_decl, tree args)
5396 {
5397   tree class_type = TREE_TYPE (class_decl);
5398   tree parm = NULL_TREE;
5399   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5400                ACC_PUBLIC : 0);
5401   int i = 0, artificial = 0;
5402   tree decl, ctor_name;
5403   char buffer [80];
5404
5405   /* The constructor name is <init> unless we're dealing with an
5406      anonymous class, in which case the name will be fixed after having
5407      be expanded. */
5408   if (ANONYMOUS_CLASS_P (class_type))
5409     ctor_name = DECL_NAME (class_decl);
5410   else
5411     ctor_name = init_identifier_node;
5412
5413   /* If we're dealing with an inner class constructor, we hide the
5414      this$<n> decl in the name field of its parameter declaration. */
5415   if (PURE_INNER_CLASS_TYPE_P (class_type))
5416     {
5417       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5418       parm = tree_cons (build_current_thisn (class_type),
5419                         build_pointer_type (type), parm);
5420
5421       /* Some more arguments to be hidden here. The values of the local
5422          variables of the outer context that the inner class needs to see. */
5423       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5424                                                      class_type, parm,
5425                                                      &artificial);
5426     }
5427
5428   /* Then if there are any args to be enforced, enforce them now */
5429   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5430     {
5431       sprintf (buffer, "parm%d", i++);
5432       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5433     }
5434
5435   CRAFTED_PARAM_LIST_FIXUP (parm);
5436   decl = create_artificial_method (class_type, flags, void_type_node,
5437                                    ctor_name, parm);
5438   fix_method_argument_names (parm, decl);
5439   /* Now, mark the artificial parameters. */
5440   DECL_FUNCTION_NAP (decl) = artificial;
5441   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5442   DECL_INLINE (decl) = 1;
5443   return decl;
5444 }
5445
5446
5447 /* Fix the constructors. This will be called right after circular
5448    references have been checked. It is necessary to fix constructors
5449    early even if no code generation will take place for that class:
5450    some generated constructor might be required by the class whose
5451    compilation triggered this one to be simply loaded.  */
5452
5453 void
5454 java_fix_constructors (void)
5455 {
5456   tree current;
5457
5458   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5459     {
5460       tree class_type = TREE_TYPE (current);
5461       int saw_ctor = 0;
5462       tree decl;
5463
5464       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5465         continue;
5466
5467       output_class = current_class = class_type;
5468       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5469         {
5470           if (DECL_CONSTRUCTOR_P (decl))
5471             {
5472               fix_constructors (decl);
5473               saw_ctor = 1;
5474             }
5475         }
5476
5477       /* Anonymous class constructor can't be generated that early. */
5478       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5479         craft_constructor (current, NULL_TREE);
5480     }
5481 }
5482
5483 /* safe_layout_class just makes sure that we can load a class without
5484    disrupting the current_class, input_file, input_line, etc, information
5485    about the class processed currently.  */
5486
5487 void
5488 safe_layout_class (tree class)
5489 {
5490   tree save_current_class = current_class;
5491   location_t save_location = input_location;
5492
5493   layout_class (class);
5494
5495   current_class = save_current_class;
5496   input_location = save_location;
5497 }
5498
5499 static tree
5500 jdep_resolve_class (jdep *dep)
5501 {
5502   tree decl;
5503
5504   if (JDEP_RESOLVED_P (dep))
5505     decl = JDEP_RESOLVED_DECL (dep);
5506   else
5507     {
5508       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5509                             JDEP_DECL (dep), JDEP_WFL (dep));
5510       JDEP_RESOLVED (dep, decl);
5511       /* If there is no WFL, that's ok.  We generate this warning
5512          elsewhere.  */
5513       if (decl && JDEP_WFL (dep) != NULL_TREE)
5514         check_deprecation (JDEP_WFL (dep), decl);
5515     }
5516
5517   if (!decl)
5518     complete_class_report_errors (dep);
5519   else if (INNER_CLASS_DECL_P (decl))
5520     {
5521       tree inner = TREE_TYPE (decl);
5522       if (! CLASS_LOADED_P (inner))
5523         {
5524           safe_layout_class (inner);
5525           if (TYPE_SIZE (inner) == error_mark_node)
5526             TYPE_SIZE (inner) = NULL_TREE;
5527         }
5528       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5529     }
5530   return decl;
5531 }
5532
5533 /* Complete unsatisfied class declaration and their dependencies */
5534
5535 void
5536 java_complete_class (void)
5537 {
5538   tree cclass;
5539   jdeplist *cclassd;
5540   int error_found;
5541   tree type;
5542
5543   /* Process imports */
5544   process_imports ();
5545
5546   /* Reverse things so we have the right order */
5547   ctxp->class_list = nreverse (ctxp->class_list);
5548   ctxp->classd_list = reverse_jdep_list (ctxp);
5549
5550   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5551        cclass && cclassd;
5552        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5553     {
5554       jdep *dep;
5555
5556       /* We keep the compilation unit imports in the class so that
5557          they can be used later to resolve type dependencies that
5558          aren't necessary to solve now. */
5559       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5560       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5561
5562       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5563         {
5564           tree decl;
5565           if (!(decl = jdep_resolve_class (dep)))
5566             continue;
5567
5568           /* Now it's time to patch */
5569           switch (JDEP_KIND (dep))
5570             {
5571             case JDEP_SUPER:
5572               /* Simply patch super */
5573               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5574                 continue;
5575               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5576                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5577               break;
5578
5579             case JDEP_FIELD:
5580               {
5581                 /* We do part of the job done in add_field */
5582                 tree field_decl = JDEP_DECL (dep);
5583                 tree field_type = TREE_TYPE (decl);
5584                 if (TREE_CODE (field_type) == RECORD_TYPE)
5585                   field_type = promote_type (field_type);
5586                 TREE_TYPE (field_decl) = field_type;
5587                 DECL_ALIGN (field_decl) = 0;
5588                 DECL_USER_ALIGN (field_decl) = 0;
5589                 layout_decl (field_decl, 0);
5590                 SOURCE_FRONTEND_DEBUG
5591                   (("Completed field/var decl `%s' with `%s'",
5592                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5593                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5594                 break;
5595               }
5596             case JDEP_METHOD:   /* We start patching a method */
5597             case JDEP_METHOD_RETURN:
5598               error_found = 0;
5599               while (1)
5600                 {
5601                   if (decl)
5602                     {
5603                       type = TREE_TYPE(decl);
5604                       if (TREE_CODE (type) == RECORD_TYPE)
5605                         type = promote_type (type);
5606                       JDEP_APPLY_PATCH (dep, type);
5607                       SOURCE_FRONTEND_DEBUG
5608                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5609                            "Completing fct `%s' with ret type `%s'":
5610                            "Completing arg `%s' with type `%s'"),
5611                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5612                                               (JDEP_DECL_WFL (dep))),
5613                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5614                     }
5615                   else
5616                     error_found = 1;
5617                   dep = JDEP_CHAIN (dep);
5618                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5619                     break;
5620                   else
5621                     decl = jdep_resolve_class (dep);
5622                 }
5623               if (!error_found)
5624                 {
5625                   tree mdecl = JDEP_DECL (dep), signature;
5626                   /* Recompute and reset the signature, check first that
5627                      all types are now defined. If they're not,
5628                      don't build the signature. */
5629                   if (check_method_types_complete (mdecl))
5630                     {
5631                       signature = build_java_signature (TREE_TYPE (mdecl));
5632                       set_java_signature (TREE_TYPE (mdecl), signature);
5633                     }
5634                 }
5635               else
5636                 continue;
5637               break;
5638
5639             case JDEP_INTERFACE:
5640               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5641                                                 JDEP_WFL (dep)))
5642                 continue;
5643               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5644               break;
5645
5646             case JDEP_PARM:
5647             case JDEP_VARIABLE:
5648               type = TREE_TYPE(decl);
5649               if (TREE_CODE (type) == RECORD_TYPE)
5650                 type = promote_type (type);
5651               JDEP_APPLY_PATCH (dep, type);
5652               break;
5653
5654             case JDEP_TYPE:
5655               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5656               SOURCE_FRONTEND_DEBUG
5657                 (("Completing a random type dependency on a '%s' node",
5658                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5659               break;
5660
5661             case JDEP_EXCEPTION:
5662               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5663               SOURCE_FRONTEND_DEBUG
5664                 (("Completing `%s' `throws' argument node",
5665                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5666               break;
5667
5668             case JDEP_ANONYMOUS:
5669               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5670               break;
5671
5672             default:
5673               abort ();
5674             }
5675         }
5676     }
5677   return;
5678 }
5679
5680 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5681    array.  */
5682
5683 static tree
5684 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5685 {
5686   tree tname = TYPE_NAME (class_type);
5687   tree resolved_type = TREE_TYPE (class_type);
5688   int array_dims = 0;
5689   tree resolved_type_decl;
5690
5691   if (resolved_type != NULL_TREE)
5692     {
5693       tree resolved_type_decl = TYPE_NAME (resolved_type);
5694       if (resolved_type_decl == NULL_TREE
5695           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5696         {
5697           resolved_type_decl = build_decl (TYPE_DECL,
5698                                            TYPE_NAME (class_type),
5699                                            resolved_type);
5700         }
5701       return resolved_type_decl;
5702     }
5703
5704   /* 1- Check to see if we have an array. If true, find what we really
5705      want to resolve  */
5706   if ((array_dims = build_type_name_from_array_name (tname,
5707                                                      &TYPE_NAME (class_type))))
5708     WFL_STRIP_BRACKET (cl, cl);
5709
5710   /* 2- Resolve the bare type */
5711   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5712                                                decl, cl)))
5713     return NULL_TREE;
5714   resolved_type = TREE_TYPE (resolved_type_decl);
5715
5716   /* 3- If we have an array, reconstruct the array down to its nesting */
5717   if (array_dims)
5718     {
5719       for (; array_dims; array_dims--)
5720         resolved_type = build_java_array_type (resolved_type, -1);
5721       resolved_type_decl = TYPE_NAME (resolved_type);
5722     }
5723   TREE_TYPE (class_type) = resolved_type;
5724   return resolved_type_decl;
5725 }
5726
5727 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5728    are used to report error messages; CL must either be NULL_TREE or a
5729    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5730    by a variable, since it is changed by find_in_imports{_on_demand}
5731    and (but it doesn't really matter) qualify_and_find.  */
5732
5733 tree
5734 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5735 {
5736   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5737   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5738   tree decl_result;
5739   htab_t circularity_hash;
5740
5741   if (QUALIFIED_P (TYPE_NAME (class_type)))
5742     {
5743       /* If the type name is of the form `Q . Id', then Q is either a
5744          package name or a class name.  First we try to find Q as a
5745          class and then treat Id as a member type.  If we can't find Q
5746          as a class then we fall through.  */
5747       tree q, left, left_type, right;
5748       if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5749         {
5750           BUILD_PTR_FROM_NAME (left_type, left);
5751           q = do_resolve_class (enclosing, left_type, decl, cl);
5752           if (q)
5753             {
5754               enclosing = q;
5755               saved_enclosing_type = TREE_TYPE (q);
5756               BUILD_PTR_FROM_NAME (class_type, right);
5757             }
5758         }
5759     }
5760
5761   if (enclosing)
5762     {
5763       /* This hash table is used to register the classes we're going
5764          through when searching the current class as an inner class, in
5765          order to detect circular references. Remember to free it before
5766          returning the section 0- of this function. */
5767       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5768                                       NULL);
5769
5770       /* 0- Search in the current class as an inner class.
5771          Maybe some code here should be added to load the class or
5772          something, at least if the class isn't an inner class and ended
5773          being loaded from class file. FIXME. */
5774       while (enclosing)
5775         {
5776           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5777                                                 &super, class_type);
5778           if (new_class_decl)
5779             break;
5780
5781           /* If we haven't found anything because SUPER reached Object and
5782              ENCLOSING happens to be an innerclass, try the enclosing context. */
5783           if ((!super || super == object_type_node) &&
5784               enclosing && INNER_CLASS_DECL_P (enclosing))
5785             enclosing = DECL_CONTEXT (enclosing);
5786           else
5787             enclosing = NULL_TREE;
5788         }
5789
5790       htab_delete (circularity_hash);
5791
5792       if (new_class_decl)
5793         return new_class_decl;
5794     }
5795
5796   /* 1- Check for the type in single imports. This will change
5797      TYPE_NAME() if something relevant is found */
5798   find_in_imports (saved_enclosing_type, class_type);
5799
5800   /* 2- And check for the type in the current compilation unit */
5801   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5802     {
5803       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5804         load_class (TYPE_NAME (class_type), 0);
5805       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5806     }
5807
5808   /* 3- Search according to the current package definition */
5809   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5810     {
5811       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5812                                              TYPE_NAME (class_type))))
5813         return new_class_decl;
5814     }
5815
5816   /* 4- Check the import on demands. Don't allow bar.baz to be
5817      imported from foo.* */
5818   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5819     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5820       return NULL_TREE;
5821
5822   /* If found in find_in_imports_on_demand, the type has already been
5823      loaded. */
5824   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5825     return new_class_decl;
5826
5827   /* 5- Try with a name qualified with the package name we've seen so far */
5828   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5829     {
5830       tree package;
5831
5832       /* If there is a current package (ctxp->package), it's the first
5833          element of package_list and we can skip it. */
5834       for (package = (ctxp->package ?
5835                       TREE_CHAIN (package_list) : package_list);
5836            package; package = TREE_CHAIN (package))
5837         if ((new_class_decl = qualify_and_find (class_type,
5838                                                TREE_PURPOSE (package),
5839                                                TYPE_NAME (class_type))))
5840           return new_class_decl;
5841     }
5842
5843   /* 5- Check another compilation unit that bears the name of type */
5844   load_class (TYPE_NAME (class_type), 0);
5845
5846   if (!cl)
5847     cl = lookup_cl (decl);
5848
5849   /* If we don't have a value for CL, then we're being called recursively.
5850      We can't check package access just yet, but it will be taken care of
5851      by the caller. */
5852   if (cl)
5853     {
5854       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5855         return NULL_TREE;
5856     }
5857
5858   /* 6- Last call for a resolution */
5859   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5860
5861   /* The final lookup might have registered a.b.c into a.b$c If we
5862      failed at the first lookup, progressively change the name if
5863      applicable and use the matching DECL instead. */
5864   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5865     {
5866       char *separator;
5867       tree name = TYPE_NAME (class_type);
5868       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5869
5870       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5871
5872       do {
5873
5874        /* Reach the last '.', and if applicable, replace it by a `$' and
5875           see if this exists as a type. */
5876        if ((separator = strrchr (namebuffer, '.')))
5877          {
5878            *separator = '$';
5879            name = get_identifier (namebuffer);
5880            decl_result = IDENTIFIER_CLASS_VALUE (name);
5881          }
5882       } while (!decl_result && separator);
5883     }
5884   return decl_result;
5885 }
5886
5887 static tree
5888 qualify_and_find (tree class_type, tree package, tree name)
5889 {
5890   tree new_qualified = merge_qualified_name (package, name);
5891   tree new_class_decl;
5892
5893   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5894     load_class (new_qualified, 0);
5895   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5896     {
5897       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5898         load_class (TREE_TYPE (new_class_decl), 0);
5899       TYPE_NAME (class_type) = new_qualified;
5900       return IDENTIFIER_CLASS_VALUE (new_qualified);
5901     }
5902   return NULL_TREE;
5903 }
5904
5905 /* Resolve NAME and lay it out (if not done and if not the current
5906    parsed class). Return a decl node. This function is meant to be
5907    called when type resolution is necessary during the walk pass.  */
5908
5909 static tree
5910 resolve_and_layout (tree something, tree cl)
5911 {
5912   tree decl, decl_type;
5913
5914   /* Don't do that on the current class */
5915   if (something == current_class)
5916     return TYPE_NAME (current_class);
5917
5918   /* Don't do anything for void and other primitive types */
5919   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5920     return NULL_TREE;
5921
5922   /* Pointer types can be reall pointer types or fake pointers. When
5923      finding a real pointer, recheck for primitive types */
5924   if (TREE_CODE (something) == POINTER_TYPE)
5925     {
5926       if (TREE_TYPE (something))
5927         {
5928           something = TREE_TYPE (something);
5929           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5930             return NULL_TREE;
5931         }
5932       else
5933         something = TYPE_NAME (something);
5934     }
5935
5936   /* Don't do anything for arrays of primitive types */
5937   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5938       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5939     return NULL_TREE;
5940
5941   /* Something might be a WFL */
5942   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5943     something = EXPR_WFL_NODE (something);
5944
5945   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5946      TYPE_DECL or a real TYPE */
5947   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5948     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5949             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5950
5951   if (!(decl = resolve_no_layout (something, cl)))
5952     return NULL_TREE;
5953
5954   /* Resolve and layout if necessary */
5955   decl_type = TREE_TYPE (decl);
5956   layout_class_methods (decl_type);
5957   /* Check methods */
5958   if (CLASS_FROM_SOURCE_P (decl_type))
5959     java_check_methods (decl);
5960   /* Layout the type if necessary */
5961   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5962     safe_layout_class (decl_type);
5963
5964   return decl;
5965 }
5966
5967 /* Resolve a class, returns its decl but doesn't perform any
5968    layout. The current parsing context is saved and restored */
5969
5970 static tree
5971 resolve_no_layout (tree name, tree cl)
5972 {
5973   tree ptr, decl;
5974   BUILD_PTR_FROM_NAME (ptr, name);
5975   java_parser_context_save_global ();
5976   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5977   java_parser_context_restore_global ();
5978
5979   return decl;
5980 }
5981
5982 /* Called when reporting errors. Skip the '[]'s in a complex array
5983    type description that failed to be resolved. purify_type_name can't
5984    use an identifier tree.  */
5985
5986 static const char *
5987 purify_type_name (const char *name)
5988 {
5989   int len = strlen (name);
5990   int bracket_found;
5991
5992   STRING_STRIP_BRACKETS (name, len, bracket_found);
5993   if (bracket_found)
5994     {
5995       char *stripped_name = xmemdup (name, len, len+1);
5996       stripped_name [len] = '\0';
5997       return stripped_name;
5998     }
5999   return name;
6000 }
6001
6002 /* The type CURRENT refers to can't be found. We print error messages.  */
6003
6004 static void
6005 complete_class_report_errors (jdep *dep)
6006 {
6007   const char *name;
6008
6009   if (!JDEP_WFL (dep))
6010     return;
6011
6012   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6013   switch (JDEP_KIND (dep))
6014     {
6015     case JDEP_SUPER:
6016       parse_error_context
6017         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6018          purify_type_name (name),
6019          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6020       break;
6021     case JDEP_FIELD:
6022       parse_error_context
6023         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6024          purify_type_name (name),
6025          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6026       break;
6027     case JDEP_METHOD:           /* Covers arguments */
6028       parse_error_context
6029         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6030          purify_type_name (name),
6031          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6032          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6033       break;
6034     case JDEP_METHOD_RETURN:    /* Covers return type */
6035       parse_error_context
6036         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6037          purify_type_name (name),
6038          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6039       break;
6040     case JDEP_INTERFACE:
6041       parse_error_context
6042         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6043          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6044          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6045          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6046       break;
6047     case JDEP_VARIABLE:
6048       parse_error_context
6049         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6050          purify_type_name (IDENTIFIER_POINTER
6051                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6052          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6053       break;
6054     case JDEP_EXCEPTION:        /* As specified by `throws' */
6055       parse_error_context
6056           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6057          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6058       break;
6059     default:
6060       /* Fix for -Wall. Just break doing nothing. The error will be
6061          caught later */
6062       break;
6063     }
6064 }
6065
6066 /* Return a static string containing the DECL prototype string. If
6067    DECL is a constructor, use the class name instead of the form
6068    <init> */
6069
6070 static const char *
6071 get_printable_method_name (tree decl)
6072 {
6073   const char *to_return;
6074   tree name = NULL_TREE;
6075
6076   if (DECL_CONSTRUCTOR_P (decl))
6077     {
6078       name = DECL_NAME (decl);
6079       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6080     }
6081
6082   to_return = lang_printable_name (decl, 0);
6083   if (DECL_CONSTRUCTOR_P (decl))
6084     DECL_NAME (decl) = name;
6085
6086   return to_return;
6087 }
6088
6089 /* Track method being redefined inside the same class. As a side
6090    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6091    function it's a FWL, so we can track errors more accurately.)  */
6092
6093 static int
6094 check_method_redefinition (tree class, tree method)
6095 {
6096   tree redef, sig;
6097
6098   /* There's no need to verify <clinit> and finit$ and instinit$ */
6099   if (DECL_CLINIT_P (method)
6100       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6101     return 0;
6102
6103   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6104   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6105     {
6106       if (redef == method)
6107         break;
6108       if (DECL_NAME (redef) == DECL_NAME (method)
6109           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6110           && !DECL_ARTIFICIAL (method))
6111         {
6112           parse_error_context
6113             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6114              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6115              get_printable_method_name (redef));
6116           return 1;
6117         }
6118     }
6119   return 0;
6120 }
6121
6122 /* Return 1 if check went ok, 0 otherwise.  */
6123 static int
6124 check_abstract_method_definitions (int do_interface, tree class_decl,
6125                                    tree type)
6126 {
6127   tree class = TREE_TYPE (class_decl);
6128   tree method, end_type;
6129   int ok = 1;
6130
6131   end_type = (do_interface ? object_type_node : type);
6132   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6133     {
6134       tree other_super, other_method, method_sig, method_name;
6135       int found = 0;
6136       int end_type_reached = 0;
6137
6138       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6139         continue;
6140
6141       /* Now verify that somewhere in between TYPE and CLASS,
6142          abstract method METHOD gets a non abstract definition
6143          that is inherited by CLASS.  */
6144
6145       method_sig = build_java_signature (TREE_TYPE (method));
6146       method_name = DECL_NAME (method);
6147       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6148         method_name = EXPR_WFL_NODE (method_name);
6149
6150       other_super = class;
6151       do {
6152         if (other_super == end_type)
6153           end_type_reached = 1;
6154
6155         /* Method search */
6156         for (other_method = TYPE_METHODS (other_super); other_method;
6157             other_method = TREE_CHAIN (other_method))
6158           {
6159             tree s = build_java_signature (TREE_TYPE (other_method));
6160             tree other_name = DECL_NAME (other_method);
6161
6162             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6163               other_name = EXPR_WFL_NODE (other_name);
6164             if (!DECL_CLINIT_P (other_method)
6165                 && !DECL_CONSTRUCTOR_P (other_method)
6166                 && method_name == other_name
6167                 && method_sig == s
6168                 && !METHOD_ABSTRACT (other_method))
6169              {
6170                found = 1;
6171                break;
6172              }
6173           }
6174         other_super = CLASSTYPE_SUPER (other_super);
6175       } while (!end_type_reached);
6176
6177       /* Report that abstract METHOD didn't find an implementation
6178          that CLASS can use. */
6179       if (!found)
6180         {
6181           char *t = xstrdup (lang_printable_name
6182                             (TREE_TYPE (TREE_TYPE (method)), 0));
6183           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6184
6185           parse_error_context
6186             (lookup_cl (class_decl),
6187              "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",
6188              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6189              t, lang_printable_name (method, 0),
6190              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6191               "interface" : "class"),
6192              IDENTIFIER_POINTER (ccn),
6193              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6194              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6195           ok = 0;
6196           free (t);
6197         }
6198     }
6199
6200   if (ok && do_interface)
6201     {
6202       /* Check for implemented interfaces. */
6203       int i;
6204       tree vector = TYPE_BINFO_BASETYPES (type);
6205       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6206         {
6207           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6208           ok = check_abstract_method_definitions (1, class_decl, super);
6209         }
6210     }
6211
6212   return ok;
6213 }
6214
6215 /* Check that CLASS_DECL somehow implements all inherited abstract
6216    methods.  */
6217
6218 static void
6219 java_check_abstract_method_definitions (tree class_decl)
6220 {
6221   tree class = TREE_TYPE (class_decl);
6222   tree super, vector;
6223   int i;
6224
6225   if (CLASS_ABSTRACT (class_decl))
6226     return;
6227
6228   /* Check for inherited types */
6229   super = class;
6230   do {
6231     super = CLASSTYPE_SUPER (super);
6232     check_abstract_method_definitions (0, class_decl, super);
6233   } while (super != object_type_node);
6234
6235   /* Check for implemented interfaces. */
6236   vector = TYPE_BINFO_BASETYPES (class);
6237   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6238     {
6239       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6240       check_abstract_method_definitions (1, class_decl, super);
6241     }
6242 }
6243
6244 /* Check all the types method DECL uses and return 1 if all of them
6245    are now complete, 0 otherwise. This is used to check whether its
6246    safe to build a method signature or not.  */
6247
6248 static int
6249 check_method_types_complete (tree decl)
6250 {
6251   tree type = TREE_TYPE (decl);
6252   tree args;
6253
6254   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6255     return 0;
6256
6257   args = TYPE_ARG_TYPES (type);
6258   if (TREE_CODE (type) == METHOD_TYPE)
6259     args = TREE_CHAIN (args);
6260   for (; args != end_params_node; args = TREE_CHAIN (args))
6261     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6262       return 0;
6263
6264   return 1;
6265 }
6266
6267 /* Visible interface to check methods contained in CLASS_DECL */
6268
6269 void
6270 java_check_methods (tree class_decl)
6271 {
6272   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6273     return;
6274
6275   if (CLASS_INTERFACE (class_decl))
6276     java_check_abstract_methods (class_decl);
6277   else
6278     java_check_regular_methods (class_decl);
6279
6280   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6281 }
6282
6283 /* Like not_accessible_p, but doesn't refer to the current class at
6284    all.  */
6285 static bool
6286 hack_is_accessible_p (tree member, tree from_where)
6287 {
6288   int flags = get_access_flags_from_decl (member);
6289
6290   if (from_where == DECL_CONTEXT (member)
6291       || (flags & ACC_PUBLIC))
6292     return true;
6293
6294   if ((flags & ACC_PROTECTED))
6295     {
6296       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6297         return true;
6298     }
6299
6300   if ((flags & ACC_PRIVATE))
6301     return false;
6302
6303   /* Package private, or protected.  */
6304   return in_same_package (TYPE_NAME (from_where),
6305                           TYPE_NAME (DECL_CONTEXT (member)));
6306 }
6307
6308 /* Check all the methods of CLASS_DECL. Methods are first completed
6309    then checked according to regular method existence rules.  If no
6310    constructor for CLASS_DECL were encountered, then build its
6311    declaration.  */
6312 static void
6313 java_check_regular_methods (tree class_decl)
6314 {
6315   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6316   tree method;
6317   tree class = TREE_TYPE (class_decl);
6318   tree found = NULL_TREE;
6319   tree mthrows;
6320
6321   /* It is not necessary to check methods defined in java.lang.Object */
6322   if (class == object_type_node)
6323     return;
6324
6325   if (!TYPE_NVIRTUALS (class))
6326     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6327
6328   /* Should take interfaces into account. FIXME */
6329   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6330     {
6331       tree sig;
6332       tree method_wfl = DECL_FUNCTION_WFL (method);
6333       int aflags;
6334
6335       /* Check for redefinitions */
6336       if (check_method_redefinition (class, method))
6337         continue;
6338
6339       /* We verify things thrown by the method.  They must inherit from
6340          java.lang.Throwable.  */
6341       for (mthrows = DECL_FUNCTION_THROWS (method);
6342            mthrows; mthrows = TREE_CHAIN (mthrows))
6343         {
6344           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6345             parse_error_context
6346               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6347                IDENTIFIER_POINTER
6348                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6349         }
6350
6351       /* If we see one constructor a mark so we don't generate the
6352          default one.  Also skip other verifications: constructors
6353          can't be inherited hence hidden or overridden.  */
6354       if (DECL_CONSTRUCTOR_P (method))
6355         {
6356           saw_constructor = 1;
6357           continue;
6358         }
6359
6360       sig = build_java_argument_signature (TREE_TYPE (method));
6361       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6362                                               SEARCH_SUPER | SEARCH_INTERFACE);
6363
6364       /* Inner class can't declare static methods */
6365       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6366         {
6367           char *t = xstrdup (lang_printable_name (class, 0));
6368           parse_error_context
6369             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6370              lang_printable_name (method, 0), t);
6371           free (t);
6372         }
6373
6374       /* Nothing overrides or it's a private method. */
6375       if (!found)
6376         continue;
6377       if (METHOD_PRIVATE (found))
6378         {
6379           found = NULL_TREE;
6380           continue;
6381         }
6382
6383       /* If `found' is declared in an interface, make sure the
6384          modifier matches. */
6385       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6386           && clinit_identifier_node != DECL_NAME (found)
6387           && !METHOD_PUBLIC (method))
6388         {
6389           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6390           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6391                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6392                                lang_printable_name (method, 0),
6393                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6394         }
6395
6396       /* Can't override a method with the same name and different return
6397          types. */
6398       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6399         {
6400           char *t = xstrdup
6401             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6402           parse_error_context
6403             (method_wfl,
6404              "Method `%s' was defined with return type `%s' in class `%s'",
6405              lang_printable_name (found, 0), t,
6406              IDENTIFIER_POINTER
6407                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6408           free (t);
6409         }
6410
6411       aflags = get_access_flags_from_decl (found);
6412
6413       /* Can't override final. Can't override static. */
6414       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6415         {
6416           /* Static *can* override static */
6417           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6418             continue;
6419           parse_error_context
6420             (method_wfl,
6421              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6422              (METHOD_FINAL (found) ? "Final" : "Static"),
6423              lang_printable_name (found, 0),
6424              (METHOD_FINAL (found) ? "final" : "static"),
6425              IDENTIFIER_POINTER
6426                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6427           continue;
6428         }
6429
6430       /* Static method can't override instance method. */
6431       if (METHOD_STATIC (method))
6432         {
6433           parse_error_context
6434             (method_wfl,
6435              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6436              lang_printable_name (found, 0),
6437              IDENTIFIER_POINTER
6438                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6439           continue;
6440         }
6441
6442       /* - Overriding/hiding public must be public
6443          - Overriding/hiding protected must be protected or public
6444          - If the overridden or hidden method has default (package)
6445            access, then the overriding or hiding method must not be
6446            private; otherwise, a compile-time error occurs.  If
6447            `found' belongs to an interface, things have been already
6448            taken care of.  */
6449       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6450           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6451               || (METHOD_PROTECTED (found)
6452                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6453               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6454                   && METHOD_PRIVATE (method))))
6455         {
6456           parse_error_context
6457             (method_wfl,
6458              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6459              (METHOD_PUBLIC (method) ? "public" :
6460               (METHOD_PRIVATE (method) ? "private" : "protected")),
6461              IDENTIFIER_POINTER (DECL_NAME
6462                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6463           continue;
6464         }
6465
6466       /* Check this method against all the other implementations it
6467          overrides.  Here we only check the class hierarchy; the rest
6468          of the checking is done later.  If this method is just a
6469          Miranda method, we can skip the check.  */
6470       if (! METHOD_INVISIBLE (method))
6471         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6472     }
6473
6474   /* The above throws clause check only looked at superclasses.  Now
6475      we must also make sure that all methods declared in interfaces
6476      have compatible throws clauses.  FIXME: there are more efficient
6477      ways to organize this checking; we should implement one.  */
6478   check_interface_throws_clauses (class, class);
6479
6480   if (!TYPE_NVIRTUALS (class))
6481     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6482
6483   /* Search for inherited abstract method not yet implemented in this
6484      class.  */
6485   java_check_abstract_method_definitions (class_decl);
6486
6487   if (!saw_constructor)
6488     abort ();
6489 }
6490
6491 /* Check to make sure that all the methods in all the interfaces
6492    implemented by CLASS_DECL are compatible with the concrete
6493    implementations available in CHECK_CLASS_DECL.  */
6494 static void
6495 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6496 {
6497   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6498     {
6499       tree bases;
6500       int iface_len;
6501       int i;
6502
6503       if (! CLASS_LOADED_P (class_decl))
6504         {
6505           if (CLASS_FROM_SOURCE_P (class_decl))
6506             safe_layout_class (class_decl);
6507           else
6508             load_class (class_decl, 1);
6509         }
6510
6511       bases = TYPE_BINFO_BASETYPES (class_decl);
6512       iface_len = TREE_VEC_LENGTH (bases) - 1;
6513       for (i = iface_len; i > 0; --i)
6514         {
6515           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6516           tree iface_method;
6517
6518           for (iface_method = TYPE_METHODS (interface);
6519                iface_method != NULL_TREE;
6520                iface_method = TREE_CHAIN (iface_method))
6521             {
6522               tree sig, method;
6523
6524               /* First look for a concrete method implemented or
6525                  inherited by this class.  No need to search
6526                  interfaces here, since we're already looking through
6527                  all of them.  */
6528               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6529               method
6530                 = lookup_argument_method_generic (check_class_decl,
6531                                                   DECL_NAME (iface_method),
6532                                                   sig, SEARCH_VISIBLE);
6533               /* If we don't find an implementation, that is ok.  Any
6534                  potential errors from that are diagnosed elsewhere.
6535                  Also, multiple inheritance with conflicting throws
6536                  clauses is fine in the absence of a concrete
6537                  implementation.  */
6538               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6539                   && !METHOD_INVISIBLE (iface_method))
6540                 {
6541                   tree method_wfl = DECL_FUNCTION_WFL (method);
6542                   check_throws_clauses (method, method_wfl, iface_method);
6543                 }
6544             }
6545
6546           /* Now check superinterfaces.  */
6547           check_interface_throws_clauses (check_class_decl, interface);
6548         }
6549     }
6550 }
6551
6552 /* Check throws clauses of a method against the clauses of all the
6553    methods it overrides.  We do this by searching up the class
6554    hierarchy, examining all matching accessible methods.  */
6555 static void
6556 check_concrete_throws_clauses (tree class, tree self_method,
6557                                tree name, tree signature)
6558 {
6559   tree method = lookup_argument_method_generic (class, name, signature,
6560                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6561   while (method != NULL_TREE)
6562     {
6563       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6564         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6565                               method);
6566
6567       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6568                                                name, signature,
6569                                                SEARCH_SUPER | SEARCH_VISIBLE);
6570     }
6571 }
6572
6573 /* Generate an error if the `throws' clause of METHOD (if any) is
6574    incompatible with the `throws' clause of FOUND (if any).  */
6575 static void
6576 check_throws_clauses (tree method, tree method_wfl, tree found)
6577 {
6578   tree mthrows;
6579
6580   /* Can't check these things with class loaded from bytecode. FIXME */
6581   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6582     return;
6583
6584   for (mthrows = DECL_FUNCTION_THROWS (method);
6585        mthrows; mthrows = TREE_CHAIN (mthrows))
6586     {
6587       tree fthrows;
6588
6589       /* We don't verify unchecked expressions */
6590       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6591         continue;
6592       /* Checked expression must be compatible */
6593       for (fthrows = DECL_FUNCTION_THROWS (found);
6594            fthrows; fthrows = TREE_CHAIN (fthrows))
6595         {
6596           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6597             break;
6598         }
6599       if (!fthrows)
6600         {
6601           parse_error_context
6602             (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'",
6603              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6604              lang_printable_name (found, 0),
6605              IDENTIFIER_POINTER
6606              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6607         }
6608     }
6609 }
6610
6611 /* Check abstract method of interface INTERFACE */
6612 static void
6613 java_check_abstract_methods (tree interface_decl)
6614 {
6615   int i, n;
6616   tree method, basetype_vec, found;
6617   tree interface = TREE_TYPE (interface_decl);
6618
6619   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6620     {
6621       /* 2- Check for double definition inside the defining interface */
6622       if (check_method_redefinition (interface, method))
6623         continue;
6624
6625       /* 3- Overriding is OK as far as we preserve the return type.  */
6626       found = lookup_java_interface_method2 (interface, method);
6627       if (found)
6628         {
6629           char *t;
6630           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6631           parse_error_context
6632             (DECL_FUNCTION_WFL (found),
6633              "Method `%s' was defined with return type `%s' in class `%s'",
6634              lang_printable_name (found, 0), t,
6635              IDENTIFIER_POINTER
6636                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6637           free (t);
6638           continue;
6639         }
6640     }
6641
6642   /* 4- Inherited methods can't differ by their returned types */
6643   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6644     return;
6645   n = TREE_VEC_LENGTH (basetype_vec);
6646   for (i = 0; i < n; i++)
6647     {
6648       tree sub_interface_method, sub_interface;
6649       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6650       if (!vec_elt)
6651         continue;
6652       sub_interface = BINFO_TYPE (vec_elt);
6653       for (sub_interface_method = TYPE_METHODS (sub_interface);
6654            sub_interface_method;
6655            sub_interface_method = TREE_CHAIN (sub_interface_method))
6656         {
6657           found = lookup_java_interface_method2 (interface,
6658                                                  sub_interface_method);
6659           if (found && (found != sub_interface_method))
6660             {
6661               parse_error_context
6662                 (lookup_cl (sub_interface_method),
6663                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6664                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6665                  lang_printable_name (found, 0),
6666                  IDENTIFIER_POINTER
6667                    (DECL_NAME (TYPE_NAME
6668                                (DECL_CONTEXT (sub_interface_method)))),
6669                  IDENTIFIER_POINTER
6670                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6671             }
6672         }
6673     }
6674 }
6675
6676 /* Lookup methods in interfaces using their name and partial
6677    signature. Return a matching method only if their types differ.  */
6678
6679 static tree
6680 lookup_java_interface_method2 (tree class, tree method_decl)
6681 {
6682   int i, n;
6683   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6684
6685   if (!basetype_vec)
6686     return NULL_TREE;
6687
6688   n = TREE_VEC_LENGTH (basetype_vec);
6689   for (i = 0; i < n; i++)
6690     {
6691       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6692       if ((BINFO_TYPE (vec_elt) != object_type_node)
6693           && (to_return =
6694               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6695         return to_return;
6696     }
6697   for (i = 0; i < n; i++)
6698     {
6699       to_return = lookup_java_interface_method2
6700         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6701       if (to_return)
6702         return to_return;
6703     }
6704
6705   return NULL_TREE;
6706 }
6707
6708 /* Lookup method using their name and partial signature. Return a
6709    matching method only if their types differ.  */
6710
6711 static tree
6712 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6713 {
6714   tree method, method_signature, method_name, method_type, name;
6715
6716   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6717   name = DECL_NAME (method_decl);
6718   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6719                  EXPR_WFL_NODE (name) : name);
6720   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6721
6722   while (clas != NULL_TREE)
6723     {
6724       for (method = TYPE_METHODS (clas);
6725            method != NULL_TREE;  method = TREE_CHAIN (method))
6726         {
6727           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6728           tree name = DECL_NAME (method);
6729           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6730                EXPR_WFL_NODE (name) : name) == method_name
6731               && method_sig == method_signature
6732               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6733             return method;
6734         }
6735       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6736     }
6737   return NULL_TREE;
6738 }
6739
6740 /* Return the line that matches DECL line number, and try its best to
6741    position the column number. Used during error reports.  */
6742
6743 static GTY(()) tree cl_v;
6744 static tree
6745 lookup_cl (tree decl)
6746 {
6747   char *line, *found;
6748
6749   if (!decl)
6750     return NULL_TREE;
6751
6752   if (cl_v == NULL_TREE)
6753     {
6754       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6755     }
6756
6757   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6758   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6759
6760   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6761                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6762
6763   found = strstr ((const char *)line,
6764                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6765   if (found)
6766     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6767
6768   return cl_v;
6769 }
6770
6771 /* Look for a simple name in the single-type import list */
6772
6773 static tree
6774 find_name_in_single_imports (tree name)
6775 {
6776   tree node;
6777
6778   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6779     if (TREE_VALUE (node) == name)
6780       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6781
6782   return NULL_TREE;
6783 }
6784
6785 /* Process all single-type import. */
6786
6787 static int
6788 process_imports (void)
6789 {
6790   tree import;
6791   int error_found;
6792
6793   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6794     {
6795       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6796       char *original_name;
6797
6798       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6799                                IDENTIFIER_LENGTH (to_be_found),
6800                                IDENTIFIER_LENGTH (to_be_found) + 1);
6801
6802       /* Don't load twice something already defined. */
6803       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6804         continue;
6805
6806       while (1)
6807         {
6808           tree left;
6809
6810           QUALIFIED_P (to_be_found) = 1;
6811           load_class (to_be_found, 0);
6812           error_found =
6813             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6814
6815           /* We found it, we can bail out */
6816           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6817             {
6818               check_deprecation (TREE_PURPOSE (import),
6819                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6820               break;
6821             }
6822
6823           /* We haven't found it. Maybe we're trying to access an
6824              inner class.  The only way for us to know is to try again
6825              after having dropped a qualifier. If we can't break it further,
6826              we have an error. */
6827           if (breakdown_qualified (&left, NULL, to_be_found))
6828             break;
6829
6830           to_be_found = left;
6831         }
6832       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6833         {
6834           parse_error_context (TREE_PURPOSE (import),
6835                                "Class or interface `%s' not found in import",
6836                                original_name);
6837           error_found = 1;
6838         }
6839
6840       free (original_name);
6841       if (error_found)
6842         return 1;
6843     }
6844   return 0;
6845 }
6846
6847 /* Possibly find and mark a class imported by a single-type import
6848    statement.  */
6849
6850 static void
6851 find_in_imports (tree enclosing_type, tree class_type)
6852 {
6853   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6854                  ctxp->import_list);
6855   while (import)
6856     {
6857       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6858         {
6859           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6860           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6861           return;
6862         }
6863       import = TREE_CHAIN (import);
6864     }
6865 }
6866
6867 static int
6868 note_possible_classname (const char *name, int len)
6869 {
6870   tree node;
6871   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6872     len = len - 5;
6873   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6874     len = len - 6;
6875   else
6876     return 0;
6877   node = ident_subst (name, len, "", '/', '.', "");
6878   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6879   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6880   return 1;
6881 }
6882
6883 /* Read a import directory, gathering potential match for further type
6884    references. Indifferently reads a filesystem or a ZIP archive
6885    directory.  */
6886
6887 static void
6888 read_import_dir (tree wfl)
6889 {
6890   tree package_id = EXPR_WFL_NODE (wfl);
6891   const char *package_name = IDENTIFIER_POINTER (package_id);
6892   int package_length = IDENTIFIER_LENGTH (package_id);
6893   DIR *dirp = NULL;
6894   JCF *saved_jcf = current_jcf;
6895
6896   int found = 0;
6897   int k;
6898   void *entry;
6899   struct buffer filename[1];
6900
6901   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6902     return;
6903   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6904
6905   BUFFER_INIT (filename);
6906   buffer_grow (filename, package_length + 100);
6907
6908   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6909     {
6910       const char *entry_name = jcf_path_name (entry);
6911       int entry_length = strlen (entry_name);
6912       if (jcf_path_is_zipfile (entry))
6913         {
6914           ZipFile *zipf;
6915           buffer_grow (filename, entry_length);
6916           memcpy (filename->data, entry_name, entry_length - 1);
6917           filename->data[entry_length-1] = '\0';
6918           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6919           if (zipf == NULL)
6920             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6921           else
6922             {
6923               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6924               BUFFER_RESET (filename);
6925               for (k = 0; k < package_length; k++)
6926                 {
6927                   char ch = package_name[k];
6928                   *filename->ptr++ = ch == '.' ? '/' : ch;
6929                 }
6930               *filename->ptr++ = '/';
6931
6932               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6933                 {
6934                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6935                   int current_entry_len = zipd->filename_length;
6936
6937                   if (current_entry_len >= BUFFER_LENGTH (filename)
6938                       && strncmp (filename->data, current_entry,
6939                                   BUFFER_LENGTH (filename)) != 0)
6940                     continue;
6941                   found |= note_possible_classname (current_entry,
6942                                                     current_entry_len);
6943                 }
6944             }
6945         }
6946       else
6947         {
6948           BUFFER_RESET (filename);
6949           buffer_grow (filename, entry_length + package_length + 4);
6950           strcpy (filename->data, entry_name);
6951           filename->ptr = filename->data + entry_length;
6952           for (k = 0; k < package_length; k++)
6953             {
6954               char ch = package_name[k];
6955               *filename->ptr++ = ch == '.' ? '/' : ch;
6956             }
6957           *filename->ptr = '\0';
6958
6959           dirp = opendir (filename->data);
6960           if (dirp == NULL)
6961             continue;
6962           *filename->ptr++ = '/';
6963           for (;;)
6964             {
6965               int len;
6966               const char *d_name;
6967               struct dirent *direntp = readdir (dirp);
6968               if (!direntp)
6969                 break;
6970               d_name = direntp->d_name;
6971               len = strlen (direntp->d_name);
6972               buffer_grow (filename, len+1);
6973               strcpy (filename->ptr, d_name);
6974               found |= note_possible_classname (filename->data + entry_length,
6975                                                 package_length+len+1);
6976             }
6977           if (dirp)
6978             closedir (dirp);
6979         }
6980     }
6981
6982   free (filename->data);
6983
6984   /* Here we should have a unified way of retrieving an entry, to be
6985      indexed. */
6986   if (!found)
6987     {
6988       static int first = 1;
6989       if (first)
6990         {
6991           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6992           java_error_count++;
6993           first = 0;
6994         }
6995       else
6996         parse_error_context (wfl, "Package `%s' not found in import",
6997                              package_name);
6998       current_jcf = saved_jcf;
6999       return;
7000     }
7001   current_jcf = saved_jcf;
7002 }
7003
7004 /* Possibly find a type in the import on demands specified
7005    types. Returns 1 if an error occurred, 0 otherwise. Run through the
7006    entire list, to detected potential double definitions.  */
7007
7008 static int
7009 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7010 {
7011   tree class_type_name = TYPE_NAME (class_type);
7012   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7013                   ctxp->import_demand_list);
7014   tree cl = NULL_TREE;
7015   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7016   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7017   tree node;
7018
7019   for (; import; import = TREE_CHAIN (import))
7020     {
7021       int saved_lineno = input_line;
7022       int access_check;
7023       const char *id_name;
7024       tree decl, type_name_copy;
7025
7026       obstack_grow (&temporary_obstack,
7027                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7028                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7029       obstack_1grow (&temporary_obstack, '.');
7030       obstack_grow0 (&temporary_obstack,
7031                      IDENTIFIER_POINTER (class_type_name),
7032                      IDENTIFIER_LENGTH (class_type_name));
7033       id_name = obstack_finish (&temporary_obstack);
7034
7035       if (! (node = maybe_get_identifier (id_name)))
7036         continue;
7037
7038       /* Setup input_line so that it refers to the line of the import (in
7039          case we parse a class file and encounter errors */
7040       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7041
7042       type_name_copy = TYPE_NAME (class_type);
7043       TYPE_NAME (class_type) = node;
7044       QUALIFIED_P (node) = 1;
7045       decl = IDENTIFIER_CLASS_VALUE (node);
7046       access_check = -1;
7047       /* If there is no DECL set for the class or if the class isn't
7048          loaded and not seen in source yet, then load */
7049       if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
7050         {
7051           load_class (node, 0);
7052           decl = IDENTIFIER_CLASS_VALUE (node);
7053         }
7054       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7055         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7056                                                false, NULL_TREE);
7057       else
7058         /* 6.6.1: Inner classes are subject to member access rules. */
7059         access_check = 0;
7060
7061       input_line = saved_lineno;
7062
7063       /* If the loaded class is not accessible or couldn't be loaded,
7064          we restore the original TYPE_NAME and process the next
7065          import. */
7066       if (access_check || !decl)
7067         {
7068           TYPE_NAME (class_type) = type_name_copy;
7069           continue;
7070         }
7071
7072       /* If the loaded class is accessible, we keep a tab on it to
7073          detect and report multiple inclusions. */
7074       if (IS_A_CLASSFILE_NAME (node))
7075         {
7076           if (seen_once < 0)
7077             {
7078               cl = TREE_PURPOSE (import);
7079               seen_once = 1;
7080             }
7081           else if (seen_once >= 0)
7082             {
7083               tree location = (cl ? cl : TREE_PURPOSE (import));
7084               tree package = (cl ? EXPR_WFL_NODE (cl) :
7085                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7086               seen_once++;
7087               parse_error_context
7088                 (location,
7089                  "Type `%s' also potentially defined in package `%s'",
7090                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7091                  IDENTIFIER_POINTER (package));
7092             }
7093         }
7094       to_return = access_check;
7095     }
7096
7097   if (seen_once == 1)
7098     return to_return;
7099   else
7100     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7101 }
7102
7103 /* Add package NAME to the list of packages encountered so far. To
7104    speed up class lookup in do_resolve_class, we make sure a
7105    particular package is added only once.  */
7106
7107 static void
7108 register_package (tree name)
7109 {
7110   static htab_t pht;
7111   void **e;
7112
7113   if (pht == NULL)
7114     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7115
7116   e = htab_find_slot (pht, name, INSERT);
7117   if (*e == NULL)
7118     {
7119       package_list = chainon (package_list, build_tree_list (name, NULL));
7120       *e = name;
7121     }
7122 }
7123
7124 static tree
7125 resolve_package (tree pkg, tree *next, tree *type_name)
7126 {
7127   tree current;
7128   tree decl = NULL_TREE;
7129   *type_name = NULL_TREE;
7130
7131   /* The trick is to determine when the package name stops and were
7132      the name of something contained in the package starts. Then we
7133      return a fully qualified name of what we want to get. */
7134
7135   *next = EXPR_WFL_QUALIFICATION (pkg);
7136
7137   /* Try to progressively construct a type name */
7138   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7139     for (current = EXPR_WFL_QUALIFICATION (pkg);
7140          current; current = TREE_CHAIN (current))
7141       {
7142         /* If we don't have what we're expecting, exit now. TYPE_NAME
7143            will be null and the error caught later. */
7144         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7145           break;
7146         *type_name =
7147           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7148         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7149           {
7150             /* resolve_package should be used in a loop, hence we
7151                point at this one to naturally process the next one at
7152                the next iteration. */
7153             *next = current;
7154             break;
7155           }
7156       }
7157   return decl;
7158 }
7159
7160
7161 /* Check accessibility of inner classes according to member access rules.
7162    DECL is the inner class, ENCLOSING_DECL is the class from which the
7163    access is being attempted. */
7164
7165 static void
7166 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7167 {
7168   const char *access;
7169   tree enclosing_decl_type;
7170
7171   /* We don't issue an error message when CL is null. CL can be null
7172      as a result of processing a JDEP crafted by source_start_java_method
7173      for the purpose of patching its parm decl. But the error would
7174      have been already trapped when fixing the method's signature.
7175      DECL can also be NULL in case of earlier errors. */
7176   if (!decl || !cl)
7177     return;
7178
7179   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7180
7181   if (CLASS_PRIVATE (decl))
7182     {
7183       /* Access is permitted only within the body of the top-level
7184          class in which DECL is declared. */
7185       tree top_level = decl;
7186       while (DECL_CONTEXT (top_level))
7187         top_level = DECL_CONTEXT (top_level);
7188       while (DECL_CONTEXT (enclosing_decl))
7189         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7190       if (top_level == enclosing_decl)
7191         return;
7192       access = "private";
7193     }
7194   else if (CLASS_PROTECTED (decl))
7195     {
7196       tree decl_context;
7197       /* Access is permitted from within the same package... */
7198       if (in_same_package (decl, enclosing_decl))
7199         return;
7200
7201       /* ... or from within the body of a subtype of the context in which
7202          DECL is declared. */
7203       decl_context = DECL_CONTEXT (decl);
7204       while (enclosing_decl)
7205         {
7206           if (CLASS_INTERFACE (decl))
7207             {
7208               if (interface_of_p (TREE_TYPE (decl_context),
7209                                   enclosing_decl_type))
7210                 return;
7211             }
7212           else
7213             {
7214               /* Eww. The order of the arguments is different!! */
7215               if (inherits_from_p (enclosing_decl_type,
7216                                    TREE_TYPE (decl_context)))
7217                 return;
7218             }
7219           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7220         }
7221       access = "protected";
7222     }
7223   else if (! CLASS_PUBLIC (decl))
7224     {
7225       /* Access is permitted only from within the same package as DECL. */
7226       if (in_same_package (decl, enclosing_decl))
7227         return;
7228       access = "non-public";
7229     }
7230   else
7231     /* Class is public. */
7232     return;
7233
7234   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7235                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7236                        lang_printable_name (decl, 0), access);
7237 }
7238
7239 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7240    foreign package, it must be PUBLIC. Return 0 if no access
7241    violations were found, 1 otherwise. If VERBOSE is true and an error
7242    was found, it is reported and accounted for.  If CL is NULL then
7243    look it up with THIS_DECL.  */
7244
7245 static int
7246 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7247 {
7248   tree type;
7249
7250   if (!IDENTIFIER_CLASS_VALUE (class_name))
7251     return 0;
7252
7253   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7254     return 0;
7255
7256   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7257     {
7258       /* Access to a private class within the same package is
7259          allowed. */
7260       tree l, r;
7261       breakdown_qualified (&l, &r, class_name);
7262       if (!QUALIFIED_P (class_name) && !ctxp->package)
7263         /* Both in the empty package. */
7264         return 0;
7265       if (l == ctxp->package)
7266         /* Both in the same package. */
7267         return 0;
7268
7269       if (verbose)
7270         parse_error_context
7271           (cl == NULL ? lookup_cl (this_decl): cl,
7272            "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7273            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7274            IDENTIFIER_POINTER (class_name));
7275       return 1;
7276     }
7277   return 0;
7278 }
7279
7280 /* Local variable declaration. */
7281
7282 static void
7283 declare_local_variables (int modifier, tree type, tree vlist)
7284 {
7285   tree decl, current, saved_type;
7286   tree type_wfl = NULL_TREE;
7287   int must_chain = 0;
7288   int final_p = 0;
7289
7290   /* Push a new block if statements were seen between the last time we
7291      pushed a block and now. Keep a count of blocks to close */
7292   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7293     {
7294       tree b = enter_block ();
7295       BLOCK_IS_IMPLICIT (b) = 1;
7296     }
7297
7298   if (modifier)
7299     {
7300       size_t i;
7301       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7302         if (1 << i & modifier)
7303           break;
7304       if (modifier == ACC_FINAL)
7305         final_p = 1;
7306       else
7307         {
7308           parse_error_context
7309             (ctxp->modifier_ctx [i],
7310              "Only `final' is allowed as a local variables modifier");
7311           return;
7312         }
7313     }
7314
7315   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7316      hold the TYPE value if a new incomplete has to be created (as
7317      opposed to being found already existing and reused). */
7318   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7319
7320   /* If TYPE is fully resolved and we don't have a reference, make one */
7321   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7322
7323   /* Go through all the declared variables */
7324   for (current = vlist, saved_type = type; current;
7325        current = TREE_CHAIN (current), type = saved_type)
7326     {
7327       tree other, real_type;
7328       tree wfl  = TREE_PURPOSE (current);
7329       tree name = EXPR_WFL_NODE (wfl);
7330       tree init = TREE_VALUE (current);
7331
7332       /* Process NAME, as it may specify extra dimension(s) for it */
7333       type = build_array_from_name (type, type_wfl, name, &name);
7334
7335       /* Variable redefinition check */
7336       if ((other = lookup_name_in_blocks (name)))
7337         {
7338           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7339                                        DECL_SOURCE_LINE (other));
7340           continue;
7341         }
7342
7343       /* Type adjustment. We may have just readjusted TYPE because
7344          the variable specified more dimensions. Make sure we have
7345          a reference if we can and don't have one already. */
7346       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7347
7348       real_type = GET_REAL_TYPE (type);
7349       /* Never layout this decl. This will be done when its scope
7350          will be entered */
7351       decl = build_decl (VAR_DECL, name, real_type);
7352       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7353       DECL_FINAL (decl) = final_p;
7354       BLOCK_CHAIN_DECL (decl);
7355
7356       /* If doing xreferencing, replace the line number with the WFL
7357          compound value */
7358       if (flag_emit_xref)
7359         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7360
7361       /* Don't try to use an INIT statement when an error was found */
7362       if (init && java_error_count)
7363         init = NULL_TREE;
7364
7365       /* Remember it if this is an initialized-upon-declaration final
7366          variable.  */
7367       if (init && final_p)
7368         {
7369           DECL_LOCAL_FINAL_IUD (decl) = 1;
7370         }
7371
7372       /* Add the initialization function to the current function's code */
7373       if (init)
7374         {
7375           /* Name might have been readjusted */
7376           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7377           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7378           java_method_add_stmt (current_function_decl,
7379                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7380                                                       init));
7381         }
7382
7383       /* Setup dependency the type of the decl */
7384       if (must_chain)
7385         {
7386           jdep *dep;
7387           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7388           dep = CLASSD_LAST (ctxp->classd_list);
7389           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7390         }
7391     }
7392   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7393 }
7394
7395 /* Called during parsing. Build decls from argument list.  */
7396
7397 static void
7398 source_start_java_method (tree fndecl)
7399 {
7400   tree tem;
7401   tree parm_decl;
7402   int i;
7403
7404   if (!fndecl)
7405     return;
7406
7407   current_function_decl = fndecl;
7408
7409   /* New scope for the function */
7410   enter_block ();
7411   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7412        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7413     {
7414       tree type = TREE_VALUE (tem);
7415       tree name = TREE_PURPOSE (tem);
7416
7417       /* If type is incomplete. Create an incomplete decl and ask for
7418          the decl to be patched later */
7419       if (INCOMPLETE_TYPE_P (type))
7420         {
7421           jdep *jdep;
7422           tree real_type = GET_REAL_TYPE (type);
7423           parm_decl = build_decl (PARM_DECL, name, real_type);
7424           type = obtain_incomplete_type (type);
7425           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7426           jdep = CLASSD_LAST (ctxp->classd_list);
7427           JDEP_MISC (jdep) = name;
7428           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7429         }
7430       else
7431         parm_decl = build_decl (PARM_DECL, name, type);
7432
7433       /* Remember if a local variable was declared final (via its
7434          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7435       if (ARG_FINAL_P (tem))
7436         {
7437           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7438           DECL_FINAL (parm_decl) = 1;
7439         }
7440
7441       BLOCK_CHAIN_DECL (parm_decl);
7442     }
7443   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7444   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7445     nreverse (tem);
7446   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7447   DECL_MAX_LOCALS (current_function_decl) = i;
7448 }
7449
7450 /* Called during parsing. Creates an artificial method declaration.  */
7451
7452 static tree
7453 create_artificial_method (tree class, int flags, tree type,
7454                           tree name, tree args)
7455 {
7456   tree mdecl;
7457
7458   java_parser_context_save_global ();
7459   input_line = 0;
7460   mdecl = make_node (FUNCTION_TYPE);
7461   TREE_TYPE (mdecl) = type;
7462   TYPE_ARG_TYPES (mdecl) = args;
7463   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7464   java_parser_context_restore_global ();
7465   DECL_ARTIFICIAL (mdecl) = 1;
7466   return mdecl;
7467 }
7468
7469 /* Starts the body if an artificial method.  */
7470
7471 static void
7472 start_artificial_method_body (tree mdecl)
7473 {
7474   DECL_SOURCE_LINE (mdecl) = 1;
7475   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7476   source_start_java_method (mdecl);
7477   enter_block ();
7478 }
7479
7480 static void
7481 end_artificial_method_body (tree mdecl)
7482 {
7483   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7484      It has to be evaluated first. (if mdecl is current_function_decl,
7485      we have an undefined behavior if no temporary variable is used.) */
7486   tree b = exit_block ();
7487   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7488   exit_block ();
7489 }
7490
7491 /* Dump a tree of some kind.  This is a convenience wrapper for the
7492    dump_* functions in tree-dump.c.  */
7493 static void
7494 dump_java_tree (enum tree_dump_index phase, tree t)
7495 {
7496   FILE *stream;
7497   int flags;
7498
7499   stream = dump_begin (phase, &flags);
7500   flags |= TDF_SLIM;
7501   if (stream)
7502     {
7503       dump_node (t, flags, stream);
7504       dump_end (phase, stream);
7505     }
7506 }
7507
7508 /* Terminate a function and expand its body.  */
7509
7510 static void
7511 source_end_java_method (void)
7512 {
7513   tree fndecl = current_function_decl;
7514
7515   if (!fndecl)
7516     return;
7517
7518   java_parser_context_save_global ();
7519   input_line = ctxp->last_ccb_indent1;
7520
7521   /* Turn function bodies with only a NOP expr null, so they don't get
7522      generated at all and we won't get warnings when using the -W
7523      -Wall flags. */
7524   if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7525     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7526
7527   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7528       && ! flag_emit_class_files
7529       && ! flag_emit_xref)
7530     finish_method (fndecl);
7531
7532   current_function_decl = NULL_TREE;
7533   java_parser_context_restore_global ();
7534   current_function_decl = NULL_TREE;
7535 }
7536
7537 /* Record EXPR in the current function block. Complements compound
7538    expression second operand if necessary.  */
7539
7540 tree
7541 java_method_add_stmt (tree fndecl, tree expr)
7542 {
7543   if (!GET_CURRENT_BLOCK (fndecl))
7544     return NULL_TREE;
7545   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7546 }
7547
7548 static tree
7549 add_stmt_to_block (tree b, tree type, tree stmt)
7550 {
7551   tree body = BLOCK_EXPR_BODY (b), c;
7552
7553   if (java_error_count)
7554     return body;
7555
7556   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7557     return body;
7558
7559   BLOCK_EXPR_BODY (b) = c;
7560   TREE_SIDE_EFFECTS (c) = 1;
7561   return c;
7562 }
7563
7564 /* Lays out the methods for the classes seen so far.  */
7565
7566 void
7567 java_layout_seen_class_methods (void)
7568 {
7569   tree previous_list = all_class_list;
7570   tree end = NULL_TREE;
7571   tree current;
7572
7573   while (1)
7574     {
7575       for (current = previous_list;
7576            current != end; current = TREE_CHAIN (current))
7577         {
7578           tree cls = TREE_TYPE (TREE_VALUE (current));
7579
7580           if (! CLASS_LOADED_P (cls))
7581             load_class (cls, 0);
7582
7583           layout_class_methods (cls);
7584         }
7585
7586       /* Note that new classes might have been added while laying out
7587          methods, changing the value of all_class_list.  */
7588
7589       if (previous_list != all_class_list)
7590         {
7591           end = previous_list;
7592           previous_list = all_class_list;
7593         }
7594       else
7595         break;
7596     }
7597 }
7598
7599 static GTY(()) tree stop_reordering;
7600 void
7601 java_reorder_fields (void)
7602 {
7603   tree current;
7604
7605   for (current = gclass_list; current; current = TREE_CHAIN (current))
7606     {
7607       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7608
7609       if (current_class == stop_reordering)
7610         break;
7611
7612       /* Reverse the fields, but leave the dummy field in front.
7613          Fields are already ordered for Object and Class */
7614       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7615           && current_class != class_type_node)
7616       {
7617         /* If the dummy field is there, reverse the right fields and
7618            just layout the type for proper fields offset */
7619         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7620           {
7621             tree fields = TYPE_FIELDS (current_class);
7622             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7623             TYPE_SIZE (current_class) = NULL_TREE;
7624           }
7625         /* We don't have a dummy field, we need to layout the class,
7626            after having reversed the fields */
7627         else
7628           {
7629             TYPE_FIELDS (current_class) =
7630               nreverse (TYPE_FIELDS (current_class));
7631             TYPE_SIZE (current_class) = NULL_TREE;
7632           }
7633       }
7634     }
7635   /* There are cases were gclass_list will be empty. */
7636   if (gclass_list)
7637     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7638 }
7639
7640 /* Layout the methods of all classes loaded in one way or another.
7641    Check methods of source parsed classes. Then reorder the
7642    fields and layout the classes or the type of all source parsed
7643    classes */
7644
7645 void
7646 java_layout_classes (void)
7647 {
7648   tree current;
7649   int save_error_count = java_error_count;
7650
7651   /* Layout the methods of all classes seen so far */
7652   java_layout_seen_class_methods ();
7653   java_parse_abort_on_error ();
7654   all_class_list = NULL_TREE;
7655
7656   /* Then check the methods of all parsed classes */
7657   for (current = gclass_list; current; current = TREE_CHAIN (current))
7658     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7659       java_check_methods (TREE_VALUE (current));
7660   java_parse_abort_on_error ();
7661
7662   for (current = gclass_list; current; current = TREE_CHAIN (current))
7663     {
7664       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7665       layout_class (current_class);
7666
7667       /* Error reported by the caller */
7668       if (java_error_count)
7669         return;
7670     }
7671
7672   /* We might have reloaded classes durign the process of laying out
7673      classes for code generation. We must layout the methods of those
7674      late additions, as constructor checks might use them */
7675   java_layout_seen_class_methods ();
7676   java_parse_abort_on_error ();
7677 }
7678
7679 /* Expand methods in the current set of classes remembered for
7680    generation.  */
7681
7682 static void
7683 java_complete_expand_classes (void)
7684 {
7685   tree current;
7686
7687   do_not_fold = flag_emit_xref;
7688
7689   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7690     if (!INNER_CLASS_DECL_P (current))
7691       java_complete_expand_class (current);
7692 }
7693
7694 /* Expand the methods found in OUTER, starting first by OUTER's inner
7695    classes, if any.  */
7696
7697 static void
7698 java_complete_expand_class (tree outer)
7699 {
7700   tree inner_list;
7701
7702   /* We need to go after all inner classes and start expanding them,
7703      starting with most nested ones. We have to do that because nested
7704      classes might add functions to outer classes */
7705
7706   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7707        inner_list; inner_list = TREE_CHAIN (inner_list))
7708     java_complete_expand_class (TREE_PURPOSE (inner_list));
7709
7710   java_complete_expand_methods (outer);
7711 }
7712
7713 /* Expand methods registered in CLASS_DECL. The general idea is that
7714    we expand regular methods first. This allows us get an estimate on
7715    how outer context local alias fields are really used so we can add
7716    to the constructor just enough code to initialize them properly (it
7717    also lets us generate finit$ correctly.) Then we expand the
7718    constructors and then <clinit>.  */
7719
7720 static void
7721 java_complete_expand_methods (tree class_decl)
7722 {
7723   tree clinit, decl, first_decl;
7724
7725   output_class = current_class = TREE_TYPE (class_decl);
7726
7727   /* Pre-expand <clinit> to figure whether we really need it or
7728      not. If we do need it, we pre-expand the static fields so they're
7729      ready to be used somewhere else. <clinit> will be fully expanded
7730      after we processed the constructors. */
7731   first_decl = TYPE_METHODS (current_class);
7732   clinit = maybe_generate_pre_expand_clinit (current_class);
7733
7734   /* Then generate finit$ (if we need to) because constructors will
7735    try to use it.*/
7736   if (TYPE_FINIT_STMT_LIST (current_class))
7737     java_complete_expand_method (generate_finit (current_class));
7738
7739   /* Then generate instinit$ (if we need to) because constructors will
7740      try to use it. */
7741   if (TYPE_II_STMT_LIST (current_class))
7742     java_complete_expand_method (generate_instinit (current_class));
7743
7744   /* Now do the constructors */
7745   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7746     {
7747       int no_body;
7748
7749       if (!DECL_CONSTRUCTOR_P (decl))
7750         continue;
7751
7752       no_body = !DECL_FUNCTION_BODY (decl);
7753       /* Don't generate debug info on line zero when expanding a
7754          generated constructor. */
7755       if (no_body)
7756         restore_line_number_status (1);
7757
7758       java_complete_expand_method (decl);
7759
7760       if (no_body)
7761         restore_line_number_status (0);
7762     }
7763
7764   /* First, do the ordinary methods. */
7765   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7766     {
7767       /* Ctors aren't part of this batch. */
7768       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7769         continue;
7770
7771       /* Skip abstract or native methods -- but do handle native
7772          methods when generating JNI stubs.  */
7773       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7774         {
7775           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7776           continue;
7777         }
7778
7779       if (METHOD_NATIVE (decl))
7780         {
7781           tree body;
7782           current_function_decl = decl;
7783           body = build_jni_stub (decl);
7784           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7785         }
7786
7787       java_complete_expand_method (decl);
7788     }
7789
7790   /* If there is indeed a <clinit>, fully expand it now */
7791   if (clinit)
7792     {
7793       /* Prevent the use of `this' inside <clinit> */
7794       ctxp->explicit_constructor_p = 1;
7795       java_complete_expand_method (clinit);
7796       ctxp->explicit_constructor_p = 0;
7797     }
7798
7799   /* We might have generated a class$ that we now want to expand */
7800   if (TYPE_DOT_CLASS (current_class))
7801     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7802
7803   /* Now verify constructor circularity (stop after the first one we
7804      prove wrong.) */
7805   if (!CLASS_INTERFACE (class_decl))
7806     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7807       if (DECL_CONSTRUCTOR_P (decl)
7808           && verify_constructor_circularity (decl, decl))
7809         break;
7810 }
7811
7812 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7813    safely used in some other methods/constructors.  */
7814
7815 static tree
7816 maybe_generate_pre_expand_clinit (tree class_type)
7817 {
7818   tree current, mdecl;
7819
7820   if (!TYPE_CLINIT_STMT_LIST (class_type))
7821     return NULL_TREE;
7822
7823   /* Go through all static fields and pre expand them */
7824   for (current = TYPE_FIELDS (class_type); current;
7825        current = TREE_CHAIN (current))
7826     if (FIELD_STATIC (current))
7827       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7828
7829   /* Then build the <clinit> method */
7830   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7831                                     clinit_identifier_node, end_params_node);
7832   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7833                        mdecl, NULL_TREE);
7834   start_artificial_method_body (mdecl);
7835
7836   /* We process the list of assignment we produced as the result of
7837      the declaration of initialized static field and add them as
7838      statement to the <clinit> method. */
7839   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7840        current = TREE_CHAIN (current))
7841     {
7842       tree stmt = current;
7843       /* We build the assignment expression that will initialize the
7844          field to its value. There are strict rules on static
7845          initializers (8.5). FIXME */
7846       if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
7847         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7848       java_method_add_stmt (mdecl, stmt);
7849     }
7850
7851   end_artificial_method_body (mdecl);
7852
7853   /* Now we want to place <clinit> as the last method (because we need
7854      it at least for interface so that it doesn't interfere with the
7855      dispatch table based lookup. */
7856   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7857     {
7858       current = TREE_CHAIN (TYPE_METHODS (class_type));
7859       TYPE_METHODS (class_type) = current;
7860
7861       while (TREE_CHAIN (current))
7862         current = TREE_CHAIN (current);
7863
7864       TREE_CHAIN (current) = mdecl;
7865       TREE_CHAIN (mdecl) = NULL_TREE;
7866     }
7867
7868   return mdecl;
7869 }
7870
7871 /* Analyzes a method body and look for something that isn't a
7872    MODIFY_EXPR with a constant value.  */
7873
7874 static int
7875 analyze_clinit_body (tree this_class, tree bbody)
7876 {
7877   while (bbody)
7878     switch (TREE_CODE (bbody))
7879       {
7880       case BLOCK:
7881         bbody = BLOCK_EXPR_BODY (bbody);
7882         break;
7883
7884       case EXPR_WITH_FILE_LOCATION:
7885         bbody = EXPR_WFL_NODE (bbody);
7886         break;
7887
7888       case COMPOUND_EXPR:
7889         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7890           return 1;
7891         bbody = TREE_OPERAND (bbody, 1);
7892         break;
7893
7894       case MODIFY_EXPR:
7895         /* If we're generating to class file and we're dealing with an
7896            array initialization, we return 1 to keep <clinit> */
7897         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7898             && flag_emit_class_files)
7899           return 1;
7900
7901         /* There are a few cases where we're required to keep
7902            <clinit>:
7903            - If this is an assignment whose operand is not constant,
7904            - If this is an assignment to a non-initialized field,
7905            - If this field is not a member of the current class.
7906         */
7907         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7908                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7909                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7910
7911       default:
7912         return 1;
7913       }
7914   return 0;
7915 }
7916
7917
7918 /* See whether we could get rid of <clinit>. Criteria are: all static
7919    final fields have constant initial values and the body of <clinit>
7920    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7921
7922 static int
7923 maybe_yank_clinit (tree mdecl)
7924 {
7925   tree type, current;
7926   tree fbody, bbody;
7927
7928   if (!DECL_CLINIT_P (mdecl))
7929     return 0;
7930
7931   /* If the body isn't empty, then we keep <clinit>. Note that if
7932      we're emitting classfiles, this isn't enough not to rule it
7933      out. */
7934   fbody = DECL_FUNCTION_BODY (mdecl);
7935   bbody = BLOCK_EXPR_BODY (fbody);
7936   if (bbody && bbody != error_mark_node)
7937     bbody = BLOCK_EXPR_BODY (bbody);
7938   else
7939     return 0;
7940   if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
7941     return 0;
7942
7943   type = DECL_CONTEXT (mdecl);
7944   current = TYPE_FIELDS (type);
7945
7946   for (current = (current ? TREE_CHAIN (current) : current);
7947        current; current = TREE_CHAIN (current))
7948     {
7949       tree f_init;
7950
7951       /* We're not interested in non-static fields.  */
7952       if (!FIELD_STATIC (current))
7953         continue;
7954
7955       /* Nor in fields without initializers. */
7956       f_init = DECL_INITIAL (current);
7957       if (f_init == NULL_TREE)
7958         continue;
7959
7960       /* Anything that isn't String or a basic type is ruled out -- or
7961          if we know how to deal with it (when doing things natively) we
7962          should generated an empty <clinit> so that SUID are computed
7963          correctly. */
7964       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7965           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7966         return 0;
7967
7968       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7969         return 0;
7970     }
7971
7972   /* Now we analyze the method body and look for something that
7973      isn't a MODIFY_EXPR */
7974   if (!IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
7975     return 0;
7976
7977   /* Get rid of <clinit> in the class' list of methods */
7978   if (TYPE_METHODS (type) == mdecl)
7979     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7980   else
7981     for (current = TYPE_METHODS (type); current;
7982          current = TREE_CHAIN (current))
7983       if (TREE_CHAIN (current) == mdecl)
7984         {
7985           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7986           break;
7987         }
7988
7989   return 1;
7990 }
7991
7992 /* Install the argument from MDECL. Suitable to completion and
7993    expansion of mdecl's body.  */
7994
7995 void
7996 start_complete_expand_method (tree mdecl)
7997 {
7998   tree tem;
7999
8000   pushlevel (1);                /* Prepare for a parameter push */
8001   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
8002   DECL_ARGUMENTS (mdecl) = tem;
8003
8004   for (; tem; tem = TREE_CHAIN (tem))
8005     {
8006       /* TREE_CHAIN (tem) will change after pushdecl. */
8007       tree next = TREE_CHAIN (tem);
8008       tree type = TREE_TYPE (tem);
8009       if (targetm.calls.promote_prototypes (type)
8010           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8011           && INTEGRAL_TYPE_P (type))
8012         type = integer_type_node;
8013       DECL_ARG_TYPE (tem) = type;
8014       layout_decl (tem, 0);
8015       pushdecl (tem);
8016       /* Re-install the next so that the list is kept and the loop
8017          advances. */
8018       TREE_CHAIN (tem) = next;
8019     }
8020   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8021   input_line = DECL_SOURCE_LINE (mdecl);
8022   build_result_decl (mdecl);
8023 }
8024
8025
8026 /* Complete and expand a method.  */
8027
8028 static void
8029 java_complete_expand_method (tree mdecl)
8030 {
8031   tree fbody, block_body, exception_copy;
8032
8033   current_function_decl = mdecl;
8034   /* Fix constructors before expanding them */
8035   if (DECL_CONSTRUCTOR_P (mdecl))
8036     fix_constructors (mdecl);
8037
8038   /* Expand functions that have a body */
8039   if (!DECL_FUNCTION_BODY (mdecl))
8040     return;
8041
8042   fbody = DECL_FUNCTION_BODY (mdecl);
8043   block_body = BLOCK_EXPR_BODY (fbody);
8044   exception_copy = NULL_TREE;
8045
8046   current_function_decl = mdecl;
8047
8048   if (! quiet_flag)
8049     fprintf (stderr, " [%s.",
8050              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8051   announce_function (mdecl);
8052   if (! quiet_flag)
8053     fprintf (stderr, "]");
8054
8055   /* Prepare the function for tree completion */
8056   start_complete_expand_method (mdecl);
8057
8058   /* Install the current this */
8059   current_this = (!METHOD_STATIC (mdecl) ?
8060                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8061
8062   /* Purge the `throws' list of unchecked exceptions (we save a copy
8063      of the list and re-install it later.) */
8064   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8065   purge_unchecked_exceptions (mdecl);
8066
8067   /* Install exceptions thrown with `throws' */
8068   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8069
8070   if (block_body != NULL_TREE)
8071     {
8072       block_body = java_complete_tree (block_body);
8073
8074       /* Before we check initialization, attached all class initialization
8075          variable to the block_body */
8076       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8077                      attach_init_test_initialization_flags, block_body);
8078
8079       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8080         {
8081           check_for_initialization (block_body, mdecl);
8082
8083           /* Go through all the flags marking the initialization of
8084              static variables and see whether they're definitively
8085              assigned, in which case the type is remembered as
8086              definitively initialized in MDECL. */
8087           if (STATIC_CLASS_INIT_OPT_P ())
8088             {
8089               /* Always register the context as properly initialized in
8090                  MDECL. This used with caution helps removing extra
8091                  initialization of self. */
8092               if (METHOD_STATIC (mdecl))
8093                 {
8094                   *(htab_find_slot
8095                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8096                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8097                 }
8098             }
8099         }
8100       ctxp->explicit_constructor_p = 0;
8101     }
8102
8103   BLOCK_EXPR_BODY (fbody) = block_body;
8104
8105   /* If we saw a return but couldn't evaluate it properly, we'll have
8106      an error_mark_node here. */
8107   if (block_body != error_mark_node
8108       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8109       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8110       && !flag_emit_xref)
8111     missing_return_error (current_function_decl);
8112
8113   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8114   maybe_yank_clinit (mdecl);
8115
8116   /* Pop the current level, with special measures if we found errors. */
8117   if (java_error_count)
8118     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8119   poplevel (1, 0, 1);
8120
8121   /* Pop the exceptions and sanity check */
8122   POP_EXCEPTIONS();
8123   if (currently_caught_type_list)
8124     abort ();
8125
8126   /* Restore the copy of the list of exceptions if emitting xrefs. */
8127   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8128 }
8129
8130 /* For with each class for which there's code to generate. */
8131
8132 static void
8133 java_expand_method_bodies (tree class)
8134 {
8135   tree decl;
8136   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8137     {
8138       tree block;
8139
8140       if (! DECL_FUNCTION_BODY (decl))
8141         continue;
8142
8143       current_function_decl = decl;
8144
8145       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8146
8147       /* Save the function body for gimplify and inlining.  */
8148       DECL_SAVED_TREE (decl) = block;
8149
8150       /* It's time to assign the variable flagging static class
8151          initialization based on which classes invoked static methods
8152          are definitely initializing. This should be flagged. */
8153       if (STATIC_CLASS_INIT_OPT_P ())
8154         {
8155           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8156           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8157             {
8158               /* Executed for each statement calling a static function.
8159                  LIST is a TREE_LIST whose PURPOSE is the called function
8160                  and VALUE is a compound whose second operand can be patched
8161                  with static class initialization flag assignments.  */
8162
8163               tree called_method = TREE_PURPOSE (list);
8164               tree compound = TREE_VALUE (list);
8165               tree assignment_compound_list
8166                 = build_tree_list (called_method, NULL);
8167
8168               /* For each class definitely initialized in
8169                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8170                  assignment to the class initialization flag. */
8171               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8172                              emit_test_initialization,
8173                              assignment_compound_list);
8174
8175               if (TREE_VALUE (assignment_compound_list))
8176                 TREE_OPERAND (compound, 1)
8177                   = TREE_VALUE (assignment_compound_list);
8178             }
8179         }
8180
8181       /* Expand the function body.  */
8182       source_end_java_method ();
8183     }
8184 }
8185
8186 \f
8187
8188 /* This section of the code deals with accessing enclosing context
8189    fields either directly by using the relevant access to this$<n> or
8190    by invoking an access method crafted for that purpose.  */
8191
8192 /* Build the necessary access from an inner class to an outer
8193    class. This routine could be optimized to cache previous result
8194    (decl, current_class and returned access).  When an access method
8195    needs to be generated, it always takes the form of a read. It might
8196    be later turned into a write by calling outer_field_access_fix.  */
8197
8198 static tree
8199 build_outer_field_access (tree id, tree decl)
8200 {
8201   tree access = NULL_TREE;
8202   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8203   tree decl_ctx = DECL_CONTEXT (decl);
8204
8205   /* If the immediate enclosing context of the current class is the
8206      field decl's class or inherits from it; build the access as
8207      `this$<n>.<field>'. Note that we will break the `private' barrier
8208      if we're not emitting bytecodes. */
8209   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8210       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8211     {
8212       tree thisn = build_current_thisn (current_class);
8213       access = make_qualified_primary (build_wfl_node (thisn),
8214                                        id, EXPR_WFL_LINECOL (id));
8215     }
8216   /* Otherwise, generate access methods to outer this and access the
8217      field (either using an access method or by direct access.) */
8218   else
8219     {
8220       int lc = EXPR_WFL_LINECOL (id);
8221
8222       /* Now we chain the required number of calls to the access$0 to
8223          get a hold to the enclosing instance we need, and then we
8224          build the field access. */
8225       access = build_access_to_thisn (current_class, decl_ctx, lc);
8226
8227       /* If the field is private and we're generating bytecode, then
8228          we generate an access method */
8229       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8230         {
8231           tree name = build_outer_field_access_methods (decl);
8232           access = build_outer_field_access_expr (lc, decl_ctx,
8233                                                   name, access, NULL_TREE);
8234         }
8235       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8236          Once again we break the `private' access rule from a foreign
8237          class. */
8238       else
8239         access = make_qualified_primary (access, id, lc);
8240     }
8241   return resolve_expression_name (access, NULL);
8242 }
8243
8244 /* Return a nonzero value if NODE describes an outer field inner
8245    access.  */
8246
8247 static int
8248 outer_field_access_p (tree type, tree decl)
8249 {
8250   if (!INNER_CLASS_TYPE_P (type)
8251       || TREE_CODE (decl) != FIELD_DECL
8252       || DECL_CONTEXT (decl) == type)
8253     return 0;
8254
8255   /* If the inner class extends the declaration context of the field
8256      we're trying to access, then this isn't an outer field access */
8257   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8258     return 0;
8259
8260   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8261        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8262     {
8263       if (type == DECL_CONTEXT (decl))
8264         return 1;
8265
8266       if (!DECL_CONTEXT (TYPE_NAME (type)))
8267         {
8268           /* Before we give up, see whether the field is inherited from
8269              the enclosing context we're considering. */
8270           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8271             return 1;
8272           break;
8273         }
8274     }
8275
8276   return 0;
8277 }
8278
8279 /* Return a nonzero value if NODE represents an outer field inner
8280    access that was been already expanded. As a side effect, it returns
8281    the name of the field being accessed and the argument passed to the
8282    access function, suitable for a regeneration of the access method
8283    call if necessary. */
8284
8285 static int
8286 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8287                                tree *arg)
8288 {
8289   int identified = 0;
8290
8291   if (TREE_CODE (node) != CALL_EXPR)
8292     return 0;
8293
8294   /* Well, gcj generates slightly different tree nodes when compiling
8295      to native or bytecodes. It's the case for function calls. */
8296
8297   if (flag_emit_class_files
8298       && TREE_CODE (node) == CALL_EXPR
8299       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8300     identified = 1;
8301   else if (!flag_emit_class_files)
8302     {
8303       node = TREE_OPERAND (node, 0);
8304
8305       if (node && TREE_OPERAND (node, 0)
8306           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8307         {
8308           node = TREE_OPERAND (node, 0);
8309           if (TREE_OPERAND (node, 0)
8310               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8311               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8312                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8313             identified = 1;
8314         }
8315     }
8316
8317   if (identified && name && arg_type && arg)
8318     {
8319       tree argument = TREE_OPERAND (node, 1);
8320       *name = DECL_NAME (TREE_OPERAND (node, 0));
8321       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8322       *arg = TREE_VALUE (argument);
8323     }
8324   return identified;
8325 }
8326
8327 /* Detect in NODE an outer field read access from an inner class and
8328    transform it into a write with RHS as an argument. This function is
8329    called from the java_complete_lhs when an assignment to a LHS can
8330    be identified. */
8331
8332 static tree
8333 outer_field_access_fix (tree wfl, tree node, tree rhs)
8334 {
8335   tree name, arg_type, arg;
8336
8337   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8338     {
8339       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8340                                             arg_type, name, arg, rhs);
8341       return java_complete_tree (node);
8342     }
8343   return NULL_TREE;
8344 }
8345
8346 /* Construct the expression that calls an access method:
8347      <type>.access$<n>(<arg1> [, <arg2>]);
8348
8349    ARG2 can be NULL and will be omitted in that case. It will denote a
8350    read access.  */
8351
8352 static tree
8353 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8354                                tree arg1, tree arg2)
8355 {
8356   tree args, cn, access;
8357
8358   args = arg1 ? arg1 :
8359     build_wfl_node (build_current_thisn (current_class));
8360   args = build_tree_list (NULL_TREE, args);
8361
8362   if (arg2)
8363     args = tree_cons (NULL_TREE, arg2, args);
8364
8365   access = build_method_invocation (build_wfl_node (access_method_name), args);
8366   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8367   return make_qualified_primary (cn, access, lc);
8368 }
8369
8370 static tree
8371 build_new_access_id (void)
8372 {
8373   static int access_n_counter = 1;
8374   char buffer [128];
8375
8376   sprintf (buffer, "access$%d", access_n_counter++);
8377   return get_identifier (buffer);
8378 }
8379
8380 /* Create the static access functions for the outer field DECL. We define a
8381    read:
8382      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8383        return inst$.field;
8384      }
8385    and a write access:
8386      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8387                                      TREE_TYPE (<field>) value$) {
8388        return inst$.field = value$;
8389      }
8390    We should have a usage flags on the DECL so we can lazily turn the ones
8391    we're using for code generation. FIXME.
8392 */
8393
8394 static tree
8395 build_outer_field_access_methods (tree decl)
8396 {
8397   tree id, args, stmt, mdecl;
8398
8399   if (FIELD_INNER_ACCESS_P (decl))
8400     return FIELD_INNER_ACCESS (decl);
8401
8402   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8403
8404   /* Create the identifier and a function named after it. */
8405   id = build_new_access_id ();
8406
8407   /* The identifier is marked as bearing the name of a generated write
8408      access function for outer field accessed from inner classes. */
8409   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8410
8411   /* Create the read access */
8412   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8413   TREE_CHAIN (args) = end_params_node;
8414   stmt = make_qualified_primary (build_wfl_node (inst_id),
8415                                  build_wfl_node (DECL_NAME (decl)), 0);
8416   stmt = build_return (0, stmt);
8417   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8418                                            TREE_TYPE (decl), id, args, stmt);
8419   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8420
8421   /* Create the write access method. No write access for final variable */
8422   if (!FIELD_FINAL (decl))
8423     {
8424       args = build_tree_list (inst_id,
8425                               build_pointer_type (DECL_CONTEXT (decl)));
8426       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8427       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8428       stmt = make_qualified_primary (build_wfl_node (inst_id),
8429                                      build_wfl_node (DECL_NAME (decl)), 0);
8430       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8431                                                 build_wfl_node (wpv_id)));
8432       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8433                                                TREE_TYPE (decl), id,
8434                                                args, stmt);
8435     }
8436   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8437
8438   /* Return the access name */
8439   return FIELD_INNER_ACCESS (decl) = id;
8440 }
8441
8442 /* Build an field access method NAME.  */
8443
8444 static tree
8445 build_outer_field_access_method (tree class, tree type, tree name,
8446                                  tree args, tree body)
8447 {
8448   tree saved_current_function_decl, mdecl;
8449
8450   /* Create the method */
8451   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8452   fix_method_argument_names (args, mdecl);
8453   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8454
8455   /* Attach the method body. */
8456   saved_current_function_decl = current_function_decl;
8457   start_artificial_method_body (mdecl);
8458   java_method_add_stmt (mdecl, body);
8459   end_artificial_method_body (mdecl);
8460   current_function_decl = saved_current_function_decl;
8461
8462   return mdecl;
8463 }
8464
8465 \f
8466 /* This section deals with building access function necessary for
8467    certain kinds of method invocation from inner classes.  */
8468
8469 static tree
8470 build_outer_method_access_method (tree decl)
8471 {
8472   tree saved_current_function_decl, mdecl;
8473   tree args = NULL_TREE, call_args = NULL_TREE;
8474   tree carg, id, body, class;
8475   char buffer [80];
8476   int parm_id_count = 0;
8477
8478   /* Test this abort with an access to a private field */
8479   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8480     abort ();
8481
8482   /* Check the cache first */
8483   if (DECL_FUNCTION_INNER_ACCESS (decl))
8484     return DECL_FUNCTION_INNER_ACCESS (decl);
8485
8486   class = DECL_CONTEXT (decl);
8487
8488   /* Obtain an access identifier and mark it */
8489   id = build_new_access_id ();
8490   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8491
8492   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8493   /* Create the arguments, as much as the original */
8494   for (; carg && carg != end_params_node;
8495        carg = TREE_CHAIN (carg))
8496     {
8497       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8498       args = chainon (args, build_tree_list (get_identifier (buffer),
8499                                              TREE_VALUE (carg)));
8500     }
8501   args = chainon (args, end_params_node);
8502
8503   /* Create the method */
8504   mdecl = create_artificial_method (class, ACC_STATIC,
8505                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8506   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8507   /* There is a potential bug here. We should be able to use
8508      fix_method_argument_names, but then arg names get mixed up and
8509      eventually a constructor will have its this$0 altered and the
8510      outer context won't be assignment properly. The testcase is
8511      stub.java FIXME */
8512   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8513
8514   /* Attach the method body. */
8515   saved_current_function_decl = current_function_decl;
8516   start_artificial_method_body (mdecl);
8517
8518   /* The actual method invocation uses the same args. When invoking a
8519      static methods that way, we don't want to skip the first
8520      argument. */
8521   carg = args;
8522   if (!METHOD_STATIC (decl))
8523     carg = TREE_CHAIN (carg);
8524   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8525     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8526                            call_args);
8527
8528   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8529                                   call_args);
8530   if (!METHOD_STATIC (decl))
8531     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8532                                    body, 0);
8533   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8534     body = build_return (0, body);
8535   java_method_add_stmt (mdecl,body);
8536   end_artificial_method_body (mdecl);
8537   current_function_decl = saved_current_function_decl;
8538
8539   /* Back tag the access function so it know what it accesses */
8540   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8541
8542   /* Tag the current method so it knows it has an access generated */
8543   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8544 }
8545
8546 \f
8547 /* This section of the code deals with building expressions to access
8548    the enclosing instance of an inner class. The enclosing instance is
8549    kept in a generated field called this$<n>, with <n> being the
8550    inner class nesting level (starting from 0.)  */
8551
8552 /* Build an access to a given this$<n>, always chaining access call to
8553    others. Access methods to this$<n> are build on the fly if
8554    necessary. This CAN'T be used to solely access this$<n-1> from
8555    this$<n> (which alway yield to special cases and optimization, see
8556    for example build_outer_field_access).  */
8557
8558 static tree
8559 build_access_to_thisn (tree from, tree to, int lc)
8560 {
8561   tree access = NULL_TREE;
8562
8563   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8564     {
8565       if (!access)
8566         {
8567           access = build_current_thisn (from);
8568           access = build_wfl_node (access);
8569         }
8570       else
8571         {
8572           tree access0_wfl, cn;
8573
8574           maybe_build_thisn_access_method (from);
8575           access0_wfl = build_wfl_node (access0_identifier_node);
8576           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8577           EXPR_WFL_LINECOL (access0_wfl) = lc;
8578           access = build_tree_list (NULL_TREE, access);
8579           access = build_method_invocation (access0_wfl, access);
8580           access = make_qualified_primary (cn, access, lc);
8581         }
8582
8583       /* If FROM isn't an inner class, that's fine, we've done enough.
8584          What we're looking for can be accessed from there.  */
8585       from = DECL_CONTEXT (TYPE_NAME (from));
8586       if (!from)
8587         break;
8588       from = TREE_TYPE (from);
8589     }
8590   return access;
8591 }
8592
8593 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8594    is returned if nothing needs to be generated. Otherwise, the method
8595    generated and a method decl is returned.
8596
8597    NOTE: These generated methods should be declared in a class file
8598    attribute so that they can't be referred to directly.  */
8599
8600 static tree
8601 maybe_build_thisn_access_method (tree type)
8602 {
8603   tree mdecl, args, stmt, rtype;
8604   tree saved_current_function_decl;
8605
8606   /* If TYPE is a top-level class, no access method is required.
8607      If there already is such an access method, bail out. */
8608   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8609     return NULL_TREE;
8610
8611   /* We generate the method. The method looks like:
8612      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8613   */
8614   args = build_tree_list (inst_id, build_pointer_type (type));
8615   TREE_CHAIN (args) = end_params_node;
8616   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8617   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8618                                     access0_identifier_node, args);
8619   fix_method_argument_names (args, mdecl);
8620   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8621   stmt = build_current_thisn (type);
8622   stmt = make_qualified_primary (build_wfl_node (inst_id),
8623                                  build_wfl_node (stmt), 0);
8624   stmt = build_return (0, stmt);
8625
8626   saved_current_function_decl = current_function_decl;
8627   start_artificial_method_body (mdecl);
8628   java_method_add_stmt (mdecl, stmt);
8629   end_artificial_method_body (mdecl);
8630   current_function_decl = saved_current_function_decl;
8631
8632   CLASS_ACCESS0_GENERATED_P (type) = 1;
8633
8634   return mdecl;
8635 }
8636
8637 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8638    the first level of innerclassing. this$1 for the next one, etc...
8639    This function can be invoked with TYPE to NULL, available and then
8640    has to count the parser context.  */
8641
8642 static GTY(()) tree saved_thisn;
8643 static GTY(()) tree saved_type;
8644
8645 static tree
8646 build_current_thisn (tree type)
8647 {
8648   static int saved_i = -1;
8649   static int saved_type_i = 0;
8650   tree decl;
8651   char buffer [24];
8652   int i = 0;
8653
8654   if (type)
8655     {
8656       if (type == saved_type)
8657         i = saved_type_i;
8658       else
8659         {
8660           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8661                decl; decl = DECL_CONTEXT (decl), i++)
8662             ;
8663
8664           saved_type = type;
8665           saved_type_i = i;
8666         }
8667     }
8668   else
8669     i = list_length (GET_CPC_LIST ())-2;
8670
8671   if (i == saved_i)
8672     return saved_thisn;
8673
8674   sprintf (buffer, "this$%d", i);
8675   saved_i = i;
8676   saved_thisn = get_identifier (buffer);
8677   return saved_thisn;
8678 }
8679
8680 /* Return the assignment to the hidden enclosing context `this$<n>'
8681    by the second incoming parameter to the innerclass constructor. The
8682    form used is `this.this$<n> = this$<n>;'.  */
8683
8684 static tree
8685 build_thisn_assign (void)
8686 {
8687   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8688     {
8689       tree thisn = build_current_thisn (current_class);
8690       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8691                                          build_wfl_node (thisn), 0);
8692       tree rhs = build_wfl_node (thisn);
8693       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8694       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8695     }
8696   return NULL_TREE;
8697 }
8698
8699 \f
8700 /* Building the synthetic `class$' used to implement the `.class' 1.1
8701    extension for non primitive types. This method looks like:
8702
8703     static Class class$(String type) throws NoClassDefFoundError
8704     {
8705       try {return (java.lang.Class.forName (String));}
8706       catch (ClassNotFoundException e) {
8707         throw new NoClassDefFoundError(e.getMessage());}
8708     } */
8709
8710 static GTY(()) tree get_message_wfl;
8711 static GTY(()) tree type_parm_wfl;
8712
8713 static tree
8714 build_dot_class_method (tree class)
8715 {
8716 #define BWF(S) build_wfl_node (get_identifier ((S)))
8717 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8718   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8719   tree stmt, throw_stmt;
8720
8721   if (!get_message_wfl)
8722     {
8723       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8724       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8725     }
8726
8727   /* Build the arguments */
8728   args = build_tree_list (get_identifier ("type$"),
8729                           build_pointer_type (string_type_node));
8730   TREE_CHAIN (args) = end_params_node;
8731
8732   /* Build the qualified name java.lang.Class.forName */
8733   tmp = MQN (MQN (MQN (BWF ("java"),
8734                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8735
8736   /* Create the "class$" function */
8737   mdecl = create_artificial_method (class, ACC_STATIC,
8738                                     build_pointer_type (class_type_node),
8739                                     classdollar_identifier_node, args);
8740   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8741                    BWF ("NoClassDefFoundError"));
8742   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8743   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8744   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8745     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8746
8747   /* We start by building the try block. We need to build:
8748        return (java.lang.Class.forName (type)); */
8749   stmt = build_method_invocation (tmp,
8750                                   build_tree_list (NULL_TREE, type_parm_wfl));
8751   stmt = build_return (0, stmt);
8752
8753   /* Now onto the catch block. We start by building the expression
8754      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8755   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8756                                     get_message_wfl, 0);
8757   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8758
8759   /* Build new NoClassDefFoundError (_.getMessage) */
8760   throw_stmt = build_new_invocation
8761     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8762      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8763
8764   /* Build the throw, (it's too early to use BUILD_THROW) */
8765   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8766
8767   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8768   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8769                    BWF ("ClassNotFoundException"));
8770   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8771
8772   fix_method_argument_names (args, mdecl);
8773   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8774   saved_current_function_decl = current_function_decl;
8775   start_artificial_method_body (mdecl);
8776   java_method_add_stmt (mdecl, stmt);
8777   end_artificial_method_body (mdecl);
8778   current_function_decl = saved_current_function_decl;
8779   TYPE_DOT_CLASS (class) = mdecl;
8780
8781   return mdecl;
8782 }
8783
8784 static tree
8785 build_dot_class_method_invocation (tree this_class, tree type)
8786 {
8787   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8788   tree sig_id, s, t;
8789
8790   if (TYPE_ARRAY_P (type))
8791     sig_id = build_java_signature (type);
8792   else
8793     sig_id = DECL_NAME (TYPE_NAME (type));
8794
8795   /* Ensure that the proper name separator is used */
8796   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8797                                IDENTIFIER_LENGTH (sig_id));
8798
8799   s = build_string (IDENTIFIER_LENGTH (sig_id),
8800                     IDENTIFIER_POINTER (sig_id));
8801   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8802                                build_tree_list (NULL_TREE, s));
8803   if (DECL_CONTEXT (dot_class_method) != this_class)
8804     {
8805       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8806       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8807     }
8808   return t;
8809 }
8810
8811 /* This section of the code deals with constructor.  */
8812
8813 /* Craft a body for default constructor. Patch existing constructor
8814    bodies with call to super() and field initialization statements if
8815    necessary.  */
8816
8817 static void
8818 fix_constructors (tree mdecl)
8819 {
8820   tree iii;                     /* Instance Initializer Invocation */
8821   tree body = DECL_FUNCTION_BODY (mdecl);
8822   tree thisn_assign, compound = NULL_TREE;
8823   tree class_type = DECL_CONTEXT (mdecl);
8824
8825   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8826     return;
8827   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8828
8829   if (!body)
8830     {
8831       /* It is an error for the compiler to generate a default
8832          constructor if the superclass doesn't have a constructor that
8833          takes no argument, or the same args for an anonymous class */
8834       if (verify_constructor_super (mdecl))
8835         {
8836           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8837           tree save = DECL_NAME (mdecl);
8838           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8839           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8840           parse_error_context
8841             (lookup_cl (TYPE_NAME (class_type)),
8842              "No constructor matching `%s' found in class `%s'",
8843              lang_printable_name (mdecl, 0), n);
8844           DECL_NAME (mdecl) = save;
8845         }
8846
8847       /* The constructor body must be crafted by hand. It's the
8848          constructor we defined when we realize we didn't have the
8849          CLASSNAME() constructor */
8850       start_artificial_method_body (mdecl);
8851
8852       /* Insert an assignment to the this$<n> hidden field, if
8853          necessary */
8854       if ((thisn_assign = build_thisn_assign ()))
8855         java_method_add_stmt (mdecl, thisn_assign);
8856
8857       /* We don't generate a super constructor invocation if we're
8858          compiling java.lang.Object. build_super_invocation takes care
8859          of that. */
8860       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8861
8862       /* FIXME */
8863       if ((iii = build_instinit_invocation (class_type)))
8864         java_method_add_stmt (mdecl, iii);
8865
8866       end_artificial_method_body (mdecl);
8867     }
8868   /* Search for an explicit constructor invocation */
8869   else
8870     {
8871       int found = 0;
8872       int invokes_this = 0;
8873       tree found_call = NULL_TREE;
8874       tree main_block = BLOCK_EXPR_BODY (body);
8875
8876       while (body)
8877         switch (TREE_CODE (body))
8878           {
8879           case CALL_EXPR:
8880             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8881             if (CALL_THIS_CONSTRUCTOR_P (body))
8882               invokes_this = 1;
8883             body = NULL_TREE;
8884             break;
8885           case COMPOUND_EXPR:
8886           case EXPR_WITH_FILE_LOCATION:
8887             found_call = body;
8888             body = TREE_OPERAND (body, 0);
8889             break;
8890           case BLOCK:
8891             found_call = body;
8892             body = BLOCK_EXPR_BODY (body);
8893             break;
8894           default:
8895             found = 0;
8896             body = NULL_TREE;
8897           }
8898
8899       /* Generate the assignment to this$<n>, if necessary */
8900       if ((thisn_assign = build_thisn_assign ()))
8901         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8902
8903       /* The constructor is missing an invocation of super() */
8904       if (!found)
8905         compound = add_stmt_to_compound (compound, NULL_TREE,
8906                                          build_super_invocation (mdecl));
8907       /* Explicit super() invocation should take place before the
8908          instance initializer blocks. */
8909       else
8910         {
8911           compound = add_stmt_to_compound (compound, NULL_TREE,
8912                                            TREE_OPERAND (found_call, 0));
8913           TREE_OPERAND (found_call, 0) = build_java_empty_stmt ();
8914         }
8915
8916       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8917
8918       /* Insert the instance initializer block right after. */
8919       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8920         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8921
8922       /* Fix the constructor main block if we're adding extra stmts */
8923       if (compound)
8924         {
8925           compound = add_stmt_to_compound (compound, NULL_TREE,
8926                                            BLOCK_EXPR_BODY (main_block));
8927           BLOCK_EXPR_BODY (main_block) = compound;
8928         }
8929     }
8930 }
8931
8932 /* Browse constructors in the super class, searching for a constructor
8933    that doesn't take any argument. Return 0 if one is found, 1
8934    otherwise.  If the current class is an anonymous inner class, look
8935    for something that has the same signature. */
8936
8937 static int
8938 verify_constructor_super (tree mdecl)
8939 {
8940   tree class = CLASSTYPE_SUPER (current_class);
8941   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8942   tree sdecl;
8943
8944   if (!class)
8945     return 0;
8946
8947   if (ANONYMOUS_CLASS_P (current_class))
8948     {
8949       tree mdecl_arg_type;
8950       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8951       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8952         if (DECL_CONSTRUCTOR_P (sdecl))
8953           {
8954             tree m_arg_type;
8955             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8956             if (super_inner)
8957               arg_type = TREE_CHAIN (arg_type);
8958             for (m_arg_type = mdecl_arg_type;
8959                  (arg_type != end_params_node
8960                   && m_arg_type != end_params_node);
8961                  arg_type = TREE_CHAIN (arg_type),
8962                    m_arg_type = TREE_CHAIN (m_arg_type))
8963               if (!valid_method_invocation_conversion_p
8964                      (TREE_VALUE (arg_type),
8965                       TREE_VALUE (m_arg_type)))
8966                 break;
8967
8968             if (arg_type == end_params_node && m_arg_type == end_params_node)
8969               return 0;
8970           }
8971     }
8972   else
8973     {
8974       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8975         {
8976           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8977           if (super_inner)
8978             arg = TREE_CHAIN (arg);
8979           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8980             return 0;
8981         }
8982     }
8983   return 1;
8984 }
8985
8986 /* Generate code for all context remembered for code generation.  */
8987
8988 static GTY(()) tree reversed_class_list;
8989 void
8990 java_expand_classes (void)
8991 {
8992   int save_error_count = 0;
8993   static struct parser_ctxt *cur_ctxp = NULL;
8994
8995   java_parse_abort_on_error ();
8996   if (!(ctxp = ctxp_for_generation))
8997     return;
8998   java_layout_classes ();
8999   java_parse_abort_on_error ();
9000
9001   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9002     {
9003       tree current;
9004       for (current = cur_ctxp->class_list;
9005            current;
9006            current = TREE_CHAIN (current))
9007         gen_indirect_dispatch_tables (TREE_TYPE (current));
9008     }
9009
9010   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9011     {
9012       ctxp = cur_ctxp;
9013       input_filename = ctxp->filename;
9014       lang_init_source (2);            /* Error msgs have method prototypes */
9015       java_complete_expand_classes (); /* Complete and expand classes */
9016       java_parse_abort_on_error ();
9017     }
9018   input_filename = main_input_filename;
9019
9020   /* Find anonymous classes and expand their constructor. This extra pass is
9021      necessary because the constructor itself is only generated when the
9022      method in which it is defined is expanded. */
9023   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9024     {
9025       tree current;
9026       ctxp = cur_ctxp;
9027       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9028         {
9029           output_class = current_class = TREE_TYPE (current);
9030           if (ANONYMOUS_CLASS_P (current_class))
9031             {
9032               tree d;
9033               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9034                 {
9035                   if (DECL_CONSTRUCTOR_P (d))
9036                     {
9037                       restore_line_number_status (1);
9038                       java_complete_expand_method (d);
9039                       restore_line_number_status (0);
9040                       break;    /* There is only one constructor. */
9041                     }
9042                 }
9043             }
9044         }
9045     }
9046
9047   /* Expanding the constructors of anonymous classes generates access
9048      methods.  Scan all the methods looking for null DECL_RESULTs --
9049      this will be the case if a method hasn't been expanded.  */
9050   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9051     {
9052       tree current;
9053       ctxp = cur_ctxp;
9054       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9055         {
9056           tree d;
9057           output_class = current_class = TREE_TYPE (current);
9058           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9059             {
9060               if (DECL_RESULT (d) == NULL_TREE)
9061                 {
9062                   restore_line_number_status (1);
9063                   java_complete_expand_method (d);
9064                   restore_line_number_status (0);
9065                 }
9066             }
9067         }
9068     }
9069
9070   /* ???  Instead of all this we could iterate around the list of
9071      classes until there were no more un-expanded methods.  It would
9072      take a little longer -- one pass over the whole list of methods
9073      -- but it would be simpler.  Like this:  */
9074 #if 0
9075     {
9076       int something_changed;
9077
9078       do
9079         {
9080           something_changed = 0;
9081           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9082             {
9083               tree current;
9084               ctxp = cur_ctxp;
9085               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9086                 {
9087                   tree d;
9088                   output_class = current_class = TREE_TYPE (current);
9089                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9090                     {
9091                       if (DECL_RESULT (d) == NULL_TREE)
9092                         {
9093                           something_changed = 1;
9094                           restore_line_number_status (1);
9095                           java_complete_expand_method (d);
9096                           restore_line_number_status (0);
9097                         }
9098                     }
9099                 }
9100             }
9101         }
9102       while (something_changed);
9103     }
9104 #endif
9105
9106   /* If we've found error at that stage, don't try to generate
9107      anything, unless we're emitting xrefs or checking the syntax only
9108      (but not using -fsyntax-only for the purpose of generating
9109      bytecode. */
9110   if (java_error_count && !flag_emit_xref
9111       && (!flag_syntax_only && !flag_emit_class_files))
9112     return;
9113
9114   /* Now things are stable, go for generation of the class data. */
9115
9116   /* We pessimistically marked all methods and fields external until
9117      we knew what set of classes we were planning to compile.  Now mark
9118      those that will be generated locally as not external.  */
9119   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9120     {
9121       tree current;
9122       ctxp = cur_ctxp;
9123       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9124         java_mark_class_local (TREE_TYPE (current));
9125     }
9126
9127   /* Compile the classes.  */
9128   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9129     {
9130       tree current;
9131       reversed_class_list = NULL;
9132
9133       ctxp = cur_ctxp;
9134
9135       /* We write out the classes in reverse order.  This ensures that
9136          inner classes are written before their containing classes,
9137          which is important for parallel builds.  Otherwise, the
9138          class file for the outer class may be found, but the class
9139          file for the inner class may not be present.  In that
9140          situation, the compiler cannot fall back to the original
9141          source, having already read the outer class, so we must
9142          prevent that situation.  */
9143       for (current = ctxp->class_list;
9144            current;
9145            current = TREE_CHAIN (current))
9146         reversed_class_list
9147           = tree_cons (NULL_TREE, current, reversed_class_list);
9148
9149       for (current = reversed_class_list;
9150            current;
9151            current = TREE_CHAIN (current))
9152         {
9153           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9154           if (flag_emit_class_files)
9155             write_classfile (current_class);
9156           if (flag_emit_xref)
9157             expand_xref (current_class);
9158           else if (! flag_syntax_only)
9159             java_expand_method_bodies (current_class);
9160         }
9161     }
9162 }
9163
9164 void
9165 java_finish_classes (void)
9166 {
9167   static struct parser_ctxt *cur_ctxp = NULL;
9168   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9169     {
9170       tree current;
9171       ctxp = cur_ctxp;
9172       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9173         {
9174           output_class = current_class = TREE_TYPE (current);
9175           finish_class ();
9176         }
9177     }
9178 }
9179
9180 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9181    a tree list node containing RIGHT. Fore coming RIGHTs will be
9182    chained to this hook. LOCATION contains the location of the
9183    separating `.' operator.  */
9184
9185 static tree
9186 make_qualified_primary (tree primary, tree right, int location)
9187 {
9188   tree wfl;
9189
9190   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9191     wfl = build_wfl_wrap (primary, location);
9192   else
9193     {
9194       wfl = primary;
9195       /* If wfl wasn't qualified, we build a first anchor */
9196       if (!EXPR_WFL_QUALIFICATION (wfl))
9197         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9198     }
9199
9200   /* And chain them */
9201   EXPR_WFL_LINECOL (right) = location;
9202   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9203   PRIMARY_P (wfl) =  1;
9204   return wfl;
9205 }
9206
9207 /* Simple merge of two name separated by a `.' */
9208
9209 static tree
9210 merge_qualified_name (tree left, tree right)
9211 {
9212   tree node;
9213   if (!left && !right)
9214     return NULL_TREE;
9215
9216   if (!left)
9217     return right;
9218
9219   if (!right)
9220     return left;
9221
9222   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9223                 IDENTIFIER_LENGTH (left));
9224   obstack_1grow (&temporary_obstack, '.');
9225   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9226                  IDENTIFIER_LENGTH (right));
9227   node =  get_identifier (obstack_base (&temporary_obstack));
9228   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9229   QUALIFIED_P (node) = 1;
9230   return node;
9231 }
9232
9233 /* Merge the two parts of a qualified name into LEFT.  Set the
9234    location information of the resulting node to LOCATION, usually
9235    inherited from the location information of the `.' operator. */
9236
9237 static tree
9238 make_qualified_name (tree left, tree right, int location)
9239 {
9240 #ifdef USE_COMPONENT_REF
9241   tree node = build (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9242   EXPR_WFL_LINECOL (node) = location;
9243   return node;
9244 #else
9245   tree left_id = EXPR_WFL_NODE (left);
9246   tree right_id = EXPR_WFL_NODE (right);
9247   tree wfl, merge;
9248
9249   merge = merge_qualified_name (left_id, right_id);
9250
9251   /* Left wasn't qualified and is now qualified */
9252   if (!QUALIFIED_P (left_id))
9253     {
9254       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9255       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9256       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9257     }
9258
9259   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9260   EXPR_WFL_LINECOL (wfl) = location;
9261   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9262
9263   EXPR_WFL_NODE (left) = merge;
9264   return left;
9265 #endif
9266 }
9267
9268 /* Extract the last identifier component of the qualified in WFL. The
9269    last identifier is removed from the linked list */
9270
9271 static tree
9272 cut_identifier_in_qualified (tree wfl)
9273 {
9274   tree q;
9275   tree previous = NULL_TREE;
9276   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9277     if (!TREE_CHAIN (q))
9278       {
9279         if (!previous)
9280           /* Operating on a non qualified qualified WFL.  */
9281           abort ();
9282
9283         TREE_CHAIN (previous) = NULL_TREE;
9284         return TREE_PURPOSE (q);
9285       }
9286 }
9287
9288 /* Resolve the expression name NAME. Return its decl.  */
9289
9290 static tree
9291 resolve_expression_name (tree id, tree *orig)
9292 {
9293   tree name = EXPR_WFL_NODE (id);
9294   tree decl;
9295
9296   /* 6.5.5.1: Simple expression names */
9297   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9298     {
9299       /* 15.13.1: NAME can appear within the scope of a local variable
9300          declaration */
9301       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9302         return decl;
9303
9304       /* 15.13.1: NAME can appear within a class declaration */
9305       else
9306         {
9307           decl = lookup_field_wrapper (current_class, name);
9308           if (decl)
9309             {
9310               tree access = NULL_TREE;
9311               int fs = FIELD_STATIC (decl);
9312
9313               /* If we're accessing an outer scope local alias, make
9314                  sure we change the name of the field we're going to
9315                  build access to. */
9316               if (FIELD_LOCAL_ALIAS_USED (decl))
9317                 name = DECL_NAME (decl);
9318
9319               check_deprecation (id, decl);
9320
9321               /* Instance variable (8.3.1.1) can't appear within
9322                  static method, static initializer or initializer for
9323                  a static variable. */
9324               if (!fs && METHOD_STATIC (current_function_decl))
9325                 {
9326                   static_ref_err (id, name, current_class);
9327                   return error_mark_node;
9328                 }
9329               /* Instance variables can't appear as an argument of
9330                  an explicit constructor invocation */
9331               if (!fs && ctxp->explicit_constructor_p
9332                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9333                 {
9334                   parse_error_context
9335                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9336                   return error_mark_node;
9337                 }
9338
9339               /* If we're processing an inner class and we're trying
9340                  to access a field belonging to an outer class, build
9341                  the access to the field */
9342               if (!fs && outer_field_access_p (current_class, decl))
9343                 {
9344                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9345                     {
9346                       static_ref_err (id, DECL_NAME (decl), current_class);
9347                       return error_mark_node;
9348                     }
9349                   access = build_outer_field_access (id, decl);
9350                   if (orig)
9351                     *orig = access;
9352                   return access;
9353                 }
9354
9355               /* Otherwise build what it takes to access the field */
9356               access = build_field_ref ((fs ? NULL_TREE : current_this),
9357                                         DECL_CONTEXT (decl), name);
9358               if (fs)
9359                 access = maybe_build_class_init_for_field (decl, access);
9360               /* We may be asked to save the real field access node */
9361               if (orig)
9362                 *orig = access;
9363               /* Last check: can we access the field? */
9364               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9365                 {
9366                   not_accessible_field_error (id, decl);
9367                   return error_mark_node;
9368                 }
9369               /* And we return what we got */
9370               return access;
9371             }
9372           /* Fall down to error report on undefined variable */
9373         }
9374     }
9375   /* 6.5.5.2 Qualified Expression Names */
9376   else
9377     {
9378       if (orig)
9379         *orig = NULL_TREE;
9380       qualify_ambiguous_name (id);
9381       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9382       /* 15.10.2: Accessing Superclass Members using super */
9383       return resolve_field_access (id, orig, NULL);
9384     }
9385
9386   /* We've got an error here */
9387   if (INNER_CLASS_TYPE_P (current_class))
9388     parse_error_context (id,
9389                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9390                          IDENTIFIER_POINTER (name),
9391                          IDENTIFIER_POINTER (DECL_NAME
9392                                              (TYPE_NAME (current_class))));
9393   else
9394     parse_error_context (id, "Undefined variable `%s'",
9395                          IDENTIFIER_POINTER (name));
9396
9397   return error_mark_node;
9398 }
9399
9400 static void
9401 static_ref_err (tree wfl, tree field_id, tree class_type)
9402 {
9403   parse_error_context
9404     (wfl,
9405      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9406      IDENTIFIER_POINTER (field_id),
9407      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9408 }
9409
9410 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9411    We return something suitable to generate the field access. We also
9412    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9413    recipient's address can be null. */
9414
9415 static tree
9416 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9417 {
9418   int is_static = 0;
9419   tree field_ref;
9420   tree decl = NULL_TREE, where_found, type_found;
9421
9422   if (resolve_qualified_expression_name (qual_wfl, &decl,
9423                                          &where_found, &type_found))
9424     return error_mark_node;
9425
9426   /* Resolve the LENGTH field of an array here */
9427   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9428       && type_found && TYPE_ARRAY_P (type_found)
9429       && ! flag_emit_class_files && ! flag_emit_xref)
9430     {
9431       tree length = build_java_array_length_access (where_found);
9432       field_ref = length;
9433
9434       /* In case we're dealing with a static array, we need to
9435          initialize its class before the array length can be fetched.
9436          It's also a good time to create a DECL_RTL for the field if
9437          none already exists, otherwise if the field was declared in a
9438          class found in an external file and hasn't been (and won't
9439          be) accessed for its value, none will be created. */
9440       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9441         {
9442           build_static_field_ref (where_found);
9443           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9444         }
9445     }
9446   /* We might have been trying to resolve field.method(). In which
9447      case, the resolution is over and decl is the answer */
9448   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9449     field_ref = decl;
9450   else if (JDECL_P (decl))
9451     {
9452       if (!type_found)
9453         type_found = DECL_CONTEXT (decl);
9454       is_static = FIELD_STATIC (decl);
9455       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9456                                     NULL_TREE : where_found),
9457                                    type_found, DECL_NAME (decl));
9458       if (field_ref == error_mark_node)
9459         return error_mark_node;
9460       if (is_static)
9461         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9462
9463       /* If we're looking at a static field, we may need to generate a
9464          class initialization for it.  This can happen when the access
9465          looks like `field.ref', where `field' is a static field in an
9466          interface we implement.  */
9467       if (!flag_emit_class_files
9468           && !flag_emit_xref
9469           && TREE_CODE (where_found) == VAR_DECL
9470           && FIELD_STATIC (where_found))
9471         {
9472           build_static_field_ref (where_found);
9473           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9474         }
9475     }
9476   else
9477     field_ref = decl;
9478
9479   if (field_decl)
9480     *field_decl = decl;
9481   if (field_type)
9482     *field_type = (QUAL_DECL_TYPE (decl) ?
9483                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9484   return field_ref;
9485 }
9486
9487 /* If NODE is an access to f static field, strip out the class
9488    initialization part and return the field decl, otherwise, return
9489    NODE. */
9490
9491 static tree
9492 strip_out_static_field_access_decl (tree node)
9493 {
9494   if (TREE_CODE (node) == COMPOUND_EXPR)
9495     {
9496       tree op1 = TREE_OPERAND (node, 1);
9497       if (TREE_CODE (op1) == COMPOUND_EXPR)
9498          {
9499            tree call = TREE_OPERAND (op1, 0);
9500            if (TREE_CODE (call) == CALL_EXPR
9501                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9502                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9503                == soft_initclass_node)
9504              return TREE_OPERAND (op1, 1);
9505          }
9506       else if (JDECL_P (op1))
9507         return op1;
9508     }
9509   return node;
9510 }
9511
9512 /* 6.5.5.2: Qualified Expression Names */
9513
9514 static int
9515 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9516                                    tree *where_found, tree *type_found)
9517 {
9518   int from_type = 0;            /* Field search initiated from a type */
9519   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9520   int previous_call_static = 0;
9521   int is_static;
9522   tree decl = NULL_TREE, type = NULL_TREE, q;
9523   /* For certain for of inner class instantiation */
9524   tree saved_current, saved_this;
9525 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9526   { current_class = saved_current; current_this = saved_this;}
9527
9528   *type_found = *where_found = NULL_TREE;
9529
9530   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9531     {
9532       tree qual_wfl = QUAL_WFL (q);
9533       tree ret_decl;            /* for EH checking */
9534       int location;             /* for EH checking */
9535
9536       /* 15.10.1 Field Access Using a Primary */
9537       switch (TREE_CODE (qual_wfl))
9538         {
9539         case CALL_EXPR:
9540         case NEW_CLASS_EXPR:
9541           /* If the access to the function call is a non static field,
9542              build the code to access it. */
9543           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9544             {
9545               decl = maybe_access_field (decl, *where_found,
9546                                          DECL_CONTEXT (decl));
9547               if (decl == error_mark_node)
9548                 return 1;
9549             }
9550
9551           /* And code for the function call */
9552           if (complete_function_arguments (qual_wfl))
9553             return 1;
9554
9555           /* We might have to setup a new current class and a new this
9556              for the search of an inner class, relative to the type of
9557              a expression resolved as `decl'. The current values are
9558              saved and restored shortly after */
9559           saved_current = current_class;
9560           saved_this = current_this;
9561           if (decl
9562               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9563                   || from_qualified_this))
9564             {
9565               /* If we still have `from_qualified_this', we have the form
9566                  <T>.this.f() and we need to build <T>.this */
9567               if (from_qualified_this)
9568                 {
9569                   decl = build_access_to_thisn (current_class, type, 0);
9570                   decl = java_complete_tree (decl);
9571                   type = TREE_TYPE (TREE_TYPE (decl));
9572                 }
9573               current_class = type;
9574               current_this = decl;
9575               from_qualified_this = 0;
9576             }
9577
9578           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9579             CALL_USING_SUPER (qual_wfl) = 1;
9580           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9581                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9582           *where_found = patch_method_invocation (qual_wfl, decl, type,
9583                                                   from_super,
9584                                                   &is_static, &ret_decl);
9585           from_super = 0;
9586           if (*where_found == error_mark_node)
9587             {
9588               RESTORE_THIS_AND_CURRENT_CLASS;
9589               return 1;
9590             }
9591           *type_found = type = QUAL_DECL_TYPE (*where_found);
9592
9593           *where_found = force_evaluation_order (*where_found);
9594
9595           /* If we're creating an inner class instance, check for that
9596              an enclosing instance is in scope */
9597           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9598               && INNER_ENCLOSING_SCOPE_CHECK (type))
9599             {
9600               parse_error_context
9601                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9602                  lang_printable_name (type, 0),
9603                  (!current_this ? "" :
9604                   "; an explicit one must be provided when creating this inner class"));
9605               RESTORE_THIS_AND_CURRENT_CLASS;
9606               return 1;
9607             }
9608
9609           /* In case we had to change then to resolve a inner class
9610              instantiation using a primary qualified by a `new' */
9611           RESTORE_THIS_AND_CURRENT_CLASS;
9612
9613           if (location)
9614             {
9615               tree arguments = NULL_TREE;
9616               if (TREE_CODE (qual_wfl) == CALL_EXPR
9617                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9618                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9619               check_thrown_exceptions (location, ret_decl, arguments);
9620             }
9621
9622           /* If the previous call was static and this one is too,
9623              build a compound expression to hold the two (because in
9624              that case, previous function calls aren't transported as
9625              forcoming function's argument. */
9626           if (previous_call_static && is_static)
9627             {
9628               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9629                             decl, *where_found);
9630               TREE_SIDE_EFFECTS (decl) = 1;
9631             }
9632           else
9633             {
9634               previous_call_static = is_static;
9635               decl = *where_found;
9636             }
9637           from_type = 0;
9638           continue;
9639
9640         case NEW_ARRAY_EXPR:
9641         case NEW_ANONYMOUS_ARRAY_EXPR:
9642           *where_found = decl = java_complete_tree (qual_wfl);
9643           if (decl == error_mark_node)
9644             return 1;
9645           *type_found = type = QUAL_DECL_TYPE (decl);
9646           continue;
9647
9648         case CONVERT_EXPR:
9649           *where_found = decl = java_complete_tree (qual_wfl);
9650           if (decl == error_mark_node)
9651             return 1;
9652           *type_found = type = QUAL_DECL_TYPE (decl);
9653           from_cast = 1;
9654           continue;
9655
9656         case CONDITIONAL_EXPR:
9657         case STRING_CST:
9658         case MODIFY_EXPR:
9659           *where_found = decl = java_complete_tree (qual_wfl);
9660           if (decl == error_mark_node)
9661             return 1;
9662           *type_found = type = QUAL_DECL_TYPE (decl);
9663           continue;
9664
9665         case ARRAY_REF:
9666           /* If the access to the function call is a non static field,
9667              build the code to access it. */
9668           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9669             {
9670               decl = maybe_access_field (decl, *where_found, type);
9671               if (decl == error_mark_node)
9672                 return 1;
9673             }
9674           /* And code for the array reference expression */
9675           decl = java_complete_tree (qual_wfl);
9676           if (decl == error_mark_node)
9677             return 1;
9678           type = QUAL_DECL_TYPE (decl);
9679           continue;
9680
9681         case PLUS_EXPR:
9682           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9683             return 1;
9684           if ((type = patch_string (decl)))
9685             decl = type;
9686           *where_found = QUAL_RESOLUTION (q) = decl;
9687           *type_found = type = TREE_TYPE (decl);
9688           break;
9689
9690         case CLASS_LITERAL:
9691           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9692             return 1;
9693           *where_found = QUAL_RESOLUTION (q) = decl;
9694           *type_found = type = TREE_TYPE (decl);
9695           break;
9696
9697         default:
9698           /* Fix for -Wall Just go to the next statement. Don't
9699              continue */
9700           break;
9701         }
9702
9703       /* If we fall here, we weren't processing a (static) function call. */
9704       previous_call_static = 0;
9705
9706       /* It can be the keyword THIS */
9707       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9708           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9709         {
9710           if (!current_this)
9711             {
9712               parse_error_context
9713                 (wfl, "Keyword `this' used outside allowed context");
9714               return 1;
9715             }
9716           if (ctxp->explicit_constructor_p
9717               && type == current_class)
9718             {
9719               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9720               return 1;
9721             }
9722           /* We have to generate code for intermediate access */
9723           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9724             {
9725               *where_found = decl = current_this;
9726               *type_found = type = QUAL_DECL_TYPE (decl);
9727             }
9728           /* We're trying to access the this from somewhere else. Make sure
9729              it's allowed before doing so. */
9730           else
9731             {
9732               if (!enclosing_context_p (type, current_class))
9733                 {
9734                   char *p  = xstrdup (lang_printable_name (type, 0));
9735                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9736                                        p, p,
9737                                        lang_printable_name (current_class, 0));
9738                   free (p);
9739                   return 1;
9740                 }
9741               from_qualified_this = 1;
9742               /* If there's nothing else after that, we need to
9743                  produce something now, otherwise, the section of the
9744                  code that needs to produce <T>.this will generate
9745                  what is necessary. */
9746               if (!TREE_CHAIN (q))
9747                 {
9748                   decl = build_access_to_thisn (current_class, type, 0);
9749                   *where_found = decl = java_complete_tree (decl);
9750                   *type_found = type = TREE_TYPE (decl);
9751                 }
9752             }
9753
9754           from_type = 0;
9755           continue;
9756         }
9757
9758       /* 15.10.2 Accessing Superclass Members using SUPER */
9759       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9760           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9761         {
9762           tree node;
9763           /* Check on the restricted use of SUPER */
9764           if (METHOD_STATIC (current_function_decl)
9765               || current_class == object_type_node)
9766             {
9767               parse_error_context
9768                 (wfl, "Keyword `super' used outside allowed context");
9769               return 1;
9770             }
9771           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9772           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9773                              CLASSTYPE_SUPER (current_class),
9774                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9775           *where_found = decl = java_complete_tree (node);
9776           if (decl == error_mark_node)
9777             return 1;
9778           *type_found = type = QUAL_DECL_TYPE (decl);
9779           from_super = from_type = 1;
9780           continue;
9781         }
9782
9783       /* 15.13.1: Can't search for field name in packages, so we
9784          assume a variable/class name was meant. */
9785       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9786         {
9787           tree name;
9788           if ((decl = resolve_package (wfl, &q, &name)))
9789             {
9790               tree list;
9791               *where_found = decl;
9792
9793               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9794
9795               /* We want to be absolutely sure that the class is laid
9796                  out. We're going to search something inside it. */
9797               *type_found = type = TREE_TYPE (decl);
9798               layout_class (type);
9799               from_type = 1;
9800
9801               /* Fix them all the way down, if any are left. */
9802               if (q)
9803                 {
9804                   list = TREE_CHAIN (q);
9805                   while (list)
9806                     {
9807                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9808                       list = TREE_CHAIN (list);
9809                     }
9810                 }
9811             }
9812           else
9813             {
9814               if (from_super || from_cast)
9815                 parse_error_context
9816                   ((from_cast ? qual_wfl : wfl),
9817                    "No variable `%s' defined in class `%s'",
9818                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9819                    lang_printable_name (type, 0));
9820               else
9821                 parse_error_context
9822                   (qual_wfl, "Undefined variable or class name: `%s'",
9823                    IDENTIFIER_POINTER (name));
9824               return 1;
9825             }
9826         }
9827
9828       /* We have a type name. It's been already resolved when the
9829          expression was qualified. */
9830       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9831         {
9832           decl = QUAL_RESOLUTION (q);
9833
9834           /* Sneak preview. If next we see a `new', we're facing a
9835              qualification which resulted in a type being selected
9836              instead of a field.  Report the error.  */
9837           if(TREE_CHAIN (q)
9838              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9839             {
9840               parse_error_context (qual_wfl, "Undefined variable `%s'",
9841                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9842               return 1;
9843             }
9844
9845           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9846
9847           check_deprecation (qual_wfl, decl);
9848
9849           type = TREE_TYPE (decl);
9850           from_type = 1;
9851         }
9852       /* We resolve an expression name */
9853       else
9854         {
9855           tree field_decl = NULL_TREE;
9856
9857           /* If there exists an early resolution, use it. That occurs
9858              only once and we know that there are more things to
9859              come. Don't do that when processing something after SUPER
9860              (we need more thing to be put in place below */
9861           if (!from_super && QUAL_RESOLUTION (q))
9862             {
9863               decl = QUAL_RESOLUTION (q);
9864               if (!type)
9865                 {
9866                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9867                     {
9868                       if (current_this)
9869                         *where_found = current_this;
9870                       else
9871                         {
9872                           static_ref_err (qual_wfl, DECL_NAME (decl),
9873                                           current_class);
9874                           return 1;
9875                         }
9876                       if (outer_field_access_p (current_class, decl))
9877                         decl = build_outer_field_access (qual_wfl, decl);
9878                     }
9879                   else
9880                     {
9881                       *where_found = TREE_TYPE (decl);
9882                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9883                         *where_found = TREE_TYPE (*where_found);
9884                     }
9885                 }
9886             }
9887
9888           /* Report and error if we're using a numerical literal as a
9889              qualifier. It can only be an INTEGER_CST. */
9890           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9891             {
9892               parse_error_context
9893                 (wfl, "Can't use type `%s' as a qualifier",
9894                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9895               return 1;
9896             }
9897
9898           /* We have to search for a field, knowing the type of its
9899              container. The flag FROM_TYPE indicates that we resolved
9900              the last member of the expression as a type name, which
9901              means that for the resolution of this field, we'll look
9902              for other errors than if it was resolved as a member of
9903              an other field. */
9904           else
9905             {
9906               int is_static;
9907               tree field_decl_type; /* For layout */
9908
9909               if (!from_type && !JREFERENCE_TYPE_P (type))
9910                 {
9911                   parse_error_context
9912                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9913                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9914                      lang_printable_name (type, 0),
9915                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9916                   return 1;
9917                 }
9918
9919               field_decl = lookup_field_wrapper (type,
9920                                                  EXPR_WFL_NODE (qual_wfl));
9921
9922               /* Maybe what we're trying to access to is an inner
9923                  class, only if decl is a TYPE_DECL. */
9924               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9925                 {
9926                   tree ptr, inner_decl;
9927
9928                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9929                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9930                   if (inner_decl)
9931                     {
9932                       check_inner_class_access (inner_decl, decl, qual_wfl);
9933                       type = TREE_TYPE (inner_decl);
9934                       decl = inner_decl;
9935                       from_type = 1;
9936                       continue;
9937                     }
9938                 }
9939
9940               if (field_decl == NULL_TREE)
9941                 {
9942                   parse_error_context
9943                     (qual_wfl, "No variable `%s' defined in type `%s'",
9944                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9945                      GET_TYPE_NAME (type));
9946                   return 1;
9947                 }
9948               if (field_decl == error_mark_node)
9949                 return 1;
9950
9951               /* Layout the type of field_decl, since we may need
9952                  it. Don't do primitive types or loaded classes. The
9953                  situation of non primitive arrays may not handled
9954                  properly here. FIXME */
9955               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9956                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9957               else
9958                 field_decl_type = TREE_TYPE (field_decl);
9959               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9960                   && !CLASS_LOADED_P (field_decl_type)
9961                   && !TYPE_ARRAY_P (field_decl_type))
9962                 resolve_and_layout (field_decl_type, NULL_TREE);
9963
9964               /* Check on accessibility here */
9965               if (not_accessible_p (current_class, field_decl,
9966                                     DECL_CONTEXT (field_decl), from_super))
9967                 return not_accessible_field_error (qual_wfl,field_decl);
9968               check_deprecation (qual_wfl, field_decl);
9969
9970               /* There are things to check when fields are accessed
9971                  from type. There are no restrictions on a static
9972                  declaration of the field when it is accessed from an
9973                  interface */
9974               is_static = FIELD_STATIC (field_decl);
9975               if (!from_super && from_type
9976                   && !TYPE_INTERFACE_P (type)
9977                   && !is_static
9978                   && (current_function_decl
9979                       && METHOD_STATIC (current_function_decl)))
9980                 {
9981                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9982                   return 1;
9983                 }
9984               from_cast = from_super = 0;
9985
9986               /* It's an access from a type but it isn't static, we
9987                  make it relative to `this'. */
9988               if (!is_static && from_type)
9989                 decl = current_this;
9990
9991               /* If we need to generate something to get a proper
9992                  handle on what this field is accessed from, do it
9993                  now. */
9994               if (!is_static)
9995                 {
9996                   decl = maybe_access_field (decl, *where_found, *type_found);
9997                   if (decl == error_mark_node)
9998                     return 1;
9999                 }
10000
10001               /* We want to keep the location were found it, and the type
10002                  we found. */
10003               *where_found = decl;
10004               *type_found = type;
10005
10006               /* Generate the correct expression for field access from
10007                  qualified this */
10008               if (from_qualified_this)
10009                 {
10010                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10011                   from_qualified_this = 0;
10012                 }
10013
10014               /* This is the decl found and eventually the next one to
10015                  search from */
10016               decl = field_decl;
10017             }
10018           from_type = 0;
10019           type = QUAL_DECL_TYPE (decl);
10020
10021           /* Sneak preview. If decl is qualified by a `new', report
10022              the error here to be accurate on the peculiar construct */
10023           if (TREE_CHAIN (q)
10024               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10025               && !JREFERENCE_TYPE_P (type))
10026             {
10027               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10028                                    lang_printable_name (type, 0));
10029               return 1;
10030             }
10031         }
10032       /* `q' might have changed due to a after package resolution
10033          re-qualification */
10034       if (!q)
10035         break;
10036     }
10037   *found_decl = decl;
10038   return 0;
10039 }
10040
10041 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10042    can't be accessed from REFERENCE (a record type). If MEMBER
10043    features a protected access, we then use WHERE which, if non null,
10044    holds the type of MEMBER's access that is checked against
10045    6.6.2.1. This function should be used when decl is a field or a
10046    method.  */
10047
10048 static int
10049 not_accessible_p (tree reference, tree member, tree where, int from_super)
10050 {
10051   int access_flag = get_access_flags_from_decl (member);
10052
10053   /* Inner classes are processed by check_inner_class_access */
10054   if (INNER_CLASS_TYPE_P (reference))
10055     return 0;
10056
10057   /* Access always granted for members declared public */
10058   if (access_flag & ACC_PUBLIC)
10059     return 0;
10060
10061   /* Check access on protected members */
10062   if (access_flag & ACC_PROTECTED)
10063     {
10064       /* Access granted if it occurs from within the package
10065          containing the class in which the protected member is
10066          declared */
10067       if (class_in_current_package (DECL_CONTEXT (member)))
10068         return 0;
10069
10070       /* If accessed with the form `super.member', then access is granted */
10071       if (from_super)
10072         return 0;
10073
10074       /* If where is active, access was made through a
10075          qualifier. Access is granted if the type of the qualifier is
10076          or is a sublass of the type the access made from (6.6.2.1.)  */
10077       if (where && !inherits_from_p (reference, where))
10078         return 1;
10079
10080       /* Otherwise, access is granted if occurring from the class where
10081          member is declared or a subclass of it. Find the right
10082          context to perform the check */
10083       if (PURE_INNER_CLASS_TYPE_P (reference))
10084         {
10085           while (INNER_CLASS_TYPE_P (reference))
10086             {
10087               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10088                 return 0;
10089               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10090             }
10091         }
10092       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10093         return 0;
10094       return 1;
10095     }
10096
10097   /* Check access on private members. Access is granted only if it
10098      occurs from within the class in which it is declared -- that does
10099      it for innerclasses too. */
10100   if (access_flag & ACC_PRIVATE)
10101     {
10102       if (reference == DECL_CONTEXT (member))
10103         return 0;
10104       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10105         return 0;
10106       return 1;
10107     }
10108
10109   /* Default access is permitted only when occurring from within the
10110      package in which the context (MEMBER) is declared.  */
10111   return !class_in_current_package (DECL_CONTEXT (member));
10112 }
10113
10114 /* Test deprecated decl access.  */
10115 static void
10116 check_deprecation (tree wfl, tree decl)
10117 {
10118   const char *file;
10119   tree elt;
10120
10121   if (! flag_deprecated)
10122     return;
10123
10124   /* We want to look at the element type of arrays here, so we strip
10125      all surrounding array types.  */
10126   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10127     {
10128       elt = TREE_TYPE (decl);
10129       while (TYPE_ARRAY_P (elt))
10130         elt = TYPE_ARRAY_ELEMENT (elt);
10131       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10132          to the record.  */
10133       decl = TYPE_NAME (TREE_TYPE (elt));
10134     }
10135   file = DECL_SOURCE_FILE (decl);
10136
10137   /* Complain if the field is deprecated and the file it was defined
10138      in isn't compiled at the same time the file which contains its
10139      use is */
10140   if (DECL_DEPRECATED (decl)
10141       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10142     {
10143       const char *the;
10144       switch (TREE_CODE (decl))
10145         {
10146         case FUNCTION_DECL:
10147           the = "method";
10148           break;
10149         case FIELD_DECL:
10150         case VAR_DECL:
10151           the = "field";
10152           break;
10153         case TYPE_DECL:
10154           parse_warning_context (wfl, "The class `%s' has been deprecated",
10155                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10156           return;
10157         default:
10158           abort ();
10159         }
10160       /* Don't issue a message if the context as been deprecated as a
10161          whole. */
10162       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10163         parse_warning_context
10164           (wfl, "The %s `%s' in class `%s' has been deprecated",
10165            the, lang_printable_name (decl, 0),
10166            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10167     }
10168 }
10169
10170 /* Returns 1 if class was declared in the current package, 0 otherwise */
10171
10172 static GTY(()) tree cicp_cache;
10173 static int
10174 class_in_current_package (tree class)
10175 {
10176   int qualified_flag;
10177   tree left;
10178
10179   if (cicp_cache == class)
10180     return 1;
10181
10182   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10183
10184   /* If the current package is empty and the name of CLASS is
10185      qualified, class isn't in the current package.  If there is a
10186      current package and the name of the CLASS is not qualified, class
10187      isn't in the current package */
10188   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10189     return 0;
10190
10191   /* If there is not package and the name of CLASS isn't qualified,
10192      they belong to the same unnamed package */
10193   if (!ctxp->package && !qualified_flag)
10194     return 1;
10195
10196   /* Compare the left part of the name of CLASS with the package name */
10197   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10198   if (ctxp->package == left)
10199     {
10200       cicp_cache = class;
10201       return 1;
10202     }
10203   return 0;
10204 }
10205
10206 /* This function may generate code to access DECL from WHERE. This is
10207    done only if certain conditions meet.  */
10208
10209 static tree
10210 maybe_access_field (tree decl, tree where, tree type)
10211 {
10212   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10213       && !FIELD_STATIC (decl))
10214     decl = build_field_ref (where ? where : current_this,
10215                             (type ? type : DECL_CONTEXT (decl)),
10216                             DECL_NAME (decl));
10217   return decl;
10218 }
10219
10220 /* Build a method invocation, by patching PATCH. If non NULL
10221    and according to the situation, PRIMARY and WHERE may be
10222    used. IS_STATIC is set to 1 if the invoked function is static. */
10223
10224 static tree
10225 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10226                          int *is_static, tree *ret_decl)
10227 {
10228   tree wfl = TREE_OPERAND (patch, 0);
10229   tree args = TREE_OPERAND (patch, 1);
10230   tree name = EXPR_WFL_NODE (wfl);
10231   tree list;
10232   int is_static_flag = 0;
10233   int is_super_init = 0;
10234   tree this_arg = NULL_TREE;
10235   int is_array_clone_call = 0;
10236
10237   /* Should be overridden if everything goes well. Otherwise, if
10238      something fails, it should keep this value. It stop the
10239      evaluation of a bogus assignment. See java_complete_tree,
10240      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10241      evaluating an assignment */
10242   TREE_TYPE (patch) = error_mark_node;
10243
10244   /* Since lookup functions are messing with line numbers, save the
10245      context now.  */
10246   java_parser_context_save_global ();
10247
10248   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10249
10250   /* Resolution of qualified name, excluding constructors */
10251   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10252     {
10253       tree identifier, identifier_wfl, type, resolved;
10254       /* Extract the last IDENTIFIER of the qualified
10255          expression. This is a wfl and we will use it's location
10256          data during error report. */
10257       identifier_wfl = cut_identifier_in_qualified (wfl);
10258       identifier = EXPR_WFL_NODE (identifier_wfl);
10259
10260       /* Given the context, IDENTIFIER is syntactically qualified
10261          as a MethodName. We need to qualify what's before */
10262       qualify_ambiguous_name (wfl);
10263       resolved = resolve_field_access (wfl, NULL, NULL);
10264
10265       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10266          && FIELD_FINAL (resolved)
10267          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10268          && !flag_emit_class_files && !flag_emit_xref)
10269        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10270
10271       if (resolved == error_mark_node)
10272         PATCH_METHOD_RETURN_ERROR ();
10273
10274       type = GET_SKIP_TYPE (resolved);
10275       resolve_and_layout (type, NULL_TREE);
10276
10277       if (JPRIMITIVE_TYPE_P (type))
10278         {
10279           parse_error_context
10280             (identifier_wfl,
10281              "Can't invoke a method on primitive type `%s'",
10282              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10283           PATCH_METHOD_RETURN_ERROR ();
10284         }
10285
10286       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10287       args = nreverse (args);
10288
10289       /* We're resolving a call from a type */
10290       if (TREE_CODE (resolved) == TYPE_DECL)
10291         {
10292           if (CLASS_INTERFACE (resolved))
10293             {
10294               parse_error_context
10295                 (identifier_wfl,
10296                 "Can't make static reference to method `%s' in interface `%s'",
10297                  IDENTIFIER_POINTER (identifier),
10298                  IDENTIFIER_POINTER (name));
10299               PATCH_METHOD_RETURN_ERROR ();
10300             }
10301           if (list && !METHOD_STATIC (list))
10302             {
10303               char *fct_name = xstrdup (lang_printable_name (list, 0));
10304               parse_error_context
10305                 (identifier_wfl,
10306                  "Can't make static reference to method `%s %s' in class `%s'",
10307                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10308                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10309               free (fct_name);
10310               PATCH_METHOD_RETURN_ERROR ();
10311             }
10312         }
10313       else
10314         this_arg = primary = resolved;
10315
10316       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10317         is_array_clone_call = 1;
10318
10319       /* IDENTIFIER_WFL will be used to report any problem further */
10320       wfl = identifier_wfl;
10321     }
10322   /* Resolution of simple names, names generated after a primary: or
10323      constructors */
10324   else
10325     {
10326       tree class_to_search = NULL_TREE;
10327       int lc;                   /* Looking for Constructor */
10328
10329       /* We search constructor in their target class */
10330       if (CALL_CONSTRUCTOR_P (patch))
10331         {
10332           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10333             class_to_search = EXPR_WFL_NODE (wfl);
10334           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10335                    this_identifier_node)
10336             class_to_search = NULL_TREE;
10337           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10338                    super_identifier_node)
10339             {
10340               is_super_init = 1;
10341               if (CLASSTYPE_SUPER (current_class))
10342                 class_to_search =
10343                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10344               else
10345                 {
10346                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10347                   PATCH_METHOD_RETURN_ERROR ();
10348                 }
10349             }
10350
10351           /* Class to search is NULL if we're searching the current one */
10352           if (class_to_search)
10353             {
10354               class_to_search = resolve_and_layout (class_to_search, wfl);
10355
10356               if (!class_to_search)
10357                 {
10358                   parse_error_context
10359                     (wfl, "Class `%s' not found in type declaration",
10360                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10361                   PATCH_METHOD_RETURN_ERROR ();
10362                 }
10363
10364               /* Can't instantiate an abstract class, but we can
10365                  invoke it's constructor. It's use within the `new'
10366                  context is denied here. */
10367               if (CLASS_ABSTRACT (class_to_search)
10368                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10369                 {
10370                   parse_error_context
10371                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10372                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10373                   PATCH_METHOD_RETURN_ERROR ();
10374                 }
10375
10376               class_to_search = TREE_TYPE (class_to_search);
10377             }
10378           else
10379             class_to_search = current_class;
10380           lc = 1;
10381         }
10382       /* This is a regular search in the local class, unless an
10383          alternate class is specified. */
10384       else
10385         {
10386           if (where != NULL_TREE)
10387             class_to_search = where;
10388           else if (QUALIFIED_P (name))
10389             class_to_search = current_class;
10390           else
10391             {
10392               class_to_search = current_class;
10393
10394               for (;;)
10395                 {
10396                   if (has_method (class_to_search, name))
10397                     break;
10398                   if (! INNER_CLASS_TYPE_P (class_to_search))
10399                     {
10400                       parse_error_context (wfl,
10401                                            "No method named `%s' in scope",
10402                                            IDENTIFIER_POINTER (name));
10403                       PATCH_METHOD_RETURN_ERROR ();
10404                     }
10405                   class_to_search
10406                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10407                 }
10408             }
10409           lc = 0;
10410         }
10411
10412       /* NAME is a simple identifier or comes from a primary. Search
10413          in the class whose declaration contain the method being
10414          invoked. */
10415       resolve_and_layout (class_to_search, NULL_TREE);
10416
10417       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10418       /* Don't continue if no method were found, as the next statement
10419          can't be executed then. */
10420       if (!list)
10421         PATCH_METHOD_RETURN_ERROR ();
10422
10423       if (TYPE_ARRAY_P (class_to_search)
10424           && DECL_NAME (list) == get_identifier ("clone"))
10425         is_array_clone_call = 1;
10426
10427       /* Check for static reference if non static methods */
10428       if (check_for_static_method_reference (wfl, patch, list,
10429                                              class_to_search, primary))
10430         PATCH_METHOD_RETURN_ERROR ();
10431
10432       /* Check for inner classes creation from illegal contexts */
10433       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10434                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10435           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10436           && !DECL_INIT_P (current_function_decl))
10437         {
10438           parse_error_context
10439             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10440              lang_printable_name (class_to_search, 0),
10441              (!current_this ? "" :
10442               "; an explicit one must be provided when creating this inner class"));
10443           PATCH_METHOD_RETURN_ERROR ();
10444         }
10445
10446       /* Non static methods are called with the current object extra
10447          argument. If patch a `new TYPE()', the argument is the value
10448          returned by the object allocator. If method is resolved as a
10449          primary, use the primary otherwise use the current THIS. */
10450       args = nreverse (args);
10451       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10452         {
10453           this_arg = primary ? primary : current_this;
10454
10455           /* If we're using an access method, things are different.
10456              There are two family of cases:
10457
10458              1) We're not generating bytecodes:
10459
10460              - LIST is non static. It's invocation is transformed from
10461                x(a1,...,an) into this$<n>.x(a1,....an).
10462              - LIST is static. It's invocation is transformed from
10463                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10464
10465              2) We're generating bytecodes:
10466
10467              - LIST is non static. It's invocation is transformed from
10468                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10469              - LIST is static. It's invocation is transformed from
10470                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10471
10472              Of course, this$<n> can be arbitrarily complex, ranging from
10473              this$0 (the immediate outer context) to
10474              access$0(access$0(...(this$0))).
10475
10476              maybe_use_access_method returns a nonzero value if the
10477              this_arg has to be moved into the (then generated) stub
10478              argument list. In the meantime, the selected function
10479              might have be replaced by a generated stub. */
10480           if (!primary &&
10481               maybe_use_access_method (is_super_init, &list, &this_arg))
10482             {
10483               args = tree_cons (NULL_TREE, this_arg, args);
10484               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10485             }
10486         }
10487     }
10488
10489   /* Merge point of all resolution schemes. If we have nothing, this
10490      is an error, already signaled */
10491   if (!list)
10492     PATCH_METHOD_RETURN_ERROR ();
10493
10494   /* Check accessibility, position the is_static flag, build and
10495      return the call */
10496   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10497                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10498                          NULL_TREE), from_super)
10499       /* Calls to clone() on array types are permitted as a special-case. */
10500       && !is_array_clone_call)
10501     {
10502       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10503       const char *const access =
10504         accessibility_string (get_access_flags_from_decl (list));
10505       const char *const klass =
10506         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10507       const char *const refklass =
10508         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10509       const char *const what = (DECL_CONSTRUCTOR_P (list)
10510                                 ? "constructor" : "method");
10511       /* FIXME: WFL yields the wrong message here but I don't know
10512          what else to use.  */
10513       parse_error_context (wfl,
10514                            "Can't access %s %s `%s.%s' from `%s'",
10515                            access, what, klass, fct_name, refklass);
10516       PATCH_METHOD_RETURN_ERROR ();
10517     }
10518
10519   /* Deprecation check: check whether the method being invoked or the
10520      instance-being-created's type are deprecated.  */
10521   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10522     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10523   check_deprecation (wfl, list);
10524
10525   /* If invoking a innerclass constructor, there are hidden parameters
10526      to pass */
10527   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10528       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10529     {
10530       /* And make sure we add the accessed local variables to be saved
10531          in field aliases. */
10532       args = build_alias_initializer_parameter_list
10533         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10534
10535       /* Secretly pass the current_this/primary as a second argument */
10536       if (primary || current_this)
10537         {
10538           tree extra_arg;
10539           tree this_type = (current_this ?
10540                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10541           /* Method's (list) enclosing context */
10542           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10543           /* If we have a primary, use it. */
10544           if (primary)
10545             extra_arg = primary;
10546           /* The current `this' is an inner class but isn't a direct
10547              enclosing context for the inner class we're trying to
10548              create. Build an access to the proper enclosing context
10549              and use it. */
10550           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10551                    && this_type != TREE_TYPE (mec))
10552             {
10553
10554               extra_arg = build_access_to_thisn (current_class,
10555                                                  TREE_TYPE (mec), 0);
10556               extra_arg = java_complete_tree (extra_arg);
10557             }
10558           /* Otherwise, just use the current `this' as an enclosing
10559              context. */
10560           else
10561             extra_arg = current_this;
10562           args = tree_cons (NULL_TREE, extra_arg, args);
10563         }
10564       else
10565         args = tree_cons (NULL_TREE, integer_zero_node, args);
10566     }
10567
10568   /* This handles the situation where a constructor invocation needs
10569      to have an enclosing context passed as a second parameter (the
10570      constructor is one of an inner class). */
10571   if ((is_super_init ||
10572        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10573       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10574     {
10575       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10576       tree extra_arg =
10577         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10578       extra_arg = java_complete_tree (extra_arg);
10579       args = tree_cons (NULL_TREE, extra_arg, args);
10580     }
10581
10582   is_static_flag = METHOD_STATIC (list);
10583   if (! is_static_flag && this_arg != NULL_TREE)
10584     args = tree_cons (NULL_TREE, this_arg, args);
10585
10586   /* In the context of an explicit constructor invocation, we can't
10587      invoke any method relying on `this'. Exceptions are: we're
10588      invoking a static function, primary exists and is not the current
10589      this, we're creating a new object. */
10590   if (ctxp->explicit_constructor_p
10591       && !is_static_flag
10592       && (!primary || primary == current_this)
10593       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10594     {
10595       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10596       PATCH_METHOD_RETURN_ERROR ();
10597     }
10598   java_parser_context_restore_global ();
10599   if (is_static)
10600     *is_static = is_static_flag;
10601   /* Sometimes, we want the decl of the selected method. Such as for
10602      EH checking */
10603   if (ret_decl)
10604     *ret_decl = list;
10605   patch = patch_invoke (patch, list, args);
10606
10607   /* Now is a good time to insert the call to finit$ */
10608   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10609     {
10610       tree finit_parms, finit_call;
10611
10612       /* Prepare to pass hidden parameters to finit$, if any. */
10613       finit_parms = build_alias_initializer_parameter_list
10614         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10615
10616       finit_call =
10617         build_method_invocation (build_wfl_node (finit_identifier_node),
10618                                  finit_parms);
10619
10620       /* Generate the code used to initialize fields declared with an
10621          initialization statement and build a compound statement along
10622          with the super constructor invocation. */
10623       CAN_COMPLETE_NORMALLY (patch) = 1;
10624       patch = build (COMPOUND_EXPR, void_type_node, patch,
10625                      java_complete_tree (finit_call));
10626     }
10627   return patch;
10628 }
10629
10630 /* Check that we're not trying to do a static reference to a method in
10631    non static method. Return 1 if it's the case, 0 otherwise. */
10632
10633 static int
10634 check_for_static_method_reference (tree wfl, tree node, tree method,
10635                                    tree where, tree primary)
10636 {
10637   if (METHOD_STATIC (current_function_decl)
10638       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10639     {
10640       char *fct_name = xstrdup (lang_printable_name (method, 0));
10641       parse_error_context
10642         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10643          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10644          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10645       free (fct_name);
10646       return 1;
10647     }
10648   return 0;
10649 }
10650
10651 /* Fix the invocation of *MDECL if necessary in the case of a
10652    invocation from an inner class. *THIS_ARG might be modified
10653    appropriately and an alternative access to *MDECL might be
10654    returned.  */
10655
10656 static int
10657 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10658 {
10659   tree ctx;
10660   tree md = *mdecl, ta = *this_arg;
10661   int to_return = 0;
10662   int non_static_context = !METHOD_STATIC (md);
10663
10664   if (is_super_init
10665       || DECL_CONTEXT (md) == current_class
10666       || !PURE_INNER_CLASS_TYPE_P (current_class)
10667       || DECL_FINIT_P (md)
10668       || DECL_INSTINIT_P (md))
10669     return 0;
10670
10671   /* If we're calling a method found in an enclosing class, generate
10672      what it takes to retrieve the right this. Don't do that if we're
10673      invoking a static method. Note that if MD's type is unrelated to
10674      CURRENT_CLASS, then the current this can be used. */
10675
10676   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10677     {
10678       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10679       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10680         {
10681           ta = build_current_thisn (current_class);
10682           ta = build_wfl_node (ta);
10683         }
10684       else
10685         {
10686           tree type = ctx;
10687           while (type)
10688             {
10689               maybe_build_thisn_access_method (type);
10690               if (inherits_from_p (type, DECL_CONTEXT (md)))
10691                 {
10692                   ta = build_access_to_thisn (ctx, type, 0);
10693                   break;
10694                 }
10695               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10696                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10697             }
10698         }
10699       ta = java_complete_tree (ta);
10700     }
10701
10702   /* We might have to use an access method to get to MD. We can
10703      break the method access rule as far as we're not generating
10704      bytecode */
10705   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10706     {
10707       md = build_outer_method_access_method (md);
10708       to_return = 1;
10709     }
10710
10711   *mdecl = md;
10712   *this_arg = ta;
10713
10714   /* Returning a nonzero value indicates we were doing a non static
10715      method invocation that is now a static invocation. It will have
10716      callee displace `this' to insert it in the regular argument
10717      list. */
10718   return (non_static_context && to_return);
10719 }
10720
10721 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10722    mode.  */
10723
10724 static tree
10725 patch_invoke (tree patch, tree method, tree args)
10726 {
10727   tree dtable, func;
10728   tree original_call, t, ta;
10729   tree check = NULL_TREE;
10730
10731   /* Last step for args: convert build-in types. If we're dealing with
10732      a new TYPE() type call, the first argument to the constructor
10733      isn't found in the incoming argument list, but delivered by
10734      `new' */
10735   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10736   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10737     t = TREE_CHAIN (t);
10738   for (ta = args; t != end_params_node && ta;
10739        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10740     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10741         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10742       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10743
10744   /* Resolve unresolved returned type issues */
10745   t = TREE_TYPE (TREE_TYPE (method));
10746   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10747     resolve_and_layout (TREE_TYPE (t), NULL);
10748
10749   if (flag_emit_class_files || flag_emit_xref)
10750     func = method;
10751   else
10752     {
10753       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10754         {
10755         case INVOKE_VIRTUAL:
10756           dtable = invoke_build_dtable (0, args);
10757           func = build_invokevirtual (dtable, method);
10758           break;
10759
10760         case INVOKE_NONVIRTUAL:
10761           /* If the object for the method call is null, we throw an
10762              exception.  We don't do this if the object is the current
10763              method's `this'.  In other cases we just rely on an
10764              optimization pass to eliminate redundant checks.  */
10765           if (TREE_VALUE (args) != current_this)
10766             {
10767               /* We use a save_expr here to make sure we only evaluate
10768                  the new `self' expression once.  */
10769               tree save_arg = save_expr (TREE_VALUE (args));
10770               TREE_VALUE (args) = save_arg;
10771               check = java_check_reference (save_arg, 1);
10772             }
10773           /* Fall through.  */
10774
10775         case INVOKE_SUPER:
10776         case INVOKE_STATIC:
10777           {
10778             tree signature = build_java_signature (TREE_TYPE (method));
10779             func = build_known_method_ref (method, TREE_TYPE (method),
10780                                            DECL_CONTEXT (method),
10781                                            signature, args);
10782           }
10783           break;
10784
10785         case INVOKE_INTERFACE:
10786           dtable = invoke_build_dtable (1, args);
10787           func = build_invokeinterface (dtable, method);
10788           break;
10789
10790         default:
10791           abort ();
10792         }
10793
10794       /* Ensure self_type is initialized, (invokestatic). FIXME */
10795       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10796     }
10797
10798   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10799   TREE_OPERAND (patch, 0) = func;
10800   TREE_OPERAND (patch, 1) = args;
10801   patch = check_for_builtin (method, patch);
10802   original_call = patch;
10803
10804   /* We're processing a `new TYPE ()' form. New is called and its
10805      returned value is the first argument to the constructor. We build
10806      a COMPOUND_EXPR and use saved expression so that the overall NEW
10807      expression value is a pointer to a newly created and initialized
10808      class. */
10809   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10810     {
10811       tree class = DECL_CONTEXT (method);
10812       tree c1, saved_new, size, new;
10813       tree alloc_node;
10814
10815       if (flag_emit_class_files || flag_emit_xref)
10816         {
10817           TREE_TYPE (patch) = build_pointer_type (class);
10818           return patch;
10819         }
10820       if (!TYPE_SIZE (class))
10821         safe_layout_class (class);
10822       size = size_in_bytes (class);
10823       alloc_node =
10824         (class_has_finalize_method (class) ? alloc_object_node
10825                                            : alloc_no_finalizer_node);
10826       new = build (CALL_EXPR, promote_type (class),
10827                      build_address_of (alloc_node),
10828                      build_tree_list (NULL_TREE, build_class_ref (class)),
10829                      NULL_TREE);
10830       saved_new = save_expr (new);
10831       c1 = build_tree_list (NULL_TREE, saved_new);
10832       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10833       TREE_OPERAND (original_call, 1) = c1;
10834       TREE_SET_CODE (original_call, CALL_EXPR);
10835       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10836     }
10837
10838   /* If CHECK is set, then we are building a check to see if the object
10839      is NULL.  */
10840   if (check != NULL_TREE)
10841     {
10842       /* We have to call force_evaluation_order now because creating a
10843          COMPOUND_EXPR wraps the arg list in a way that makes it
10844          unrecognizable by force_evaluation_order later.  Yuk.  */
10845       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10846                      force_evaluation_order (patch));
10847       TREE_SIDE_EFFECTS (patch) = 1;
10848     }
10849
10850   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10851      put it as the first expression of a COMPOUND_EXPR. The second
10852      expression being an empty statement to be later patched if
10853      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10854      the VALUE is the compound) in a hashtable and return a
10855      COMPOUND_EXPR built so that the result of the evaluation of the
10856      original PATCH node is returned. */
10857   if (STATIC_CLASS_INIT_OPT_P ()
10858       && current_function_decl && METHOD_STATIC (method))
10859     {
10860       tree list;
10861       tree fndecl = current_function_decl;
10862       /* We have to call force_evaluation_order now because creating a
10863          COMPOUND_EXPR wraps the arg list in a way that makes it
10864          unrecognizable by force_evaluation_order later.  Yuk.  */
10865       tree save = force_evaluation_order (patch);
10866       tree type = TREE_TYPE (patch);
10867
10868       patch = build (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
10869       list = tree_cons (method, patch,
10870                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10871
10872       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10873
10874       patch = build (COMPOUND_EXPR, type, patch, save);
10875     }
10876
10877   return patch;
10878 }
10879
10880 static int
10881 invocation_mode (tree method, int super)
10882 {
10883   int access = get_access_flags_from_decl (method);
10884
10885   if (super)
10886     return INVOKE_SUPER;
10887
10888   if (access & ACC_STATIC)
10889     return INVOKE_STATIC;
10890
10891   /* We have to look for a constructor before we handle nonvirtual
10892      calls; otherwise the constructor will look nonvirtual.  */
10893   if (DECL_CONSTRUCTOR_P (method))
10894     return INVOKE_STATIC;
10895
10896   if (access & ACC_FINAL || access & ACC_PRIVATE)
10897     return INVOKE_NONVIRTUAL;
10898
10899   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10900     return INVOKE_NONVIRTUAL;
10901
10902   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10903     return INVOKE_INTERFACE;
10904
10905   return INVOKE_VIRTUAL;
10906 }
10907
10908 /* Retrieve a refined list of matching methods. It covers the step
10909    15.11.2 (Compile-Time Step 2) */
10910
10911 static tree
10912 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10913 {
10914   tree atl = end_params_node;           /* Arg Type List */
10915   tree method, signature, list, node;
10916   const char *candidates;               /* Used for error report */
10917   char *dup;
10918
10919   /* Fix the arguments */
10920   for (node = arg_list; node; node = TREE_CHAIN (node))
10921     {
10922       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10923       /* Non primitive type may have to be resolved */
10924       if (!JPRIMITIVE_TYPE_P (current_arg))
10925         resolve_and_layout (current_arg, NULL_TREE);
10926       /* And promoted */
10927       if (TREE_CODE (current_arg) == RECORD_TYPE)
10928         current_arg = promote_type (current_arg);
10929       atl = tree_cons (NULL_TREE, current_arg, atl);
10930     }
10931
10932   /* Presto. If we're dealing with an anonymous class and a
10933      constructor call, generate the right constructor now, since we
10934      know the arguments' types. */
10935
10936   if (lc && ANONYMOUS_CLASS_P (class))
10937     {
10938       tree saved_current_class;
10939       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10940       saved_current_class = current_class;
10941       current_class = class;
10942       fix_constructors (mdecl);
10943       current_class = saved_current_class;
10944     }
10945
10946   /* Find all candidates and then refine the list, searching for the
10947      most specific method. */
10948   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10949   list = find_most_specific_methods_list (list);
10950   if (list && !TREE_CHAIN (list))
10951     return TREE_VALUE (list);
10952
10953   /* Issue an error. List candidates if any. Candidates are listed
10954      only if accessible (non accessible methods may end-up here for
10955      the sake of a better error report). */
10956   candidates = NULL;
10957   if (list)
10958     {
10959       tree current;
10960       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10961       for (current = list; current; current = TREE_CHAIN (current))
10962         {
10963           tree cm = TREE_VALUE (current);
10964           char string [4096];
10965           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10966             continue;
10967           sprintf
10968             (string, "  `%s' in `%s'%s",
10969              get_printable_method_name (cm),
10970              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10971              (TREE_CHAIN (current) ? "\n" : ""));
10972           obstack_grow (&temporary_obstack, string, strlen (string));
10973         }
10974       obstack_1grow (&temporary_obstack, '\0');
10975       candidates = obstack_finish (&temporary_obstack);
10976     }
10977   /* Issue the error message */
10978   method = make_node (FUNCTION_TYPE);
10979   TYPE_ARG_TYPES (method) = atl;
10980   signature = build_java_argument_signature (method);
10981   dup = xstrdup (lang_printable_name (class, 0));
10982   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10983                        (lc ? "constructor" : "method"),
10984                        (lc ? dup : IDENTIFIER_POINTER (name)),
10985                        IDENTIFIER_POINTER (signature), dup,
10986                        (candidates ? candidates : ""));
10987   free (dup);
10988   return NULL_TREE;
10989 }
10990
10991 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10992    when we're looking for a constructor. */
10993
10994 static tree
10995 find_applicable_accessible_methods_list (int lc, tree class, tree name,
10996                                          tree arglist)
10997 {
10998   static htab_t searched_classes;
10999   static int search_not_done = 0;
11000   tree list = NULL_TREE, all_list = NULL_TREE;
11001
11002   /* Check the hash table to determine if this class has been searched
11003      already. */
11004   if (searched_classes)
11005     {
11006       if (htab_find (searched_classes, class) != NULL)
11007         return NULL;
11008     }
11009   else
11010     {
11011       searched_classes = htab_create (10, htab_hash_pointer,
11012                                       htab_eq_pointer, NULL);
11013     }
11014
11015   search_not_done++;
11016   *htab_find_slot (searched_classes, class, INSERT) = class;
11017
11018   if (!CLASS_LOADED_P (class))
11019     {
11020       load_class (class, 1);
11021       safe_layout_class (class);
11022     }
11023
11024   /* Search interfaces */
11025   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11026       && CLASS_INTERFACE (TYPE_NAME (class)))
11027     {
11028       int i, n;
11029       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11030       search_applicable_methods_list (lc, TYPE_METHODS (class),
11031                                       name, arglist, &list, &all_list);
11032       n = TREE_VEC_LENGTH (basetype_vec);
11033       for (i = 1; i < n; i++)
11034         {
11035           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11036           tree rlist;
11037
11038           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11039                                                            arglist);
11040           list = chainon (rlist, list);
11041         }
11042     }
11043   /* Search classes */
11044   else
11045     {
11046       search_applicable_methods_list (lc, TYPE_METHODS (class),
11047                                       name, arglist, &list, &all_list);
11048
11049       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11050          that we only search in class. Note that we should have found
11051          something at this point. */
11052       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11053         {
11054           lc = 1;
11055           if (!list)
11056             abort ();
11057         }
11058
11059       /* We must search all interfaces of this class */
11060       if (!lc)
11061       {
11062         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11063         int n = TREE_VEC_LENGTH (basetype_vec), i;
11064         for (i = 1; i < n; i++)
11065           {
11066             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11067             if (t != object_type_node)
11068               {
11069                 tree rlist
11070                   = find_applicable_accessible_methods_list (lc, t,
11071                                                              name, arglist);
11072                 list = chainon (rlist, list);
11073               }
11074           }
11075       }
11076
11077       /* Search superclass */
11078       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11079         {
11080           tree rlist;
11081           class = CLASSTYPE_SUPER (class);
11082           rlist = find_applicable_accessible_methods_list (lc, class,
11083                                                            name, arglist);
11084           list = chainon (rlist, list);
11085         }
11086     }
11087
11088   search_not_done--;
11089
11090   /* We're done. Reset the searched classes list and finally search
11091      java.lang.Object if it wasn't searched already. */
11092   if (!search_not_done)
11093     {
11094       if (!lc
11095           && TYPE_METHODS (object_type_node)
11096           && htab_find (searched_classes, object_type_node) == NULL)
11097         {
11098           search_applicable_methods_list (lc,
11099                                           TYPE_METHODS (object_type_node),
11100                                           name, arglist, &list, &all_list);
11101         }
11102       htab_delete (searched_classes);
11103       searched_classes = NULL;
11104     }
11105
11106   /* Either return the list obtained or all selected (but
11107      inaccessible) methods for better error report. */
11108   return (!list ? all_list : list);
11109 }
11110
11111 /* Effectively search for the appropriate method in method */
11112
11113 static void
11114 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11115                                 tree *list, tree *all_list)
11116 {
11117   for (; method; method = TREE_CHAIN (method))
11118     {
11119       /* When dealing with constructor, stop here, otherwise search
11120          other classes */
11121       if (lc && !DECL_CONSTRUCTOR_P (method))
11122         continue;
11123       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11124                        || (DECL_NAME (method) != name)))
11125         continue;
11126
11127       if (argument_types_convertible (method, arglist))
11128         {
11129           /* Retain accessible methods only */
11130           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11131                                  method, NULL_TREE, 0))
11132             *list = tree_cons (NULL_TREE, method, *list);
11133           else
11134             /* Also retain all selected method here */
11135             *all_list = tree_cons (NULL_TREE, method, *list);
11136         }
11137     }
11138 }
11139
11140 /* 15.11.2.2 Choose the Most Specific Method */
11141
11142 static tree
11143 find_most_specific_methods_list (tree list)
11144 {
11145   int max = 0;
11146   int abstract, candidates;
11147   tree current, new_list = NULL_TREE;
11148   for (current = list; current; current = TREE_CHAIN (current))
11149     {
11150       tree method;
11151       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11152
11153       for (method = list; method; method = TREE_CHAIN (method))
11154         {
11155           tree method_v, current_v;
11156           /* Don't test a method against itself */
11157           if (method == current)
11158             continue;
11159
11160           method_v = TREE_VALUE (method);
11161           current_v = TREE_VALUE (current);
11162
11163           /* Compare arguments and location where methods where declared */
11164           if (argument_types_convertible (method_v, current_v))
11165             {
11166               if (valid_method_invocation_conversion_p
11167                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11168                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11169                       && enclosing_context_p (DECL_CONTEXT (method_v),
11170                                               DECL_CONTEXT (current_v))))
11171                 {
11172                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11173                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11174                   max = (v > max ? v : max);
11175                 }
11176             }
11177         }
11178     }
11179
11180   /* Review the list and select the maximally specific methods */
11181   for (current = list, abstract = -1, candidates = -1;
11182        current; current = TREE_CHAIN (current))
11183     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11184       {
11185         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11186         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11187         candidates++;
11188       }
11189
11190   /* If we have several and they're all abstract, just pick the
11191      closest one. */
11192   if (candidates > 0 && candidates == abstract)
11193     {
11194       /* FIXME: merge the throws clauses.  There is no convenient way
11195          to do this in gcj right now, since ideally we'd like to
11196          introduce a new METHOD_DECL here, but that is really not
11197          possible.  */
11198       new_list = nreverse (new_list);
11199       TREE_CHAIN (new_list) = NULL_TREE;
11200       return new_list;
11201     }
11202
11203   /* We have several (we couldn't find a most specific), all but one
11204      are abstract, we pick the only non abstract one. */
11205   if (candidates > 0 && (candidates == abstract+1))
11206     {
11207       for (current = new_list; current; current = TREE_CHAIN (current))
11208         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11209           {
11210             TREE_CHAIN (current) = NULL_TREE;
11211             new_list = current;
11212           }
11213     }
11214
11215   /* If we can't find one, lower expectations and try to gather multiple
11216      maximally specific methods */
11217   while (!new_list && max)
11218     {
11219       while (--max > 0)
11220         {
11221           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11222             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11223         }
11224     }
11225
11226   return new_list;
11227 }
11228
11229 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11230    converted by method invocation conversion (5.3) to the type of the
11231    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11232    to change less often than M1. */
11233
11234 static GTY(()) tree m2_arg_value;
11235 static GTY(()) tree m2_arg_cache;
11236
11237 static int
11238 argument_types_convertible (tree m1, tree m2_or_arglist)
11239 {
11240   tree m1_arg, m2_arg;
11241
11242   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11243
11244   if (m2_arg_value == m2_or_arglist)
11245     m2_arg = m2_arg_cache;
11246   else
11247     {
11248       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11249          argument types */
11250       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11251         {
11252           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11253           if (!METHOD_STATIC (m2_or_arglist))
11254             m2_arg = TREE_CHAIN (m2_arg);
11255         }
11256       else
11257         m2_arg = m2_or_arglist;
11258
11259       m2_arg_value = m2_or_arglist;
11260       m2_arg_cache = m2_arg;
11261     }
11262
11263   while (m1_arg != end_params_node && m2_arg != end_params_node)
11264     {
11265       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11266       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11267                                                  TREE_VALUE (m2_arg)))
11268         break;
11269       m1_arg = TREE_CHAIN (m1_arg);
11270       m2_arg = TREE_CHAIN (m2_arg);
11271     }
11272   return m1_arg == end_params_node && m2_arg == end_params_node;
11273 }
11274
11275 /* Qualification routines */
11276
11277 /* Given a name x.y.z, look up x locally.  If it's found, save the
11278    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11279    so that we later try and load the appropriate classes.  */
11280 static void
11281 qualify_ambiguous_name (tree id)
11282 {
11283   tree name, decl;
11284
11285   /* We inspect the first item of the qualification list.  As a sanity
11286      check, make sure that it is an identfier node.  */
11287   tree qual = EXPR_WFL_QUALIFICATION (id);
11288   tree qual_wfl = QUAL_WFL (qual);
11289
11290   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11291     return;
11292
11293   name = EXPR_WFL_NODE (qual_wfl);
11294
11295   /* If we don't have an identifier, or we have a 'this' or 'super',
11296      then field access processing is all we need : there is nothing
11297      for us to do.  */
11298   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11299       name == this_identifier_node ||
11300       name == super_identifier_node)
11301     return;
11302
11303   /* If name appears within the scope of a local variable declaration
11304      or parameter declaration, or is a field within an enclosing
11305      class, then it is an expression name.  Save the decl and let
11306      resolve_field_access do it's work.  */
11307   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11308       (decl = lookup_field_wrapper (current_class, name)))
11309     {
11310       QUAL_RESOLUTION (qual) = decl;
11311       return;
11312     }
11313
11314   /* If name is a known class name (either declared or imported), mark
11315      us as a type name.  */
11316   if ((decl = resolve_and_layout (name, NULL_TREE)))
11317     {
11318       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11319       QUAL_RESOLUTION (qual) = decl;
11320     }
11321
11322   /* Check here that NAME isn't declared by more than one
11323      type-import-on-demand declaration of the compilation unit
11324      containing NAME. FIXME */
11325
11326   /* We couldn't find a declaration for the name.  Assume for now that
11327      we have a qualified class name that needs to be loaded from an
11328      external class file.  */
11329   else
11330     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11331
11332   /* Propagate the qualification across other components of the
11333      qualified name */
11334   for (qual = TREE_CHAIN (qual); qual;
11335        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11336     {
11337       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11338         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11339     }
11340
11341   /* Store the global qualification for the ambiguous part of ID back
11342      into ID fields */
11343   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11344     RESOLVE_TYPE_NAME_P (id) = 1;
11345   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11346     RESOLVE_PACKAGE_NAME_P (id) = 1;
11347 }
11348
11349 static int
11350 breakdown_qualified (tree *left, tree *right, tree source)
11351 {
11352   char *p, *base;
11353   int l = IDENTIFIER_LENGTH (source);
11354
11355   base = alloca (l + 1);
11356   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11357
11358   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11359   p = base + l - 1;
11360   while (*p != '.' && p != base)
11361     p--;
11362
11363   /* We didn't find a '.'. Return an error.  */
11364   if (p == base)
11365     return 1;
11366
11367   *p = '\0';
11368   if (right)
11369     *right = get_identifier (p+1);
11370   *left = get_identifier (base);
11371
11372   return 0;
11373 }
11374
11375 /* Return TRUE if two classes are from the same package. */
11376
11377 static int
11378 in_same_package (tree name1, tree name2)
11379 {
11380   tree tmp;
11381   tree pkg1;
11382   tree pkg2;
11383
11384   if (TREE_CODE (name1) == TYPE_DECL)
11385     name1 = DECL_NAME (name1);
11386   if (TREE_CODE (name2) == TYPE_DECL)
11387     name2 = DECL_NAME (name2);
11388
11389   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11390     /* One in empty package. */
11391     return 0;
11392
11393   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11394     /* Both in empty package. */
11395     return 1;
11396
11397   breakdown_qualified (&pkg1, &tmp, name1);
11398   breakdown_qualified (&pkg2, &tmp, name2);
11399
11400   return (pkg1 == pkg2);
11401 }
11402
11403 /* Patch tree nodes in a function body. When a BLOCK is found, push
11404    local variable decls if present.
11405    Same as java_complete_lhs, but does resolve static finals to values. */
11406
11407 static tree
11408 java_complete_tree (tree node)
11409 {
11410   node = java_complete_lhs (node);
11411   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11412       && DECL_INITIAL (node) != NULL_TREE
11413       && !flag_emit_xref)
11414     {
11415       tree value = fold_constant_for_init (node, node);
11416       if (value != NULL_TREE)
11417         return value;
11418     }
11419   return node;
11420 }
11421
11422 static tree
11423 java_stabilize_reference (tree node)
11424 {
11425   if (TREE_CODE (node) == COMPOUND_EXPR)
11426     {
11427       tree op0 = TREE_OPERAND (node, 0);
11428       tree op1 = TREE_OPERAND (node, 1);
11429       TREE_OPERAND (node, 0) = save_expr (op0);
11430       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11431       return node;
11432     }
11433   return stabilize_reference (node);
11434 }
11435
11436 /* Patch tree nodes in a function body. When a BLOCK is found, push
11437    local variable decls if present.
11438    Same as java_complete_tree, but does not resolve static finals to values. */
11439
11440 static tree
11441 java_complete_lhs (tree node)
11442 {
11443   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11444   int flag;
11445
11446   /* CONVERT_EXPR always has its type set, even though it needs to be
11447      worked out. */
11448   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11449     return node;
11450
11451   /* The switch block implements cases processing container nodes
11452      first.  Contained nodes are always written back. Leaves come
11453      next and return a value. */
11454   switch (TREE_CODE (node))
11455     {
11456     case BLOCK:
11457
11458       /* 1- Block section.
11459          Set the local values on decl names so we can identify them
11460          faster when they're referenced. At that stage, identifiers
11461          are legal so we don't check for declaration errors. */
11462       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11463         {
11464           DECL_CONTEXT (cn) = current_function_decl;
11465           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11466         }
11467       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11468           CAN_COMPLETE_NORMALLY (node) = 1;
11469       else
11470         {
11471           tree stmt = BLOCK_EXPR_BODY (node);
11472           tree *ptr;
11473           int error_seen = 0;
11474           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11475             {
11476               /* Re-order from (((A; B); C); ...; Z) to
11477                  (A; (B; (C ; (...; Z)))).
11478                  This makes it easier to scan the statements left-to-right
11479                  without using recursion (which might overflow the stack
11480                  if the block has many statements. */
11481               for (;;)
11482                 {
11483                   tree left = TREE_OPERAND (stmt, 0);
11484                   if (TREE_CODE (left) != COMPOUND_EXPR)
11485                     break;
11486                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11487                   TREE_OPERAND (left, 1) = stmt;
11488                   stmt = left;
11489                 }
11490               BLOCK_EXPR_BODY (node) = stmt;
11491             }
11492
11493           /* Now do the actual complete, without deep recursion for
11494              long blocks. */
11495           ptr = &BLOCK_EXPR_BODY (node);
11496           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11497                  && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11498             {
11499               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11500               tree *next = &TREE_OPERAND (*ptr, 1);
11501               TREE_OPERAND (*ptr, 0) = cur;
11502               if (IS_EMPTY_STMT (cur))
11503                 {
11504                   /* Optimization;  makes it easier to detect empty bodies.
11505                      Most useful for <clinit> with all-constant initializer. */
11506                   *ptr = *next;
11507                   continue;
11508                 }
11509               if (TREE_CODE (cur) == ERROR_MARK)
11510                 error_seen++;
11511               else if (! CAN_COMPLETE_NORMALLY (cur))
11512                 {
11513                   wfl_op2 = *next;
11514                   for (;;)
11515                     {
11516                       if (TREE_CODE (wfl_op2) == BLOCK)
11517                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11518                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11519                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11520                       else
11521                         break;
11522                     }
11523                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11524                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11525                     unreachable_stmt_error (*ptr);
11526                 }
11527               if (TREE_TYPE (*ptr) == NULL_TREE)
11528                 TREE_TYPE (*ptr) = void_type_node;
11529               ptr = next;
11530             }
11531           *ptr = java_complete_tree (*ptr);
11532
11533           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11534             return error_mark_node;
11535           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11536         }
11537       /* Turn local bindings to null */
11538       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11539         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11540
11541       TREE_TYPE (node) = void_type_node;
11542       break;
11543
11544       /* 2- They are expressions but ultimately deal with statements */
11545
11546     case THROW_EXPR:
11547       wfl_op1 = TREE_OPERAND (node, 0);
11548       COMPLETE_CHECK_OP_0 (node);
11549       /* 14.19 A throw statement cannot complete normally. */
11550       CAN_COMPLETE_NORMALLY (node) = 0;
11551       return patch_throw_statement (node, wfl_op1);
11552
11553     case SYNCHRONIZED_EXPR:
11554       wfl_op1 = TREE_OPERAND (node, 0);
11555       return patch_synchronized_statement (node, wfl_op1);
11556
11557     case TRY_EXPR:
11558       return patch_try_statement (node);
11559
11560     case TRY_FINALLY_EXPR:
11561       COMPLETE_CHECK_OP_0 (node);
11562       COMPLETE_CHECK_OP_1 (node);
11563       if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11564         /* Reduce try/finally nodes with an empty try block.  */
11565         return TREE_OPERAND (node, 1);
11566       if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11567         /* Likewise for an empty finally block.  */
11568         return TREE_OPERAND (node, 0);
11569       CAN_COMPLETE_NORMALLY (node)
11570         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11571            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11572       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11573       return node;
11574
11575     case LABELED_BLOCK_EXPR:
11576       PUSH_LABELED_BLOCK (node);
11577       if (LABELED_BLOCK_BODY (node))
11578         COMPLETE_CHECK_OP_1 (node);
11579       TREE_TYPE (node) = void_type_node;
11580       POP_LABELED_BLOCK ();
11581
11582       if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11583         {
11584           LABELED_BLOCK_BODY (node) = NULL_TREE;
11585           CAN_COMPLETE_NORMALLY (node) = 1;
11586         }
11587       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11588         CAN_COMPLETE_NORMALLY (node) = 1;
11589       return node;
11590
11591     case EXIT_BLOCK_EXPR:
11592       /* We don't complete operand 1, because it's the return value of
11593          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11594       return patch_bc_statement (node);
11595
11596     case CASE_EXPR:
11597       cn = java_complete_tree (TREE_OPERAND (node, 0));
11598       if (cn == error_mark_node)
11599         return cn;
11600
11601       /* First, the case expression must be constant. Values of final
11602          fields are accepted. */
11603       cn = fold (cn);
11604       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11605           && JDECL_P (TREE_OPERAND (cn, 1))
11606           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11607           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11608         {
11609           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11610                                        TREE_OPERAND (cn, 1));
11611         }
11612       /* Accept final locals too. */
11613       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11614                && DECL_INITIAL (cn))
11615         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11616
11617       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11618         {
11619           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11620           parse_error_context (node, "Constant expression required");
11621           return error_mark_node;
11622         }
11623
11624       nn = ctxp->current_loop;
11625
11626       /* It must be assignable to the type of the switch expression. */
11627       if (!try_builtin_assignconv (NULL_TREE,
11628                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11629         {
11630           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11631           parse_error_context
11632             (wfl_operator,
11633              "Incompatible type for case. Can't convert `%s' to `int'",
11634              lang_printable_name (TREE_TYPE (cn), 0));
11635           return error_mark_node;
11636         }
11637
11638       cn = fold (convert (int_type_node, cn));
11639       TREE_CONSTANT_OVERFLOW (cn) = 0;
11640       CAN_COMPLETE_NORMALLY (cn) = 1;
11641
11642       /* Save the label on a list so that we can later check for
11643          duplicates.  */
11644       case_label_list = tree_cons (node, cn, case_label_list);
11645
11646       /* Multiple instance of a case label bearing the same value is
11647          checked later. The case expression is all right so far. */
11648       if (TREE_CODE (cn) == VAR_DECL)
11649         cn = DECL_INITIAL (cn);
11650       TREE_OPERAND (node, 0) = cn;
11651       TREE_TYPE (node) = void_type_node;
11652       CAN_COMPLETE_NORMALLY (node) = 1;
11653       TREE_SIDE_EFFECTS (node) = 1;
11654       break;
11655
11656     case DEFAULT_EXPR:
11657       nn = ctxp->current_loop;
11658       /* Only one default label is allowed per switch statement */
11659       if (SWITCH_HAS_DEFAULT (nn))
11660         {
11661           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11662           parse_error_context (wfl_operator,
11663                                "Duplicate case label: `default'");
11664           return error_mark_node;
11665         }
11666       else
11667         SWITCH_HAS_DEFAULT (nn) = 1;
11668       TREE_TYPE (node) = void_type_node;
11669       TREE_SIDE_EFFECTS (node) = 1;
11670       CAN_COMPLETE_NORMALLY (node) = 1;
11671       break;
11672
11673     case SWITCH_EXPR:
11674     case LOOP_EXPR:
11675       PUSH_LOOP (node);
11676       /* Check whether the loop was enclosed in a labeled
11677          statement. If not, create one, insert the loop in it and
11678          return the node */
11679       nn = patch_loop_statement (node);
11680
11681       /* Anyways, walk the body of the loop */
11682       if (TREE_CODE (node) == LOOP_EXPR)
11683         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11684       /* Switch statement: walk the switch expression and the cases */
11685       else
11686         node = patch_switch_statement (node);
11687
11688       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11689         nn = error_mark_node;
11690       else
11691         {
11692           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11693           /* If we returned something different, that's because we
11694              inserted a label. Pop the label too. */
11695           if (nn != node)
11696             {
11697               if (CAN_COMPLETE_NORMALLY (node))
11698                 CAN_COMPLETE_NORMALLY (nn) = 1;
11699               POP_LABELED_BLOCK ();
11700             }
11701         }
11702       POP_LOOP ();
11703       return nn;
11704
11705     case EXIT_EXPR:
11706       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11707       return patch_exit_expr (node);
11708
11709     case COND_EXPR:
11710       /* Condition */
11711       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11712       if (TREE_OPERAND (node, 0) == error_mark_node)
11713         return error_mark_node;
11714       /* then-else branches */
11715       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11716       if (TREE_OPERAND (node, 1) == error_mark_node)
11717         return error_mark_node;
11718       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11719       if (TREE_OPERAND (node, 2) == error_mark_node)
11720         return error_mark_node;
11721       return patch_if_else_statement (node);
11722       break;
11723
11724     case CONDITIONAL_EXPR:
11725       /* Condition */
11726       wfl_op1 = TREE_OPERAND (node, 0);
11727       COMPLETE_CHECK_OP_0 (node);
11728       wfl_op2 = TREE_OPERAND (node, 1);
11729       COMPLETE_CHECK_OP_1 (node);
11730       wfl_op3 = TREE_OPERAND (node, 2);
11731       COMPLETE_CHECK_OP_2 (node);
11732       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11733
11734       /* 3- Expression section */
11735     case COMPOUND_EXPR:
11736       wfl_op2 = TREE_OPERAND (node, 1);
11737       TREE_OPERAND (node, 0) = nn =
11738         java_complete_tree (TREE_OPERAND (node, 0));
11739       if (IS_EMPTY_STMT (wfl_op2))
11740         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11741       else
11742         {
11743           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11744             {
11745               /* An unreachable condition in a do-while statement
11746                  is *not* (technically) an unreachable statement. */
11747               nn = wfl_op2;
11748               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11749                 nn = EXPR_WFL_NODE (nn);
11750               /* NN can be NULL_TREE exactly when UPDATE is, in
11751                  finish_for_loop.  */
11752               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11753                 {
11754                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11755                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11756                     {
11757                       /* Perhaps this warning should have an
11758                          associated flag.  The code being compiled is
11759                          pedantically correct, but useless.  */
11760                       parse_warning_context (wfl_operator,
11761                                              "Unreachable statement");
11762                     }
11763                   else
11764                     parse_error_context (wfl_operator,
11765                                          "Unreachable statement");
11766                 }
11767             }
11768           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11769           if (TREE_OPERAND (node, 1) == error_mark_node)
11770             return error_mark_node;
11771           /* Even though we might allow the case where the first
11772              operand doesn't return normally, we still should compute
11773              CAN_COMPLETE_NORMALLY correctly.  */
11774           CAN_COMPLETE_NORMALLY (node)
11775             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11776                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11777         }
11778       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11779       break;
11780
11781     case RETURN_EXPR:
11782       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11783       return patch_return (node);
11784
11785     case EXPR_WITH_FILE_LOCATION:
11786       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11787           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11788         {
11789           tree wfl = node;
11790           node = resolve_expression_name (node, NULL);
11791           if (node == error_mark_node)
11792             return node;
11793           /* Keep line number information somewhere were it doesn't
11794              disrupt the completion process. */
11795           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11796             {
11797               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11798               TREE_OPERAND (node, 1) = wfl;
11799             }
11800           CAN_COMPLETE_NORMALLY (node) = 1;
11801         }
11802       else
11803         {
11804           tree body;
11805           int save_lineno = input_line;
11806           input_line = EXPR_WFL_LINENO (node);
11807           body = java_complete_tree (EXPR_WFL_NODE (node));
11808           input_line = save_lineno;
11809           EXPR_WFL_NODE (node) = body;
11810           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11811           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11812           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11813             {
11814               /* Makes it easier to constant fold, detect empty bodies. */
11815               return body;
11816             }
11817           if (body == error_mark_node)
11818             {
11819               /* Its important for the evaluation of assignment that
11820                  this mark on the TREE_TYPE is propagated. */
11821               TREE_TYPE (node) = error_mark_node;
11822               return error_mark_node;
11823             }
11824           else
11825             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11826
11827         }
11828       break;
11829
11830     case NEW_ARRAY_EXPR:
11831       /* Patch all the dimensions */
11832       flag = 0;
11833       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11834         {
11835           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11836           tree dim = convert (int_type_node,
11837                               java_complete_tree (TREE_VALUE (cn)));
11838           if (dim == error_mark_node)
11839             {
11840               flag = 1;
11841               continue;
11842             }
11843           else
11844             {
11845               TREE_VALUE (cn) = dim;
11846               /* Setup the location of the current dimension, for
11847                  later error report. */
11848               TREE_PURPOSE (cn) =
11849                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11850               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11851             }
11852         }
11853       /* They complete the array creation expression, if no errors
11854          were found. */
11855       CAN_COMPLETE_NORMALLY (node) = 1;
11856       return (flag ? error_mark_node
11857               : force_evaluation_order (patch_newarray (node)));
11858
11859     case NEW_ANONYMOUS_ARRAY_EXPR:
11860       /* Create the array type if necessary. */
11861       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11862         {
11863           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11864           if (!(type = resolve_type_during_patch (type)))
11865             return error_mark_node;
11866           type = build_array_from_name (type, NULL_TREE,
11867                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11868           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11869         }
11870       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11871                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11872       if (node == error_mark_node)
11873         return error_mark_node;
11874       CAN_COMPLETE_NORMALLY (node) = 1;
11875       return node;
11876
11877     case NEW_CLASS_EXPR:
11878     case CALL_EXPR:
11879       /* Complete function's argument(s) first */
11880       if (complete_function_arguments (node))
11881         return error_mark_node;
11882       else
11883         {
11884           tree decl, wfl = TREE_OPERAND (node, 0);
11885           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11886           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11887                            super_identifier_node);
11888           tree arguments;
11889           int location = EXPR_WFL_LINECOL (node);
11890
11891           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11892                                           from_super, 0, &decl);
11893           if (node == error_mark_node)
11894             return error_mark_node;
11895
11896           if (TREE_CODE (node) == CALL_EXPR
11897               && TREE_OPERAND (node, 1) != NULL_TREE)
11898             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11899           else
11900             arguments = NULL_TREE;
11901           check_thrown_exceptions (location, decl, arguments);
11902           /* If we call this(...), register signature and positions */
11903           if (in_this)
11904             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11905               tree_cons (wfl, decl,
11906                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11907           CAN_COMPLETE_NORMALLY (node) = 1;
11908           return force_evaluation_order (node);
11909         }
11910
11911     case MODIFY_EXPR:
11912       /* Save potential wfls */
11913       wfl_op1 = TREE_OPERAND (node, 0);
11914       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11915
11916       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11917           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11918           && DECL_INITIAL (nn) != NULL_TREE)
11919         {
11920           tree value;
11921
11922           value = fold_constant_for_init (nn, nn);
11923
11924           /* When we have a primitype type, or a string and we're not
11925              emitting a class file, we actually don't want to generate
11926              anything for the assignment. */
11927           if (value != NULL_TREE &&
11928               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11929                (TREE_TYPE (value) == string_ptr_type_node &&
11930                 ! flag_emit_class_files)))
11931             {
11932               /* Prepare node for patch_assignment */
11933               TREE_OPERAND (node, 1) = value;
11934               /* Call patch assignment to verify the assignment */
11935               if (patch_assignment (node, wfl_op1) == error_mark_node)
11936                 return error_mark_node;
11937               /* Set DECL_INITIAL properly (a conversion might have
11938                  been decided by patch_assignment) and return the
11939                  empty statement. */
11940               else
11941                 {
11942                   tree patched = patch_string (TREE_OPERAND (node, 1));
11943                   if (patched)
11944                     DECL_INITIAL (nn) = patched;
11945                   else
11946                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11947                   DECL_FIELD_FINAL_IUD (nn) = 1;
11948                   return build_java_empty_stmt ();
11949                 }
11950             }
11951           if (! flag_emit_class_files)
11952             DECL_INITIAL (nn) = NULL_TREE;
11953         }
11954       wfl_op2 = TREE_OPERAND (node, 1);
11955
11956       if (TREE_OPERAND (node, 0) == error_mark_node)
11957         return error_mark_node;
11958
11959       flag = COMPOUND_ASSIGN_P (wfl_op2);
11960       if (flag)
11961         {
11962           /* This might break when accessing outer field from inner
11963              class. TESTME, FIXME */
11964           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11965
11966           /* Hand stabilize the lhs on both places */
11967           TREE_OPERAND (node, 0) = lvalue;
11968           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11969             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11970
11971           /* 15.25.2.a: Left hand is not an array access. FIXME */
11972           /* Now complete the RHS. We write it back later on. */
11973           nn = java_complete_tree (TREE_OPERAND (node, 1));
11974
11975           if ((cn = patch_string (nn)))
11976             nn = cn;
11977
11978           /* The last part of the rewrite for E1 op= E2 is to have
11979              E1 = (T)(E1 op E2), with T being the type of E1. */
11980           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11981                                                TREE_TYPE (lvalue), nn));
11982
11983           /* If the assignment is compound and has reference type,
11984              then ensure the LHS has type String and nothing else.  */
11985           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
11986               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
11987             parse_error_context (wfl_op2,
11988                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
11989                                  lang_printable_name (TREE_TYPE (lvalue), 0));
11990
11991           /* 15.25.2.b: Left hand is an array access. FIXME */
11992         }
11993
11994       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11995          function to complete this RHS. Note that a NEW_ARRAY_INIT
11996          might have been already fully expanded if created as a result
11997          of processing an anonymous array initializer. We avoid doing
11998          the operation twice by testing whether the node already bears
11999          a type. */
12000       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12001         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12002                                    TREE_OPERAND (node, 1));
12003       /* Otherwise we simply complete the RHS */
12004       else
12005         nn = java_complete_tree (TREE_OPERAND (node, 1));
12006
12007       if (nn == error_mark_node)
12008         return error_mark_node;
12009
12010       /* Write back the RHS as we evaluated it. */
12011       TREE_OPERAND (node, 1) = nn;
12012
12013       /* In case we're handling = with a String as a RHS, we need to
12014          produce a String out of the RHS (it might still be a
12015          STRING_CST or a StringBuffer at this stage */
12016       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12017         TREE_OPERAND (node, 1) = nn;
12018
12019       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12020                                         TREE_OPERAND (node, 1))))
12021         {
12022           /* We return error_mark_node if outer_field_access_fix
12023              detects we write into a final. */
12024           if (nn == error_mark_node)
12025             return error_mark_node;
12026           node = nn;
12027         }
12028       else
12029         {
12030           node = patch_assignment (node, wfl_op1);
12031           if (node == error_mark_node)
12032             return error_mark_node;
12033           /* Reorganize the tree if necessary. */
12034           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12035                        || JSTRING_P (TREE_TYPE (node))))
12036             node = java_refold (node);
12037         }
12038
12039       /* Seek to set DECL_INITIAL to a proper value, since it might have
12040          undergone a conversion in patch_assignment. We do that only when
12041          it's necessary to have DECL_INITIAL properly set. */
12042       nn = TREE_OPERAND (node, 0);
12043       if (TREE_CODE (nn) == VAR_DECL
12044           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12045           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12046           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12047               || TREE_TYPE (nn) == string_ptr_type_node))
12048         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12049
12050       CAN_COMPLETE_NORMALLY (node) = 1;
12051       return node;
12052
12053     case MULT_EXPR:
12054     case PLUS_EXPR:
12055     case MINUS_EXPR:
12056     case LSHIFT_EXPR:
12057     case RSHIFT_EXPR:
12058     case URSHIFT_EXPR:
12059     case BIT_AND_EXPR:
12060     case BIT_XOR_EXPR:
12061     case BIT_IOR_EXPR:
12062     case TRUNC_MOD_EXPR:
12063     case TRUNC_DIV_EXPR:
12064     case RDIV_EXPR:
12065     case TRUTH_ANDIF_EXPR:
12066     case TRUTH_ORIF_EXPR:
12067     case EQ_EXPR:
12068     case NE_EXPR:
12069     case GT_EXPR:
12070     case GE_EXPR:
12071     case LT_EXPR:
12072     case LE_EXPR:
12073       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12074          knows how to handle those cases. */
12075       wfl_op1 = TREE_OPERAND (node, 0);
12076       wfl_op2 = TREE_OPERAND (node, 1);
12077
12078       CAN_COMPLETE_NORMALLY (node) = 1;
12079       /* Don't complete string nodes if dealing with the PLUS operand. */
12080       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12081         {
12082           nn = java_complete_tree (wfl_op1);
12083           if (nn == error_mark_node)
12084             return error_mark_node;
12085
12086           TREE_OPERAND (node, 0) = nn;
12087         }
12088       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12089         {
12090           nn = java_complete_tree (wfl_op2);
12091           if (nn == error_mark_node)
12092             return error_mark_node;
12093
12094           TREE_OPERAND (node, 1) = nn;
12095         }
12096       return patch_binop (node, wfl_op1, wfl_op2);
12097
12098     case INSTANCEOF_EXPR:
12099       wfl_op1 = TREE_OPERAND (node, 0);
12100       COMPLETE_CHECK_OP_0 (node);
12101       if (flag_emit_xref)
12102         {
12103           TREE_TYPE (node) = boolean_type_node;
12104           return node;
12105         }
12106       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12107
12108     case UNARY_PLUS_EXPR:
12109     case NEGATE_EXPR:
12110     case TRUTH_NOT_EXPR:
12111     case BIT_NOT_EXPR:
12112     case PREDECREMENT_EXPR:
12113     case PREINCREMENT_EXPR:
12114     case POSTDECREMENT_EXPR:
12115     case POSTINCREMENT_EXPR:
12116     case CONVERT_EXPR:
12117       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12118          how to handle those cases. */
12119       wfl_op1 = TREE_OPERAND (node, 0);
12120       CAN_COMPLETE_NORMALLY (node) = 1;
12121       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12122       if (TREE_OPERAND (node, 0) == error_mark_node)
12123         return error_mark_node;
12124       node = patch_unaryop (node, wfl_op1);
12125       CAN_COMPLETE_NORMALLY (node) = 1;
12126       break;
12127
12128     case ARRAY_REF:
12129       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12130          how to handle those cases. */
12131       wfl_op1 = TREE_OPERAND (node, 0);
12132       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12133       if (TREE_OPERAND (node, 0) == error_mark_node)
12134         return error_mark_node;
12135       if (!flag_emit_class_files && !flag_emit_xref)
12136         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12137       /* The same applies to wfl_op2 */
12138       wfl_op2 = TREE_OPERAND (node, 1);
12139       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12140       if (TREE_OPERAND (node, 1) == error_mark_node)
12141         return error_mark_node;
12142       if (!flag_emit_class_files && !flag_emit_xref)
12143         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12144       return patch_array_ref (node);
12145
12146     case RECORD_TYPE:
12147       return node;;
12148
12149     case COMPONENT_REF:
12150       /* The first step in the re-write of qualified name handling.  FIXME.
12151          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12152       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12153       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12154         {
12155           tree name = TREE_OPERAND (node, 1);
12156           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12157           if (field == NULL_TREE)
12158             {
12159               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12160               return error_mark_node;
12161             }
12162           if (! FIELD_STATIC (field))
12163             {
12164               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12165               return error_mark_node;
12166             }
12167           return field;
12168         }
12169       else
12170         abort ();
12171       break;
12172
12173     case THIS_EXPR:
12174       /* Can't use THIS in a static environment */
12175       if (!current_this)
12176         {
12177           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12178           parse_error_context (wfl_operator,
12179                                "Keyword `this' used outside allowed context");
12180           TREE_TYPE (node) = error_mark_node;
12181           return error_mark_node;
12182         }
12183       if (ctxp->explicit_constructor_p)
12184         {
12185           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12186           parse_error_context
12187             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12188           TREE_TYPE (node) = error_mark_node;
12189           return error_mark_node;
12190         }
12191       return current_this;
12192
12193     case CLASS_LITERAL:
12194       CAN_COMPLETE_NORMALLY (node) = 1;
12195       node = patch_incomplete_class_ref (node);
12196       if (node == error_mark_node)
12197         return error_mark_node;
12198       break;
12199
12200     default:
12201       CAN_COMPLETE_NORMALLY (node) = 1;
12202       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12203          and it's time to turn it into the appropriate String object */
12204       if ((nn = patch_string (node)))
12205         node = nn;
12206       else
12207         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12208     }
12209   return node;
12210 }
12211
12212 /* Complete function call's argument. Return a nonzero value is an
12213    error was found.  */
12214
12215 static int
12216 complete_function_arguments (tree node)
12217 {
12218   int flag = 0;
12219   tree cn;
12220
12221   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12222   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12223     {
12224       tree wfl = TREE_VALUE (cn), parm, temp;
12225       parm = java_complete_tree (wfl);
12226
12227       if (parm == error_mark_node)
12228         {
12229           flag = 1;
12230           continue;
12231         }
12232       /* If have a string literal that we haven't transformed yet or a
12233          crafted string buffer, as a result of use of the the String
12234          `+' operator. Build `parm.toString()' and expand it. */
12235       if ((temp = patch_string (parm)))
12236         parm = temp;
12237
12238       TREE_VALUE (cn) = parm;
12239     }
12240   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12241   return flag;
12242 }
12243
12244 /* Sometimes (for loops and variable initialized during their
12245    declaration), we want to wrap a statement around a WFL and turn it
12246    debugable.  */
12247
12248 static tree
12249 build_debugable_stmt (int location, tree stmt)
12250 {
12251   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12252     {
12253       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12254       EXPR_WFL_LINECOL (stmt) = location;
12255     }
12256   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12257   return stmt;
12258 }
12259
12260 static tree
12261 build_expr_block (tree body, tree decls)
12262
12263 {
12264   tree node = make_node (BLOCK);
12265   BLOCK_EXPR_DECLS (node) = decls;
12266   BLOCK_EXPR_BODY (node) = body;
12267   if (body)
12268     TREE_TYPE (node) = TREE_TYPE (body);
12269   TREE_SIDE_EFFECTS (node) = 1;
12270   return node;
12271 }
12272
12273 /* Create a new function block and link it appropriately to current
12274    function block chain */
12275
12276 static tree
12277 enter_block (void)
12278 {
12279   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12280
12281   /* Link block B supercontext to the previous block. The current
12282      function DECL is used as supercontext when enter_a_block is called
12283      for the first time for a given function. The current function body
12284      (DECL_FUNCTION_BODY) is set to be block B.  */
12285
12286   tree fndecl = current_function_decl;
12287
12288   if (!fndecl) {
12289     BLOCK_SUPERCONTEXT (b) = current_static_block;
12290     current_static_block = b;
12291   }
12292
12293   else if (!DECL_FUNCTION_BODY (fndecl))
12294     {
12295       BLOCK_SUPERCONTEXT (b) = fndecl;
12296       DECL_FUNCTION_BODY (fndecl) = b;
12297     }
12298   else
12299     {
12300       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12301       DECL_FUNCTION_BODY (fndecl) = b;
12302     }
12303   return b;
12304 }
12305
12306 /* Exit a block by changing the current function body
12307    (DECL_FUNCTION_BODY) to the current block super context, only if
12308    the block being exited isn't the method's top level one.  */
12309
12310 static tree
12311 exit_block (void)
12312 {
12313   tree b;
12314   if (current_function_decl)
12315     {
12316       b = DECL_FUNCTION_BODY (current_function_decl);
12317       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12318         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12319     }
12320   else
12321     {
12322       b = current_static_block;
12323
12324       if (BLOCK_SUPERCONTEXT (b))
12325         current_static_block = BLOCK_SUPERCONTEXT (b);
12326     }
12327   return b;
12328 }
12329
12330 /* Lookup for NAME in the nested function's blocks, all the way up to
12331    the current toplevel one. It complies with Java's local variable
12332    scoping rules.  */
12333
12334 static tree
12335 lookup_name_in_blocks (tree name)
12336 {
12337   tree b = GET_CURRENT_BLOCK (current_function_decl);
12338
12339   while (b != current_function_decl)
12340     {
12341       tree current;
12342
12343       /* Paranoid sanity check. To be removed */
12344       if (TREE_CODE (b) != BLOCK)
12345         abort ();
12346
12347       for (current = BLOCK_EXPR_DECLS (b); current;
12348            current = TREE_CHAIN (current))
12349         if (DECL_NAME (current) == name)
12350           return current;
12351       b = BLOCK_SUPERCONTEXT (b);
12352     }
12353   return NULL_TREE;
12354 }
12355
12356 static void
12357 maybe_absorb_scoping_blocks (void)
12358 {
12359   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12360     {
12361       tree b = exit_block ();
12362       java_method_add_stmt (current_function_decl, b);
12363       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12364     }
12365 }
12366
12367 \f
12368 /* This section of the source is reserved to build_* functions that
12369    are building incomplete tree nodes and the patch_* functions that
12370    are completing them.  */
12371
12372 /* Wrap a non WFL node around a WFL.  */
12373
12374 static tree
12375 build_wfl_wrap (tree node, int location)
12376 {
12377   tree wfl, node_to_insert = node;
12378
12379   /* We want to process THIS . xxx symbolically, to keep it consistent
12380      with the way we're processing SUPER. A THIS from a primary as a
12381      different form than a SUPER. Turn THIS into something symbolic */
12382   if (TREE_CODE (node) == THIS_EXPR)
12383     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12384   else
12385     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12386
12387   EXPR_WFL_LINECOL (wfl) = location;
12388   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12389   return wfl;
12390 }
12391
12392 /* Build a super() constructor invocation. Returns an empty statement if
12393    we're currently dealing with the class java.lang.Object. */
12394
12395 static tree
12396 build_super_invocation (tree mdecl)
12397 {
12398   if (DECL_CONTEXT (mdecl) == object_type_node)
12399     return build_java_empty_stmt ();
12400   else
12401     {
12402       tree super_wfl = build_wfl_node (super_identifier_node);
12403       tree a = NULL_TREE, t;
12404       /* If we're dealing with an anonymous class, pass the arguments
12405          of the crafted constructor along. */
12406       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12407         {
12408           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12409           for (; t != end_params_node; t = TREE_CHAIN (t))
12410             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12411         }
12412       return build_method_invocation (super_wfl, a);
12413     }
12414 }
12415
12416 /* Build a SUPER/THIS qualified method invocation.  */
12417
12418 static tree
12419 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12420                                        int lloc, int rloc)
12421 {
12422   tree invok;
12423   tree wfl =
12424     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12425   EXPR_WFL_LINECOL (wfl) = lloc;
12426   invok = build_method_invocation (name, args);
12427   return make_qualified_primary (wfl, invok, rloc);
12428 }
12429
12430 /* Build an incomplete CALL_EXPR node. */
12431
12432 static tree
12433 build_method_invocation (tree name, tree args)
12434 {
12435   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12436   TREE_SIDE_EFFECTS (call) = 1;
12437   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12438   return call;
12439 }
12440
12441 /* Build an incomplete new xxx(...) node. */
12442
12443 static tree
12444 build_new_invocation (tree name, tree args)
12445 {
12446   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12447   TREE_SIDE_EFFECTS (call) = 1;
12448   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12449   return call;
12450 }
12451
12452 /* Build an incomplete assignment expression. */
12453
12454 static tree
12455 build_assignment (int op, int op_location, tree lhs, tree rhs)
12456 {
12457   tree assignment;
12458   /* Build the corresponding binop if we deal with a Compound
12459      Assignment operator. Mark the binop sub-tree as part of a
12460      Compound Assignment expression */
12461   if (op != ASSIGN_TK)
12462     {
12463       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12464       COMPOUND_ASSIGN_P (rhs) = 1;
12465     }
12466   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12467   TREE_SIDE_EFFECTS (assignment) = 1;
12468   EXPR_WFL_LINECOL (assignment) = op_location;
12469   return assignment;
12470 }
12471
12472 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12473    the buffer.  This is used only for string conversion.  */
12474 static char *
12475 string_convert_int_cst (tree node)
12476 {
12477   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12478   static char buffer[21];
12479
12480   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12481   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12482   char *p = buffer + sizeof (buffer);
12483   int neg = 0;
12484
12485   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12486                                   << (HOST_BITS_PER_WIDE_INT - 1));
12487
12488   *--p = '\0';
12489
12490   /* If negative, note the fact and negate the value.  */
12491   if ((hi & hibit))
12492     {
12493       lo = ~lo;
12494       hi = ~hi;
12495       if (++lo == 0)
12496         ++hi;
12497       neg = 1;
12498     }
12499
12500   /* Divide by 10 until there are no bits left.  */
12501   do
12502     {
12503       unsigned HOST_WIDE_INT acc = 0;
12504       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12505       unsigned int i;
12506
12507       /* Use long division to compute the result and the remainder.  */
12508       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12509         {
12510           /* Shift a bit into accumulator.  */
12511           acc <<= 1;
12512           if ((hi & hibit))
12513             acc |= 1;
12514
12515           /* Shift the value.  */
12516           hi <<= 1;
12517           if ((lo & hibit))
12518             hi |= 1;
12519           lo <<= 1;
12520
12521           /* Shift the correct bit into the result.  */
12522           outhi <<= 1;
12523           if ((outlo & hibit))
12524             outhi |= 1;
12525           outlo <<= 1;
12526           if (acc >= 10)
12527             {
12528               acc -= 10;
12529               outlo |= 1;
12530             }
12531         }
12532
12533       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12534       *--p = '\060' + acc;
12535
12536       hi = outhi;
12537       lo = outlo;
12538     }
12539   while (hi || lo);
12540
12541   if (neg)
12542     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12543
12544   return p;
12545 }
12546
12547 /* Print an INTEGER_CST node in a static buffer, and return the
12548    buffer.  This is used only for error handling.  */
12549 char *
12550 print_int_node (tree node)
12551 {
12552   static char buffer [80];
12553   if (TREE_CONSTANT_OVERFLOW (node))
12554     sprintf (buffer, "<overflow>");
12555
12556   if (TREE_INT_CST_HIGH (node) == 0)
12557     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12558              TREE_INT_CST_LOW (node));
12559   else if (TREE_INT_CST_HIGH (node) == -1
12560            && TREE_INT_CST_LOW (node) != 0)
12561     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12562              -TREE_INT_CST_LOW (node));
12563   else
12564     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12565              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12566
12567   return buffer;
12568 }
12569
12570 \f
12571 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12572    context.  */
12573
12574 /* 15.25 Assignment operators. */
12575
12576 static tree
12577 patch_assignment (tree node, tree wfl_op1)
12578 {
12579   tree rhs = TREE_OPERAND (node, 1);
12580   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12581   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12582   int error_found = 0;
12583   int lvalue_from_array = 0;
12584   int is_return = 0;
12585
12586   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12587
12588   /* Lhs can be a named variable */
12589   if (JDECL_P (lvalue))
12590     {
12591       lhs_type = TREE_TYPE (lvalue);
12592     }
12593   /* Or Lhs can be an array access. */
12594   else if (TREE_CODE (lvalue) == ARRAY_REF)
12595     {
12596       lhs_type = TREE_TYPE (lvalue);
12597       lvalue_from_array = 1;
12598     }
12599   /* Or a field access */
12600   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12601     lhs_type = TREE_TYPE (lvalue);
12602   /* Or a function return slot */
12603   else if (TREE_CODE (lvalue) == RESULT_DECL)
12604     {
12605       /* If the return type is an integral type, then we create the
12606          RESULT_DECL with a promoted type, but we need to do these
12607          checks against the unpromoted type to ensure type safety.  So
12608          here we look at the real type, not the type of the decl we
12609          are modifying.  */
12610       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12611       is_return = 1;
12612     }
12613   /* Otherwise, we might want to try to write into an optimized static
12614      final, this is an of a different nature, reported further on. */
12615   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12616            && resolve_expression_name (wfl_op1, &llvalue))
12617     {
12618       lhs_type = TREE_TYPE (lvalue);
12619     }
12620   else
12621     {
12622       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12623       error_found = 1;
12624     }
12625
12626   rhs_type = TREE_TYPE (rhs);
12627
12628   /* 5.1 Try the assignment conversion for builtin type. */
12629   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12630
12631   /* 5.2 If it failed, try a reference conversion */
12632   if (!new_rhs)
12633     new_rhs = try_reference_assignconv (lhs_type, rhs);
12634
12635   /* 15.25.2 If we have a compound assignment, convert RHS into the
12636      type of the LHS */
12637   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12638     new_rhs = convert (lhs_type, rhs);
12639
12640   /* Explicit cast required. This is an error */
12641   if (!new_rhs)
12642     {
12643       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12644       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12645       tree wfl;
12646       char operation [32];      /* Max size known */
12647
12648       /* If the assignment is part of a declaration, we use the WFL of
12649          the declared variable to point out the error and call it a
12650          declaration problem. If the assignment is a genuine =
12651          operator, we call is a operator `=' problem, otherwise we
12652          call it an assignment problem. In both of these last cases,
12653          we use the WFL of the operator to indicate the error. */
12654
12655       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12656         {
12657           wfl = wfl_op1;
12658           strcpy (operation, "declaration");
12659         }
12660       else
12661         {
12662           wfl = wfl_operator;
12663           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12664             strcpy (operation, "assignment");
12665           else if (is_return)
12666             strcpy (operation, "`return'");
12667           else
12668             strcpy (operation, "`='");
12669         }
12670
12671       if (!valid_cast_to_p (rhs_type, lhs_type))
12672         parse_error_context
12673           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12674            operation, t1, t2);
12675       else
12676         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12677                              operation, t1, t2);
12678       free (t1); free (t2);
12679       error_found = 1;
12680     }
12681
12682   if (error_found)
12683     return error_mark_node;
12684
12685   /* If we're processing a `return' statement, promote the actual type
12686      to the promoted type.  */
12687   if (is_return)
12688     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12689
12690   /* 10.10: Array Store Exception runtime check */
12691   if (!flag_emit_class_files
12692       && !flag_emit_xref
12693       && lvalue_from_array
12694       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12695     {
12696       tree array, store_check, base, index_expr;
12697
12698       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12699       new_rhs = save_expr (new_rhs);
12700
12701       /* Get the INDIRECT_REF. */
12702       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12703       /* Get the array pointer expr. */
12704       array = TREE_OPERAND (array, 0);
12705       store_check = build_java_arraystore_check (array, new_rhs);
12706
12707       index_expr = TREE_OPERAND (lvalue, 1);
12708
12709       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12710         {
12711           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12712              happen before the store check, so prepare to insert the store
12713              check within the second operand of the existing COMPOUND_EXPR. */
12714           base = index_expr;
12715         }
12716       else
12717         base = lvalue;
12718
12719       index_expr = TREE_OPERAND (base, 1);
12720       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12721                                       store_check, index_expr);
12722     }
12723
12724   /* Final locals can be used as case values in switch
12725      statement. Prepare them for this eventuality. */
12726   if (TREE_CODE (lvalue) == VAR_DECL
12727       && DECL_FINAL (lvalue)
12728       && TREE_CONSTANT (new_rhs)
12729       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12730       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12731       )
12732     {
12733       TREE_CONSTANT (lvalue) = 1;
12734       TREE_INVARIANT (lvalue) = 1;
12735       DECL_INITIAL (lvalue) = new_rhs;
12736     }
12737
12738   /* Copy the rhs if it's a reference.  */
12739   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12740     {
12741       switch (TREE_CODE (new_rhs))
12742         {
12743         case ARRAY_REF:
12744         case INDIRECT_REF:
12745         case COMPONENT_REF:
12746           /* Transform a = foo.bar
12747              into a = ({int tmp; tmp = foo.bar;}).
12748              We need to ensure that if a read from memory fails
12749              because of a NullPointerException, a destination variable
12750              will remain unchanged.  An explicit temporary does what
12751              we need.
12752
12753              If flag_check_references is set, this is unnecessary
12754              because we'll check each reference before doing any
12755              reads.  If optimize is not set the result will never be
12756              written to a stack slot that contains the LHS.  */
12757           {
12758             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12759                                    TREE_TYPE (new_rhs));
12760             tree block = make_node (BLOCK);
12761             tree assignment
12762               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12763             DECL_CONTEXT (tmp) = current_function_decl;
12764             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12765             BLOCK_VARS (block) = tmp;
12766             BLOCK_EXPR_BODY (block) = assignment;
12767             TREE_SIDE_EFFECTS (block) = 1;
12768             new_rhs = block;
12769           }
12770           break;
12771         default:
12772           break;
12773         }
12774     }
12775
12776   TREE_OPERAND (node, 0) = lvalue;
12777   TREE_OPERAND (node, 1) = new_rhs;
12778   TREE_TYPE (node) = lhs_type;
12779   return node;
12780 }
12781
12782 /* Check that type SOURCE can be cast into type DEST. If the cast
12783    can't occur at all, return NULL; otherwise, return a possibly
12784    modified rhs.  */
12785
12786 static tree
12787 try_reference_assignconv (tree lhs_type, tree rhs)
12788 {
12789   tree new_rhs = NULL_TREE;
12790   tree rhs_type = TREE_TYPE (rhs);
12791
12792   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12793     {
12794       /* `null' may be assigned to any reference type */
12795       if (rhs == null_pointer_node)
12796         new_rhs = null_pointer_node;
12797       /* Try the reference assignment conversion */
12798       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12799         new_rhs = rhs;
12800       /* This is a magic assignment that we process differently */
12801       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12802         new_rhs = rhs;
12803     }
12804   return new_rhs;
12805 }
12806
12807 /* Check that RHS can be converted into LHS_TYPE by the assignment
12808    conversion (5.2), for the cases of RHS being a builtin type. Return
12809    NULL_TREE if the conversion fails or if because RHS isn't of a
12810    builtin type. Return a converted RHS if the conversion is possible.  */
12811
12812 static tree
12813 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12814 {
12815   tree new_rhs = NULL_TREE;
12816   tree rhs_type = TREE_TYPE (rhs);
12817
12818   /* Handle boolean specially.  */
12819   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12820       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12821     {
12822       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12823           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12824         new_rhs = rhs;
12825     }
12826
12827   /* 5.1.1 Try Identity Conversion,
12828      5.1.2 Try Widening Primitive Conversion */
12829   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12830     new_rhs = convert (lhs_type, rhs);
12831
12832   /* Try a narrowing primitive conversion (5.1.3):
12833        - expression is a constant expression of type byte, short, char,
12834          or int, AND
12835        - variable is byte, short or char AND
12836        - The value of the expression is representable in the type of the
12837          variable */
12838   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12839             || rhs_type == char_type_node || rhs_type == int_type_node)
12840             && TREE_CONSTANT (rhs)
12841            && (lhs_type == byte_type_node || lhs_type == char_type_node
12842                || lhs_type == short_type_node))
12843     {
12844       if (int_fits_type_p (rhs, lhs_type))
12845         new_rhs = convert (lhs_type, rhs);
12846       else if (wfl_op1)         /* Might be called with a NULL */
12847         parse_warning_context
12848           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12849            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12850       /* Reported a warning that will turn into an error further
12851          down, so we don't return */
12852     }
12853
12854   return new_rhs;
12855 }
12856
12857 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12858    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12859    0 is the conversion test fails.  This implements parts the method
12860    invocation conversion (5.3).  */
12861
12862 static int
12863 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12864 {
12865   /* 5.1.1: This is the identity conversion part. */
12866   if (lhs_type == rhs_type)
12867     return 1;
12868
12869   /* Reject non primitive types and boolean conversions.  */
12870   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12871     return 0;
12872
12873   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12874      than a char can't be converted into a char. Short can't too, but
12875      the < test below takes care of that */
12876   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12877     return 0;
12878
12879   /* Accept all promoted type here. Note, we can't use <= in the test
12880      below, because we still need to bounce out assignments of short
12881      to char and the likes */
12882   if (lhs_type == int_type_node
12883       && (rhs_type == promoted_byte_type_node
12884           || rhs_type == promoted_short_type_node
12885           || rhs_type == promoted_char_type_node
12886           || rhs_type == promoted_boolean_type_node))
12887     return 1;
12888
12889   /* From here, an integral is widened if its precision is smaller
12890      than the precision of the LHS or if the LHS is a floating point
12891      type, or the RHS is a float and the RHS a double. */
12892   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12893        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12894       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12895       || (rhs_type == float_type_node && lhs_type == double_type_node))
12896     return 1;
12897
12898   return 0;
12899 }
12900
12901 /* Check that something of SOURCE type can be assigned or cast to
12902    something of DEST type at runtime. Return 1 if the operation is
12903    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12904    were SOURCE is cast into DEST, which borrows a lot of the
12905    assignment check. */
12906
12907 static int
12908 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12909 {
12910   /* SOURCE or DEST might be null if not from a declared entity. */
12911   if (!source || !dest)
12912     return 0;
12913   if (JNULLP_TYPE_P (source))
12914     return 1;
12915   if (TREE_CODE (source) == POINTER_TYPE)
12916     source = TREE_TYPE (source);
12917   if (TREE_CODE (dest) == POINTER_TYPE)
12918     dest = TREE_TYPE (dest);
12919
12920   /* If source and dest are being compiled from bytecode, they may need to
12921      be loaded. */
12922   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12923     {
12924       load_class (source, 1);
12925       safe_layout_class (source);
12926     }
12927   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12928     {
12929       load_class (dest, 1);
12930       safe_layout_class (dest);
12931     }
12932
12933   /* Case where SOURCE is a class type */
12934   if (TYPE_CLASS_P (source))
12935     {
12936       if (TYPE_CLASS_P (dest))
12937         return  (source == dest
12938                  || inherits_from_p (source, dest)
12939                  || (cast && inherits_from_p (dest, source)));
12940       if (TYPE_INTERFACE_P (dest))
12941         {
12942           /* If doing a cast and SOURCE is final, the operation is
12943              always correct a compile time (because even if SOURCE
12944              does not implement DEST, a subclass of SOURCE might). */
12945           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12946             return 1;
12947           /* Otherwise, SOURCE must implement DEST */
12948           return interface_of_p (dest, source);
12949         }
12950       /* DEST is an array, cast permitted if SOURCE is of Object type */
12951       return (cast && source == object_type_node ? 1 : 0);
12952     }
12953   if (TYPE_INTERFACE_P (source))
12954     {
12955       if (TYPE_CLASS_P (dest))
12956         {
12957           /* If not casting, DEST must be the Object type */
12958           if (!cast)
12959             return dest == object_type_node;
12960           /* We're doing a cast. The cast is always valid is class
12961              DEST is not final, otherwise, DEST must implement SOURCE */
12962           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12963             return 1;
12964           else
12965             return interface_of_p (source, dest);
12966         }
12967       if (TYPE_INTERFACE_P (dest))
12968         {
12969           /* If doing a cast, then if SOURCE and DEST contain method
12970              with the same signature but different return type, then
12971              this is a (compile time) error */
12972           if (cast)
12973             {
12974               tree method_source, method_dest;
12975               tree source_type;
12976               tree source_sig;
12977               tree source_name;
12978               for (method_source = TYPE_METHODS (source); method_source;
12979                    method_source = TREE_CHAIN (method_source))
12980                 {
12981                   source_sig =
12982                     build_java_argument_signature (TREE_TYPE (method_source));
12983                   source_type = TREE_TYPE (TREE_TYPE (method_source));
12984                   source_name = DECL_NAME (method_source);
12985                   for (method_dest = TYPE_METHODS (dest);
12986                        method_dest; method_dest = TREE_CHAIN (method_dest))
12987                     if (source_sig ==
12988                         build_java_argument_signature (TREE_TYPE (method_dest))
12989                         && source_name == DECL_NAME (method_dest)
12990                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12991                       return 0;
12992                 }
12993               return 1;
12994             }
12995           else
12996             return source == dest || interface_of_p (dest, source);
12997         }
12998       else
12999         {
13000           /* Array */
13001           return (cast
13002                   && (DECL_NAME (TYPE_NAME (source))
13003                       == java_lang_cloneable_identifier_node
13004                       || (DECL_NAME (TYPE_NAME (source))
13005                           == java_io_serializable_identifier_node)));
13006         }
13007     }
13008   if (TYPE_ARRAY_P (source))
13009     {
13010       if (TYPE_CLASS_P (dest))
13011         return dest == object_type_node;
13012       /* Can't cast an array to an interface unless the interface is
13013          java.lang.Cloneable or java.io.Serializable.  */
13014       if (TYPE_INTERFACE_P (dest))
13015         return (DECL_NAME (TYPE_NAME (dest))
13016                 == java_lang_cloneable_identifier_node
13017                 || (DECL_NAME (TYPE_NAME (dest))
13018                     == java_io_serializable_identifier_node));
13019       else                      /* Arrays */
13020         {
13021           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13022           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13023
13024           /* In case of severe errors, they turn out null */
13025           if (!dest_element_type || !source_element_type)
13026             return 0;
13027           if (source_element_type == dest_element_type)
13028             return 1;
13029           return valid_ref_assignconv_cast_p (source_element_type,
13030                                               dest_element_type, cast);
13031         }
13032       return 0;
13033     }
13034   return 0;
13035 }
13036
13037 static int
13038 valid_cast_to_p (tree source, tree dest)
13039 {
13040   if (TREE_CODE (source) == POINTER_TYPE)
13041     source = TREE_TYPE (source);
13042   if (TREE_CODE (dest) == POINTER_TYPE)
13043     dest = TREE_TYPE (dest);
13044
13045   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13046     return valid_ref_assignconv_cast_p (source, dest, 1);
13047
13048   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13049     return 1;
13050
13051   else if (TREE_CODE (source) == BOOLEAN_TYPE
13052            && TREE_CODE (dest) == BOOLEAN_TYPE)
13053     return 1;
13054
13055   return 0;
13056 }
13057
13058 static tree
13059 do_unary_numeric_promotion (tree arg)
13060 {
13061   tree type = TREE_TYPE (arg);
13062   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13063       || TREE_CODE (type) == CHAR_TYPE)
13064     arg = convert (int_type_node, arg);
13065   return arg;
13066 }
13067
13068 /* Return a nonzero value if SOURCE can be converted into DEST using
13069    the method invocation conversion rule (5.3).  */
13070 static int
13071 valid_method_invocation_conversion_p (tree dest, tree source)
13072 {
13073   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13074            && valid_builtin_assignconv_identity_widening_p (dest, source))
13075           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13076               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13077               && valid_ref_assignconv_cast_p (source, dest, 0)));
13078 }
13079
13080 /* Build an incomplete binop expression. */
13081
13082 static tree
13083 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13084 {
13085   tree binop = build (op, NULL_TREE, op1, op2);
13086   TREE_SIDE_EFFECTS (binop) = 1;
13087   /* Store the location of the operator, for better error report. The
13088      string of the operator will be rebuild based on the OP value. */
13089   EXPR_WFL_LINECOL (binop) = op_location;
13090   return binop;
13091 }
13092
13093 /* Build the string of the operator retained by NODE. If NODE is part
13094    of a compound expression, add an '=' at the end of the string. This
13095    function is called when an error needs to be reported on an
13096    operator. The string is returned as a pointer to a static character
13097    buffer. */
13098
13099 static char *
13100 operator_string (tree node)
13101 {
13102 #define BUILD_OPERATOR_STRING(S)                                        \
13103   {                                                                     \
13104     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13105     return buffer;                                                      \
13106   }
13107
13108   static char buffer [10];
13109   switch (TREE_CODE (node))
13110     {
13111     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13112     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13113     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13114     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13115     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13116     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13117     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13118     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13119     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13120     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13121     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13122     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13123     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13124     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13125     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13126     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13127     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13128     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13129     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13130     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13131     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13132     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13133     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13134     case PREINCREMENT_EXPR:     /* Fall through */
13135     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13136     case PREDECREMENT_EXPR:     /* Fall through */
13137     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13138     default:
13139       internal_error ("unregistered operator %s",
13140                       tree_code_name [TREE_CODE (node)]);
13141     }
13142   return NULL;
13143 #undef BUILD_OPERATOR_STRING
13144 }
13145
13146 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13147
13148 static int
13149 java_decl_equiv (tree var_acc1, tree var_acc2)
13150 {
13151   if (JDECL_P (var_acc1))
13152     return (var_acc1 == var_acc2);
13153
13154   return (TREE_CODE (var_acc1) == COMPONENT_REF
13155           && TREE_CODE (var_acc2) == COMPONENT_REF
13156           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13157              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13158           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13159 }
13160
13161 /* Return a nonzero value if CODE is one of the operators that can be
13162    used in conjunction with the `=' operator in a compound assignment.  */
13163
13164 static int
13165 binop_compound_p (enum tree_code code)
13166 {
13167   int i;
13168   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13169     if (binop_lookup [i] == code)
13170       break;
13171
13172   return i < BINOP_COMPOUND_CANDIDATES;
13173 }
13174
13175 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13176
13177 static tree
13178 java_refold (tree t)
13179 {
13180   tree c, b, ns, decl;
13181
13182   if (TREE_CODE (t) != MODIFY_EXPR)
13183     return t;
13184
13185   c = TREE_OPERAND (t, 1);
13186   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13187          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13188          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13189     return t;
13190
13191   /* Now the left branch of the binary operator. */
13192   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13193   if (! (b && TREE_CODE (b) == NOP_EXPR
13194          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13195     return t;
13196
13197   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13198   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13199          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13200     return t;
13201
13202   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13203   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13204       /* It's got to be the an equivalent decl */
13205       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13206     {
13207       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13208       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13209       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13210       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13211       /* Change the right part of the BINOP_EXPR */
13212       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13213     }
13214
13215   return t;
13216 }
13217
13218 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13219    errors but we modify NODE so that it contains the type computed
13220    according to the expression, when it's fixed. Otherwise, we write
13221    error_mark_node as the type. It allows us to further the analysis
13222    of remaining nodes and detects more errors in certain cases.  */
13223
13224 static tree
13225 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13226 {
13227   tree op1 = TREE_OPERAND (node, 0);
13228   tree op2 = TREE_OPERAND (node, 1);
13229   tree op1_type = TREE_TYPE (op1);
13230   tree op2_type = TREE_TYPE (op2);
13231   tree prom_type = NULL_TREE, cn;
13232   enum tree_code code = TREE_CODE (node);
13233
13234   /* If 1, tell the routine that we have to return error_mark_node
13235      after checking for the initialization of the RHS */
13236   int error_found = 0;
13237
13238   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13239
13240   /* If either op<n>_type are NULL, this might be early signs of an
13241      error situation, unless it's too early to tell (in case we're
13242      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13243      correctly so the error can be later on reported accurately. */
13244   if (! (code == PLUS_EXPR || code == NE_EXPR
13245          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13246     {
13247       tree n;
13248       if (! op1_type)
13249         {
13250           n = java_complete_tree (op1);
13251           op1_type = TREE_TYPE (n);
13252         }
13253       if (! op2_type)
13254         {
13255           n = java_complete_tree (op2);
13256           op2_type = TREE_TYPE (n);
13257         }
13258     }
13259
13260   switch (code)
13261     {
13262     /* 15.16 Multiplicative operators */
13263     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13264     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13265     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13266     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13267       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13268         {
13269           if (!JNUMERIC_TYPE_P (op1_type))
13270             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13271           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13272             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13273           TREE_TYPE (node) = error_mark_node;
13274           error_found = 1;
13275           break;
13276         }
13277       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13278
13279       /* Detect integral division by zero */
13280       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13281           && TREE_CODE (prom_type) == INTEGER_TYPE
13282           && (op2 == integer_zero_node || op2 == long_zero_node ||
13283               (TREE_CODE (op2) == INTEGER_CST &&
13284                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13285         {
13286           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13287           TREE_CONSTANT (node) = 0;
13288           TREE_INVARIANT (node) = 0;
13289         }
13290
13291       /* Change the division operator if necessary */
13292       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13293         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13294
13295       /* Before divisions as is disappear, try to simplify and bail if
13296          applicable, otherwise we won't perform even simple
13297          simplifications like (1-1)/3. We can't do that with floating
13298          point number, folds can't handle them at this stage. */
13299       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13300           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13301         {
13302           TREE_TYPE (node) = prom_type;
13303           node = fold (node);
13304           if (TREE_CODE (node) != code)
13305             return node;
13306         }
13307
13308       if (TREE_CODE (prom_type) == INTEGER_TYPE
13309           && flag_use_divide_subroutine
13310           && ! flag_emit_class_files
13311           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13312         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13313
13314       /* This one is more complicated. FLOATs are processed by a
13315          function call to soft_fmod. Duplicate the value of the
13316          COMPOUND_ASSIGN_P flag. */
13317       if (code == TRUNC_MOD_EXPR)
13318         {
13319           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13320           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13321           TREE_SIDE_EFFECTS (mod)
13322             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13323           return mod;
13324         }
13325       break;
13326
13327     /* 15.17 Additive Operators */
13328     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13329
13330       /* Operation is valid if either one argument is a string
13331          constant, a String object or a StringBuffer crafted for the
13332          purpose of the a previous usage of the String concatenation
13333          operator */
13334
13335       if (TREE_CODE (op1) == STRING_CST
13336           || TREE_CODE (op2) == STRING_CST
13337           || JSTRING_TYPE_P (op1_type)
13338           || JSTRING_TYPE_P (op2_type)
13339           || IS_CRAFTED_STRING_BUFFER_P (op1)
13340           || IS_CRAFTED_STRING_BUFFER_P (op2))
13341         return build_string_concatenation (op1, op2);
13342
13343     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13344                                    Numeric Types */
13345       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13346         {
13347           if (!JNUMERIC_TYPE_P (op1_type))
13348             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13349           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13350             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13351           TREE_TYPE (node) = error_mark_node;
13352           error_found = 1;
13353           break;
13354         }
13355       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13356       break;
13357
13358     /* 15.18 Shift Operators */
13359     case LSHIFT_EXPR:
13360     case RSHIFT_EXPR:
13361     case URSHIFT_EXPR:
13362       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13363         {
13364           if (!JINTEGRAL_TYPE_P (op1_type))
13365             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13366           else
13367             {
13368               if (JNUMERIC_TYPE_P (op2_type))
13369                 parse_error_context (wfl_operator,
13370                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13371                                      operator_string (node),
13372                                      lang_printable_name (op2_type, 0));
13373               else
13374                 parse_error_context (wfl_operator,
13375                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13376                                      operator_string (node),
13377                                      lang_printable_name (op2_type, 0));
13378             }
13379           TREE_TYPE (node) = error_mark_node;
13380           error_found = 1;
13381           break;
13382         }
13383
13384       /* Unary numeric promotion (5.6.1) is performed on each operand
13385          separately */
13386       op1 = do_unary_numeric_promotion (op1);
13387       op2 = do_unary_numeric_promotion (op2);
13388
13389       /* If the right hand side is of type `long', first cast it to
13390          `int'.  */
13391       if (TREE_TYPE (op2) == long_type_node)
13392         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13393
13394       /* The type of the shift expression is the type of the promoted
13395          type of the left-hand operand */
13396       prom_type = TREE_TYPE (op1);
13397
13398       /* Shift int only up to 0x1f and long up to 0x3f */
13399       if (prom_type == int_type_node)
13400         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13401                            build_int_2 (0x1f, 0)));
13402       else
13403         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13404                            build_int_2 (0x3f, 0)));
13405
13406       /* The >>> operator is a >> operating on unsigned quantities */
13407       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13408         {
13409           tree to_return;
13410           tree utype = java_unsigned_type (prom_type);
13411           op1 = convert (utype, op1);
13412           TREE_SET_CODE (node, RSHIFT_EXPR);
13413           TREE_OPERAND (node, 0) = op1;
13414           TREE_OPERAND (node, 1) = op2;
13415           TREE_TYPE (node) = utype;
13416           to_return = convert (prom_type, node);
13417           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13418           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13419           TREE_SIDE_EFFECTS (to_return)
13420             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13421           return to_return;
13422         }
13423       break;
13424
13425       /* 15.19.1 Type Comparison Operator instanceof */
13426     case INSTANCEOF_EXPR:
13427
13428       TREE_TYPE (node) = boolean_type_node;
13429
13430       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13431       if ((cn = patch_string (op1)))
13432         {
13433           op1 = cn;
13434           op1_type = TREE_TYPE (op1);
13435         }
13436       if (op1_type == NULL_TREE)
13437         abort ();
13438
13439       if (!(op2_type = resolve_type_during_patch (op2)))
13440         return error_mark_node;
13441
13442       /* The first operand must be a reference type or the null type */
13443       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13444         error_found = 1;        /* Error reported further below */
13445
13446       /* The second operand must be a reference type */
13447       if (!JREFERENCE_TYPE_P (op2_type))
13448         {
13449           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13450           parse_error_context
13451             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13452              lang_printable_name (op2_type, 0));
13453           error_found = 1;
13454         }
13455
13456       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13457         {
13458           /* If the first operand is null, the result is always false */
13459           if (op1 == null_pointer_node)
13460             return boolean_false_node;
13461           else if (flag_emit_class_files)
13462             {
13463               TREE_OPERAND (node, 1) = op2_type;
13464               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13465               return node;
13466             }
13467           /* Otherwise we have to invoke instance of to figure it out */
13468           else
13469             return build_instanceof (op1, op2_type);
13470         }
13471       /* There is no way the expression operand can be an instance of
13472          the type operand. This is a compile time error. */
13473       else
13474         {
13475           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13476           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13477           parse_error_context
13478             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13479              t1, lang_printable_name (op2_type, 0));
13480           free (t1);
13481           error_found = 1;
13482         }
13483
13484       break;
13485
13486       /* 15.21 Bitwise and Logical Operators */
13487     case BIT_AND_EXPR:
13488     case BIT_XOR_EXPR:
13489     case BIT_IOR_EXPR:
13490       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13491         /* Binary numeric promotion is performed on both operand and the
13492            expression retain that type */
13493         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13494
13495       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13496                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13497         /* The type of the bitwise operator expression is BOOLEAN */
13498         prom_type = boolean_type_node;
13499       else
13500         {
13501           if (!JINTEGRAL_TYPE_P (op1_type))
13502             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13503           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13504             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13505           TREE_TYPE (node) = error_mark_node;
13506           error_found = 1;
13507           /* Insert a break here if adding thing before the switch's
13508              break for this case */
13509         }
13510       break;
13511
13512       /* 15.22 Conditional-And Operator */
13513     case TRUTH_ANDIF_EXPR:
13514       /* 15.23 Conditional-Or Operator */
13515     case TRUTH_ORIF_EXPR:
13516       /* Operands must be of BOOLEAN type */
13517       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13518           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13519         {
13520           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13521             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13522           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13523             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13524           TREE_TYPE (node) = boolean_type_node;
13525           error_found = 1;
13526           break;
13527         }
13528       else if (integer_zerop (op1))
13529         {
13530           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13531         }
13532       else if (integer_onep (op1))
13533         {
13534           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13535         }
13536       /* The type of the conditional operators is BOOLEAN */
13537       prom_type = boolean_type_node;
13538       break;
13539
13540       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13541     case LT_EXPR:
13542     case GT_EXPR:
13543     case LE_EXPR:
13544     case GE_EXPR:
13545       /* The type of each of the operands must be a primitive numeric
13546          type */
13547       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13548         {
13549           if (!JNUMERIC_TYPE_P (op1_type))
13550             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13551           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13552             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13553           TREE_TYPE (node) = boolean_type_node;
13554           error_found = 1;
13555           break;
13556         }
13557       /* Binary numeric promotion is performed on the operands */
13558       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13559       /* The type of the relation expression is always BOOLEAN */
13560       prom_type = boolean_type_node;
13561       break;
13562
13563       /* 15.20 Equality Operator */
13564     case EQ_EXPR:
13565     case NE_EXPR:
13566       /* It's time for us to patch the strings. */
13567       if ((cn = patch_string (op1)))
13568        {
13569          op1 = cn;
13570          op1_type = TREE_TYPE (op1);
13571        }
13572       if ((cn = patch_string (op2)))
13573        {
13574          op2 = cn;
13575          op2_type = TREE_TYPE (op2);
13576        }
13577
13578       /* 15.20.1 Numerical Equality Operators == and != */
13579       /* Binary numeric promotion is performed on the operands */
13580       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13581         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13582
13583       /* 15.20.2 Boolean Equality Operators == and != */
13584       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13585           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13586         ;                       /* Nothing to do here */
13587
13588       /* 15.20.3 Reference Equality Operators == and != */
13589       /* Types have to be either references or the null type. If
13590          they're references, it must be possible to convert either
13591          type to the other by casting conversion. */
13592       else if (op1 == null_pointer_node || op2 == null_pointer_node
13593                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13594                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13595                        || valid_ref_assignconv_cast_p (op2_type,
13596                                                        op1_type, 1))))
13597         ;                       /* Nothing to do here */
13598
13599       /* Else we have an error figure what can't be converted into
13600          what and report the error */
13601       else
13602         {
13603           char *t1;
13604           t1 = xstrdup (lang_printable_name (op1_type, 0));
13605           parse_error_context
13606             (wfl_operator,
13607              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13608              operator_string (node), t1,
13609              lang_printable_name (op2_type, 0));
13610           free (t1);
13611           TREE_TYPE (node) = boolean_type_node;
13612           error_found = 1;
13613           break;
13614         }
13615       prom_type = boolean_type_node;
13616       break;
13617     default:
13618       abort ();
13619     }
13620
13621   if (error_found)
13622     return error_mark_node;
13623
13624   TREE_OPERAND (node, 0) = op1;
13625   TREE_OPERAND (node, 1) = op2;
13626   TREE_TYPE (node) = prom_type;
13627   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13628
13629   if (flag_emit_xref)
13630     return node;
13631
13632   /* fold does not respect side-effect order as required for Java but not C.
13633    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13634    * bytecode.
13635    */
13636   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13637       : ! TREE_SIDE_EFFECTS (node))
13638     node = fold (node);
13639   return node;
13640 }
13641
13642 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13643    zero value, the value of CSTE comes after the valude of STRING */
13644
13645 static tree
13646 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13647 {
13648   const char *old = TREE_STRING_POINTER (cste);
13649   int old_len = TREE_STRING_LENGTH (cste);
13650   int len = old_len + string_len;
13651   char *new = alloca (len+1);
13652
13653   if (after)
13654     {
13655       memcpy (new, string, string_len);
13656       memcpy (&new [string_len], old, old_len);
13657     }
13658   else
13659     {
13660       memcpy (new, old, old_len);
13661       memcpy (&new [old_len], string, string_len);
13662     }
13663   new [len] = '\0';
13664   return build_string (len, new);
13665 }
13666
13667 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13668    new STRING_CST on success, NULL_TREE on failure.  */
13669
13670 static tree
13671 merge_string_cste (tree op1, tree op2, int after)
13672 {
13673   /* Handle two string constants right away.  */
13674   if (TREE_CODE (op2) == STRING_CST)
13675     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13676                                  TREE_STRING_LENGTH (op2), after);
13677
13678   /* Reasonable integer constant can be treated right away.  */
13679   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13680     {
13681       static const char *const boolean_true = "true";
13682       static const char *const boolean_false = "false";
13683       static const char *const null_pointer = "null";
13684       char ch[4];
13685       const char *string;
13686
13687       if (op2 == boolean_true_node)
13688         string = boolean_true;
13689       else if (op2 == boolean_false_node)
13690         string = boolean_false;
13691       else if (op2 == null_pointer_node
13692                || (integer_zerop (op2)
13693                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13694         /* FIXME: null is not a compile-time constant, so it is only safe to
13695            merge if the overall expression is non-constant. However, this
13696            code always merges without checking the overall expression.  */
13697         string = null_pointer;
13698       else if (TREE_TYPE (op2) == char_type_node)
13699         {
13700           /* Convert the character into UTF-8.  */
13701           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13702           unsigned char *p = (unsigned char *) ch;
13703           if (0x01 <= c && c <= 0x7f)
13704             *p++ = (unsigned char) c;
13705           else if (c < 0x7ff)
13706             {
13707               *p++ = (unsigned char) (c >> 6 | 0xc0);
13708               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13709             }
13710           else
13711             {
13712               *p++ = (unsigned char) (c >> 12 | 0xe0);
13713               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13714               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13715             }
13716           *p = '\0';
13717
13718           string = ch;
13719         }
13720       else
13721         string = string_convert_int_cst (op2);
13722
13723       return do_merge_string_cste (op1, string, strlen (string), after);
13724     }
13725   return NULL_TREE;
13726 }
13727
13728 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13729    has to be a STRING_CST and the other part must be a STRING_CST or a
13730    INTEGRAL constant. Return a new STRING_CST if the operation
13731    succeed, NULL_TREE otherwise.
13732
13733    If the case we want to optimize for space, we might want to return
13734    NULL_TREE for each invocation of this routine. FIXME */
13735
13736 static tree
13737 string_constant_concatenation (tree op1, tree op2)
13738 {
13739   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13740     {
13741       tree string, rest;
13742       int invert;
13743
13744       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13745       rest   = (string == op1 ? op2 : op1);
13746       invert = (string == op1 ? 0 : 1 );
13747
13748       /* Walk REST, only if it looks reasonable */
13749       if (TREE_CODE (rest) != STRING_CST
13750           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13751           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13752           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13753         {
13754           rest = java_complete_tree (rest);
13755           if (rest == error_mark_node)
13756             return error_mark_node;
13757           rest = fold (rest);
13758         }
13759       return merge_string_cste (string, rest, invert);
13760     }
13761   return NULL_TREE;
13762 }
13763
13764 /* Implement the `+' operator. Does static optimization if possible,
13765    otherwise create (if necessary) and append elements to a
13766    StringBuffer. The StringBuffer will be carried around until it is
13767    used for a function call or an assignment. Then toString() will be
13768    called on it to turn it into a String object. */
13769
13770 static tree
13771 build_string_concatenation (tree op1, tree op2)
13772 {
13773   tree result;
13774   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13775
13776   if (flag_emit_xref)
13777     return build (PLUS_EXPR, string_type_node, op1, op2);
13778
13779   /* Try to do some static optimization */
13780   if ((result = string_constant_concatenation (op1, op2)))
13781     return result;
13782
13783   /* Discard empty strings on either side of the expression */
13784   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13785     {
13786       op1 = op2;
13787       op2 = NULL_TREE;
13788     }
13789   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13790     op2 = NULL_TREE;
13791
13792   /* If operands are string constant, turn then into object references */
13793   if (TREE_CODE (op1) == STRING_CST)
13794     op1 = patch_string_cst (op1);
13795   if (op2 && TREE_CODE (op2) == STRING_CST)
13796     op2 = patch_string_cst (op2);
13797
13798   /* If either one of the constant is null and the other non null
13799      operand is a String constant, return it. */
13800   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13801     return op1;
13802
13803   /* If OP1 isn't already a StringBuffer, create and
13804      initialize a new one */
13805   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13806     {
13807       /* Two solutions here:
13808          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13809          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13810       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13811         op1 = BUILD_STRING_BUFFER (op1);
13812       else
13813         {
13814           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13815           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13816         }
13817     }
13818
13819   if (op2)
13820     {
13821       /* OP1 is no longer the last node holding a crafted StringBuffer */
13822       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13823       /* Create a node for `{new...,xxx}.append (op2)' */
13824       if (op2)
13825         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13826     }
13827
13828   /* Mark the last node holding a crafted StringBuffer */
13829   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13830
13831   TREE_SIDE_EFFECTS (op1) = side_effects;
13832   return op1;
13833 }
13834
13835 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13836    StringBuffer. If no string were found to be patched, return
13837    NULL. */
13838
13839 static tree
13840 patch_string (tree node)
13841 {
13842   if (node == error_mark_node)
13843     return error_mark_node;
13844   if (TREE_CODE (node) == STRING_CST)
13845     return patch_string_cst (node);
13846   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13847     {
13848       int saved = ctxp->explicit_constructor_p;
13849       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13850       tree ret;
13851       /* Temporary disable forbid the use of `this'. */
13852       ctxp->explicit_constructor_p = 0;
13853       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13854       /* String concatenation arguments must be evaluated in order too. */
13855       ret = force_evaluation_order (ret);
13856       /* Restore it at its previous value */
13857       ctxp->explicit_constructor_p = saved;
13858       return ret;
13859     }
13860   return NULL_TREE;
13861 }
13862
13863 /* Build the internal representation of a string constant.  */
13864
13865 static tree
13866 patch_string_cst (tree node)
13867 {
13868   int location;
13869   if (! flag_emit_class_files)
13870     {
13871       node = get_identifier (TREE_STRING_POINTER (node));
13872       location = alloc_name_constant (CONSTANT_String, node);
13873       node = build_ref_from_constant_pool (location);
13874     }
13875   TREE_CONSTANT (node) = 1;
13876   TREE_INVARIANT (node) = 1;
13877
13878   /* ??? Guessing that the class file code can't handle casts.  */
13879   if (! flag_emit_class_files)
13880     node = convert (string_ptr_type_node, node);
13881   else
13882     TREE_TYPE (node) = string_ptr_type_node;
13883
13884   return node;
13885 }
13886
13887 /* Build an incomplete unary operator expression. */
13888
13889 static tree
13890 build_unaryop (int op_token, int op_location, tree op1)
13891 {
13892   enum tree_code op;
13893   tree unaryop;
13894   switch (op_token)
13895     {
13896     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13897     case MINUS_TK: op = NEGATE_EXPR; break;
13898     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13899     case NOT_TK: op = BIT_NOT_EXPR; break;
13900     default: abort ();
13901     }
13902
13903   unaryop = build1 (op, NULL_TREE, op1);
13904   TREE_SIDE_EFFECTS (unaryop) = 1;
13905   /* Store the location of the operator, for better error report. The
13906      string of the operator will be rebuild based on the OP value. */
13907   EXPR_WFL_LINECOL (unaryop) = op_location;
13908   return unaryop;
13909 }
13910
13911 /* Special case for the ++/-- operators, since they require an extra
13912    argument to build, which is set to NULL and patched
13913    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13914
13915 static tree
13916 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13917 {
13918   static const enum tree_code lookup [2][2] =
13919     {
13920       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13921       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13922     };
13923   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13924                      NULL_TREE, op1, NULL_TREE);
13925   TREE_SIDE_EFFECTS (node) = 1;
13926   /* Store the location of the operator, for better error report. The
13927      string of the operator will be rebuild based on the OP value. */
13928   EXPR_WFL_LINECOL (node) = op_location;
13929   return node;
13930 }
13931
13932 /* Build an incomplete cast operator, based on the use of the
13933    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13934    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13935    though its type is already set.  */
13936
13937 static tree
13938 build_cast (int location, tree type, tree exp)
13939 {
13940   tree node = build1 (CONVERT_EXPR, type, exp);
13941   EXPR_WFL_LINECOL (node) = location;
13942   return node;
13943 }
13944
13945 /* Build an incomplete class reference operator.  */
13946 static tree
13947 build_incomplete_class_ref (int location, tree class_name)
13948 {
13949   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13950   tree class_decl = GET_CPC ();
13951   tree this_class = TREE_TYPE (class_decl);
13952
13953   /* Generate the synthetic static method `class$'.  (Previously we
13954      deferred this, causing different method tables to be emitted
13955      for native code and bytecode.)  */
13956   if (!TYPE_DOT_CLASS (this_class)
13957       && !JPRIMITIVE_TYPE_P (class_name)
13958       && !(TREE_CODE (class_name) == VOID_TYPE))
13959     {
13960       tree cpc_list = GET_CPC_LIST();
13961       tree cpc = cpc_list;
13962       tree target_class;
13963
13964       /* For inner classes, add a 'class$' method to their outermost
13965          context, creating it if necessary.  */
13966
13967       while (GET_NEXT_ENCLOSING_CPC(cpc))
13968         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
13969       class_decl = TREE_VALUE (cpc);
13970
13971       target_class = TREE_TYPE (class_decl);
13972
13973       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
13974         {
13975           /* For interfaces, adding a static 'class$' method directly
13976              is illegal.  So create an inner class to contain the new
13977              method.  Empirically this matches the behavior of javac.  */
13978           tree t, inner;
13979           /* We want the generated inner class inside the outermost class. */
13980           GET_CPC_LIST() = cpc;
13981           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13982           inner = create_anonymous_class (0, t);
13983           target_class = TREE_TYPE (inner);
13984           end_class_declaration (1);
13985           GET_CPC_LIST() = cpc_list;
13986         }
13987
13988       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
13989         build_dot_class_method (target_class);
13990
13991       if (this_class != target_class)
13992         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
13993     }
13994
13995   EXPR_WFL_LINECOL (node) = location;
13996   return node;
13997 }
13998
13999 /* Complete an incomplete class reference operator.  */
14000 static tree
14001 patch_incomplete_class_ref (tree node)
14002 {
14003   tree type = TREE_OPERAND (node, 0);
14004   tree ref_type;
14005
14006   if (!(ref_type = resolve_type_during_patch (type)))
14007     return error_mark_node;
14008
14009   /* If we're not emitting class files and we know ref_type is a
14010      compiled class, build a direct reference.  */
14011   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14012       || JPRIMITIVE_TYPE_P (ref_type)
14013       || TREE_CODE (ref_type) == VOID_TYPE)
14014     {
14015       tree dot = build_class_ref (ref_type);
14016       /* A class referenced by `foo.class' is initialized.  */
14017       if (!flag_emit_class_files)
14018        dot = build_class_init (ref_type, dot);
14019       return java_complete_tree (dot);
14020     }
14021
14022   /* If we're emitting class files and we have to deal with non
14023      primitive types, we invoke the synthetic static method `class$'.  */
14024   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14025   return java_complete_tree (ref_type);
14026 }
14027
14028 /* 15.14 Unary operators. We return error_mark_node in case of error,
14029    but preserve the type of NODE if the type is fixed.  */
14030
14031 static tree
14032 patch_unaryop (tree node, tree wfl_op)
14033 {
14034   tree op = TREE_OPERAND (node, 0);
14035   tree op_type = TREE_TYPE (op);
14036   tree prom_type = NULL_TREE, value, decl;
14037   int outer_field_flag = 0;
14038   int code = TREE_CODE (node);
14039   int error_found = 0;
14040
14041   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14042
14043   switch (code)
14044     {
14045       /* 15.13.2 Postfix Increment Operator ++ */
14046     case POSTINCREMENT_EXPR:
14047       /* 15.13.3 Postfix Increment Operator -- */
14048     case POSTDECREMENT_EXPR:
14049       /* 15.14.1 Prefix Increment Operator ++ */
14050     case PREINCREMENT_EXPR:
14051       /* 15.14.2 Prefix Decrement Operator -- */
14052     case PREDECREMENT_EXPR:
14053       op = decl = strip_out_static_field_access_decl (op);
14054       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14055       /* We might be trying to change an outer field accessed using
14056          access method. */
14057       if (outer_field_flag)
14058         {
14059           /* Retrieve the decl of the field we're trying to access. We
14060              do that by first retrieving the function we would call to
14061              access the field. It has been already verified that this
14062              field isn't final */
14063           if (flag_emit_class_files)
14064             decl = TREE_OPERAND (op, 0);
14065           else
14066             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14067           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14068         }
14069       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14070       else if (!JDECL_P (decl)
14071           && TREE_CODE (decl) != COMPONENT_REF
14072           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14073           && TREE_CODE (decl) != INDIRECT_REF
14074           && !(TREE_CODE (decl) == COMPOUND_EXPR
14075                && TREE_OPERAND (decl, 1)
14076                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14077         {
14078           TREE_TYPE (node) = error_mark_node;
14079           error_found = 1;
14080         }
14081
14082       /* From now on, we know that op if a variable and that it has a
14083          valid wfl. We use wfl_op to locate errors related to the
14084          ++/-- operand. */
14085       if (!JNUMERIC_TYPE_P (op_type))
14086         {
14087           parse_error_context
14088             (wfl_op, "Invalid argument type `%s' to `%s'",
14089              lang_printable_name (op_type, 0), operator_string (node));
14090           TREE_TYPE (node) = error_mark_node;
14091           error_found = 1;
14092         }
14093       else
14094         {
14095           /* Before the addition, binary numeric promotion is performed on
14096              both operands, if really necessary */
14097           if (JINTEGRAL_TYPE_P (op_type))
14098             {
14099               value = build_int_2 (1, 0);
14100               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14101             }
14102           else
14103             {
14104               value = build_int_2 (1, 0);
14105               TREE_TYPE (node) =
14106                 binary_numeric_promotion (op_type,
14107                                           TREE_TYPE (value), &op, &value);
14108             }
14109
14110           /* We remember we might be accessing an outer field */
14111           if (outer_field_flag)
14112             {
14113               /* We re-generate an access to the field */
14114               value = build (PLUS_EXPR, TREE_TYPE (op),
14115                              build_outer_field_access (wfl_op, decl), value);
14116
14117               /* And we patch the original access$() into a write
14118                  with plus_op as a rhs */
14119               return outer_field_access_fix (node, op, value);
14120             }
14121
14122           /* And write back into the node. */
14123           TREE_OPERAND (node, 0) = op;
14124           TREE_OPERAND (node, 1) = value;
14125           /* Convert the overall back into its original type, if
14126              necessary, and return */
14127           if (JINTEGRAL_TYPE_P (op_type))
14128             return fold (node);
14129           else
14130             return fold (convert (op_type, node));
14131         }
14132       break;
14133
14134       /* 15.14.3 Unary Plus Operator + */
14135     case UNARY_PLUS_EXPR:
14136       /* 15.14.4 Unary Minus Operator - */
14137     case NEGATE_EXPR:
14138       if (!JNUMERIC_TYPE_P (op_type))
14139         {
14140           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14141           TREE_TYPE (node) = error_mark_node;
14142           error_found = 1;
14143         }
14144       /* Unary numeric promotion is performed on operand */
14145       else
14146         {
14147           op = do_unary_numeric_promotion (op);
14148           prom_type = TREE_TYPE (op);
14149           if (code == UNARY_PLUS_EXPR)
14150             return fold (op);
14151         }
14152       break;
14153
14154       /* 15.14.5 Bitwise Complement Operator ~ */
14155     case BIT_NOT_EXPR:
14156       if (!JINTEGRAL_TYPE_P (op_type))
14157         {
14158           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14159           TREE_TYPE (node) = error_mark_node;
14160           error_found = 1;
14161         }
14162       else
14163         {
14164           op = do_unary_numeric_promotion (op);
14165           prom_type = TREE_TYPE (op);
14166         }
14167       break;
14168
14169       /* 15.14.6 Logical Complement Operator ! */
14170     case TRUTH_NOT_EXPR:
14171       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14172         {
14173           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14174           /* But the type is known. We will report an error if further
14175              attempt of a assignment is made with this rhs */
14176           TREE_TYPE (node) = boolean_type_node;
14177           error_found = 1;
14178         }
14179       else
14180         prom_type = boolean_type_node;
14181       break;
14182
14183       /* 15.15 Cast Expression */
14184     case CONVERT_EXPR:
14185       value = patch_cast (node, wfl_operator);
14186       if (value == error_mark_node)
14187         {
14188           /* If this cast is part of an assignment, we tell the code
14189              that deals with it not to complain about a mismatch,
14190              because things have been cast, anyways */
14191           TREE_TYPE (node) = error_mark_node;
14192           error_found = 1;
14193         }
14194       else
14195         {
14196           value = fold (value);
14197           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14198           return value;
14199         }
14200       break;
14201     }
14202
14203   if (error_found)
14204     return error_mark_node;
14205
14206   /* There are cases where node has been replaced by something else
14207      and we don't end up returning here: UNARY_PLUS_EXPR,
14208      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14209   TREE_OPERAND (node, 0) = fold (op);
14210   TREE_TYPE (node) = prom_type;
14211   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14212   return fold (node);
14213 }
14214
14215 /* Generic type resolution that sometimes takes place during node
14216    patching. Returned the resolved type or generate an error
14217    message. Return the resolved type or NULL_TREE.  */
14218
14219 static tree
14220 resolve_type_during_patch (tree type)
14221 {
14222   if (unresolved_type_p (type, NULL))
14223     {
14224       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14225       if (!type_decl)
14226         {
14227           parse_error_context (type,
14228                                "Class `%s' not found in type declaration",
14229                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14230           return NULL_TREE;
14231         }
14232
14233       check_deprecation (type, type_decl);
14234
14235       return TREE_TYPE (type_decl);
14236     }
14237   return type;
14238 }
14239
14240 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14241    found. Otherwise NODE or something meant to replace it is returned.  */
14242
14243 static tree
14244 patch_cast (tree node, tree wfl_op)
14245 {
14246   tree op = TREE_OPERAND (node, 0);
14247   tree cast_type = TREE_TYPE (node);
14248   tree patched, op_type;
14249   char *t1;
14250
14251   /* Some string patching might be necessary at this stage */
14252   if ((patched = patch_string (op)))
14253     TREE_OPERAND (node, 0) = op = patched;
14254   op_type = TREE_TYPE (op);
14255
14256   /* First resolve OP_TYPE if unresolved */
14257   if (!(cast_type = resolve_type_during_patch (cast_type)))
14258     return error_mark_node;
14259
14260   /* Check on cast that are proven correct at compile time */
14261   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14262     {
14263       /* Same type */
14264       if (cast_type == op_type)
14265         return node;
14266
14267       /* A narrowing conversion from a floating-point number to an
14268          integral type requires special handling (5.1.3).  */
14269       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14270         if (cast_type != long_type_node)
14271           op = convert (integer_type_node, op);
14272
14273       /* Try widening/narrowing conversion.  Potentially, things need
14274          to be worked out in gcc so we implement the extreme cases
14275          correctly.  fold_convert() needs to be fixed.  */
14276       return convert (cast_type, op);
14277     }
14278
14279   /* It's also valid to cast a boolean into a boolean */
14280   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14281     return node;
14282
14283   /* null can be casted to references */
14284   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14285     return build_null_of_type (cast_type);
14286
14287   /* The remaining legal casts involve conversion between reference
14288      types. Check for their compile time correctness. */
14289   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14290       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14291     {
14292       TREE_TYPE (node) = promote_type (cast_type);
14293       /* Now, the case can be determined correct at compile time if
14294          OP_TYPE can be converted into CAST_TYPE by assignment
14295          conversion (5.2) */
14296
14297       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14298         {
14299           TREE_SET_CODE (node, NOP_EXPR);
14300           return node;
14301         }
14302
14303       if (flag_emit_class_files)
14304         {
14305           TREE_SET_CODE (node, CONVERT_EXPR);
14306           return node;
14307         }
14308
14309       /* The cast requires a run-time check */
14310       return build (CALL_EXPR, promote_type (cast_type),
14311                     build_address_of (soft_checkcast_node),
14312                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14313                                build_tree_list (NULL_TREE, op)),
14314                     NULL_TREE);
14315     }
14316
14317   /* Any other casts are proven incorrect at compile time */
14318   t1 = xstrdup (lang_printable_name (op_type, 0));
14319   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14320                        t1, lang_printable_name (cast_type, 0));
14321   free (t1);
14322   return error_mark_node;
14323 }
14324
14325 /* Build a null constant and give it the type TYPE.  */
14326
14327 static tree
14328 build_null_of_type (tree type)
14329 {
14330   tree node = build_int_2 (0, 0);
14331   TREE_TYPE (node) = promote_type (type);
14332   return node;
14333 }
14334
14335 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14336    a list of indices. */
14337 static tree
14338 build_array_ref (int location, tree array, tree index)
14339 {
14340   tree node = build (ARRAY_REF, NULL_TREE, array, index, NULL_TREE, NULL_TREE);
14341   EXPR_WFL_LINECOL (node) = location;
14342   return node;
14343 }
14344
14345 /* 15.12 Array Access Expression */
14346
14347 static tree
14348 patch_array_ref (tree node)
14349 {
14350   tree array = TREE_OPERAND (node, 0);
14351   tree array_type  = TREE_TYPE (array);
14352   tree index = TREE_OPERAND (node, 1);
14353   tree index_type = TREE_TYPE (index);
14354   int error_found = 0;
14355
14356   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14357
14358   if (TREE_CODE (array_type) == POINTER_TYPE)
14359     array_type = TREE_TYPE (array_type);
14360
14361   /* The array reference must be an array */
14362   if (!TYPE_ARRAY_P (array_type))
14363     {
14364       parse_error_context
14365         (wfl_operator,
14366          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14367          lang_printable_name (array_type, 0));
14368       TREE_TYPE (node) = error_mark_node;
14369       error_found = 1;
14370     }
14371
14372   /* The array index undergoes unary numeric promotion. The promoted
14373      type must be int */
14374   index = do_unary_numeric_promotion (index);
14375   if (TREE_TYPE (index) != int_type_node)
14376     {
14377       if (valid_cast_to_p (index_type, int_type_node))
14378         parse_error_context (wfl_operator,
14379    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14380                              lang_printable_name (index_type, 0));
14381       else
14382         parse_error_context (wfl_operator,
14383           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14384                              lang_printable_name (index_type, 0));
14385       TREE_TYPE (node) = error_mark_node;
14386       error_found = 1;
14387     }
14388
14389   if (error_found)
14390     return error_mark_node;
14391
14392   array_type = TYPE_ARRAY_ELEMENT (array_type);
14393
14394   if (flag_emit_class_files || flag_emit_xref)
14395     {
14396       TREE_OPERAND (node, 0) = array;
14397       TREE_OPERAND (node, 1) = index;
14398     }
14399   else
14400     node = build_java_arrayaccess (array, array_type, index);
14401   TREE_TYPE (node) = array_type;
14402   return node;
14403 }
14404
14405 /* 15.9 Array Creation Expressions */
14406
14407 static tree
14408 build_newarray_node (tree type, tree dims, int extra_dims)
14409 {
14410   tree node =
14411     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14412            build_int_2 (extra_dims, 0));
14413   return node;
14414 }
14415
14416 static tree
14417 patch_newarray (tree node)
14418 {
14419   tree type = TREE_OPERAND (node, 0);
14420   tree dims = TREE_OPERAND (node, 1);
14421   tree cdim, array_type;
14422   int error_found = 0;
14423   int ndims = 0;
14424   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14425
14426   /* Dimension types are verified. It's better for the types to be
14427      verified in order. */
14428   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14429     {
14430       int dim_error = 0;
14431       tree dim = TREE_VALUE (cdim);
14432
14433       /* Dim might have been saved during its evaluation */
14434       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14435
14436       /* The type of each specified dimension must be an integral type. */
14437       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14438         dim_error = 1;
14439
14440       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14441          promoted type must be int. */
14442       else
14443         {
14444           dim = do_unary_numeric_promotion (dim);
14445           if (TREE_TYPE (dim) != int_type_node)
14446             dim_error = 1;
14447         }
14448
14449       /* Report errors on types here */
14450       if (dim_error)
14451         {
14452           parse_error_context
14453             (TREE_PURPOSE (cdim),
14454              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14455              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14456               "Explicit cast needed to" : "Can't"),
14457              lang_printable_name (TREE_TYPE (dim), 0));
14458           error_found = 1;
14459         }
14460
14461       TREE_PURPOSE (cdim) = NULL_TREE;
14462     }
14463
14464   /* Resolve array base type if unresolved */
14465   if (!(type = resolve_type_during_patch (type)))
14466     error_found = 1;
14467
14468   if (error_found)
14469     {
14470       /* We don't want further evaluation of this bogus array creation
14471          operation */
14472       TREE_TYPE (node) = error_mark_node;
14473       return error_mark_node;
14474     }
14475
14476   /* Set array_type to the actual (promoted) array type of the result. */
14477   if (TREE_CODE (type) == RECORD_TYPE)
14478     type = build_pointer_type (type);
14479   while (--xdims >= 0)
14480     {
14481       type = promote_type (build_java_array_type (type, -1));
14482     }
14483   dims = nreverse (dims);
14484   array_type = type;
14485   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14486     {
14487       type = array_type;
14488       array_type
14489         = build_java_array_type (type,
14490                                  TREE_CODE (cdim) == INTEGER_CST
14491                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14492                                  : -1);
14493       array_type = promote_type (array_type);
14494     }
14495   dims = nreverse (dims);
14496
14497   /* The node is transformed into a function call. Things are done
14498      differently according to the number of dimensions. If the number
14499      of dimension is equal to 1, then the nature of the base type
14500      (primitive or not) matters. */
14501   if (ndims == 1)
14502     return build_new_array (type, TREE_VALUE (dims));
14503
14504   /* Can't reuse what's already written in expr.c because it uses the
14505      JVM stack representation. Provide a build_multianewarray. FIXME */
14506   return build (CALL_EXPR, array_type,
14507                 build_address_of (soft_multianewarray_node),
14508                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14509                            tree_cons (NULL_TREE,
14510                                       build_int_2 (ndims, 0), dims )),
14511                 NULL_TREE);
14512 }
14513
14514 /* 10.6 Array initializer.  */
14515
14516 /* Build a wfl for array element that don't have one, so we can
14517    pin-point errors.  */
14518
14519 static tree
14520 maybe_build_array_element_wfl (tree node)
14521 {
14522   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14523     return build_expr_wfl (NULL_TREE, ctxp->filename,
14524                            ctxp->elc.line, ctxp->elc.prev_col);
14525   else
14526     return NULL_TREE;
14527 }
14528
14529 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14530    identification of initialized arrays easier to detect during walk
14531    and expansion.  */
14532
14533 static tree
14534 build_new_array_init (int location, tree values)
14535 {
14536   tree constructor = build_constructor (NULL_TREE, values);
14537   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14538   EXPR_WFL_LINECOL (to_return) = location;
14539   return to_return;
14540 }
14541
14542 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14543    occurred.  Otherwise return NODE after having set its type
14544    appropriately.  */
14545
14546 static tree
14547 patch_new_array_init (tree type, tree node)
14548 {
14549   int error_seen = 0;
14550   tree current, element_type;
14551   HOST_WIDE_INT length;
14552   int all_constant = 1;
14553   tree init = TREE_OPERAND (node, 0);
14554
14555   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14556     {
14557       parse_error_context (node,
14558                            "Invalid array initializer for non-array type `%s'",
14559                            lang_printable_name (type, 1));
14560       return error_mark_node;
14561     }
14562   type = TREE_TYPE (type);
14563   element_type = TYPE_ARRAY_ELEMENT (type);
14564
14565   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14566
14567   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14568        current;  length++, current = TREE_CHAIN (current))
14569     {
14570       tree elt = TREE_VALUE (current);
14571       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14572         {
14573           error_seen |= array_constructor_check_entry (element_type, current);
14574           elt = TREE_VALUE (current);
14575           /* When compiling to native code, STRING_CST is converted to
14576              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14577           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14578             all_constant = 0;
14579         }
14580       else
14581         {
14582           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14583           TREE_PURPOSE (current) = NULL_TREE;
14584           all_constant = 0;
14585         }
14586       if (elt && TREE_CODE (elt) == TREE_LIST
14587           && TREE_VALUE (elt) == error_mark_node)
14588         error_seen = 1;
14589     }
14590
14591   if (error_seen)
14592     return error_mark_node;
14593
14594   /* Create a new type. We can't reuse the one we have here by
14595      patching its dimension because it originally is of dimension -1
14596      hence reused by gcc. This would prevent triangular arrays. */
14597   type = build_java_array_type (element_type, length);
14598   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14599   TREE_TYPE (node) = promote_type (type);
14600   TREE_CONSTANT (init) = all_constant;
14601   TREE_INVARIANT (init) = all_constant;
14602   TREE_CONSTANT (node) = all_constant;
14603   TREE_INVARIANT (node) = all_constant;
14604   return node;
14605 }
14606
14607 /* Verify that one entry of the initializer element list can be
14608    assigned to the array base type. Report 1 if an error occurred, 0
14609    otherwise.  */
14610
14611 static int
14612 array_constructor_check_entry (tree type, tree entry)
14613 {
14614   char *array_type_string = NULL;       /* For error reports */
14615   tree value, type_value, new_value, wfl_value, patched;
14616   int error_seen = 0;
14617
14618   new_value = NULL_TREE;
14619   wfl_value = TREE_VALUE (entry);
14620
14621   value = java_complete_tree (TREE_VALUE (entry));
14622   /* patch_string return error_mark_node if arg is error_mark_node */
14623   if ((patched = patch_string (value)))
14624     value = patched;
14625   if (value == error_mark_node)
14626     return 1;
14627
14628   type_value = TREE_TYPE (value);
14629
14630   /* At anytime, try_builtin_assignconv can report a warning on
14631      constant overflow during narrowing. */
14632   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14633   new_value = try_builtin_assignconv (wfl_operator, type, value);
14634   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14635     type_value = promote_type (type);
14636
14637   /* Check and report errors */
14638   if (!new_value)
14639     {
14640       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14641                    "Can't" : "Explicit cast needed to");
14642       if (!array_type_string)
14643         array_type_string = xstrdup (lang_printable_name (type, 1));
14644       parse_error_context
14645         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14646          msg, lang_printable_name (type_value, 1), array_type_string);
14647       error_seen = 1;
14648     }
14649
14650   if (new_value)
14651     TREE_VALUE (entry) = new_value;
14652
14653   if (array_type_string)
14654     free (array_type_string);
14655
14656   TREE_PURPOSE (entry) = NULL_TREE;
14657   return error_seen;
14658 }
14659
14660 static tree
14661 build_this (int location)
14662 {
14663   tree node = build_wfl_node (this_identifier_node);
14664   TREE_SET_CODE (node, THIS_EXPR);
14665   EXPR_WFL_LINECOL (node) = location;
14666   return node;
14667 }
14668
14669 /* 14.15 The return statement. It builds a modify expression that
14670    assigns the returned value to the RESULT_DECL that hold the value
14671    to be returned. */
14672
14673 static tree
14674 build_return (int location, tree op)
14675 {
14676   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14677   EXPR_WFL_LINECOL (node) = location;
14678   node = build_debugable_stmt (location, node);
14679   return node;
14680 }
14681
14682 static tree
14683 patch_return (tree node)
14684 {
14685   tree return_exp = TREE_OPERAND (node, 0);
14686   tree meth = current_function_decl;
14687   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14688   int error_found = 0;
14689
14690   TREE_TYPE (node) = error_mark_node;
14691   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14692
14693   /* It's invalid to have a return value within a function that is
14694      declared with the keyword void or that is a constructor */
14695   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14696     error_found = 1;
14697
14698   /* It's invalid to use a return statement in a static block */
14699   if (DECL_CLINIT_P (current_function_decl))
14700     error_found = 1;
14701
14702   /* It's invalid to have a no return value within a function that
14703      isn't declared with the keyword `void' */
14704   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14705     error_found = 2;
14706
14707   if (DECL_INSTINIT_P (current_function_decl))
14708     error_found = 1;
14709
14710   if (error_found)
14711     {
14712       if (DECL_INSTINIT_P (current_function_decl))
14713         parse_error_context (wfl_operator,
14714                              "`return' inside instance initializer");
14715
14716       else if (DECL_CLINIT_P (current_function_decl))
14717         parse_error_context (wfl_operator,
14718                              "`return' inside static initializer");
14719
14720       else if (!DECL_CONSTRUCTOR_P (meth))
14721         {
14722           char *t = xstrdup (lang_printable_name (mtype, 0));
14723           parse_error_context (wfl_operator,
14724                                "`return' with%s value from `%s %s'",
14725                                (error_found == 1 ? "" : "out"),
14726                                t, lang_printable_name (meth, 0));
14727           free (t);
14728         }
14729       else
14730         parse_error_context (wfl_operator,
14731                              "`return' with value from constructor `%s'",
14732                              lang_printable_name (meth, 0));
14733       return error_mark_node;
14734     }
14735
14736   /* If we have a return_exp, build a modify expression and expand
14737      it. Note: at that point, the assignment is declared valid, but we
14738      may want to carry some more hacks */
14739   if (return_exp)
14740     {
14741       tree exp = java_complete_tree (return_exp);
14742       tree modify, patched;
14743
14744       if ((patched = patch_string (exp)))
14745         exp = patched;
14746
14747       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14748       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14749       modify = java_complete_tree (modify);
14750
14751       if (modify != error_mark_node)
14752         {
14753           TREE_SIDE_EFFECTS (modify) = 1;
14754           TREE_OPERAND (node, 0) = modify;
14755         }
14756       else
14757         return error_mark_node;
14758     }
14759   TREE_TYPE (node) = void_type_node;
14760   TREE_SIDE_EFFECTS (node) = 1;
14761   return node;
14762 }
14763
14764 /* 14.8 The if Statement */
14765
14766 static tree
14767 build_if_else_statement (int location, tree expression, tree if_body,
14768                          tree else_body)
14769 {
14770   tree node;
14771   if (!else_body)
14772     else_body = build_java_empty_stmt ();
14773   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14774   EXPR_WFL_LINECOL (node) = location;
14775   node = build_debugable_stmt (location, node);
14776   return node;
14777 }
14778
14779 static tree
14780 patch_if_else_statement (tree node)
14781 {
14782   tree expression = TREE_OPERAND (node, 0);
14783   int can_complete_normally
14784     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14785        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14786
14787   TREE_TYPE (node) = error_mark_node;
14788   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14789
14790   /* The type of expression must be boolean */
14791   if (TREE_TYPE (expression) != boolean_type_node
14792       && TREE_TYPE (expression) != promoted_boolean_type_node)
14793     {
14794       parse_error_context
14795         (wfl_operator,
14796          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14797          lang_printable_name (TREE_TYPE (expression), 0));
14798       return error_mark_node;
14799     }
14800
14801   TREE_TYPE (node) = void_type_node;
14802   TREE_SIDE_EFFECTS (node) = 1;
14803   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14804   return node;
14805 }
14806
14807 /* 14.6 Labeled Statements */
14808
14809 /* Action taken when a labeled statement is parsed. a new
14810    LABELED_BLOCK_EXPR is created. No statement is attached to the
14811    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14812
14813 static tree
14814 build_labeled_block (int location, tree label)
14815 {
14816   tree label_name ;
14817   tree label_decl, node;
14818   if (label == NULL_TREE || label == continue_identifier_node)
14819     label_name = label;
14820   else
14821     {
14822       label_name = merge_qualified_name (label_id, label);
14823       /* Issue an error if we try to reuse a label that was previously
14824          declared */
14825       if (IDENTIFIER_LOCAL_VALUE (label_name))
14826         {
14827           EXPR_WFL_LINECOL (wfl_operator) = location;
14828           parse_error_context (wfl_operator,
14829             "Declaration of `%s' shadows a previous label declaration",
14830                                IDENTIFIER_POINTER (label));
14831           EXPR_WFL_LINECOL (wfl_operator) =
14832             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14833           parse_error_context (wfl_operator,
14834             "This is the location of the previous declaration of label `%s'",
14835                                IDENTIFIER_POINTER (label));
14836           java_error_count--;
14837         }
14838     }
14839
14840   label_decl = create_label_decl (label_name);
14841   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14842   EXPR_WFL_LINECOL (node) = location;
14843   TREE_SIDE_EFFECTS (node) = 1;
14844   return node;
14845 }
14846
14847 /* A labeled statement LBE is attached a statement.  */
14848
14849 static tree
14850 finish_labeled_statement (tree lbe, /* Labeled block expr */
14851                           tree statement)
14852 {
14853   /* In anyways, tie the loop to its statement */
14854   LABELED_BLOCK_BODY (lbe) = statement;
14855   pop_labeled_block ();
14856   POP_LABELED_BLOCK ();
14857   return lbe;
14858 }
14859
14860 /* 14.10, 14.11, 14.12 Loop Statements */
14861
14862 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14863    list. */
14864
14865 static tree
14866 build_new_loop (tree loop_body)
14867 {
14868   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14869   TREE_SIDE_EFFECTS (loop) = 1;
14870   PUSH_LOOP (loop);
14871   return loop;
14872 }
14873
14874 /* Create a loop body according to the following structure:
14875      COMPOUND_EXPR
14876        COMPOUND_EXPR            (loop main body)
14877          EXIT_EXPR              (this order is for while/for loops.
14878          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14879            LABEL_DECL           (a continue occurring here branches at the
14880            BODY                  end of this labeled block)
14881        INCREMENT                (if any)
14882
14883   REVERSED, if nonzero, tells that the loop condition expr comes
14884   after the body, like in the do-while loop.
14885
14886   To obtain a loop, the loop body structure described above is
14887   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14888
14889    LABELED_BLOCK_EXPR
14890      LABEL_DECL                   (use this label to exit the loop)
14891      LOOP_EXPR
14892        <structure described above> */
14893
14894 static tree
14895 build_loop_body (int location, tree condition, int reversed)
14896 {
14897   tree first, second, body;
14898
14899   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14900   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14901   condition = build_debugable_stmt (location, condition);
14902   TREE_SIDE_EFFECTS (condition) = 1;
14903
14904   body = build_labeled_block (0, continue_identifier_node);
14905   first = (reversed ? body : condition);
14906   second = (reversed ? condition : body);
14907   return
14908     build (COMPOUND_EXPR, NULL_TREE,
14909            build (COMPOUND_EXPR, NULL_TREE, first, second),
14910                   build_java_empty_stmt ());
14911 }
14912
14913 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14914    their order) on the current loop. Unlink the current loop from the
14915    loop list.  */
14916
14917 static tree
14918 finish_loop_body (int location, tree condition, tree body, int reversed)
14919 {
14920   tree to_return = ctxp->current_loop;
14921   tree loop_body = LOOP_EXPR_BODY (to_return);
14922   if (condition)
14923     {
14924       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14925       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14926          The real EXIT_EXPR is one operand further. */
14927       EXPR_WFL_LINECOL (cnode) = location;
14928       /* This one is for accurate error reports */
14929       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14930       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14931     }
14932   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14933   POP_LOOP ();
14934   return to_return;
14935 }
14936
14937 /* Tailored version of finish_loop_body for FOR loops, when FOR
14938    loops feature the condition part */
14939
14940 static tree
14941 finish_for_loop (int location, tree condition, tree update, tree body)
14942 {
14943   /* Put the condition and the loop body in place */
14944   tree loop = finish_loop_body (location, condition, body, 0);
14945   /* LOOP is the current loop which has been now popped of the loop
14946      stack.  Mark the update block as reachable and install it.  We do
14947      this because the (current interpretation of the) JLS requires
14948      that the update expression be considered reachable even if the
14949      for loop's body doesn't complete normally.  */
14950   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
14951     {
14952       tree up2 = update;
14953       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14954         up2 = EXPR_WFL_NODE (up2);
14955       /* It is possible for the update expression to be an
14956          EXPR_WFL_NODE wrapping nothing.  */
14957       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
14958         {
14959           /* Try to detect constraint violations.  These would be
14960              programming errors somewhere.  */
14961           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14962               || TREE_CODE (up2) == LOOP_EXPR)
14963             abort ();
14964           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14965         }
14966     }
14967   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14968   return loop;
14969 }
14970
14971 /* Try to find the loop a block might be related to. This comprises
14972    the case where the LOOP_EXPR is found as the second operand of a
14973    COMPOUND_EXPR, because the loop happens to have an initialization
14974    part, then expressed as the first operand of the COMPOUND_EXPR. If
14975    the search finds something, 1 is returned. Otherwise, 0 is
14976    returned. The search is assumed to start from a
14977    LABELED_BLOCK_EXPR's block.  */
14978
14979 static tree
14980 search_loop (tree statement)
14981 {
14982   if (TREE_CODE (statement) == LOOP_EXPR)
14983     return statement;
14984
14985   if (TREE_CODE (statement) == BLOCK)
14986     statement = BLOCK_SUBBLOCKS (statement);
14987   else
14988     return NULL_TREE;
14989
14990   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14991     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14992       statement = TREE_OPERAND (statement, 1);
14993
14994   return (TREE_CODE (statement) == LOOP_EXPR
14995           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14996 }
14997
14998 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14999    returned otherwise.  */
15000
15001 static int
15002 labeled_block_contains_loop_p (tree block, tree loop)
15003 {
15004   if (!block)
15005     return 0;
15006
15007   if (LABELED_BLOCK_BODY (block) == loop)
15008     return 1;
15009
15010   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15011     return 1;
15012
15013   return 0;
15014 }
15015
15016 /* If the loop isn't surrounded by a labeled statement, create one and
15017    insert LOOP as its body.  */
15018
15019 static tree
15020 patch_loop_statement (tree loop)
15021 {
15022   tree loop_label;
15023
15024   TREE_TYPE (loop) = void_type_node;
15025   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15026     return loop;
15027
15028   loop_label = build_labeled_block (0, NULL_TREE);
15029   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15030      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15031   LABELED_BLOCK_BODY (loop_label) = loop;
15032   PUSH_LABELED_BLOCK (loop_label);
15033   return loop_label;
15034 }
15035
15036 /* 14.13, 14.14: break and continue Statements */
15037
15038 /* Build a break or a continue statement. a null NAME indicates an
15039    unlabeled break/continue statement.  */
15040
15041 static tree
15042 build_bc_statement (int location, int is_break, tree name)
15043 {
15044   tree break_continue, label_block_expr = NULL_TREE;
15045
15046   if (name)
15047     {
15048       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15049             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15050         /* Null means that we don't have a target for this named
15051            break/continue. In this case, we make the target to be the
15052            label name, so that the error can be reported accurately in
15053            patch_bc_statement. */
15054         label_block_expr = EXPR_WFL_NODE (name);
15055     }
15056   /* Unlabeled break/continue will be handled during the
15057      break/continue patch operation */
15058   break_continue
15059     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15060
15061   IS_BREAK_STMT_P (break_continue) = is_break;
15062   TREE_SIDE_EFFECTS (break_continue) = 1;
15063   EXPR_WFL_LINECOL (break_continue) = location;
15064   break_continue = build_debugable_stmt (location, break_continue);
15065   return break_continue;
15066 }
15067
15068 /* Verification of a break/continue statement. */
15069
15070 static tree
15071 patch_bc_statement (tree node)
15072 {
15073   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15074   tree labeled_block = ctxp->current_labeled_block;
15075   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15076
15077   /* Having an identifier here means that the target is unknown. */
15078   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15079     {
15080       parse_error_context (wfl_operator, "No label definition found for `%s'",
15081                            IDENTIFIER_POINTER (bc_label));
15082       return error_mark_node;
15083     }
15084   if (! IS_BREAK_STMT_P (node))
15085     {
15086       /* It's a continue statement. */
15087       for (;; labeled_block = TREE_CHAIN (labeled_block))
15088         {
15089           if (labeled_block == NULL_TREE)
15090             {
15091               if (bc_label == NULL_TREE)
15092                 parse_error_context (wfl_operator,
15093                                      "`continue' must be in loop");
15094               else
15095                 parse_error_context
15096                   (wfl_operator, "continue label `%s' does not name a loop",
15097                    IDENTIFIER_POINTER (bc_label));
15098               return error_mark_node;
15099             }
15100           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15101                == continue_identifier_node)
15102               && (bc_label == NULL_TREE
15103                   || TREE_CHAIN (labeled_block) == bc_label))
15104             {
15105               bc_label = labeled_block;
15106               break;
15107             }
15108         }
15109     }
15110   else if (!bc_label)
15111     {
15112       for (;; labeled_block = TREE_CHAIN (labeled_block))
15113         {
15114           if (labeled_block == NULL_TREE)
15115             {
15116               parse_error_context (wfl_operator,
15117                                      "`break' must be in loop or switch");
15118               return error_mark_node;
15119             }
15120           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15121           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15122               || search_loop (target_stmt))
15123             {
15124               bc_label = labeled_block;
15125               break;
15126             }
15127         }
15128     }
15129
15130   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15131   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15132
15133   /* Our break/continue don't return values. */
15134   TREE_TYPE (node) = void_type_node;
15135   /* Encapsulate the break within a compound statement so that it's
15136      expanded all the times by expand_expr (and not clobbered
15137      sometimes, like after a if statement) */
15138   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15139   TREE_SIDE_EFFECTS (node) = 1;
15140   return node;
15141 }
15142
15143 /* Process the exit expression belonging to a loop. Its type must be
15144    boolean.  */
15145
15146 static tree
15147 patch_exit_expr (tree node)
15148 {
15149   tree expression = TREE_OPERAND (node, 0);
15150   TREE_TYPE (node) = error_mark_node;
15151   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15152
15153   /* The type of expression must be boolean */
15154   if (TREE_TYPE (expression) != boolean_type_node)
15155     {
15156       parse_error_context
15157         (wfl_operator,
15158     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15159          lang_printable_name (TREE_TYPE (expression), 0));
15160       return error_mark_node;
15161     }
15162   /* Now we know things are allright, invert the condition, fold and
15163      return */
15164   TREE_OPERAND (node, 0) =
15165     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15166
15167   if (! integer_zerop (TREE_OPERAND (node, 0))
15168       && ctxp->current_loop != NULL_TREE
15169       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15170     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15171   if (! integer_onep (TREE_OPERAND (node, 0)))
15172     CAN_COMPLETE_NORMALLY (node) = 1;
15173
15174
15175   TREE_TYPE (node) = void_type_node;
15176   return node;
15177 }
15178
15179 /* 14.9 Switch statement */
15180
15181 static tree
15182 patch_switch_statement (tree node)
15183 {
15184   tree se = TREE_OPERAND (node, 0), se_type;
15185   tree save, iter;
15186
15187   /* Complete the switch expression */
15188   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15189   se_type = TREE_TYPE (se);
15190   /* The type of the switch expression must be char, byte, short or
15191      int */
15192   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15193     {
15194       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15195       parse_error_context (wfl_operator,
15196           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15197                            lang_printable_name (se_type, 0));
15198       /* This is what java_complete_tree will check */
15199       TREE_OPERAND (node, 0) = error_mark_node;
15200       return error_mark_node;
15201     }
15202
15203   /* Save and restore the outer case label list.  */
15204   save = case_label_list;
15205   case_label_list = NULL_TREE;
15206
15207   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15208
15209   /* See if we've found a duplicate label.  We can't leave this until
15210      code generation, because in `--syntax-only' and `-C' modes we
15211      don't do ordinary code generation.  */
15212   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15213     {
15214       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15215       tree subiter;
15216       for (subiter = TREE_CHAIN (iter);
15217            subiter != NULL_TREE;
15218            subiter = TREE_CHAIN (subiter))
15219         {
15220           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15221           if (val == subval)
15222             {
15223               EXPR_WFL_LINECOL (wfl_operator)
15224                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15225               /* The case_label_list is in reverse order, so print the
15226                  outer label first.  */
15227               parse_error_context (wfl_operator, "duplicate case label: `"
15228                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15229               EXPR_WFL_LINECOL (wfl_operator)
15230                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15231               parse_error_context (wfl_operator, "original label is here");
15232
15233               break;
15234             }
15235         }
15236     }
15237
15238   case_label_list = save;
15239
15240   /* Ready to return */
15241   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15242     {
15243       TREE_TYPE (node) = error_mark_node;
15244       return error_mark_node;
15245     }
15246   TREE_TYPE (node) = void_type_node;
15247   TREE_SIDE_EFFECTS (node) = 1;
15248   CAN_COMPLETE_NORMALLY (node)
15249     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15250       || ! SWITCH_HAS_DEFAULT (node);
15251   return node;
15252 }
15253
15254 /* Assertions.  */
15255
15256 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15257    might be NULL_TREE.  */
15258 static tree
15259 build_assertion (int location, tree condition, tree value)
15260 {
15261   tree node;
15262   tree klass = GET_CPC ();
15263
15264   if (! enable_assertions (klass))
15265     {
15266       condition = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15267                          boolean_false_node, condition);
15268       if (value == NULL_TREE)
15269         value = build_java_empty_stmt ();
15270       return build_if_else_statement (location, condition,
15271                                       value, NULL_TREE);
15272     }
15273
15274   if (! CLASS_USES_ASSERTIONS (klass))
15275     {
15276       tree field, classdollar, id, call;
15277       tree class_type = TREE_TYPE (klass);
15278
15279       field = add_field (class_type,
15280                          get_identifier ("$assertionsDisabled"),
15281                          boolean_type_node,
15282                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15283       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15284       FIELD_SYNTHETIC (field) = 1;
15285
15286       classdollar = build_incomplete_class_ref (location, class_type);
15287
15288       /* Call CLASS.desiredAssertionStatus().  */
15289       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15290       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15291       call = make_qualified_primary (classdollar, call, location);
15292       TREE_SIDE_EFFECTS (call) = 1;
15293
15294       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15295          seem odd, but we do it to generate code identical to that of
15296          the JDK.  */
15297       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15298       TREE_SIDE_EFFECTS (call) = 1;
15299       DECL_INITIAL (field) = call;
15300
15301       /* Record the initializer in the initializer statement list.  */
15302       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15303       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15304       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15305       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15306
15307       CLASS_USES_ASSERTIONS (klass) = 1;
15308     }
15309
15310   if (value != NULL_TREE)
15311     value = tree_cons (NULL_TREE, value, NULL_TREE);
15312
15313   node = build_wfl_node (get_identifier ("java"));
15314   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15315                               location);
15316   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15317                               location);
15318
15319   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15320   TREE_SIDE_EFFECTS (node) = 1;
15321   /* It is too early to use BUILD_THROW.  */
15322   node = build1 (THROW_EXPR, NULL_TREE, node);
15323   TREE_SIDE_EFFECTS (node) = 1;
15324
15325   /* We invert the condition; if we just put NODE as the `else' part
15326      then we generate weird-looking bytecode.  */
15327   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15328   /* Check $assertionsDisabled.  */
15329   condition
15330     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15331              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15332                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15333              condition);
15334   node = build_if_else_statement (location, condition, node, NULL_TREE);
15335   return node;
15336 }
15337
15338 /* 14.18 The try/catch statements */
15339
15340 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15341    catches TYPE and executes CATCH_STMTS.  */
15342
15343 static tree
15344 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15345                             tree catch_stmts)
15346 {
15347   tree try_block, catch_clause_param, catch_block, catch;
15348
15349   /* First build a try block */
15350   try_block = build_expr_block (try_stmts, NULL_TREE);
15351
15352   /* Build a catch block: we need a catch clause parameter */
15353   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15354     {
15355       tree catch_type = obtain_incomplete_type (type_or_name);
15356       jdep *dep;
15357       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15358       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15359                                 catch_clause_param, catch_type);
15360       dep = CLASSD_LAST (ctxp->classd_list);
15361       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15362     }
15363   else
15364     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15365                                      build_pointer_type (type_or_name));
15366
15367   /* And a block */
15368   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15369
15370   /* Initialize the variable and store in the block */
15371   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15372                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15373   add_stmt_to_block (catch_block, NULL_TREE, catch);
15374
15375   /* Add the catch statements */
15376   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15377
15378   /* Now we can build a JAVA_CATCH_EXPR */
15379   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15380
15381   return build_try_statement (location, try_block, catch_block);
15382 }
15383
15384 static tree
15385 build_try_statement (int location, tree try_block, tree catches)
15386 {
15387   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15388   EXPR_WFL_LINECOL (node) = location;
15389   return node;
15390 }
15391
15392 static tree
15393 build_try_finally_statement (int location, tree try_block, tree finally)
15394 {
15395   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15396   EXPR_WFL_LINECOL (node) = location;
15397   return node;
15398 }
15399
15400 static tree
15401 patch_try_statement (tree node)
15402 {
15403   int error_found = 0;
15404   tree try = TREE_OPERAND (node, 0);
15405   /* Exception handlers are considered in left to right order */
15406   tree catch = nreverse (TREE_OPERAND (node, 1));
15407   tree current, caught_type_list = NULL_TREE;
15408
15409   /* Check catch clauses, if any. Every time we find an error, we try
15410      to process the next catch clause. We process the catch clause before
15411      the try block so that when processing the try block we can check thrown
15412      exceptions againts the caught type list. */
15413   for (current = catch; current; current = TREE_CHAIN (current))
15414     {
15415       tree carg_decl, carg_type;
15416       tree sub_current, catch_block, catch_clause;
15417       int unreachable;
15418
15419       /* At this point, the structure of the catch clause is
15420            JAVA_CATCH_EXPR              (catch node)
15421              BLOCK              (with the decl of the parameter)
15422                COMPOUND_EXPR
15423                  MODIFY_EXPR   (assignment of the catch parameter)
15424                  BLOCK          (catch clause block)
15425        */
15426       catch_clause = TREE_OPERAND (current, 0);
15427       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15428       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15429
15430       /* Catch clauses can't have more than one parameter declared,
15431          but it's already enforced by the grammar. Make sure that the
15432          only parameter of the clause statement in of class Throwable
15433          or a subclass of Throwable, but that was done earlier. The
15434          catch clause parameter type has also been resolved. */
15435
15436       /* Just make sure that the catch clause parameter type inherits
15437          from java.lang.Throwable */
15438       if (!inherits_from_p (carg_type, throwable_type_node))
15439         {
15440           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15441           parse_error_context (wfl_operator,
15442                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15443                                lang_printable_name (carg_type, 0));
15444           error_found = 1;
15445           continue;
15446         }
15447
15448       /* Partial check for unreachable catch statement: The catch
15449          clause is reachable iff is no earlier catch block A in
15450          the try statement such that the type of the catch
15451          clause's parameter is the same as or a subclass of the
15452          type of A's parameter */
15453       unreachable = 0;
15454       for (sub_current = catch;
15455            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15456         {
15457           tree sub_catch_clause, decl;
15458           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15459           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15460
15461           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15462             {
15463               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15464               parse_error_context
15465                 (wfl_operator,
15466                  "`catch' not reached because of the catch clause at line %d",
15467                  EXPR_WFL_LINENO (sub_current));
15468               unreachable = error_found = 1;
15469               break;
15470             }
15471         }
15472       /* Complete the catch clause block */
15473       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15474       if (catch_block == error_mark_node)
15475         {
15476           error_found = 1;
15477           continue;
15478         }
15479       if (CAN_COMPLETE_NORMALLY (catch_block))
15480         CAN_COMPLETE_NORMALLY (node) = 1;
15481       TREE_OPERAND (current, 0) = catch_block;
15482
15483       if (unreachable)
15484         continue;
15485
15486       /* Things to do here: the exception must be thrown */
15487
15488       /* Link this type to the caught type list */
15489       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15490     }
15491
15492   PUSH_EXCEPTIONS (caught_type_list);
15493   if ((try = java_complete_tree (try)) == error_mark_node)
15494     error_found = 1;
15495   if (CAN_COMPLETE_NORMALLY (try))
15496     CAN_COMPLETE_NORMALLY (node) = 1;
15497   POP_EXCEPTIONS ();
15498
15499   /* Verification ends here */
15500   if (error_found)
15501     return error_mark_node;
15502
15503   TREE_OPERAND (node, 0) = try;
15504   TREE_OPERAND (node, 1) = catch;
15505   TREE_TYPE (node) = void_type_node;
15506   return node;
15507 }
15508
15509 /* 14.17 The synchronized Statement */
15510
15511 static tree
15512 patch_synchronized_statement (tree node, tree wfl_op1)
15513 {
15514   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15515   tree block = TREE_OPERAND (node, 1);
15516
15517   tree tmp, enter, exit, expr_decl, assignment;
15518
15519   if (expr == error_mark_node)
15520     {
15521       block = java_complete_tree (block);
15522       return expr;
15523     }
15524
15525   /* We might be trying to synchronize on a STRING_CST */
15526   if ((tmp = patch_string (expr)))
15527     expr = tmp;
15528
15529   /* The TYPE of expr must be a reference type */
15530   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15531     {
15532       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15533       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15534                            lang_printable_name (TREE_TYPE (expr), 0));
15535       return error_mark_node;
15536     }
15537
15538   if (flag_emit_xref)
15539     {
15540       TREE_OPERAND (node, 0) = expr;
15541       TREE_OPERAND (node, 1) = java_complete_tree (block);
15542       CAN_COMPLETE_NORMALLY (node) = 1;
15543       return node;
15544     }
15545
15546   /* Generate a try-finally for the synchronized statement, except
15547      that the handler that catches all throw exception calls
15548      _Jv_MonitorExit and then rethrow the exception.
15549      The synchronized statement is then implemented as:
15550      TRY
15551        {
15552          _Jv_MonitorEnter (expression)
15553          synchronized_block
15554          _Jv_MonitorExit (expression)
15555        }
15556      CATCH_ALL
15557        {
15558          e = _Jv_exception_info ();
15559          _Jv_MonitorExit (expression)
15560          Throw (e);
15561        } */
15562
15563   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15564   BUILD_MONITOR_ENTER (enter, expr_decl);
15565   BUILD_MONITOR_EXIT (exit, expr_decl);
15566   CAN_COMPLETE_NORMALLY (enter) = 1;
15567   CAN_COMPLETE_NORMALLY (exit) = 1;
15568   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15569   TREE_SIDE_EFFECTS (assignment) = 1;
15570   node = build (COMPOUND_EXPR, NULL_TREE,
15571                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15572                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15573   node = build_expr_block (node, expr_decl);
15574
15575   return java_complete_tree (node);
15576 }
15577
15578 /* 14.16 The throw Statement */
15579
15580 static tree
15581 patch_throw_statement (tree node, tree wfl_op1)
15582 {
15583   tree expr = TREE_OPERAND (node, 0);
15584   tree type = TREE_TYPE (expr);
15585   int unchecked_ok = 0, tryblock_throws_ok = 0;
15586
15587   /* Thrown expression must be assignable to java.lang.Throwable */
15588   if (!try_reference_assignconv (throwable_type_node, expr))
15589     {
15590       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15591       parse_error_context (wfl_operator,
15592     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15593                            lang_printable_name (type, 0));
15594       /* If the thrown expression was a reference, we further the
15595          compile-time check. */
15596       if (!JREFERENCE_TYPE_P (type))
15597         return error_mark_node;
15598     }
15599
15600   /* At least one of the following must be true */
15601
15602   /* The type of the throw expression is a not checked exception,
15603      i.e. is a unchecked expression. */
15604   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15605
15606   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15607   /* An instance can't throw a checked exception unless that exception
15608      is explicitly declared in the `throws' clause of each
15609      constructor. This doesn't apply to anonymous classes, since they
15610      don't have declared constructors. */
15611   if (!unchecked_ok
15612       && DECL_INSTINIT_P (current_function_decl)
15613       && !ANONYMOUS_CLASS_P (current_class))
15614     {
15615       tree current;
15616       for (current = TYPE_METHODS (current_class); current;
15617            current = TREE_CHAIN (current))
15618         if (DECL_CONSTRUCTOR_P (current)
15619             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15620           {
15621             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)",
15622                                  lang_printable_name (TREE_TYPE (expr), 0));
15623             return error_mark_node;
15624           }
15625     }
15626
15627   /* Throw is contained in a try statement and at least one catch
15628      clause can receive the thrown expression or the current method is
15629      declared to throw such an exception. Or, the throw statement is
15630      contained in a method or constructor declaration and the type of
15631      the Expression is assignable to at least one type listed in the
15632      throws clause the declaration. */
15633   if (!unchecked_ok)
15634     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15635   if (!(unchecked_ok || tryblock_throws_ok))
15636     {
15637       /* If there is a surrounding try block that has no matching
15638          clatch clause, report it first. A surrounding try block exits
15639          only if there is something after the list of checked
15640          exception thrown by the current function (if any). */
15641       if (IN_TRY_BLOCK_P ())
15642         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15643                              lang_printable_name (type, 0));
15644       /* If we have no surrounding try statement and the method doesn't have
15645          any throws, report it now. FIXME */
15646
15647       /* We report that the exception can't be throw from a try block
15648          in all circumstances but when the `throw' is inside a static
15649          block. */
15650       else if (!EXCEPTIONS_P (currently_caught_type_list)
15651                && !tryblock_throws_ok)
15652         {
15653           if (DECL_CLINIT_P (current_function_decl))
15654             parse_error_context (wfl_operator,
15655                    "Checked exception `%s' can't be thrown in initializer",
15656                                  lang_printable_name (type, 0));
15657           else
15658             parse_error_context (wfl_operator,
15659                    "Checked exception `%s' isn't thrown from a `try' block",
15660                                  lang_printable_name (type, 0));
15661         }
15662       /* Otherwise, the current method doesn't have the appropriate
15663          throws declaration */
15664       else
15665         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15666                              lang_printable_name (type, 0));
15667       return error_mark_node;
15668     }
15669
15670   if (! flag_emit_class_files && ! flag_emit_xref)
15671     BUILD_THROW (node, expr);
15672
15673   /* If doing xrefs, keep the location where the `throw' was seen. */
15674   if (flag_emit_xref)
15675     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15676   return node;
15677 }
15678
15679 /* Check that exception said to be thrown by method DECL can be
15680    effectively caught from where DECL is invoked.  THIS_EXPR is the
15681    expression that computes `this' for the method call.  */
15682 static void
15683 check_thrown_exceptions (int location, tree decl, tree this_expr)
15684 {
15685   tree throws;
15686   int is_array_call = 0;
15687
15688   /* Skip check within generated methods, such as access$<n>.  */
15689   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15690     return;
15691
15692   if (this_expr != NULL_TREE
15693       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15694       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15695     is_array_call = 1;
15696
15697   /* For all the unchecked exceptions thrown by DECL.  */
15698   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15699        throws = TREE_CHAIN (throws))
15700     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15701       {
15702         /* Suppress errors about cloning arrays.  */
15703         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15704           continue;
15705
15706         EXPR_WFL_LINECOL (wfl_operator) = location;
15707         if (DECL_FINIT_P (current_function_decl))
15708           parse_error_context
15709             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15710              lang_printable_name (TREE_VALUE (throws), 0));
15711         else
15712           {
15713             parse_error_context
15714               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15715                lang_printable_name (TREE_VALUE (throws), 0),
15716                (DECL_INIT_P (current_function_decl) ?
15717                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15718                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15719           }
15720       }
15721 }
15722
15723 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15724    try-catch blocks, OR is listed in the `throws' clause of the
15725    current method.  */
15726
15727 static int
15728 check_thrown_exceptions_do (tree exception)
15729 {
15730   tree list = currently_caught_type_list;
15731   resolve_and_layout (exception, NULL_TREE);
15732   /* First, all the nested try-catch-finally at that stage. The
15733      last element contains `throws' clause exceptions, if any. */
15734   if (IS_UNCHECKED_EXCEPTION_P (exception))
15735     return 1;
15736   while (list)
15737     {
15738       tree caught;
15739       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15740         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15741           return 1;
15742       list = TREE_CHAIN (list);
15743     }
15744   return 0;
15745 }
15746
15747 static void
15748 purge_unchecked_exceptions (tree mdecl)
15749 {
15750   tree throws = DECL_FUNCTION_THROWS (mdecl);
15751   tree new = NULL_TREE;
15752
15753   while (throws)
15754     {
15755       tree next = TREE_CHAIN (throws);
15756       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15757         {
15758           TREE_CHAIN (throws) = new;
15759           new = throws;
15760         }
15761       throws = next;
15762     }
15763   /* List is inverted here, but it doesn't matter */
15764   DECL_FUNCTION_THROWS (mdecl) = new;
15765 }
15766
15767 /* This function goes over all of CLASS_TYPE ctors and checks whether
15768    each of them features at least one unchecked exception in its
15769    `throws' clause. If it's the case, it returns `true', `false'
15770    otherwise.  */
15771
15772 static bool
15773 ctors_unchecked_throws_clause_p (tree class_type)
15774 {
15775   tree current;
15776
15777   for (current = TYPE_METHODS (class_type); current;
15778        current = TREE_CHAIN (current))
15779     {
15780       bool ctu = false; /* Ctor Throws Unchecked */
15781       if (DECL_CONSTRUCTOR_P (current))
15782         {
15783           tree throws;
15784           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15785                throws = TREE_CHAIN (throws))
15786             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15787               ctu = true;
15788         }
15789       /* We return false as we found one ctor that is unfit. */
15790       if (!ctu && DECL_CONSTRUCTOR_P (current))
15791         return false;
15792     }
15793   /* All ctors feature at least one unchecked exception in their
15794      `throws' clause. */
15795   return true;
15796 }
15797
15798 /* 15.24 Conditional Operator ?: */
15799
15800 static tree
15801 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15802 {
15803   tree cond = TREE_OPERAND (node, 0);
15804   tree op1 = TREE_OPERAND (node, 1);
15805   tree op2 = TREE_OPERAND (node, 2);
15806   tree resulting_type = NULL_TREE;
15807   tree t1, t2, patched;
15808   int error_found = 0;
15809
15810   /* Operands of ?: might be StringBuffers crafted as a result of a
15811      string concatenation. Obtain a descent operand here.  */
15812   if ((patched = patch_string (op1)))
15813     TREE_OPERAND (node, 1) = op1 = patched;
15814   if ((patched = patch_string (op2)))
15815     TREE_OPERAND (node, 2) = op2 = patched;
15816
15817   t1 = TREE_TYPE (op1);
15818   t2 = TREE_TYPE (op2);
15819
15820   /* The first expression must be a boolean */
15821   if (TREE_TYPE (cond) != boolean_type_node)
15822     {
15823       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15824       parse_error_context (wfl_operator,
15825                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15826                            lang_printable_name (TREE_TYPE (cond), 0));
15827       error_found = 1;
15828     }
15829
15830   /* Second and third can be numeric, boolean (i.e. primitive),
15831      references or null. Anything else results in an error */
15832   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15833         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15834             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15835         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15836     error_found = 1;
15837
15838   /* Determine the type of the conditional expression. Same types are
15839      easy to deal with */
15840   else if (t1 == t2)
15841     resulting_type = t1;
15842
15843   /* There are different rules for numeric types */
15844   else if (JNUMERIC_TYPE_P (t1))
15845     {
15846       /* if byte/short found, the resulting type is short */
15847       if ((t1 == byte_type_node && t2 == short_type_node)
15848           || (t1 == short_type_node && t2 == byte_type_node))
15849         resulting_type = short_type_node;
15850
15851       /* If t1 is a constant int and t2 is of type byte, short or char
15852          and t1's value fits in t2, then the resulting type is t2 */
15853       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15854           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15855         resulting_type = t2;
15856
15857       /* If t2 is a constant int and t1 is of type byte, short or char
15858          and t2's value fits in t1, then the resulting type is t1 */
15859       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15860           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15861         resulting_type = t1;
15862
15863       /* Otherwise, binary numeric promotion is applied and the
15864          resulting type is the promoted type of operand 1 and 2 */
15865       else
15866         resulting_type = binary_numeric_promotion (t1, t2,
15867                                                    &TREE_OPERAND (node, 1),
15868                                                    &TREE_OPERAND (node, 2));
15869     }
15870
15871   /* Cases of a reference and a null type */
15872   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15873     resulting_type = t1;
15874
15875   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15876     resulting_type = t2;
15877
15878   /* Last case: different reference types. If a type can be converted
15879      into the other one by assignment conversion, the latter
15880      determines the type of the expression */
15881   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15882     resulting_type = promote_type (t1);
15883
15884   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15885     resulting_type = promote_type (t2);
15886
15887   /* If we don't have any resulting type, we're in trouble */
15888   if (!resulting_type)
15889     {
15890       char *t = xstrdup (lang_printable_name (t1, 0));
15891       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15892       parse_error_context (wfl_operator,
15893                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15894                            t, lang_printable_name (t2, 0));
15895       free (t);
15896       error_found = 1;
15897     }
15898
15899   if (error_found)
15900     {
15901       TREE_TYPE (node) = error_mark_node;
15902       return error_mark_node;
15903     }
15904
15905   TREE_TYPE (node) = resulting_type;
15906   TREE_SET_CODE (node, COND_EXPR);
15907   CAN_COMPLETE_NORMALLY (node) = 1;
15908   return node;
15909 }
15910
15911 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15912
15913 static tree
15914 maybe_build_class_init_for_field (tree decl, tree expr)
15915 {
15916   tree clas = DECL_CONTEXT (decl);
15917   if (flag_emit_class_files || flag_emit_xref)
15918     return expr;
15919
15920   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15921       && FIELD_FINAL (decl))
15922     {
15923       tree init = DECL_INITIAL (decl);
15924       if (init != NULL_TREE)
15925         init = fold_constant_for_init (init, decl);
15926       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15927         return expr;
15928     }
15929
15930   return build_class_init (clas, expr);
15931 }
15932
15933 /* Try to constant fold NODE.
15934    If NODE is not a constant expression, return NULL_EXPR.
15935    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15936
15937 static tree
15938 fold_constant_for_init (tree node, tree context)
15939 {
15940   tree op0, op1, val;
15941   enum tree_code code = TREE_CODE (node);
15942
15943   switch (code)
15944     {
15945     case INTEGER_CST:
15946       if (node == null_pointer_node)
15947         return NULL_TREE;
15948     case STRING_CST:
15949     case REAL_CST:
15950       return node;
15951
15952     case PLUS_EXPR:
15953     case MINUS_EXPR:
15954     case MULT_EXPR:
15955     case TRUNC_MOD_EXPR:
15956     case RDIV_EXPR:
15957     case LSHIFT_EXPR:
15958     case RSHIFT_EXPR:
15959     case URSHIFT_EXPR:
15960     case BIT_AND_EXPR:
15961     case BIT_XOR_EXPR:
15962     case BIT_IOR_EXPR:
15963     case TRUTH_ANDIF_EXPR:
15964     case TRUTH_ORIF_EXPR:
15965     case EQ_EXPR:
15966     case NE_EXPR:
15967     case GT_EXPR:
15968     case GE_EXPR:
15969     case LT_EXPR:
15970     case LE_EXPR:
15971       op0 = TREE_OPERAND (node, 0);
15972       op1 = TREE_OPERAND (node, 1);
15973       val = fold_constant_for_init (op0, context);
15974       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15975         return NULL_TREE;
15976       TREE_OPERAND (node, 0) = val;
15977       val = fold_constant_for_init (op1, context);
15978       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15979         return NULL_TREE;
15980       TREE_OPERAND (node, 1) = val;
15981       return patch_binop (node, op0, op1);
15982
15983     case UNARY_PLUS_EXPR:
15984     case NEGATE_EXPR:
15985     case TRUTH_NOT_EXPR:
15986     case BIT_NOT_EXPR:
15987     case CONVERT_EXPR:
15988       op0 = TREE_OPERAND (node, 0);
15989       val = fold_constant_for_init (op0, context);
15990       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15991         return NULL_TREE;
15992       TREE_OPERAND (node, 0) = val;
15993       val = patch_unaryop (node, op0);
15994       if (! TREE_CONSTANT (val))
15995         return NULL_TREE;
15996       return val;
15997
15998       break;
15999
16000     case COND_EXPR:
16001       val = fold_constant_for_init (TREE_OPERAND (node, 0), 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 (TREE_OPERAND (node, 1), context);
16006       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16007         return NULL_TREE;
16008       TREE_OPERAND (node, 1) = val;
16009       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16010       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16011         return NULL_TREE;
16012       TREE_OPERAND (node, 2) = val;
16013       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16014         : TREE_OPERAND (node, 2);
16015
16016     case VAR_DECL:
16017     case FIELD_DECL:
16018       if (! FIELD_FINAL (node)
16019           || DECL_INITIAL (node) == NULL_TREE)
16020         return NULL_TREE;
16021       val = DECL_INITIAL (node);
16022       /* Guard against infinite recursion. */
16023       DECL_INITIAL (node) = NULL_TREE;
16024       val = fold_constant_for_init (val, node);
16025       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16026         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16027       DECL_INITIAL (node) = val;
16028       return val;
16029
16030     case EXPR_WITH_FILE_LOCATION:
16031       /* Compare java_complete_tree and resolve_expression_name. */
16032       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16033           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16034         {
16035           tree name = EXPR_WFL_NODE (node);
16036           tree decl;
16037           if (PRIMARY_P (node))
16038             return NULL_TREE;
16039           else if (! QUALIFIED_P (name))
16040             {
16041               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16042               if (decl == NULL_TREE
16043                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16044                 return NULL_TREE;
16045               return fold_constant_for_init (decl, decl);
16046             }
16047           else
16048             {
16049               /* Install the proper context for the field resolution.
16050                  The prior context is restored once the name is
16051                  properly qualified. */
16052               tree saved_current_class = current_class;
16053               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16054               current_class = DECL_CONTEXT (context);
16055               qualify_ambiguous_name (node);
16056               current_class = saved_current_class;
16057               if (resolve_field_access (node, &decl, NULL)
16058                   && decl != NULL_TREE)
16059                 return fold_constant_for_init (decl, decl);
16060               return NULL_TREE;
16061             }
16062         }
16063       else
16064         {
16065           op0 = TREE_OPERAND (node, 0);
16066           val = fold_constant_for_init (op0, context);
16067           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16068             return NULL_TREE;
16069           TREE_OPERAND (node, 0) = val;
16070           return val;
16071         }
16072
16073 #ifdef USE_COMPONENT_REF
16074     case IDENTIFIER:
16075     case COMPONENT_REF:
16076       ?;
16077 #endif
16078
16079     default:
16080       return NULL_TREE;
16081     }
16082 }
16083
16084 #ifdef USE_COMPONENT_REF
16085 /* Context is 'T' for TypeName, 'P' for PackageName,
16086    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16087
16088 tree
16089 resolve_simple_name (tree name, int context)
16090 {
16091 }
16092
16093 tree
16094 resolve_qualified_name (tree name, int context)
16095 {
16096 }
16097 #endif
16098
16099 void
16100 init_src_parse (void)
16101 {
16102   /* Sanity check; we've been bit by this before.  */
16103   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16104     abort ();
16105 }
16106
16107 \f
16108
16109 /* This section deals with the functions that are called when tables
16110    recording class initialization information are traversed.  */
16111
16112 /* Attach to PTR (a block) the declaration found in ENTRY. */
16113
16114 static int
16115 attach_init_test_initialization_flags (void **entry, void *ptr)
16116 {
16117   tree block = (tree)ptr;
16118   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16119
16120   if (block != error_mark_node)
16121     {
16122       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16123       BLOCK_EXPR_DECLS (block) = ite->value;
16124     }
16125   return true;
16126 }
16127
16128 /* This function is called for each class that is known definitely
16129    initialized when a given static method was called. This function
16130    augments a compound expression (INFO) storing all assignment to
16131    initialized static class flags if a flag already existed, otherwise
16132    a new one is created.  */
16133
16134 static int
16135 emit_test_initialization (void **entry_p, void *info)
16136 {
16137   tree l = (tree) info;
16138   tree decl, init;
16139   tree key = (tree) *entry_p;
16140   tree *ite;
16141   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16142
16143   /* If we haven't found a flag and we're dealing with self registered
16144      with current_function_decl, then don't do anything. Self is
16145      always added as definitely initialized but this information is
16146      valid only if used outside the current function. */
16147   if (current_function_decl == TREE_PURPOSE (l)
16148       && java_treetreehash_find (cf_ht, key) == NULL)
16149     return true;
16150
16151   ite = java_treetreehash_new (cf_ht, key);
16152
16153   /* If we don't have a variable, create one and install it. */
16154   if (*ite == NULL)
16155     {
16156       tree block;
16157
16158       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16159       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16160       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16161       DECL_CONTEXT (decl) = current_function_decl;
16162       DECL_INITIAL (decl) = boolean_true_node;
16163       /* Don't emit any symbolic debugging info for this decl.  */
16164       DECL_IGNORED_P (decl) = 1;
16165
16166       /* The trick is to find the right context for it. */
16167       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16168       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16169       BLOCK_EXPR_DECLS (block) = decl;
16170       *ite = decl;
16171     }
16172   else
16173     decl = *ite;
16174
16175   /* Now simply augment the compound that holds all the assignments
16176      pertaining to this method invocation. */
16177   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16178   TREE_SIDE_EFFECTS (init) = 1;
16179   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16180   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16181
16182   return true;
16183 }
16184
16185 #include "gt-java-parse.h"
16186 #include "gtype-java.h"